es6新增了很多的属性和方法

一：块级作用域

1：let，没有变量提升，不允许重复声明，都有作用域链，会一直向上级查找，直到全局作用域

let a=10

2：const 声明一定要赋初始值，只是一个可读变量不允许修改(对象、数组除外，引用类型)，不会提升，不可重复声明

const PI=3.1415

二：解构赋值(解析、重构)

1：对象的解析

const note = {
  id: 1,
  title: 'My first note',
  date: '01/01/1970',
}
const { id, title, date } = note

2：数组的解析

const date = ['1970', '12', '01']

// Destructure Array values into variables
const [year, month, day] = date

3：混合解析

const note = {
  title: 'My first note',
  author: {
    firstName: 'Sherlock',
    lastName: 'Holmes',
  },
  tags: ['personal', 'writing', 'investigations'],
}
const {
  title,
  date = new Date(),
  author: { firstName },
  tags: [personalTag, writingTag],
} = note

4：解构传递参数

function sayName({ firstName, lastName } = {}) {
  console.log( firstName + ' ' + lastName );
}
let person = {
  firstName: 'Stephen',
  lastName: 'Curry'
}
sayName(person);

5：解构返回结果，找共性分类

data = {
    value1:'123',
    value2:'222',
    arr1:[1,2,3,4,5],
    value3:'333',
    obj:{
       a:'1',
       b:'2'
    }
}
let {obj,arr1,...values} = data

6：解构字符串

const [a, b, c, d, e] = 'hello';  

7：解构数值和布尔值

let { valueOf } = 12; //Number.prototype.valueOf
let { valueOf } = true; //Boolean.prototype.valueOf

三：spread运算符与rest参数(...)

1：spread运算符(扩展运算符)

let str = "Hello";

alert( [...str] ); // H,e,l,l,o

2：rest参数(剩余运算符)

var [a,...temp]=[1, 2, 4];

四：数组的扩展

1：Array.from()=>创建一个新的浅拷贝实例，不影响原数组

let arr = [1,2,3];
let array = Array.from(arr);

2：Array.of()=>通过可变数量的参数创建一个新的 Array 实例，而不考虑参数的数量或类型

Array.of(7); // [7]                      Array.of 与 Array() 的区别
Array(7); // array of 7 empty slots      一个参数表示长度为7，但是数组为空，7个空元素

3：copyWithin()=>浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度

target=>目标位置

start=>开始复制位置

end=>结束复制位置

const array1 = ['a', 'b', 'c', 'd', 'e'];
console.log(array1.copyWithin(0, 3, 4));  

4：fill()=>用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引

value=>填充值

start =>起始索引

end=>终止索引

const array1 = [1, 2, 3, 4];
console.log(array1.fill(0, 2, 4)); 

5：entries()=>返回一个给定对象自身可枚举属性的键值对数组

let arr = ['one','two','three','four','five'];
for(let [key,val] of arr.entries()) {                
   console.log(key,val);                              // output:   1 'one'   2 'two'  3 'three'  4 'four'  5 'five'
}

6：keys()=>返回一个由一个给定对象的自身可枚举属性组成的数组 ,获取key

for (let key of arr.keys()) {
 console.log(key);
}

7：values()=>返回一个由一个给定对象的自身可枚举属性组成的数组 , 获取值

for (let key of arr.values()) {
 console.log(key);
}

8：find()=>找到匹配到的第一个值。否则返回 undefined

let arr = ['one', 'two', 'three', 'four'];
let result = arr.find(item => item === 'four');

9：findIndex=>找到匹配到的第一个索引。没有找到相应的元素返回 -1

let arr = ['one', 'two', 'three', 'four'];
let result = arr.findIndex(item => item === 'four');

10：includes()=>判断数组是否包含一个指定的值，包含则返回 true，否则返回 false

const array1 = [1, 2, 3];

console.log(array1.includes(2));

11：flat()=>会根据参数进行扁平化数组,对原数组没有影响。

const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat());			

五：函数的扩展

1：箭头函数,没有自己的this,内部并不是指向调用时指向的对象，而是定义时，不能用于构造函数和new关键字调用，使用call、apply、bind无法改变this指向

let fn = (name) => {
    // 函数体
    return `Hello ${name} !`;
};

六：对象的扩展

1：对象的简写

let username='java1234';
let pwd='123456';

let obj={
    username,
    pwd
}

2：属性名表达式

let lastWord = 'last word';

const a = {
  'first word': 'hello',
  [lastWord]: 'world'
};

3：对象的扩展运算符(...)

let person = {name: "Amy", age: 15};
let someone = { ...person };

4：Object.is=>断两个值是否为同一个值

Object.is(NaN,NaN);         // true     解决了NaN不等于NaN的问题
console.log(NaN === NaN);   // false

5：Object.assign()=>合并两个对象，返回新的对象

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source);

6：Object.keys()=>返回一个数组，包含每项的key属性

let obj = {
name:'ling',
age:16
}
console.log(Object.keys(obj))  //[name,age]

7：Object.values()=>返回一个数组，包含每项的值

let obj = {
name:'ling',
age:16
}

console.log(Object.values(obj)) //[ling,16]

七：Match新增方法

1：指数运算符

console.log(2 ** 2); // 4

2：进制写法，二进制(0b/0B,),十进制(0o/0O)

const a = 0B0101
console.log(a)

const b = 0O777
console.log(b)

3：Math.trunc()=>将数字的小数部分去掉，只保留整数部分

let num=Math.trunc(1.03)

4：Math.sign()=>判断一个数字的正数还是负数 还是0 或者是NaN

let num=Math.sign(1)
let num=Math.sign(-5)

5：Math.sqrt()=>平方根

let sum=Math.sqrt(4)

6：Math.cbrt()=>立方根

let sum=Math.cbrt(8)

7：Math.hypot()=>求所有参数平方和的平方根

console.log(Math.hypot(3, 4)); //9+16=25 25的平方根5

八：Number的扩展

1：Number.isFinite(i)=>用来检查一个数值是否为有限

umber.isFinite(15) // true

2：Number.isNaN(i)=>判断是否是NaN

Number.isNaN(NaN) // true

3：Number.isInteger(i)=>判断是否是整数

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

4：Number.parseInt(str)=>将字符串转换为对应的数值

Number.parseInt('12.34') // 12

5：Number.parseFloat()=>将字符串转换为对应的数值

Number.parseFloat('123.45#') // 123.45

九：新增的数据类型

1：Symbol原始数据类型,表示独一无二的值，值通过Symbol函数生成

const a = Symbol();

2：BigInt大整数，用于当整数值大于Number 数据类型支持的范围时，主要解决数值精度值到53个二进制位的问题，主要是在类型后面添加n然后进行计算，

console.log(104545454545454545454524n+112421122n);
console.log(1024n.toString()); //1024

十：新增的数据结构

1：Set,类似于数组，但是成员的值都是唯一的，没有重复的值.可接手数组、类似数组的对象

数组去重：　[...new Set(Array)]

字符串去重：[...new Set('string')].join(' ')

add(value)：添加某个值。

delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。

has(value)：返回一个布尔值，表示该值是否为Set的成员。

clear(value)：清除所有成员。

const set = new Set([1, 2, 3, 4, 4, 4]);
[...set]
//输出结果：[1, 2, 3, 4]

2：Map类似于对象,本质上是键值对的集合,但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键

set()=>设置键名key对应的键值为value，然后返回整个 Map 结构

get()=>get方法读取key对应的键值，如果找不到key，返回undefined

has()=>返回一个布尔值，表示某个键是否在当前 Map 对象之中

size=>返回 Map 结构的成员总数

delete=>方法删除某个键，返回true。如果删除失败，返回false。

clear=>方法清除所有成员，没有返回值。

keys()=>返回键名的遍历器。

values()=>返回键值的遍历器。

entries()=>返回所有成员的遍历器。

forEach()=>遍历 Map 的所有成员

const m = new Map();

map.set('foo', true);

十一：iterator遍历器（Iterator）就是这样一种机制。它是一种接口,为各种不同的数据结构提供统一的访问机制,使得数据结构成员按某种次序排列，创造了新的一种遍历for of循环