ES6（第一部分）

1.let const 和块级作用域

• es6之前只有函数作用域和全局作用域
  {}内形成块级作用域
  if(){} for(){} function(){}

• let具有块级作用域
  不存在变量提升==》先声明再使用
  存在暂时性死区域
  不允许重复声明

for(let i=0;i<10;i++){
let i =123
}

let i{
   let i{
     let i 
  }
}

var arr =[]
for(var i=0;i<10;i++){
(function(j){
    arr[j]=function(){
      console.log(j)
           }
   })(i)
}
console.log(i)

• const
  具有块级作用域
  暂时性死区
  不允许重复声明（不可改变）
  不存在变量提升
• 实质
  const A=123表示a拿到的是123所占用内存的地址
  定义一个对象，可改变属性，引用值可改，原始值不可改

2.变量的结构赋值

• 数组的结构赋值（实质是模式匹配）

let [a,b,c]=[1,2,3]

let [a,b]=[2]

结构失败
a=2 b=undefined

let [a,b]=[1,2,3]

不完全结构
a=1 b=2

let [x=10]=[20]

默认是10，先对应匹配再默认
如果绝对相等undefinded走默认值
如果不绝对相等则走模式匹配的值

function fn(){
return 2
}
let [x=fn()]=[2]
a[0]===undefinded?x=fn():x=3
let [x=y,y=1]=[]=>
let x=y;
let y//报错

• 对象的结构赋值

标准

let {aa:aa,bb:bb}={aa:12,bb:33}

对象的结构赋值无序

let {bar,foo}={bar :123,foo:234}
let {bar,foo}={foo:234,bar:123}

let {foo:bar}={foo:123//相当于123赋值给bar}

let [a,b,c,d]=love''//类数组

let {pow,ceil,floor}=MATH

• 使用场景

swap：let a=1,b=2
[a,b]=[b,a]
函数返回值的结构

3.字符串的扩展

• 模版字符串

var str ='life \n id \n'//换行

增强字符串
在字符串中添加变量和表达式
变量

var x=3,y=5;
var str=`${x}+${y}=${x+y}`

var xm={
name:xm,
age:18,
heigth:180
}
方法
var {age,name,heigth}=xm
var str=`name:${name} age:${age}`

函数

var str =[1,2,3,4,5]
var retr=${arr.map(function(item,index){
   return `${item}:${index}`
})}

• 标签模版
  实质：函数调用的特殊形式
  应用：过滤HTML字符串（防止xss攻击，防注入）
• 函数参数的默认形式

调用函数时，age=undefinded的时候走默认值18

function Person(name,age=18){}

与结构赋值结合使用

function fn(x,y=5){
   console.log(x,y)
}
fn(3)--->undefinded 5
fn({x=1})---> 1 5
fn({x=1,y=2})--->1 2
fn()--->错 无法结构

• 参数作用域及注意事项

function fn(x=5){
  let x=10
}

相当于(报错)
function fn(let x =5){ let x =10 }
同名参数报错

fn(x,x)
let默认声明报错
fn(x,x,z=10){}

• 扩展运算符...arg

x=1
y=[2,3,4,5]
var [x,...y]=[1,2,3,4,5]

合并多个数组
var newArr=[...arr,...arr1,...arr2]

4.数组的扩展

• Array.from()
  把类数组转化为数组
  常见类数组：DOM列表 arguments
  Array.from(类数组，function(item,index){类数组的每一位执行这个函数 })
  应用
  处理节点列表

<div>1</div>
...
var divs =document.getElementsByTagName('div')
var divTest =Array.from(divs,item=>item.innerText)

• Array.of()
  将一组数转化成数组
  var arr=Array.of(1,2,3,4,5)
var arr1=new Array(1,2,3,4,5)
  返回数组[1,2,3,4,5]
  Array.of(6)--->[6]
new Array(6)--->返回一个长度为6的空数组
• 数组实例的方法
  Array.prototype.copewithin(target,start=0,end=this.length)

var arr=[1,2,3,4,5]
arr.copewithin(0,3)--->[4,5,3,4,5]
arr.copewithin(0,3,4)--->[4,2,3,4,5]
支持负数===>倒着数

• fill()
  按照一定的规则填充
  var arr = new Array(5)
arr.fill(7)--->[7,7,7,7,7]
fill(a,从第几位开始填充，填充到哪)

• entries()
  key,values组合
  for([.item,index] of arr.keys())

• keys()
  下标遍历
  arr.keys()
for(item of arr.keys())

• values()
  下标对应的值

• includes()
  includes(b)有则返回true无则返回-1，可判断NaN

可写条件去查询

• find()
  arr.find(item=>item>2)找到满足条件的第一个数

• findIndex()
  arr.findIndex(item=>item>2)找到满足条件的第一个数的下标

• indexOf()
  arr.indexOf()若没找到返回-1，不可判断NaN

5.对象的扩展

• 属性的简洁表示以及属性名表达式

var obj={
name:'xm',
age:18,
getMsg(){
console.log(this.age,this.name)
        }
}

var foo='123'
var name='name',age='age'
var obj={[name]:'xm'}

• 属性的可枚举以及属性的遍历
  Object.getOwnPropertyDescriptor(obj,属性)
  可获取该属性描述的对象
  Object.is()等同于===
  用来判断两个值是否相等
  console.log(NaN===NaN)//false
  console.log(+0===-0)//false
  cosole.log(Object.is(NaN,NaN))//true
  cosole.log(Object.is(+0,-0))//true

• Object.assign()
  将多个愿对象的可枚举属性放到一个对象中

var obj={}
var obj1={name:'xm'}
var obj2={age:18}
var newobj=Object.assign(obj,obj1,obj2)

    如果第一个参数不是对象则会先转换成对象

• 对象的扩展运算符…
  var {a,b,...c}={a:123,b:638,d:222,c:333}
var obj={name:122} var obj1={age:12} var newobj={...obj,...obj1}
  实现合并多个对象

• Object.keys()//返回数组

• Object.values()//返回数组

• Object.entries()//[key,value]

• ES5把方法写在原型上，把属性写在构造函数里