ES6新特性（一）

ES5的升级版,ES6是JavaScript的下一代标准，2015年正式发布，目标成为企业级开发语言，可以用来编写复杂的大型应用程序。

 变量声明

let

1.不可对一个变量进行重复声明
2.不存在变量声明的提升
3.具有局部作用域
4.暂时性死区：在一个代码中，let可以锁定某个变量

let a = 1;

const

用于声明一个常量，一旦声明不能改变，
其他与let保持相同特性

const PI = 3.1415;

解构

 快速从一个对象或数组中获取值，从数组和对象中提取值，对变量进行赋值

 对象解构

通过⼤括号来匹配等号右边的对象

let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
let {foo} = {bar: 'baz'}; //foo为 undefined

数组解构

通过中括号来匹配等号右边的数组值。对于 Set 结构，也可以使⽤数组的解构赋值。

let [ a, b, c] = [ 'bry', 'jacky', 'tom'];
let [ a, b, c, d ] = [ 1, 2, 3 ]; 
let [ a, b ] = [ 1, [ 2, 3 ];

字符串拓展

遍历：ES6 为字符串添加了遍历器接⼝，使得字符串可以被 for...of 循环遍历

let str = "hello world" 
for(let s of str){
 console.log(s); 
}

实例方法

includes() ：返回布尔值，表示是否找到了参数字符串。

startsWith() ：返回布尔值，表示参数字符串是否在原字符串的头部。

endsWith() ：返回布尔值，表示参数字符串是否在原字符串的尾部。

let s = 'Hello world!';
s.startsWith('Hello') // true 
s.endsWith('!') // true 
s.includes('o') // true

 repeat() 方法返回一个新字符串，表示将原字符串重复n次。

padStart()，padEnd() 如果某个字符串不够指定长度，会在头部或尾部补全。padStart()用于头部补全，padEnd()用于尾部补全。

trimStart()和trimEnd()这两个方法。它们的行为与trim()一致，trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。

replaceAll() 可以一次性替换所有匹配。

'aabbcc'.replaceAll('b', '_')// 'aa__cc'

matchAll()方法返回一个正则表达式在当前字符串的所有匹配

数值拓展

Number.isFinite(), Number.isNaN()

与isFinite、isNaN不同，这两个新⽅法只对数值有效， Number.isFinite() 对于⾮数值⼀ 律返回 false , Number.isNaN() 只有对于 NaN 才返回 true ，⾮ NaN ⼀律返回 false 。

Number.isFinite(0.8); // true 
Number.isFinite(NaN); // false 
Number.isFinite(Infinity); // false 
Number.isNaN(NaN) // true 
Number.isNaN(15) // false

Number.parseInt(), Number.parseFloat()

ES6 将全局⽅法 parseInt() 和 parseFloat() ，移植到 Number 对象上⾯，⾏为完全 保持不变。

Number.parseInt('12.34') // 12 
Number.parseFloat('123.45#') // 123.45

Number.isInteger()

⽤来判断⼀个数值是否为整数

Number.isInteger(25) // true 
Number.isInteger(25.1) // false

对象拓展

对象的简写

ES6 允许在⼤括号⾥⾯，直接写⼊变量和函数，作为对象的属性和⽅法

 对象的拓展运算符

解构赋值

let {name,...other} = { name: 'bry', age: 12, gender: 'male' };  
name // 'bry'
other // {age: 12, gender: 'male'}

对象的扩展运算符（ ... ）⽤于取出参数对象的所有可遍历属性，拷⻉到当前对象之中。 对象的扩

展运算符等同于使⽤ Object.assign() ⽅法。

let obj = {name: 'bry', age: 12, gender: 'male'}  
let o = {...obj} 
o // {name: 'bry', age: 12, gender: 'male'}

Object静态⽅法扩展

 Object.is()⽤于⽐较两个值是否相等，与严格⽐较运算符（===）的⾏为基本⼀致。不同之处只有

两 个：⼀是 +0 不等于 -0 ，⼆是 NaN 等于⾃身。

Object.assign()

⽤于对象的合并，将源对象（ source）的所有可枚举属性，复制到⽬标对象（target）, 如果源对象

中的对象存在嵌套关系，进⾏浅拷⻉

let obj1 = { name: 'bry', age: 13, gender: 'male' }
let obj2 = Object.assign({},obj1)
obj1 === obj2 // false
obj1.age = obj.age + 1;
obj1.age // 14  
obj2.age // 13

Object.setPrototypeOf() 为某个对象设置原型

let prototype = { 
foo(){console.log('foo')}, 
bar(){console.log('bar')} 
} 
 let obj = {} 
Object.setPrototypeOf(obj,prototype)

Object.getPrototypeOf() 获取某个对象的原型

Object.getOwnPropertySymbols() 获取指定对象的所有 Symbol 属性名。该⽅法返回⼀个数组，成员是当前对象的所有⽤作 属性名的 Symbol 值。

Object.keys() 该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（ enumerable） 属性的键名。

let obj = { name: 'bry', age: 14, gender: 'male' }; 
Object.keys(obj) //[ 'name', 'age', 'gender' ]

Object.values() 该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（ enumerable）属性的键值。

let obj = { name: 'bry', age: 14, gender: 'male' }; 
Object.values(obj) //[ 'bry', 14, 'male' ]

Object.entries() 该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（ enumerable）属性的键值对数组。

let obj = { name: 'bry', age: 14, gender: 'male' }; 
Object.entries(obj) //[ [ 'name', 'bry' ], [ 'age', 14 ], [ 'gender', 'male']]

Object.fromEntries()

该⽅法是entries的逆操作，⽤于将⼀个键值对数组转为对象。

let entries = [[ 'name', 'bry'], ['age', 14], ['gender', 'male']]; 
let obj = Object.fromEntries(entries)

数组拓展

 扩展运算符

 可以看做是rest的逆运算，⽤于将数组中的元素拆分出来

console.log(...[1, 2, 3]) // 1,2,3

静态⽅法扩展

Array.from()

⽤于将两类对象转为真正的数组：类似数组的对象和可遍历的对象

Array.of()

⽤于将⼀组值，转换为数组。

实例⽅法拓展

find() 和 findIndex()

与fifilter类似，属于数组类型⽅法， find ⽅法⽤于找出第⼀个符合条件的数组成员。它的

参数是⼀个回调函数，所有数组成员依次执⾏该回调函数，直到找出第⼀个返回值为 true 的

成员，然后返回该成员。如果没有符合条件的成员，则返回 undefined 。

findIndex ⽅法的⽤法与 find ⽅法⾮常类似，返回第⼀个符合条件的数组成员的位

置，如果所有成员都不符合条件，则返回 -1 。

[1, 4, -5, 10].find((n) => n < 0) //-5 
[1, 5, 10, 15].findIndex(value => value>9) //2

fill()

使⽤给定值，填充⼀个数组。

new Array(3).fill(7)  // [7, 7, 7]

entries()，keys() 和 values()

它们都返回⼀个遍历器对象，可以⽤ for...of 循环进⾏遍历，唯⼀的区别是 keys() 是

对键名的遍历、 values() 是对键值的遍历， entries() 是对键值对的遍历。

includes()

返回⼀个布尔值，表示某个数组是否包含给定的值，与字符串的 includes ⽅法类似。

flat()

该⽅法⽤于将嵌套的数组“拉平”，变成⼀维的数组。该⽅法返回⼀个新数组，对原数据没

有影响。 flat() 默认只会“拉平”⼀层，如果想要“拉平”多层的嵌套数组，可以将 flat() ⽅

法的参数写成⼀个整数，表示想要拉平的层数，默认为1。 如果不管有多少层嵌套，都要转成⼀

维数组，可以⽤ Infinity 关键字作为参数。

[1, 2, [3, 4]].flat() // [1, 2, 3, 4] 
[1, 2, [3, [4, 5]]].flat() // [1, 2, 3, [4, 5]]
[1, 2, [3, [4, 5]]].flat(2) // [1, 2, 3, 4, 5] 
[1, [2, [3]]].flat(Infinity) // [1, 2, 3]

flatMap()

该⽅法对原数组的每个成员执⾏⼀个函数（相当于执⾏ Array.prototype.map() ），然后

对返回值组成的数组执⾏ flat() ⽅法。该⽅法返回⼀个新数组，不改变原数组。 该⽅法只能 展开⼀层数组。

// 相当于 [[2, 4], [3, 6], [4, 8]].flat() 
[2, 3, 4].flatMap((x) => [x, x * 2]) // [2, 4, 3, 6, 4, 8]