当前位置：首页 > news >正文

ES6新特性

news 2025/7/5 22:12:28

let、const(es6)和var的区别

var：var声明变量存在作用域的提升，变量可以在未声明就调用。变量为undefined。

let: let声明变量是块级作用域，一个{}为一块，不存在作用域提升。只有声明变量后才能使用变量，否则会报错。

const:const 定义的常量是基本数据类型，不能修改。定义的常量要是引用数据类型，就可以修改。因为保存在栈内存的数据是不可以被修改的。而基本数据类型是直接存储在栈内存中的，所以不能被修改。引用数据类型在栈内存中存储的是一个隐式指针，真正的数据存储在隐式指针指向的堆地址，不可被修改的是指针，真正的数据是可变的。

解构赋值

数组的解构赋值:相当于剥皮

let res = [0,1,2,'a'];
console.log(...res); // 0 1 2 a

对象的解构赋值

let res={name: '张杰',chaozuo: function () {console.log('张杰'); // 张杰},dance: function () {console.log('18');  // 18}}
let { chaozuo, dance } = res;
chaozuo();
dance();

模版字符串反引号（``）

标签和标签之间可以直接换行，类似于vue中render函数的作用。

字符串拼接时不用加号，变量直接放在${}中

let name = "张杰";
let age = "18";
let send = `我是${name},我今年${age}` 
console.log(send); // 我是张杰，我今年18

箭头函数

let arr = [1,2,3];
let index = arr.findIndex((item)=>{return item == 1;
})

当箭头函数没有参数或者有多个参数，要用 () 括起来。

当箭头函数函数体有多行语句，用 {} 包裹起来，表示代码块，当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。

当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来。

箭头函数没有自己的this指向，它指向自己的父级

函数形参默认值

为形参赋默认值，有传实参用实参，没有用默认值

// es6允许给形参赋初始值// 参数直接设置默认值，位置一般靠后function add(a,b,c=2) {console.log(a + b + c);}add(1,2)
// 与解构赋值结合使用 结构赋值的先后不影响function connect({name, age=18, sex}) {console.log(name);console.log(age);console.log(sex);}connect({name:'小宝',sex: 'man'})

简化对象写法

let odj={name,age,
}

扩展运算符

解构赋值的...就是扩展运算符。

Symbol

Symbol 是 ES6 新引入的一种原始数据类型，表示独一无二的值。它是 js 第七种数据类型是一种类似于字符串的数据类型。

//创建 Symbol
let h = Symbol()
console.log(a) //Symbol()
console.log(typeof a) //"symbol"

//正常的 Symbol
let h1 = Symbol('张杰')
let h2 = Symbol('张杰')
console.log(h1 === h2) // false

//相等的Symbol   ----使用 Symbol.for()
let h3 = Symbol.for('小杰')
let h4 = Symbol.for('小杰')
console.log(h1 === h2) // true

集合（set）

Set是es6新增的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值，我们一般称为集合。项目里面数组去重用到set。

字典（Map）

Map类型是键值对的有序列表，而键和值都可以是任意类型。

        // 声明Maplet m = new Map()
// 1.添加元素(键值对)m.set('name','小宝')m.set('age',18)
// 2.获取元素console.log(m.get(name)) //小宝
// 3.删除元素m.delete('name')
// 4.获取元素个数let size = m.sizeconsole.log(size) //1
// 5.检测是否包含某个元素console.log(m.has('age')); //true// 6.清空Mapm.clear()console.log(m) //0

Promise

http://t.csdn.cn/2B9Gp请看Promise详解

类（class）

ES6 引入了class类这个概念，通过class关键字可以定义类，这就是更符合我们平时所理解的面向对象的语言。

1.简单的类

    //类的声明class Phone {//构造方法 不是必须的，但是constructor名字不能修改constructor(brand, price) {this.brand = brand;this.price = price;}
//声明成员方法call(someone) {console.log(`我可以给${someone}打电话`);}sendMessage(someone) {console.log(`我可以给${someone}打电话`);}
//声明静态成员static name = '手机';static change() {console.log('吃了吗');}}

2.类的继承

    //子类继承父类class SmartPhone extends Phone {//子类的构造方法constructor(brand,price,screen,pixel) {//调用父类的构造方法进行初始化  supersuper(brand,price);this.screen = screen;this.pixel = pixel;}//方法声明playGame() {console.log('我可以玩游戏');}
sw() {console.log('我可以上网');}}
// 子类实例化const onePlus = new SmartPhone('1+', 3999, 6.5, '4800w');console.log(onePlus);
console.dir(Phone)console.log(Phone.name);

Proxy

Proxy 对象就是可以让你去对JavaScript中的一切合法对象的基本操作进行自定义.然后用你自定义的操作去覆盖其对象的基本操作，也就是当一个对象去执行一个基本操作时,其执行的过程和结果是你自定义的,而不是对象的。

let p = new Proxy(target, handler);// target 是你要代理的对象.它可以是JavaScript中的任何合法对象.如: (数组, 对象, 函数等等)// handler 是你要自定义操作方法的一个集合.// p 是一个被代理后的新对象,它拥有 target 的一切属性和方法.只不过其行为和结果是在 handler 中自定义的.let obj = {a: 1,b: 2,
}const p = new Proxy(obj, {get(target, key, value) {if (key === 'c') {return '我是自定义的一个结果';} else {return target[key];}},set(target, key, value) {if (value === 4) {target[key] = '我是自定义的一个结果';} else {target[key] = value;}}
})
console.log(obj.a) // 1
console.log(obj.c) // undefined
console.log(p.a) // 1
console.log(p.c) // 我是自定义的一个结果
obj.name = '李白';
console.log(obj.name); // 李白
obj.age = 4;
console.log(obj.age); // 4
p.name = '李白';
console.log(p.name); // 李白
p.age = 4;
console.log(p.age); // 我是自定义的一个结果// 从上面这段代码中,我可以很清楚的看到 Proxy 对象的作用.即是之前所受的 用于定义基本操作的自定
//义行为 .同样的 get 和 set 操作.没有没代理的对象所得的结果是其JavaScript本身的执行机制运行
//计算后所得到的.而被代理了的对象的结果则是我们自定义的.

1.Proxy所能代理的范围--handler

实际上 handler 本身就是ES6所新设计的一个对象.它的作用就是用来自定义代理对象的各种可代理操作。它本身一共有13中方法,每种方法都可以代理一种操作.其13种方法如下:

handler.getPrototypeOf()// 在读取代理对象的原型时触发该操作，比如在执行 Object.getPrototypeOf(proxy) 时。handler.setPrototypeOf()// 在设置代理对象的原型时触发该操作，比如在执行 Object.setPrototypeOf(proxy, null) 时。handler.isExtensible()// 在判断一个代理对象是否是可扩展时触发该操作，比如在执行 Object.isExtensible(proxy) 时。handler.preventExtensions()// 在让一个代理对象不可扩展时触发该操作，比如在执行 Object.preventExtensions(proxy) 时。handler.getOwnPropertyDescriptor()// 在获取代理对象某个属性的属性描述时触发该操作，比如在执行 Object.getOwnPropertyDescriptor(proxy, "foo") 时。handler.defineProperty()// 在定义代理对象某个属性时的属性描述时触发该操作，比如在执行 Object.defineProperty(proxy, "foo", {}) 时。handler.has()// 在判断代理对象是否拥有某个属性时触发该操作，比如在执行 "foo" in proxy 时。handler.get()// 在读取代理对象的某个属性时触发该操作，比如在执行 proxy.foo 时。handler.set()// 在给代理对象的某个属性赋值时触发该操作，比如在执行 proxy.foo = 1 时。handler.deleteProperty()// 在删除代理对象的某个属性时触发该操作，比如在执行 delete proxy.foo 时。handler.ownKeys()// 在获取代理对象的所有属性键时触发该操作，比如在执行 Object.getOwnPropertyNames(proxy) 时。handler.apply()// 在调用一个目标对象为函数的代理对象时触发该操作，比如在执行 proxy() 时。handler.construct()// 在给一个目标对象为构造函数的代理对象构造实例时触发该操作，比如在执行new proxy() 时。

2.proxy的作用

对于代理模式 Proxy 的作用主要体现在三个方面:

1、拦截和监视外部对对象的访问

2、降低函数或类的复杂度

3、在复杂操作前对操作进行校验或对所需资源进行管理

Generator函数

        形式上： Generator函数是一个普通的函数，不过相对于普通函数多出了两个特征。一是在function关键字和函数明之间多了’*'号；二是函数内部使用了yield表达式，用于定义Generator函数中的每个状态。
        语法上： Generator函数封装了多个内部状态(通过yield表达式定义内部状态)。执行Generator函数时会返回一个遍历器对象(Iterator(迭代器)对象)。也就是说，Generator是遍历器对象生成函数，函数内部封装了多个状态。通过返回的Iterator对象，可以依次遍历(调用next方法)Generator函数的每个内部状态。
        调用上：普通函数在调用之后会立即执行，而Generator函数调用之后不会立即执行，而是会返回遍历器对象(Iterator对象)。通过Iterator对象的next方法来遍历内部yield表达式定义的每一个状态。
generator函数执行后得到一个生成器
        Next()方法:每次调用next()方法，内部执行就从函数头部或上一次停下的地方开始执行，直到遇到下一个yield语句为止。