es6声明和表达式学习小结

---

解构赋值

---

概念

ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构赋值。

如下面变量赋值

var a=1;
var b=2;
var c=3;

在ES6语法中可以写为

var [a,b,c]=[1,2,3];    // 等号两边的模式相同

如果解构不成功，变量的值就等于undefined。

如果等号的右边不是数组（不是可遍历的结构），将会报错。

解构赋值不仅适用于var命令，也适用于let和const命令。

---

设置默认值

解构赋值允许指定默认值。当等式右边没值或是undefined时，使用默认值。

语法 let [变量=默认值]=[赋值]

let [num=2]=[];    // 输出为2
let [num1,num2=10]=[5];     //输出 num1为5, num2为10
let [x = 1, y = x] = [];     // x=1; y=1
let [x = 1, y = x] = [2];    // x=2; y=2
let [x = 1, y = x] = [1, 2];     // x=1; y=2
let [x = y, y = 1] = [];     // 报错,因为x用到默认值y时，y还没有声明
[x, y = 'b'] = ['a', undefined];     // x='a', y='b'

---

对象的解构赋值

对象的解构赋值的内部机制是：先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者。

var { foo: foo, bar: bar } = { foo: "aaa", bar: "bbb" };    // foo：aaa，bar：bbb

---

字符串的解构赋值

字符串也可以解构赋值。这是因为，此时的字符串被转换成了一个类似数组的对象。

  let [a, b, c, d] = 'nice';     // a为n，b为i，c为c，d为e

类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。

let {length : name} = 'hello'; 
console.log(name)        // len：5

---

函数参数的解构赋值

函数的参数也可以使用解构赋值。

function add([x, y]){

  return x + y;

}

add([1, 2]);     // 3

上面代码中，函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们接收的参数就是x和y。

函数参数的解构也可以使用默认值。

---

let和const

---

let

ES6新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。

---

let不存在变量提升

变量的提升：javascript并不是严格的自上而下执行的语言，它会将当前作用域的所有变量的声明提升到程序的顶部。

如下面代码，变量aa未声明就赋值，赋值完再用var声明，最后输出aa是不会报错的。

但是，使用 let声明变量，在赋值前未声明会报错。

aa=2222;
var aa;
console.log(aa)  //输出2222，当换成 let aa会报错

下面代码输出undefined的原因是 js会将变量的声明提升到顶部，可是赋值语句并不会提升。同样使用let声明就会报错。

console.log(aa)  // 输出undefined
var aa=2222;    // 实际上是分两步执行  var aa；aa=2222；

---

let 暂时性死区

var num=111;
if(1){
    console.log(num);
    let num=222;    //块级作用域内let又声明了一个局部变量num，导致后者绑定这个块级作用域
}

ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量就会报错。

总之，在代码块内使用let命令声明变量之前，该变量都是不可用的。

这在语法上，称为“暂时性死区”（temporal dead zone，简称TDZ）。

---

let 不能重复声明同个变量

let不允许在相同作用域内，重复声明同一个变量。

let num=111;
let num=222;  // 报错内容：Identifier 'num' has already been declared

---

const

const 声明一个只读的常量。一旦声明，常量的值就不能改变。

const num=123;
num=456    // 报错内容：TypeError: Assignment to constant variable.

console.log(num)

const声明的变量不得改变值，这意味着，const一旦声明变量就必须立即初始化，不能留到以后赋值。

只声明不赋值同样会报错。

const命令声明的常量和let类似，也是不能变量的提升，同样存在暂时性死区，只能在声明的位置后面使用，只在声明所在的块级作用域内有效，不可重复声明。

---

const声明的数组

const aa= []; 
aa.push('firstNumber');     // 可执行 
aa.length = 0;      // 可执行 
aa= ['secondNumber'];      // 报错

以上代码说明，const定义的数组本身进行操作是不会报错的，但是将另一个数组赋值给aa会产生错误，因为const声明的常量不能重新赋值。

---

Symbol数据类型

---

概述

ES5的对象属性名都是字符串，这容易造成属性名的冲突。

ES6引入了一种新的原始数据类型Symbol，表示独一无二的值。

它是JavaScript语言的第七种数据类型，前六种是：Undefined、Null、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）。

Symbol值通过Symbol函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的Symbol类型。

凡是属性名属于Symbol类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。

let s = Symbol();
console.log(typeof s)        //  symbol

上面代码中，变量s就是一个独一无二的值。typeof运算符的结果，表明变量s是Symbol数据类型，而不是字符串之类的其他类型。

Symbol函数可以接受一个字符串作为参数，表示对Symbol实例的描述。这主要是为了在控制台显示或者转为字符串时，比较容易区分。

var s1 = Symbol('foo');
var s2 = Symbol('bar');

console.log(s1,s2)    //  Symbol(foo)   Symbol(bar)          如果不加参数，输出都是Symbol，不能区分

每个Symbol类型都是**独一无二的值,**体现在下面这段代码中：

var a= Symbol("aaa");
var b= Symbol("aaa");

a===b         //    false    a和b是不相等的

Symbol值不能与其他类型的值进行运算，会报错。但是，Symbol值可以显式转为字符串。

 var sym = Symbol('a symbol');

//两种方法都可以转为字符串

String(sym)     //  'Symbol(a symbol)'
sym.toString()     //  'Symbol(a symbol)'

---

作为属性名的Symbol

由于每一个Symbol值都是不相等的，这意味着Symbol值可以作为标识符用于对象的属性名，这就能保证不会出现同名的属性。

两种写法：

let name = Symbol();

// 第一种写法
let student= {};
student[name] = 'jack!';    //  Symbol值name作为student的属性


// 第二种写法
let student= {
  [name]: 'jack!'        //注意要使用方括号包裹，不放在方括号中，该属性的键名就是字符串
};

Symbol值作为对象属性名时，不能用点运算符，要使用方括号。

取值对象的Symbol类型的属性也要用方括号。

普通属性是直接用点运算符:

student.name= 'jack';

---

Symbol类型定义常量

Symbol类型还可以用于定义一组常量，保证这组常量的值都是不相等的。

levels = {
  DEBUG: Symbol('debug'),
  INFO: Symbol('info'),
  WARN: Symbol('warn')
};

console.log(levels.DEBUG)        //  Symbol(debug)
console.log(levels.INFO)           //   Symbol(info)
console.log(levels.WARN)         //  Symbol(warn)

常量使用Symbol值最大的好处，就是其他任何值都不可能有相同的值了。

---

属性名的遍历

Symbol 作为属性名，该属性不会出现在for…in、for…of循环中，也不会被Object.keys()、JSON.stringify()等返回。

ES6中有一个Object.getOwnPropertySymbols方法，可以获取指定对象的所有 Symbol 属性名，返回的是一个数组。

var obj = {};

var name = Symbol('name');
var age = Symbol('age');
obj[name] = 'huang';
obj[age] = '23';

var objectSymbols = Object.getOwnPropertySymbols(obj);        // 是个数组，可以用for循环遍历
console.log(objectSymbols)        //  [ Symbol(name), Symbol(age) ]
console.log(obj[name])        //  huang     取出Symbol类型的属性要用方括号

// 遍历数组里的属性
for(var i in objectSymbols){

	console.log(objectSymbols[i])

}

另一个新的API，Reflect.ownKeys方法可以返回对象的属性所有类型的键名，包括常规键名和 Symbol 键名。

语法 Reflect.ownKeys(对象名)

var name = Symbol('name');
var age = Symbol('age');

var obj = {
    [name] : 'huang',    //  Symbol类型属性
    [age] : '23',        //  Symbol类型属性
    num : 1        //  普通属性
};

console.log(  Reflect.ownKeys(obj)  )            // [ 'num', Symbol(name), Symbol(age) ]    返回值是数组

---

Symbol.for()，Symbol.keyFor()

Symbol.for方法可以重新使用同一个Symbol值。

它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的Symbol值。如果有，就返回这个Symbol值，否则就新建并返回一个以该字符串为名称的Symbol值。

var n1 = Symbol.for('foo');
var n2 = Symbol.for('foo');
console.log(   n1 === n2 )       // true         n1 n2 实际上是同一个值

Symbol.for方法和Symbol是不一样的，Symbol每次都是创建一个新的，Symbol.for只有不存在时才创建新的。

Symbol.for("foo") === Symbol.for("foo")        // true
Symbol("foo") === Symbol("foo")         // false

Symbol.for为Symbol值登记的名字，是全局环境的。Symbol.keyFor方法返回一个已登记的 Symbol 类型值的key。

var s1 = Symbol.for("foo");
Symbol.keyFor(s1)             // "foo"       使用Symbol.for有登记名字

var s2 = Symbol("foo");
Symbol.keyFor(s2)             // undefined        使用Symbol未登记名字

---

单例中使用Symbol

单例（Singleton）指的是调用一个类，任何时候返回的都是同一个实例。

const FOO_KEY = Symbol.for('foo');        // 使FOO_KEY变成Symbol类型

function A() { 

  this.foo = 'hello';
}

if (!global[FOO_KEY]) {    //  如果不存这个实例创建新的，存在就跳过

    global[FOO_KEY] = new A();           // 创建一个新的实例，把实例放到顶层对象global
}

module.exports = global[FOO_KEY];        // 暴露这个实例，可以被其他文件引用

上面代码中，可以保证global[FOO_KEY]不会被无意间覆盖，因为Symbol.for方法只有在不存在的情况下才创建新的。

要改写global[FOO_KEY]的值的方法如下：

 global[Symbol.for('foo')] = 123;


function A() { 

  this.foo = 'hello';
}

if (!global[FOO_KEY]) {    //  如果不存这个实例创建新的，存在就跳过

    global[FOO_KEY] = new A();           // 创建一个新的实例，把实例放到顶层对象global
}

module.exports = global[FOO_KEY];        // 暴露这个实例，可以被其他文件引用

上面代码中，可以保证global[FOO_KEY]不会被无意间覆盖，因为Symbol.for方法只有在不存在的情况下才创建新的。

要改写global[FOO_KEY]的值的方法如下：

 global[Symbol.for('foo')] = 123;