改变原数组（7个）

1、push（），在数组后面添加元素

2、pop（），剪切数组的最后元素

不需要传入参数，传入也没用

3、shift( )，减去前面的元素

4、unshift( )，在前面添加元素

5、splice（），截取数组元素

6、reverse（），反转

7、sort（），升序排序，按ASCII码来排列的

从小到大排序后的数组 = 数组.sort(function(a,b){

            return a-b;

});

• 无参：按照数组元素的首字符对应的Unicode编码值，从小到大排列数组元素。

• 带参：必须为函数（回调函数：callback）。这个回调函数中带有两个参数，代表数组中的前后元素。

  • 如果返回值（a-b）为负数，a排b前面。

  • 如果返回值（a-b）等于0，不动。

  • 如果返回值（a-b）为正数，a排b后面。

上面的这个带参的排序，其实是调用了底层的冒泡排序，小的排前面，大的排后面。

PS：sort方法的功能非常强大，能对数字和字母进行排列。

升序

降序

排对象也是可以的，按字节排序。

不改变原数组（5个）

1、concat（），拼接数组

2、join（），连接数组内部元素，必须加字符串，虽然直接加数字也可以

3、split（）， 把一个字符串分割成字符串数组

4、toString（），数组元素

5、slice（），截取数据

不传入参数就是整体截取，1个参数就是从该处开始截取到尾部

实例

查找数组中的指定元素，并返回索引值

<script>
    var arr = [1,2,3,6,8];
    function indexOf(arr,item) {
        if (Array.prototype.indexOf){ //这里是考虑其兼容性问题，如果没有该方法原型的话就采取循环去自己处理
            return arr.indexOf(item);
        }else{
            for (var i = 0; i < arr.length; i++){
                if (arr[i] === item){
                    return i;
                }
            }
        }
    }
    indexOf(arr,3);
</script>

数组求和

<script>
    var arr = [1,2,3,6,8];
    function sum(arr) {
            var n = 0;
            for (var i = 0; i < arr.length; i++){
                n += arr[i];
            }
            return n;
    }
    console.log(sum(arr)); //20
</script>

移除指定元素

<script>
    // 移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组
    var arr = [1,2,3,6,8];
    function remove(arr,item) {
        var n = 0;
        var arr1 = [];
        for (var i = 0; i < arr.length; i++){
            if (arr[i]!= item){
                arr1.push(arr[i]);
            }
        }
        return arr1;
    }
    console.log(remove(arr,3)); //

    //移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回
    var arr = [1,2,3,6,8];
    function remove(arr,item) {
        for (var i = 0; i < arr.length; i++){
            if (arr[i] === item){
                arr.splice(i,1);
                i--;
            }
        }
        return arr;
    }
    console.log(remove(arr,3)); //

</script>

添加和删除元素

<script>
    //在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组
    var arr = [1,2,3,6,8];
    function append(arr,item) {
        var arr1 = arr.slice(0);
        arr1.push(item);
        return arr1;
    }
    console.log(append(arr,3)); //

    //删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组
    var arr = [1,2,3,6,8];
    function del(arr) {
        var arr1 = arr.slice(0);
        arr1.pop();
        return arr1;
    }
    console.log(del(arr)); //

    //在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
        var arr = [1,2,3,6,8];
        function append(arr,item) {
            var arr1 = arr.slice(0);
            arr1.unshift(item);
            return arr1;
        }
        console.log(append(arr,3)); //

    //删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组
        var arr = [1,2,3,6,8];
        function del(arr) {
            var arr1 = arr.slice(0);
            arr1.shift();
            return arr1;
        }
        console.log(del(arr)); //

    //合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组
    var arr1 = [1, 2, 3, 4];
    var arr2 = ['a', 'b', 'c', 1];
    function concat( ) {
        var arr = arr1.concat(arr2);
        return arr;
    }
    console.log(concat(arr1,arr2));

    //在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
    var arr = [1, 2, 3, 4];
    function insert(arr, item, index) {
            var arr1 = arr.slice(0);
            arr1.splice(index,0,item);
            return arr1;
    }
    console.log(insert(arr,5,2));  // 1,2,5,3,4


</script>

数组或字符串去重

<script>
//第一种
    var str = "abcdedddffhssjssjssksk";
    var arr = str.split("");
//    var arr = ['ss','ss','aa','aa','b','f'];
    Array.prototype.unique = function () {
        var temp = {};
        var arr = [];
        var len = this.length;
        for (var i = 0; i < len; i++) {
            if (!temp[this[i]]) {
                temp[this[i]] = 'a';//如果里面没有这个属性名的话，就添加进去
                arr.push(this[i]);
            }
        }
        return arr.join('');
    }

//第二种
//        问题：编写一个方法去掉一个数组中的重复元素。
//        分析：创建一个新数组，循环遍历，只要新数组中有老数组的值，就不用再添加了。
        var arr = [1,2,3,4,5,2,3,4];
        console.log(arr);
        var aaa = fn(arr);
        console.log(aaa);
        //思路：创建一个新数组，循环遍历，只要新数组中有老数组的值，就不用再添加了。
        function fn(array){
            var newArr = [];
            for(var i=0;i<array.length;i++){
                //开闭原则
                var bool = true;
                //每次都要判断新数组中是否有旧数组中的值。
                for(var j=0;j<newArr.length;j++){
                    if(array[i] === newArr[j]){
                        bool = false;
                    }
                }
                if(bool){
                    newArr[newArr.length] = array[i];
                }
            }
            return newArr;
        }
 
//第三种
function duplicates(arr) {
     var a = [],b = [];
     //遍历arr，如果以arr中元素为下标的的b元素已存在，则该b元素加1，否则设置为1
     for(var i = 0; i < arr.length; i++){
         if(!b[arr[i]]){
             b[arr[i]] = 1;
             continue;
         }
         b[arr[i]]++;
     }
     //遍历b数组，将其中元素值大于1的元素下标存入a数组中
     for(var i = 0; i < b.length; i++){
         if(b[i] > 1){
             a.push(i);
         }
     }
     return a;
}
    </script>