ES6中对象字面看的增强与函数参数默认值

属性和方法的简介表示法：
1、对象字面量是什么：

      // 实例化构造函数生成对象 --- 先new一个对象，然后往对象里面加属性
      const person = new Object();
      person.age = 18;
      person.speak = function () {};

      // 对象字面量
      const person = {
        age: 18,
        speak: function () {}
      };

2、属性的简洁表示法：
键名和变量或常量名一样的时候，可以只写一个。
未用属性的简洁表示法：

	  const age = 18;
      const person = {
        age: age
      };
      console.log(person.age); // 18

用完属性的简介表示法：

      const age = 18;
      const person = {
        // age: age
        age
      };
      console.log(person.age); // 18

3、方法的简洁表示法：
简洁方法可以省略冒号和 function 关键字
以前的写法：

	  const person = {
        speak: function () {}
      };
      console.log(person.speak); // ƒ speak() {}

简洁表示法：

	  const person = {
        speak() {}
      };
      console.log(person.speak); // ƒ speak() {}

方括号语法增强：
1、方括号语法的用法：
以前通过方括号给对象增加属性：

      const prop = 'age';
      const person = {};
      person.prop = 18;
      console.log(person); // {prop: 18}
      // 这种 . 的方法不能奏效，都是通过方括号 [] 来添加的，代码见下一个案例：

      const prop = 'age';
      const person = {};
      person[prop] = 18;
      console.log(person); // {age: 18}

方括号语法简洁表示法：

      // 方括号语法可以写在对象字面量中
      const prop = 'age';
      const person = {
        [prop]: 18
      };
      console.log(person); // {age: 18}

2、方括号中可以放什么：
[值或通过计算可以得到值的（表达式）]：

      const prop = 'age';
      const func = () => 'age2';
      const person = {
        // [prop]: 18 
        // [func()]: 18 
        // ['sex']: 'male'  // 放字符串的时候就显得有点多此一举了，举这个例子是为了告诉你可以这样做，但不需要这样做 直接sex: 'male'（之前的写法）
        ['s' + 'ex']: 'male'
      };
      console.log(person);

3、方括号语法和点语法的区别：
点语法是方括号语法的特殊形式，当属性名由数字、字母、下划线以及 $ 构成，并且数字还不能打头的时候可以使用点语法，即当我们的属性或方法名是合法的标识符的时候可以用 . 语法，其他情况下请使用方括号语法。
函数参数的默认值：
1、认识函数参数的默认值：
调用函数的时候传参了，就用传递的参数；如果没传参，就用默认值。
2、函数参数默认值的基本用法：
之前写法：

      const multiply = (x, y) => {
        if (typeof y === 'undefined') {
          y = 1;
        }
        return x * y;
      };
      console.log(multiply(2)); // 2

改后写法：

  const multiply = (x, y = 1) => x * y;
  console.log(multiply(2)); // 2

函数参数默认值的注意事项：
1、默认值的生效条件：
不传参数，或者明确的传递 undefined 作为参数，只有这两种情况下，默认值才会生效。
举几个例子：

      const multiply = (x, y = 1) => x * y;
      console.log(multiply(2, 0)); // 0

      const multiply = (x, y = 1) => x * y;
      console.log(multiply(2, null)); // 0

这个例子中是0的原因是null不是undefined所以传进去的就是null，在函数里面null又会转换成0，然后再和0相乘，因此结果是0

      const multiply = (x, y = 1) => x * y;
      console.log(multiply(2, undefined)); // 2
      console.log(multiply(2)); // 2
      // 这个例子中，这两句意思一样，要么是undefined，要么是不传

2、默认值表达式：
如果默认值是表达式，默认值表达式是惰性求值的。（这个点在解构赋值里有细讲，这里就不再赘述了）
3、设置默认值的小技巧：
函数参数的默认值，最好从参数列表的右边开始设置。

// 例1：
      const multiply = (x = 1, y) => x * y;
      console.log(multiply(undefined, 2));
      // 调用麻烦，如果第一次参数不想传还必须设置undefined
// 例2：
      const multiply = (x, y = 1) => x * y;
      console.log(multiply(2));
      // 较为方便，不想传第二个参数时直接不写

函数参数默认值的应用：
1、接收很多参数的时候：
要按顺序！（函数传参要按顺序）

	  const logUser = (username = 'ZhangSan', age = 0, sex = 'male') =>
      console.log(username, age, sex);
      logUser('Alex', 18, 'male');
      logUser();

这种写法在实际开发中一般不采用这种方式，因为参数太多其顺序易出错误。
2、接收一个对象作为参数：

	  const logUser = options => console.log(options.username, options.age, options.sex);
	  logUser({
        username: 'alex',
        age: 18,
        sex: 'male'
      });

这种写法看着挺好的，但里面写的东西太多了，可以通过解构赋值解决这个问题。

// 解构赋值的默认值：
      const logUser = ({ username = 'zhangsan', age = 0, sex = 'male' }) => console.log(username, age, sex);
      logUser({ username: 'alex' }); // alex 0 male
      // 但这种写法当 logUser();调用时就会报错
      

logUser();报错的原因很简单，因为什么都不传就是undefined，那就相当于{ username = ‘zhangsan’, age = 0, sex = ‘male’ } = undefined，在解构赋值中知道这种写法是错误的，所以会报错，解决这个错误的办法就是令{ username = ‘zhangsan’, age = 0, sex = ‘male’ } = {} ，这样在什么都不传的情况下就是传进一个空对象，那么解构赋值就会正常的传进去默认值了。具体代码如下：

      const logUser = ({ username = 'zhangsan', age = 0, sex = 'male' } = {}) => console.log(username, age, sex);
      logUser(); // zhangsan 0 male
      logUser({}); // zhangsan 0 male
      logUser({ username: 'alex' }); // alex 0 male

这样写就很nice！