ES6

http://es6.ruanyifeng.com/

1.ES6中申明变量

let申明变量

（1）let申明变量不可以重复申明

（2）let申明的变量有块级作用域

const 申明常量

（1）const申明变量不可以重复申明

（2）const申明的变量有块级作用域

（3）const申明的变量不可以被赋值

（4）const申明变量的时候必须赋值

2.对象的简写

（1）属性的简写 如果属性名和属性值相同，就可以写成一个

let obj={
name
}

（2）方法简写  省略：function

let obj={
sing(){
  console.log("对象的方法简写")
}
}

 3.对象的解构赋值

let{对象的属性名：对象的属性值}=对象

就会自动申明一个变量，变量的值就是对象中对应的属性值

  let obj={
      name:'张三'
    }
let{name:name1}=obj
console.log(name1)

let{对象的属性名：对象的属性值}=对象

如果对象的属性名和要申明的变量同名

   let obj={
      name:'李四'
    }
let{name}=obj
console.log(name)

    let obj={
      name:'李四',
      age:15
    }
function test({name,age}){
  console.log(name,age)
}
test(obj)

4.数组的解构赋值

（1）

let arr=[1,2,3,4]
   let[num1,num2,num3,num4]=arr;
   console.log(num1,num2,num3,num4)

 let arr=[1,2,3,4]
   let[,,,num4]=arr;
   console.log(num4)

 let arr=[[1,2],[3,4]]
   let[[num1,num2],[num3,num4]]=arr;
   console.log(num1,num2,num3,num4)

（2）...语法在数组解构赋值中叫做RestElement

 let arr=[1,2,3,4,5]
   let[num1,...num2]=arr;
   console.log(num1,num2)

5.箭头函数

（1）基本使用

let f=(参数列表)=>{
    函数体
   }



   let say=()=>{
     console.log('hi,箭头函数')
   }
   say()

（2）箭头函数的简写

如果箭头函数的参数只要一个，可以省略（）

 let double=a=>{
     console.log(a*2)
   }
   double(21)

如果函数的函数体只有一句代码，那么函数体的{ }可以省略

let f=()=>
     console.log('hi')
   f()

let tri=a=>console.log(a*5)
   tri(6)

如果箭头函数的函数体只有一句代码，并且这句话是返回语句，那么return和 { }都可以省略

   let sum=(a,b)=>a+b
  console.log(sum(5,8))

  let square=a=>a*a
  console.log(square(5))

 （3）箭头函数中没有this

如果在箭头函数中使用this，this会向上一级作用域进行查找

 let obj={
    name:'张三',
    say(){
let f=()=>{
  console.log(this)
}
f()
    }
  }
  obj.say()

之前var that=this

let obj={
    name:'张三',
    say(){
      let that=this
setTimeout(function(){
console.log('我叫'+that.name)
},1000)
    }
  }
  obj.say()

用箭头函数  省略 let that=this

  let obj={
    name:'张三',
    say(){
    
setTimeout(()=>{
console.log('我叫'+this.name)
},1000)
    }
  }
  obj.say()

 （4）箭头函数没有arguments

 在箭头函数中，如果要获取不定数量的实参，就可以使用剩余参数

剩余参数是一个真数组

function f(...a){
   console.log(a)
 }
 f(1,2,3,4)

6.函数的默认值

function sum(a=1,b=2){
  return console.log(a+b);
}
sum()

7.使用变量作为属性名

var key='name';
var obj={
  [key]:"李四" 
};
console.log(obj)

8.对象扩展运算符  ...

var obj1={

  name:'zhangs',

  age:19

}

var obj2={...obj1,money:999999}

console.log(obj2)

9....在数组传参时候的用法

将数组所有元素拆解，一次传递给函数形参

function sum(a,b,c){
return a+b+c;
}
var arr=[1,2,3]
console.log(sum(...arr))

10.class关键字的使用

class Person{
  constructor(){
    this.name="zhangs";
    this.age=19
  }
}
var p=new Person()
console.log(p)

 在class中为构造函数添加静态成员

class Person{
  constructor(name,age){
    this.name='name',
    this.age=age
  }
  // 添加实例成员，添加到原型中
  sayHello(){
  console.log('hello')
  }
  // 添加静态成员，添加到Person上
  static sayHi(){
  console.log('Hi')
  }
}
var p=new Person("zhangs",18)
console.log(p)
Person.sayHi()

使用class关键字继承

class Person{
  constructor(){
    this.name='张三',
    this.age=16
  }
  sing(){
    console.log('sing方法')
  }
}
class Student extends Person {
 
}
var p=new Student()
console.log(p)
p.sing()

子类构造函数第一句代码就需要调用一下父类的构造函数

super（）就是父类的构造函数

class Person{
  constructor(){
    this.name='张三',
    this.age=16
  }
  sing(){
    console.log('sing方法')
  }
}
class Student extends Person {
 constructor(){
   super();
   this.stuNumb=110
 }
 coding(){
   console.log('student')
 }
}
var p=new Student()
console.log(p)

 11.模板字符串

反引号

1.模板字符串可以换行

var p=`字符
 串`

2.可以直接在字符串中嵌入变量

 var name='张三'
 var age=40
 var str=`我叫${name},我今年${age}岁了`
console.log(str)