ES6-Array

 /*
              * 数组解构赋值：
              * ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这种被称为解构。
              * 示例如下：
              */
             var [a,b,c] = [1,2,3];
             console.log(a); //可以直接使用。
             //本质上，这种写法属于模式匹配，只要等号两边的模式相同，左边的变量就会被赋予对应的值。
             //如果解构不成功，变量的值就等于undefined
             var [foo] = [];
             console.log(foo);
             var [bar,hoo] = [1];
             console.log(hoo);
                //上边这两种都属于解构不成功
                //下面情况属于不完全解构，但是会成功
                var [m,n] = [1,2,3];
                console.log([m,n]);

                //如果等号右边不是可以遍历的结构，那么将会报错：
 //               let [foo]=1;类似这种，因为转成对象后找不到Iterator接口。{}本身不具备Iterator接口。
             //对于Set结构，也可以使用数组的解构赋值：
             let [x,y,z] = new Set(["a","b","c"]);
             console.log(x);

             //解构赋值允许有默认值
             var [foo = true] = [];
             console.log(foo);
             //ES6内部使用严格相等运算符(===), 判断一个位置是否有值。
             //所以如果一个数组成员不严格等于undefined，默认值是不会生效的。
 //            var [foo = 1] = [k];
             console.log(foo);   //默认值不生效，报错k没有定义
             var [l = 1] = [undefined];
             console.log(l);     //严格等于undefined的时候，默认值才生效。
             //如果默认值是一个表达式，那么这个表达式是惰性求值的，即只有在生效用到的时候才会求值。
             //默认值也可以引用结构赋值的其他变量，但该变量必须已经声明：
             let [p = 1,q=p] = [2];
             console.log([p,q]);

             //数组的扩展
             /*
              * Array.from()将两类对象转换为真正的数组：类似数组的对象和可遍历的对象
              * 包括es6新增数据类型Set和Map。
              * 下面是一个类似数组的对象，Array.from()将它转为真正的数组：
              */
             let arrLike = {
                 "0":"a",
                 "1":"b",
                 "2":"c",
                 length:3
             }
             //es5的写法：
             var arr1 = [].slice.call(arrLike);
             console.log(arr1);
             //es6 的写法
             var arr2 = Array.from(arrLike);
             console.log(arr2);
             //实际应用中，常见的类似数组的对象是DOM操作返回的NodeList集合，以及函数内部arguments对象。
             //Array.from都可以将它们转换为数组。
             //nodelist对象
             let ps = document.querySelectorAll("p");
             Array.from(ps).forEach(function(p){
                 console.log(p);
             })
             //arguments对象
             function test(a,...rest){
                 var args = Array.from(arguments);
                 console.log(args);
             }
             test(1,2,3,4,5,6);
             //只要是部署了Iterator接口的数据，Array.from都可以将它转换为数组。
             console.log(Array.from("hello"));
             let nameSet = new Set(["a","b"]);
             console.log(Array.from(nameSet));
             //如果参数是一个真正的数组，Array.from会返回一个一模一样的新数组。
             //值得注意的是 扩展运算符(...)也可以将某些数据结构转为数组。
             //arguments对象
             function test2(){
                 var args = [...arguments];
                 console.log(args);
             }
             test2(2,4,5,6);
             //nodelist对象
             console.log([...document.querySelectorAll("p")]);

             //任何有length属性的对象，都可以被Array.from转成数组，但扩展运算符在这时候不能转：
             console.log(Array.from({length:3}));
             console.log( [...{length:3}]);  //实际上也转换成功了。 ？？？

             /*
              * 对于没有部署的浏览器可以用Array.prototype.slice方法替代。
              */
             const toArray = (() =>
                 Array.from ? Array.from : obj=>[].slice.call(obj)
             )();

             //Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，
             //将处理后的值放入返回的数组。
             Array.from(arrLike,x=>x*x);
             //等同于
              Array.from(arrLike).map(x=>x*x);

              console.log(Array.from([1,2,3],x=>x*x));

              //用途比较广，dom操作，到数组值得转换，到返回一组数据的数据类型。
              function typesOf(){
                  return Array.from(arguments,value=>typeof value)
              }
              console.log(typesOf("s",1,Number,[]))

              //如果map函数里用到了this关键字，还可以传入Array.from的第三个参数，用来绑定this。

              //只要有一个原始的数据结构，就可以对它的值进行处理，然后转成规范的数组，进而使用数组的方法。
              console.log(Array.from({length:2},()=>"jack"));
              //上面代码中，第一个参数，指定了第二个参数的运行次数，这种特性可以让该方法的方法变得非常灵活。

              //另一个应用是将字符串转为数组，然后返回字符串的长度，这样可以正确处理各种Unicode字符，可以
              //避免将大于\uFFFF的Unicode字符，算作两个字符的bug。

              function countSymbols(string){
                  return Array.from(string).length;
              }

              //Array.of()将一组值，转换为数组。
              console.log(Array.of(3,11,8));
              console.log(Array.of(3));
              console.log(Array.of(3,11,8).length);
              //这个方法的主要目标是弥补数组构造函数的不足。因为参数个数不同，会导致Array()的行为有差异。
              console.log(Array());  //[]
              console.log(Array(3));  //[,,]
              console.log(Array(3,8,4)); //[3,8,4]
              // 上面代码中，Array方法参数为0，1，3时候，返回结果都不一样，只有当参数个数不少于2个时，Array才会返回
              //由参数组成的额数组，一个参数时，实际上是在指定数组长度。

              //Array.of() 基本上可以用来替代Array或new Array(), 并且不存在由于参数不同而导致的重载。行为非常统一。
              //Array.of()总是返回由参数值组成的数组。如果参数没有值，就返回一个空数组。
              //Array.of()可以用下面的代码模拟实现：
              function Arrayof(){
                  return [].slice.call(arguments);
              }

             /*
              * 数组实例的copyWithin
              * 在当前的数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返当前数组，也就是说，使用这个方法，会修改当前数组。
              * Array.prototype.copyWithin(target,start=0,end=this.length);
              * 接收三个参数：
              *    target：从该位置开始替换数据；
              *    start：从该位置开始读取数据，默认为0，如果为负值，表示倒数。
              *    end:到该位置停止读取数据，默认等于数组长度。如果是负值，表示倒数。
              * 这三个都应该是数值，如果不是，自动转换。
              */
             console.log([1,2,3,4,5].copyWithin(0,3));
             //将3号位复制到0号位
             console.log([].copyWithin.call({length:5,3:1},0,3));

             //不再举例

             /*
              * 数组实例的find()和findIndex()
              * find()方法用于找出第一个符合条件的数组成员。它的参数是一个回调函数，
              * 所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。
              * 如果没有符合条件的成员，返回undefined。
              */
             console.log([1,2,-5,7].find(x=>x<0));  //-5
             console.log([1,5,10,15].find(function(value,index,arr){
                 return value > 9;
             }))  //
             //上面代码中，find的回调函数有三个参数，值，索引，原数组。

             //findIndex方法的用法与find方法非常类似，返回一个符合条件的数组成员的索引，都不符合就返回-1。
              console.log([1,5,10,15].findIndex(function(value,index,arr){
                 return value > 9;
             }))  //2 索引
             //这两个方法都可以接受第二个参数，用来绑定回调函数的this对象。
              //另外这两个方法都可以发现NaN，弥补了数组IndexOf方法的不足。
              console.log([NaN].indexOf(NaN))  //-1
              console.log([NaN].findIndex(y=>Object.is(NaN,y)));  //
              /*
               * 关于Object.is()  多数时候与"===" 等价，
               * 但对于NaN、0、+0、 -0，则和 “===” 不同。
               * 也就是用Object.is(NaN，NaN) //true
               * Object.is(0,-0) //false
               * Object.is(+0,-0) //false
               */

              /*
               * 数组实例的fill()
               * 使用给定值，填充一个数组。相当于重写。
               * 接受第二和第三个参数，用于指定填充的起始位置和结束位置（不包括结束的位置）。
               */
              console.log([1,2,3].fill("a"));  //[a,a,a]
              console.log(new Array(3).fill(4));  //[4,4,4]
              console.log([1,2,3,4,5,6].fill("a",2,4))  //[1,2,a,a,5,6]

              /*
               * 数组实例的entries(),keys(),values()用于遍历数组。
               * 都返回一个Iterator对象，用for of循环，区别是
               * keys()是对键名的遍历，values()是对键值的遍历，entries是对键值对的遍历。
               */
              for(let index of ["a","b"].keys()){
                  console.log("index：",index);
              }
              for(let ele of [1,2,3]){
                 //values这个方法好像找不到了。应该换成了这样的写法
                  console.log("value：",ele);
              }
              for(let [index,ele] of ["a","b"].entries()){
                  console.log("key-val：",index,ele);
              }
              //下面这个倒是可以用的，但是是绑定在Object上的。
             var obj = {"a":"html","b":"javascript"};
             console.log(Object.values(obj));
         //如果不使用for of循环，可以用手动的next进行遍历：
         let letter = ["a","b","v"];
         let entries = letter.entries();
         console.log(entries.next().value);
         console.log(entries.next().value);
         console.log(entries.next().value);
         console.log(entries.next().value); //超过了长度就是undefined

         /*
          * 数组实例的includes(),返回一个布尔值，表示某个数组是否包含给定的值，与字符串的
          * includes类似，属于es7，但babel已经支持。
         */
         console.log([1,2,3].includes(2));  //true
         console.log([1,2,3].includes(4));  //false
         console.log([1,2,NaN].includes(NaN)); //true
         //该方法的第二个参数表示搜索的起始位置，默认为0，如果第二个参数为负数，
         //表示倒数，如果这是它大于数组的长度，则会重置为从0开始。
         //没有这个方法之前，都是用数组的indexOf方法，检查是否包含某个值。
         //indexOf的缺点：不够语义化，他要找到参数出现的第一个位置，所以要和-1比较，
         //            内部使用===判断，对NaN误判。
         console.log([NaN].includes(NaN));  //true
         //下面的代码检查当前环境是否支持该方法，如果不支持，部署一个简易版本：
         const contains = (()=>
             Array.prototype.includes?(arr,value)=>arr.includes(value)
             :(arr,value)=>arr.some(el=>el===value)
         )();
         console.log(contains(["foo","baz"],"baz"));
         /*
          *另外，Map和Set数据结构有一个has方法，需要注意与includes区分。
          * Map的has方法，用来查找键名的。
          * Set的has方法，用来查找值的。
          */

         /*
          * 数组的空位：
          * 空位不是undefined，一个位置的值等于undefined，依然是有值的。
          * 空位是米有任何值的。
          */
         console.log( 0 in [undefined]);  //true
         console.log( 0 in [,]);    //false
         /*
          * 上面代码说明，第一个数组的0号位置是有值的，第二个数组的0号位是没有值的。
          * es5对空位的处理很不一致，大多数情况，跳过空位。
          * forEach(),filter(),every(),some()都会跳过空位。
          * map()会跳过空位，但会保留这个值
          * join()和toString()会将空位视为undefined，而undefined和null会被
          * 处理成空字符串。
          *
          * es6明确将空位转为undefined。
          * Array.from会将数组的空位转为undefined，也就是不会忽略空位。
          */
         console.log(Array.from(["a",,"b"])); //[a,undefined,b]
         //扩展运算符也将空位转为undefined
         console.log([...["a",,"b"]]);  //[1,undefined,2]
         //上面代码实测的时候，结果是[a,2:b]; 并没有undefined。

依赖文件地址：https://github.com/chanceLe/ES6-Basic-Syntax/tree/master/js