ES6语法汇总上

第二章  let 和 const 命令
所有变量都必须用var或者let 或者const赋值 ，都必须声明的同时赋予初值
var ff = []
for (let i = 0;i < 10; i++){  //习惯就是用let  局部作用域
    ff[i] = function () {    //ff是一个数组，每个元素是函数的句柄
        console.log(i)
    }
}
ff[6]()        //6  根据index取出函数句柄后  最后的圆括号别忘了


//局部作用域
var tmp = 123;
if (true) {
    let tmp ='abc'
    console.log(tmp)   //abc
}
console.log(tmp) //123
var tmp = new Date() //重名定义赋值
console.log(tmp)  //2017-11-12T06:12:38.847Z




//慎重 var的变量提升
var tmp = new Date() //重名定义赋值
console.log(tmp)  //2017-11-12T06:12:38.847Z

function f() {
    console.log(tmp)
    if(false){
        var tmp = 'hello world' //闲的蛋疼 干嘛取同名
    }
}

f()  //undefined  代码的原意是，if代码块的外部使用外层的tmp变量，内部使用内层的tmp变量。但是，函数f执行后，输出结果为undefined，原因在于变量提升，导致内层的tmp变量覆盖了外层的tmp变量。



let实际上为 JavaScript 新增了块级作用域。
块级作用域的出现，实际上使得获得广泛应用的立即执行函数表达式（IIFE）不再必要了。


本质上，块级作用域是一个语句，将多个操作封装在一起，没有返回值。
以前在ES5中({。。。}())就是立即执行意思


const的作用域与let命令相同：只在声明所在的块级作用域内有效。



const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心。

const foo = {};

// 为 foo 添加一个属性，可以成功
foo.prop = 123;
foo.prop // 123

// 将 foo 指向另一个对象，就会报错
foo = {}; // TypeError: "foo" is read-only


除了将对象本身冻结，对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。
var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach( (key, i) => {
    if ( typeof obj[key] === 'object' ) {
      constantize( obj[key] );
    }
  });
};


第三章 变量的解构赋值

let [a,b,c] = [1,2,3]
console.log(a)   //1

let [,,third] = ['foo','bar','baz']
console.log(third)   //baz



let [aa,bb,...cc] = [1,2,3]
console.log(aa)  // 1
console.log(bb)  // 2
console.log(cc)  //[ 3 ]

let [xx, yy, ...zz] = ['a'];
console.log(xx)  // a
console.log(yy)  // undefined
console.log(zz)  // []


let [xxx,yyy] = [1,2,3]
console.log(xxx)  //1
console.log(yyy)  //2

let [aaa,[bbb],ddd] = [1,[2,3],4]
console.log(bbb)  //2


// 报错
let [foo] = 1;
let [foo] = false;
let [foo] = NaN;
let [foo] = undefined;
let [foo] = null;
let [foo] = {};
上面的语句都会报错，因为等号右边的值，要么转为对象以后不具备 Iterator 接口（前五个表达式），要么本身就不具备 Iterator 接口（最后一个表达式）。



第四章 字符串的扩展
ES6 加强了对 Unicode 的支持，并且扩展了字符串对象。


第六章   数字
/**
 * Created by Administrator on 2017/11/12.
 */
console.log(0b001100) //12
console.log(0o767)   //503  ，八进制

// 如果要将0b和0o前缀的字符串数值转为十进制，要使用Number方法。
console.log(Number('0b111'))     // 7

console.log(Number.isFinite(15)) //true
console.log(Number.isFinite(NaN)) //false
console.log(NaN)  //NaN
console.log(Number.isFinite(Infinity)) //false
console.log(Number.isFinite(-Infinity)) //false
console.log(Number.isFinite('foo'))  //false
console.log(Number.isFinite('15'))  //false
console.log(Number.isNaN(NaN)) //true
console.log(Number.isNaN(9/NaN))  //true
console.log(Number.isNaN('true'/0))  //true
console.log(Number.isNaN('true'/'true'))   //true


console.log(Number.parseInt('12.34'))  //12
console.log(Number.parseFloat('12.34#$'))  //12.34
console.log(Number.MAX_SAFE_INTEGER)  //9007199254740991
console.log(Number.MIN_SAFE_INTEGER)  //-9007199254740991
console.log(Number.MAX_SAFE_INTEGER === Math.pow(2,53)-1)  //true


// Math对象的扩展
console.log(Math.trunc(2.23))   //2  Math.trunc方法用于去除一个数的小数部分，返回整数部分。
// Math.sign方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。
// Math.cbrt方法用于计算一个数的立方根。
// JavaScript的整数使用32位二进制形式表示，Math.clz32方法返回一个数的32位无符号整数形式有多少个前导0。
// Math.imul方法返回两个数以32位带符号整数形式相乘的结果，返回的也是一个32位的带符号整数。
// Math.fround方法返回一个数的单精度浮点数形式。
// Math.hypot方法返回所有参数的平方和的平方根。
// （1） Math.expm1()  Math.expm1(x)返回ex - 1，即Math.exp(x) - 1。
// （2）Math.log1p()  Math.log1p(x)方法返回1 + x的自然对数，即Math.log(1 + x)。如果x小于-1，返回NaN。
// （3）Math.log10()  /Math.log10(x)返回以10为底的x的对数。如果x小于0，则返回NaN。
// （4）Math.log2()  Math.log2(x)返回以2为底的x的对数。如果x小于0，则返回NaN。

// 双曲函数方法
// ES6新增了6个双曲函数方法。
//
// Math.sinh(x) 返回x的双曲正弦（hyperbolic sine）
// Math.cosh(x) 返回x的双曲余弦（hyperbolic cosine）
// Math.tanh(x) 返回x的双曲正切（hyperbolic tangent）
// Math.asinh(x) 返回x的反双曲正弦（inverse hyperbolic sine）
// Math.acosh(x) 返回x的反双曲余弦（inverse hyperbolic cosine）
// Math.atanh(x) 返回x的反双曲正切（inverse hyperbolic tangent）

// Math.signbit()
// Math.sign()用来判断一个值的正负，但是如果参数是-0，它会返回-0

// ES2016 新增了一个指数运算符（**）。
// 2 ** 2 // 4
// 2 ** 3 // 8



函数
/**
 * Created by Administrator on 2017/11/12.
 */
function log(x, y) {
    y = y||'world'  //检查函数log的参数y有没有赋值，如果没有，则指定默认值为World。这种写法的缺点在于，如果参数y赋值了，但是对应的布尔值为false，则该赋值不起作用。就像上面代码的最后一行，参数y等于空字符，结果被改为默认值。
    console.log(x,y)
}
log('hello')  //hello world
log('hello','china')  //hello china
log('hello','')  //hello world

// ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面。简洁多了
function newLog(x, y = 'world' ) {
    console.log(x,y)
}
newLog('hello','')  //hello world

/**
 * Created by Administrator on 2017/11/12.
 */
console.log('\u0061')  //a
console.log('\uD842\uDFB7')  //