//ES6对象
let Person = {
    name:'haha',
    sex:'female',
    age:18
}
let person = new Proxy(Person,{
    get(target,key){
        return target[key];
    },
    set(target,key,value){
        if(key !== 'sex'){
            target[key] = value;
        }
        return target[key];
    }
})

ES5数组合并用数组的concat()方法，ES6利用扩展运算符

...a是ES6中的可变参数，在不确定的时候传值方便

《ECMAScript 6 入门》

http://es6.ruanyifeng.com/

https://github.com/cucygh/fe-material

常量

作用域

箭头函数

默认参数

对象代理

好基础，随便看10分钟书就结束了

es6已经成为了各大框架的基础，不错不错，有点意思

一、对象代理

什么是对象代理？比如我们封装了一组数据，通过访问代理，对数据访问做限制，而用户访问的是代理层，而不是源数据。这样就数据进行保护。

二、es3,es5,es6中的对象代理

{
  // es3,闭包方式保护
  var Person = function() {
    var data = {
      name: 'es3',
      sex: 'male',
      age: 15
    }
    this.get = function(key) {
      return data[key];
    };
    this.set = function(key) {
      if (key != 'sex') {
        data[key] = value;
      }
    };
  }
  // 声明一个实例
  var person = new Person();
  // 读取
  console.table({
    name: person.get('name'),
    sex: person.get('sex'),
    age: person.get('age')
    }
  );
  // 修改
  person.set('name', 'es3-cname');
  console.table({
      name: person.get('name'),
      sex: person.get('sex'),
      age: person.get('age')
    }
  );
  person.set('sex', 'female');
  console.table({
      name: person.get('name'),
      sex: person.get('sex'),
      age: person.get('age')
    }
  );
}
{
  // es5
  var Person = {
    name: 'es5',
    age: 15,
    sex: 'male'
  }
  Object.defineProperty(Person, 'sex', {
    writable: false,
    value: 'male'
  });
  console.table({
    name: Person.name,
    sex: Person.sex,
    age: Person.age
  });
  Person.sex = 'female';
  // 如果改变sex的值，会报错：cannot assign to read only property 'sex' of object '#<object>'，为了不影响执行，可用try...catch
}

{
  // es6
  let Person = {
    name: 'es6',
    sex: 'male',
    age: 15
  };
  let Person = new Proxy(Person, { // ES6原生语法代理 : let  object = new Proxy() ;  object 为 用户访问操作的代理对象，而不是原始对象
    get(target, key) {
      return target[key];
    },
    set(target, key) { // 既不影响get，又与业务代码隔离
      if (key !== 'sex') {
        target[key] = value;
      }
    }
  });
  console.table({
    name: Person.name,
    sex: Person.sex,
    age: Person.age
  });
  try {
    person.sex = 'female';
  } catch(e) {
    console.log(e);
  } finally{
    
  }
}

二、进阶

{
  // es3,es5
  function f() {
    var a = Array.prototype.slice.call(arguments); // call之后能将参数转换成数组
    a.forEach(function(item) {
      sum += item * 1; // 能将字符串类型转换成数值类型
    })
    return sum;
  }
  console.log(f(1, 2, 3))
}
{
  // es6
  function f(...a) { // ...a :...扩展运算符，a是一个可变长度参数的列表，而且是个数组
    var sum = 0;
    a.forEach(item => {
      sum += item * 1;
    });
    return sum;
  }
}
{
  // es5合并数组
  var params = ['hello', true, 7];
  var other = [1, 2].concat(param);
  console.log(other);
}
{
  // es6 利用扩展运算符合并数组
  var params = ['hello', true, 7];
  var other = [1, 2, ...params];
  console.log(other);
}

一、es6可以用()=> {}声明函数，这样声明的好处：

（1）省去function，写法简单。

（2）this的指向有了新的意义。

二、es6方法：

let odds = evens.map(v => v + 1)

三、this指向

（1）es3/es5: this的指向是该函数被调用的指向。

var factory = function() {
  this.a = 'a';
  this.b = 'b';
  this.c = {
    a: 'a+',
    b: function() {
      return this.a
    }
  }
}
console.log(new factory().c.b());

new factory(),c.b()中，b()是c调用的，所以this指向c，得到的是a+。

（2）箭头函数中this的指向是定义时this的指向。

b在定义函数时，this指向这个函数体中的this，函数体中的this指向factory这个构造函数的实例。this指向factory的实例，所以this.a 就是'a'。

一、常量写法：

（1）es5

Object.defineProperty(window, 'PI2', {

    value: 3.1415926,

    writable:false

}

（2）es6

const PI = 3.1415926

git clone https:///github.com/cucygh/es6-webpack.git

一、callbacks中的return i*2，是对变量的引用，而不是对函数变量值的引用。函数体中是一个变量，而不是一个值。

二、用let声明的变量有块作用域的概念，这个时候的闭包取决于当前的块作用域，会将当前值保存，供后面的闭包使用。

三、es6:{}表示一个新的作用域，{}可以对作用域进行隔离。

es5中要执行立即执行函数（(function(){},()），才能对作用域进行隔离。