• JS操作数组


    1.  如果数组中存在 item,则返回元素在数组中的位置,否则返回 -1

    function indexOf(arr, item) {
        if(Array.prototype.indexOf) {//IE浏览器支不支持indexOf
           return arr.indexOf(item);
           }
        for (var i=0;i<arr.length;i++) {
            if (arr[i]==item) {
                return i;
            }
        return -1;
        }
    
    }

    2.计算给定数组 arr 中所有元素的总和 .有多种解法。

    (1)使用forEach函数

    function sum(arr) {
        var s =0;
        arr.forEach(function(currentValue,index,arr) {
            s+=currentValue;
        },0);
        return s;
    }

    (2)使用eval, 将字符串转化为可执行的代码,但是性能不好

    function sum(arr) {
    return eval(arr.join('+'));
    }

    (3)函数式编程,之后补充。

    数组方法 reduce 用来迭代一个数组,并且把它累积到一个值中。
    
    使用 reduce 方法时,你要传入一个回调函数,这个回调函数的参数是一个 累加器 (比如例子中的 previousVal) 和当前值 (currentVal)。
    
    reduce 方法有一个可选的第二参数,它可以被用来设置累加器的初始值。如果没有在这定义初始值,那么初始值将变成数组中的第一项,而 currentVal 将从数组的第二项开始。
    
    
    function sum(arr) {
        return arr.reduce(function(prev, curr, idx, arr){
            return prev + curr;
        });
    }

    3. 移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr,结果返回新的数组

    function remove(arr, item) {
        var result =[];
        arr.forEach(function(cur, index, arr) {
            if (cur!==item) {
                result.push(cur);
            } 
        });
        return result;
    }

    也可以用filter

    function remove(arr, item) {
        return arr.filter(function (elem) {
            return elem !== item;
        });
    }

    4. 移除数组 arr 中的所有值与 item 相等的元素,直接在给定的 arr 数组上进行操作,并将结果返回.

    splice(index,len,[item])    注释:该方法会改变原始数组。
    splice有3个参数,它也可以用来替换/删除/添加数组内某一个或者几个值
    index:数组开始下标        len: 替换/删除的长度       item:替换的值,删除操作的话 item为空
    function removeWithoutCopy(arr, item) {
        for(var i =0;i<arr.length;i++) {
            if (arr[i]==item) {
                arr.splice(i,1);
                i--;       //注意这里要减去1
            }
        }
        return arr;
    }

    5. 在数组 arr 末尾添加元素 item。不要直接修改数组 arr,结果返回新的数组

    function append(arr, item) {
        return arr.concat(item);
    }
    使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回

    function append(arr, item) {
    var newArr = arr.slice(0);//slice浅拷贝(start,end)
    newArr.push(item);
    return newArr;
    }

    6. 删除数组 arr 最后一个元素。不要直接修改数组 arr,结果返回新的数组

    链接:https://www.nowcoder.com/questionTerminal/df4b0b7a459447538351c4c7008b34e7
    来源:牛客网
    
    //利用slice
    function truncate(arr) {
        return arr.slice(0,-1);
    }
    //利用filter
    function truncate(arr) {
        return arr.filter(function(v,i,ar) {
            return i!==ar.length-1;
        });
    }
    //利用push.apply+pop
    function truncate(arr) {
        var newArr=[];
        [].push.apply(newArr, arr);
        newArr.pop();
        return newArr;
    }
    //利用join+split+pop    注意!!!:数据类型会变成字符型
    function truncate(arr) {
        var newArr = arr.join().split(',');
        newArr.pop();
        return newArr;
    }
    //利用concat+pop
    function truncate(arr) {
        var newArr = arr.concat();
        newArr.pop();
        return newArr;
    }
    //普通的迭代拷贝
    function truncate(arr, item) {
        var newArr=[];
        for(var i=0;i<arr.length-1;i++){
            newArr.push(arr[i]);
        }
        return newArr;
    }

    7. 

    在数组 arr 开头添加元素 item。不要直接修改数组 arr,结果返回新的数组
    //利用concat
    function prepend(arr, item) {
        return [item].concat(arr);
    }
    //使用push.apply
    function prepend(arr, item) {
        var newArr=[item];
        [].push.apply(newArr, arr);
        return newArr;
    }
    //利用slice+unshift/splice
    function prepend(arr, item) {
        var newArr=arr.slice(0);
        newArr.unshift(item);//newArr.splice(0,0,item);
        return newArr;
    }
    //使用join+split+unshift/splice组合
    function prepend(arr, item) {
        var newArr=arr.join().split(',');
        newArr.unshift(item);//newArr.splice(0,0,item);
        return newArr;
    }
    //普通的迭代拷贝
    function prepend(arr, item) {
        var newArr=[];
        for(var i=0;i<arr.length;i++){
            newArr.push(arr[i]);
        }
        newArr.unshift(item);
        return newArr;
    }

    8. 删除数组 arr 第一个元素。不要直接修改数组 arr,结果返回新的数组

    //利用slice
    function curtail(arr) {
        return arr.slice(1);
    }
    //利用filter
    function curtail(arr) {
        return arr.filter(function(v,i) {
            return i!==0;
        });
    }
    //利用push.apply+shift
    function curtail(arr) {
        var newArr=[];
        [].push.apply(newArr, arr);
        newArr.shift();
        return newArr;
    }
    //利用join+split+shift    注意!!!:数据类型会变成字符型
    function curtail(arr) {
        var newArr = arr.join().split(',');
        newArr.shift();
        return newArr;
    }
    //利用concat+shift
    function curtail(arr) {
        var newArr = arr.concat();
        newArr.shift();
        return newArr;
    }
    //普通的迭代拷贝
    function curtail(arr) {
        var newArr=[];
        for(var i=1;i<arr.length;i++){
            newArr.push(arr[i]);
        }
        return newArr;
    }

    9. 在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr,结果返回新的数组

    function insert(arr, item, index) {
        var newArr=arr.slice(0);
        newArr.splice(index,0,item);///////////
        return newArr;////return 另起一行
    }
    //利用slice+concat
    function insert(arr, item, index) {
        return arr.slice(0,index).concat(item,arr.slice(index));
    }
    //利用concat +splice
    function insert(arr, item, index) {
        var newArr=arr.concat();
        newArr.splice(index,0,item);
        return newArr;
    }
    //利用slice+splice
    function insert(arr, item, index) {
        var newArr=arr.slice(0);
        newArr.splice(index,0,item);
        return newArr;
    }
    //利用push.apply+splice
    function insert(arr, item, index) {
        var newArr=[];
        [].push.apply(newArr, arr);
        newArr.splice(index,0,item);
        return newArr;
    }
    //普通的迭代拷贝
    function insert(arr, item, index) {
        var newArr=[];
        for(var i=0;i<arr.length;i++){
            newArr.push(arr[i]);
        }
        newArr.splice(index,0,item);
        return newArr;
    }

    10. 统计数组 arr 中值等于 item 的元素出现的次数

    //filter()-->利用指定的函数确定是否在返回的数组中包含某一项
            function count(arr, item) {
                var count = arr.filter(function(a) {
                    return a === item;   //返回true的项组成的数组
                });
                return count.length;
            }
            //map()-->对数组中的每一项进行给定函数,
            //返回每次函数条用的结果组成的数组;
            function count(arr, item) {
                var count = 0;
                arr.map(function(a) {
                    if(a === item) {
                        count++;
                    }
                });
                return count;
            }
            //for循环
            function count(arr, item) {
                var count = 0;
                for(var i=0; i<arr.length; i++) {
                    if(arr[i] === item) {
                        count++;
                    }
                }
                return count;
            }
            //reduce()-->从数组的第一项开始,逐个遍历到最后;
            function count(arr, item) {
                var count = arr.reduce(function(prev, curr) {
                    return curr === item ? prev+1 : prev;
                }, 0);
                return count;
            }
                    //forEach()-->对数组中的每一项运行传入的函数
            function count(arr, item) {
                var count = 0;
                arr.forEach(function(a) {
                    a === item ? count++ : 0;
                });
                return count;
            }
  • 相关阅读:
    8常用控件
    7对话框
    6控件
    5Lambda表达式
    4自定义信号和槽函数
    3信号与槽
    2指定父对象
    springboot整合activemq
    springboot整合springtask
    jvm与tomcat启动优化配置
  • 原文地址:https://www.cnblogs.com/sarah-wen/p/10752692.html
Copyright © 2020-2023  润新知