es6 梳理

let 命令

/*
*  let 代码块有效 不存在变量提升
* */

  // let i = "全局";
    var i = "va";//同时使用var let /let let/ 声明i变量 Identifier 'i' has already been declared   /var var不存在

    for(let i = 0; i<3; i++){  //i变量在父级作用域
        console.log(i);//1,2,3
    }

    for(let i = 0; i<3; i++){
        let i = "abc"; // i 变量在子级作用域 且绑定此作用域，不再受外部影响
        console.log(i);//abc 3次
    }
    console.log(i);
    // 

暂时性死区

{
/*
* 暂时性死区，
* 解决：先定义在使用
*/
// tmp = "TDZ" //ReferenceError: not defined => 暂时性死区
    // console.log(tmp);   //ReferenceError: not defined => 未被定义
    let tmp ;   // let存在，即绑定该作用域，tmp在let声明之前不可用
    console.log(tmp); //undefined => 缺少值
    tmp = "TDZ 结束";
    console.log(tmp); //TDZ 结束
    // 暂时性死区  =>
}

typeof命令 数据类型

{
  console.log(
        typeof (123), //number
        typeof ("123"), //string
        typeof (x), //not defined
        typeof (true),//boolean
        typeof ({}), //object
        typeof (function () { //function
            return 123;
        })
    )
    let x; 
    console.log(typeof (x)) // undefined
    }

{
    /*
    * 块级作用域内声明函数，在支持es6的浏览器中会报错
    * 在最顶级作用域中声明函数/ 函数表达式 禁用函数声明语句
    * */
        function f() {
            console.log("123");
        }
        (function () {
            if(false){
                function f() {
                    console.log("===========");
                }
                // f();
            };
            console.log(f); //undefined 变量提升
            f();
        })();
    }

const 命令

    {
        /*
         * const 声明常量 不可变
         * 指向内存地址 
         * */
        const ttt = "常量";
        // ttt = "变量";//Assignment to constant variable.
        // console.log(ttt);
        // const obj = {};
        const obj = {}; //同时声明两个相同的对象 Identifier 'obj' has already been declared
        obj.name = "name";
        console.log(obj);
    }

块级作用域任意嵌套

{
    /*
* 块级作用域任意嵌套
*支持es6的浏览器，块级作用域内函数声明提前
* */
    {
        let abc = "abcd";
        console.log(abc);
        {
            let abc = "12374"
            console.log(abc)
        }
    }
}

变量解构赋值

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

（对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

详细见：http://es6.ruanyifeng.com/#docs/destructuring

模板字符串``

··标识，既可以是普通字符串，又可以添加变量 变量以 ${var}区分

let dog = "大黄";
console.log(`这是${dog}`);//这是大黄

扩展

1.数组

1.0 扩展运算符

...[1,2,3] //复制数组 -- 浅拷贝

[...arr1,...arr3,...arr2] //合并数组  -- 浅拷贝

1.1.Array.from()

// 将类数组转化为数组
let obj = {
	"0":'a',
	"1":'b',
}
let arr = Array.from(obj);//['a','b']
let arr = Array.from('abc');//['a','b','c']

1.2.Array.of()

// 将一组数值转为数组
let arr = Array.of(1,2,3); //[1,2,3]

1.3.find()和findIndex()

// find()返回第一个符合条件的成员
[1,2,3].find((n)=> n = 2) // 2

// findIndex()返回第一个符合条件的成员
[1,2,3].findIndex((n)=> n = 2) // 1

1.4.排序

// sort((s1,s2)=>{})
const arr = [
  'peach',
  'straw',
  'apple',
  'spork'
];

const stableSorting = (s1, s2) => {
  if (s1[0] < s2[0]) return -1;
  return 1;
};

arr.sort(stableSorting)
// ["apple", "peach", "straw", "spork"]

2.对象

2.0 简写

let str = 'abc';
log({str}); //{str:'abc'}

2.1

//待续。。。