常量

ES6中定义了常量 const ，常量只读不可以进行修改

//ES5中常量得这么写
Object.defineProperty(window, "demaxiya",{
    value: 'nuokesasi',
    writable: false
})
console.log(demaxiya)  //输出  nuokesasi
demaxiya = aioniya  //报错
//强大的ES6
const demo = 'lalalademaxiya'
console.log(demo) //输出  lalalademaxiya
demo = 'lalalalualua'  //报错

作用域

ES6用｛｝来划分一个作用域

{
    let a = 5
    console.log(a)  //输出5
}
{
  let a = 50
  console.log(a)  //输出50
}
{
  let a = 500
  console.log(a)  //输出500
}
{
  let a = 5000
  console.log(a)  //输出5000
}
console.log(a)  //输出undefined

像上面那样，在块级作用域里面用let定义一个变量，let跟var的作用差不多，但是let定义的变量只在作用域范围内有效，所以在var跟let都能用的情况下推荐使用let来定义变量

箭头函数

//es6之前定义一个函数
function a() {
  xxx
}
//在es6中你可以这么定义
()=>{
  xxx
}
//举个栗子
//es6之前
var demo = function(x,y) { 
    return x + y
}
console.log(demo(5,6))  //输出11
//在es6中你可以这么写
var demoA = (x,y) => x+y
console.log(demoA(5,6))  //输出11
//甚至如果参数只有一个的话你看一连括号都省略了
//es6之前
var demo = function(x) { 
    return x+1
}
//在es6中你可以这么写
var demoA = x => x + 1

ES6确实是猛的一批.....

箭头函数的this指向问题

var factory = function() {
  this.a = 'a'
  this.b = { 
        a : 'aaaa',
        b: function () {
              return this.a
        }
  ｝
}
console.log(new factory().b.b())  // 输出‘aaaa’

//es6
let factory = function() {
  this.a = 'a'
  this.b = { 
        a : 'aaaa',
        b: () => {
              return this.a
        }
  ｝
}
console.log(new factory().b.b())  // 输出‘a’

函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。这个是重点

默认参数

let demo = function (x, y = 5) {
    return x + y
}
console.log(demo(5)) //输出为10
console.log(demo(5，10)) //输出为15

es6中可以像上面那样定义一个默认参数，如果该参数没有赋值，则调用默认参数作为参数

可变参数

当你不确定你参数的个数的时候，你可以使用可变参数

//实现加数不定的加法运算
function f(...a) {  //...是扩展运算符
  let sun = 0
  a.forEach(item => {
    sum+=item
  })
}

扩展运算符 ...

扩展运算符你可以这么用

let arr = [1,2,3,4,5]
//合并数组
let arr1 = [1,2,3,4,...arr]
console.log(arr1) // 1,2,3,4,1,2,3,4,5

以上就是我对ES6基础的一点点总结

ES6好玩的地方远远不止于这么丢丢，大家一起继续探索吧