ES6 数组、字符串操作

一、find()是一个查找回调函数，用来查找目标元素，找到数组中符合当前搜索规则的第一个元素，返回它，并且终止搜索。找不到返回undefined。

    查找函数有三个参数。
    value：每一次迭代查找的数组元素。
    index：每一次迭代查找的数组元素索引。
    arr：被查找的数组。
    [1, 2, 3, 4].find((value, index, arr) => {
        return  value > 3
    }) //4
    [1,2,3,4].find(value =>typeof value > 4) //undefined

二、findIndex()是一个查找回调函数，用来查找目标元素，找到数组中符合当前搜索规则的第一个元素，返回它的下标，终止搜索。找不到就返回-1。

    查找函数有三个参数。
    value：每一次迭代查找的数组元素。
    index：每一次迭代查找的数组元素索引。
    arr：被查找的数组。
    [1, 2, 3, 4].findIndex((value, index, arr) => {
            return value > 3
    }) //3
    [1,2,3,4].findIndex(value =>typeof value > 4) //-1

三、fill()是一个替换函数，用新元素替换掉数组内的元素，可以指定替换下标范围。

    value：填充值。
    start：填充起始位置，可以省略。
    end：填充结束位置，可以省略，实际结束位置是end-1。
    arr.fill(value, start, end)
    [1,2,3,4,5].fill(7, 1, 3); //[1,7,7,7,5]

四、copyWithin()是一个复制函数，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。

    target （必需）：从该位置开始替换数据。
    start （可选）：从该位置开始读取数据，默认为 0 。如果为负值，表示倒数。
    end （可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。
    arr.copyWithin(target, start = 0, end = this.length)
    [1, 2, 3, 4, 5].copyWithin(0, 3, 4);  、 [1, 2, 3, 4, 5].copyWithin(0, -2, -1);  
    //[4,2,3,4,5]将3号位复制到0号位

五、push()方法可向数组的末尾添加一个或多个元素，并返回新的长度。

    let arr = [1,2,3];
    var les = arr.push('a');
    //arr = [1,2,3,'a']
    //les = 4

六、unshift()方法是向数组的开头添加一个或多个元素，并且返回新的长度。

    let arr = Array.of(1,2,3);
    let res = arr.unshift('a');
    //arr = ['a', 1, 2, 3] 、res = 4

七、pop()方法用于删除并返回数组的最后一个元素。如果数组是空的，pop()方法将不进行任何操作，返回undefined的值。

    let arr = ['a','b','c'];
  let resEle = arr.pop();
    //arr = [ 'a',' b' ] 、resEle = c

八、shift()方法用于删除并返回数组的第一个元素。如果数组是空的，shift()方法将不进行任何操作，返回undefined的值。

    let arr = ['a','b','c'];
    let res = arr.shift();
    //arr = ['b','c'] 、res = a

九、concat()方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

    let arr = [1,2,3];
    let arr2 = [1,2,3];
    let resArr = arr.concat(arr2);
    //arr = [1,2,3] 、arr2 = [1,2,3] 、resArr = [1,2,3,1,2,3]

十、join()方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。

    let arr = [1,2,3];
    let resStr = arr.join(",");
    //arr = [ 1, 2, 3 ] 、resStr = 1,2,3

十一、sort()方法用于对数组的元素进行排序。

    排序不是按整型大小，而是字符串对比，取第一个字符的ANSI码对比，小的排前面，相同的话取第二个字符再比：
    let arr = Array.of(3, 11, 8);
    let res = arr.sort();
    //arr = [ 11, 3, 8 ] 、res = [11, 3, 8]
    要按整型数值比较，可以这样：
    let arr = Array.of(3, 11, 8);
    let res = arr.sort((a, b) => a - b);
    //arr = [ 3, 8, 11 ] 、res = [3, 8, 11]

十二、reverse()方法用于颠倒数组中元素的顺序。

    let arr = Array.of(3, 11, 8, 9);
    let res = arr.reverse();
    //arr = [ 9, 8, 11, 3 ] 、res = [9, 8, 11, 3]

十三、Array.of()与Array()的异同，生成数组，当传入单个参数时，Array()的行为表现的不统一。Array.of的行为很统一。

    Array.of() // []
    Array.of(3) // [ 3 ]
    Array.of(3, 11, 8) // [ 3, 11, 8 ]
    Array.of(undefined) // [undefined]
    Array() // []
    Array(3) // [ , ,  ]
    Array(3, 11, 8) // [ 3, 11, 8 ]

十四、splice()方法用于删除元素/添加新元素。

    函数有三个参数：
    start: 开始操作的索引
    deleteCount：要移除的数组元素的个数
    item:要添加进数组的元素，如果不指定，则splice只删除数组元素
    array.splice(start,deleteCount,item);

十五、slice()方法用于复制数组元素到新数组。

    函数有二个参数：
    start: 开始操作的索引
    end:结束操作的索引
    注：start <= newArray < end
    array.slice(start, end)
    let arr = Array.of(1,2,3,4,5);
    let res = arr.slice(1,3);
    //arr = [1,2,3,4,5] 、res = [2,3]

十六、includes()方法用于从一维数组或字符串中查找某指定的值，如果有，则返回true，否则false。

    方法有二个参数：
    value:查找的值
    start（可选）:开始向后查询的索引,
    arr.includes(value, start);

十七、startsWith()方法用于从字符串中正序查找某指定的值，如果有，则返回true，否则false。

    方法有二个参数：
    walue:查找的值
    start（可选）:开始向后查询的索引
    arr.startsWith(value,start);

十八、endsWith()方法用于从字符串中倒序查找某指定的值，如果有，则返回true，否则false。

    方法有二个参数：
    value:查找的值
    end（可选）:开始向前查询的索引(倒序的索引)
    arr.endsWith(value,end);

十九、indexOf()方法用于从一维数组或字符串中查询某指定的值，如果有，则返回元素所在索引，否则返回-1。

    方法有二个参数：
    value:查找的值
    start（可选）:开始查询的索引位置(默认正序查询，负值倒序查询)
    arr.indexOf(value,start);

二十、lastIndexOf()方法用于从一维数组或字符串中倒序查询某指定的值，如果有，则返回元素所在索引，否则返回-1。

    方法有二个参数：
    value:查询的值
    start（可选）:开始查询的索引位置（倒序索引位置）
    arr.lastIndexOf(value,start);

二一、forEach()方法用于遍历数组。

    函数有三个参数：
    value:表示当前项的值，
    key:表示当前索引，
    item:表示数组本身
    array.forEach((value, key, item) => {})

二二、every()和 some()方法用于确定数组的所有成员是否满足指定的测试。

    every()一假即假，必须所有都返回true才会返回true;
    some()一真即真，只要其中一个为true 就会返回true ;
    方法有三个参数：
    value:表示当前项的值；
    key:表示当前的索引；
    item:表示数组本身
    const arr = [
        {name:"Apple",ram:8},
        {name:"IBM",ram:4},
        {name:"Acer",ram:32},
    ];
    var result= arr.every((value,key,item) => {
            return value.ram > 16
    })   //false;
    var some = arr.some((value,key,item) => {
            return value.ram > 16
    })   //true

let和const都能够声明块级作用域，都是在当前块内有效，执行到块外会被销毁，也不存在变量提升（TDZ）。
let的特点是不会变量提升，而是被锁在当前块中。
const 声明常量，一旦声明，不可更改，而且常量必须初始化赋值。 const虽然是常量，不允许修改默认赋值，但如果定义的是对象Object，那么可以修改对象内部的属性值。