数组去重

…set(array)去重

{
    let array = ['aa',12,'aa',16,12,'ab'];
    function dedupe(array) { //es6
        return [...new Set(array)] 
    }
    dedupe(array);
    //等价于
    Array.from(new Set(array));
}

array.filter()要领去重

{
    let array = ['aa',12,'aa',16,12,'ab'];
    array.filter((item, index) => {
        return array.indexOf(item) == index;
    });
}

数组翻转

reverse()

{
    let arr = ['a','b','c',1,3];
    arr.reverse(); 
}

返回效果： [3, 1, “c”, “b”, “a”]

衔接两个或多个数组

concat() 要领

concat() 要领用于衔接两个或多个数组,该要领不会转变现有的数组，而仅仅会返回被衔接数组的一个副本
arr0.concat(arr1, arr2, arr3, ……, arrx);
例：

{
    [1,2,3].concat(4,5)
    
    [1,2,3].concat([4,5],6)
    
    [1,2,3].concat([4,5],[6,7,8])
}

返回效果：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8]

… 要领

es6 扩大运算符，最简朴的写法，一万个引荐！！！

{
    let arr = ['1s','2s','3s',4];
    let arr2 = ['1a','2a'];
    console.log([...arr,...arr2]);
}

返回效果：[“1s”, “2s”, “3s”, 4, “1a”, “2a”]

push() 要领

push()把一个或多个参数附加在数组末端，返回数组长度。转变数组本身。

{
    let a = ['a','b','v'];
    let b = ['c','d','g'];
    a.push(...b)
    console.log(a)
}

返回效果：[“a”, “b”, “v”, “c”, “d”, “g”]
注重： push()要领返回的是数组长度，如上示例，console.log(a.push(…b))返回值为6

unshift() 要领

unshift()把一个或多个参数插进去到数组头部，返回数组长度。转变数组本身。

{
    let arr = [1, 2, 3];
    let count = arr.unshift(4, 5);

    console.log(count); 
    console.log(arr); 
}

返回效果：
5
[4, 5, 1, 2, 3]

数组与字符串互相转化

数组转字符串

join()要领，Array.join(标识符)

{
    ['as2',12,'ss'].join('/');
}

返回效果：”as2/12/ss”

字符串转数组

split()要领，string.split(标识符)

{
    "as2/12/ss".split('/')
}

返回效果：[“as2”, “12”, “ss”]

数组删除、插进去、替代

arrayObject.splice(index,howmany,item1,…..,itemX)

参数形貌：
index：必需。整数，划定增加/删除项目的位置，运用负数可从数组末端处划定位置。
howmany：必需。要删除的项目数目。假如设置为 0，则不会删除项目。
item1, …, itemX 可选。向数组增加的新项目。
返回值：
范例形貌：Array 包括被删除项目的新数组，假如有的话。
申明：splice() 要领可删除从 index 处最先的零个或多个元素，而且用参数列表中声明的一个或多个值来替代那些被删除的元素。

假如从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。

splice插进去操纵

示例：在 aa 和 bb 之间插进去 aabb

{
    let str = ['aa','bb',123,'sd13cx','jj',45];
    str.splice(1,0,'aabb');
    console.log(str)
}

返回效果：[“aa”, “aabb”, “bb”, 123, “sd13cx”, “jj”, 45]

拓展演习：

在 aa 和 bb 之间批量插进去 ab、aabb、aaabbb
{

let str = ['aa','bb',123,'sd13cx','jj',45];
str.splice(1,0,'ab','aabb','aaabbb');
console.log(str);

}
返回效果：[“aa”, “ab”, “aabb”, “aaabbb”, “bb”, 123, “sd13cx”, “jj”, 45]

深层拓展：

es6要领，运用‘…’扩大运算符

{
    let str = ['aa','bb',123,'sd13cx','jj',45];
    let arr = ['ab','aabb','aaabbb'];
    //巧用es6 "..."
    str.splice(1,0,...arr);
    console.log(str);
}

splice替代操纵

示例：把 123 替代为 ccdd

{
    let str = ['aa','bb',123,'sd13cx','jj',45];
    str.splice(2,1,'ccdd');
    console.log(str)
}

返回效果：[“aa”, “bb”, “ccdd”, “sd13cx”, “jj”, 45]

拓展演习：

把 123 替代为 1234、12345

{
    let str = ['aa','bb',123,'sd13cx','jj',45];
    str.splice(2,1,1234,12345);
    console.log(str);
}

返回效果:[“aa”, “bb”, 1234, 12345, “sd13cx”, “jj”, 45]

splice删除操纵

示例：把 123 删除

{
    let str = ['aa','bb',123,'sd13cx','jj',45];
    str.splice(2,1);
    console.log(str)
}

delete删除操纵

{
    let arr = ['aaa',111,222];
    delete arr[1]
    console.log(arr,arr.length)
    //delete 只删除值，不删除援用空间
}

返回效果：[“aaa”, empty, 222] 3

数组排序

冒泡排序

{
    let array = [1,4,-8,-3,6,12,9,8];
    let bubbleSort = function(arr){
        for(let i = 0;i < arr.length-1;i++){
            for(let j = 0;j < arr.length-i-1;j++){
                if(arr[j] < arr[j+1]){
                    let temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
    bubbleSort(array);
}    

（1）比较相邻的元素。假如第一个比第二个大，就交流他们两个位置。
（2）对每一对相邻元素作一样的事情，从最先第一对到末端的末了一对。在这一点，末了的元素应当会是最大的数。
（3）针对一切的元素反复以上的步骤，除了末了一个。
（4）延续每次对越来越少的元素反复上面的步骤，直到没有任何一对数字须要比较。

疾速排序排序

{
    //递归头脑，双方疾速的排序，冒泡排序的革新
    let array = [1,4,-8,-3,6,12,9,8];
    let quickSort = function(arr){
        if(arr.length <= 1){
            return arr;
        }
        let index = Math.floor(arr.length/2);
        let temp = arr.splice(index,1);
        let left = [],right = [];
        for(let item of arr){
            if(item < temp){
                left.push(item);
            }else{
                right.push(item);
            }
        }
        return quickSort(left).concat(temp,quickSort(right));
    }
    quickSort(array);
}

Math.floor(x)要领是向下取整，返回小于或即是x的最接近的整数。

splice(index,num,item)要领是向数组中增加项目，或是从数组中删除项目，并返回被删除的项目。

index是整数，被操纵项目地点的位置（必需）
num是整数，要删除的项目的数目，假如为0，示意不删除（必需）
item是向数组中增加的新项目，可所以多个（可选）
push()要领是向数组末端增加一个或多个新项目并返回新数组的长度

concat()要领衔接两个或多个数组，不会转变原有数组，返回一个新数组