js 数组小习题

找出元素 item 在给定数组 arr 中的索引位置

  mounted(){
      //找出元素 item 在给定数组 arr 中的索引位置
     console.log(this.indexOf([ 1, 2, 3, 4 ], 3))  //2
  },
  methods:{
       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;
                }
            }
        }     
        return -1;
    }
  },

计算给定数组 arr 中所有元素的总和

  mounted(){
       //计算给定数组 arr 中所有元素的总和
       console.log(this.sum([1,2,3,4]))  //10
  },

  methods:{

        sum(arr) {
        var length = arr.length,
        sum = 0;
        for (var i = 0; i < length; i++) {
        sum += arr[i];
    }
        return sum;
    }

  },

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

mounted(){
       //移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组
       console.log(this.remove([1,2,3,4,1],1))  //[2,3,4]
       console.log(this.remove2([1,2,3,4,1],1)) //[2,3,4]
       console.log(this.remove3([1,2,3,4,1],1)) //[2,3,4]
  },

  methods:{
    //第一种
     remove(arr,item){
        var newarr = arr.slice(0);
        for(var i=0;i<newarr.length;i++){
            if(newarr[i] == item){
                newarr.splice(i,1);
                i--;
            }
        }
        return newarr;
},
    //第二种
    remove2(arr,item){
    var newarr = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i] != item){
            newarr.push(arr[i]);
        }
    }
    return newarr;
},
    //第三种
   remove3(arr,item){
    return arr.filter(function(ele){
         return ele != item;
    })
}

  },

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

 mounted(){
       //在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组
       console.log(this.append([1,2,3,4,1],7))  // [1, 2, 3, 4, 1, 7]
       console.log(this.append2([1,2,3,4,1],7)) // [1, 2, 3, 4, 1, 7]
  },

  methods:{
    //第一种
    append(arr, item) {
        //复制数组
        var a = arr.slice(0); //复制数组
        //添加元素
        a.push(item);
        return a;
    },

    //第二种
    append2 (arr, item) {
        var length = arr.length,
            newArr = [];  
        for (var i = 0; i < length; i++) {
            newArr.push(arr[i]);
        }
        newArr.push(item);
 
        return newArr;
    }
  },

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

 mounted(){
       //删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组
       console.log(this.truncate([1,2,3,4],4))  // [1, 2, 3]
       console.log(this.truncate2([1,2,3,4],4)) // [1, 2, 3]
  },

  methods:{
    //第一种
    truncate(arr) {
    var a = arr.slice(0);
     a.pop();
     return a;
    },

    //第二种
    truncate2(arr, item) {
    var newArr=[];
    for(var i=0;i<arr.length-1;i++){
        newArr.push(arr[i]);
    }
    return newArr;
    },

  }

 在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组

 mounted(){
       //在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
       console.log(this.prepend([1,2,3,4],7))  // [7, 1, 2, 3, 4]
       console.log(this.prepend2([1,2,3,4],7)) // [7, 1, 2, 3, 4]
  },

  methods:{
    //第一种 
   prepend(arr, item) {
      return [item].concat(arr); //concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
},

    //第二种
   prepend2(arr, item) {
    var newArr=arr.slice(0);
    newArr.unshift(item);
    return newArr;
}

  }

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

 mounted(){
       //删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组
       console.log(this.curtail([1,2,3,4]))  // [2, 3, 4]
       console.log(this.curtail2([1,2,3,4])) // [2, 3, 4]
  },

  methods:{
    //第一种 
    curtail(arr) {
    return arr.slice(1);
},

    //第二种
  curtail2(arr) {
    var newArr = arr.concat();
    newArr.shift();
    return newArr;
}

  }

合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组

 mounted(){
       //合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组
       console.log(this.concat([1,2,3,4],[1,2,3,4]))  // [1, 2, 3, 4, 1, 2, 3, 4]
       console.log(this.concat2([1,2,3,4],[1,2,3,4])) // [1, 2, 3, 4, 1, 2, 3, 4]
  },

  methods:{
    //第一种 
    concat(arr1, arr2) {
    return arr1.concat(arr2);
},

    //第二种
    concat2(arr1, arr2) {
    var newArr=arr1.slice(0);
    for(var i=0;i<arr2.length;i++){
        newArr.push(arr2[i]);
    }
    return newArr;
}

  }

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

mounted(){
       //在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
       console.log(this.insert([1,2,3,4],'hello',1))  // [1, "hello", 2, 3, 4]
       console.log(this.insert2([1,2,3,4],'hello',1)) // [1, "hello", 2, 3, 4]
  },

  methods:{
    //第一种 
   insert(arr, item, index) {
     //复制数组
     var a = arr.slice(0);
     a.splice(index, 0, item);
     return a;
 },

    //第二种
    insert2(arr, item, index) {
    var newArr=[];
    for(var i=0;i<arr.length;i++){
        newArr.push(arr[i]);
    }
    newArr.splice(index,0,item);
    return newArr;
}

  }

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

  mounted(){
       //统计数组 arr 中值等于 item 的元素出现的次数
       console.log(this.count([1,2,3,4,4],4))   // 2
       console.log(this.count2([1,2,3,4,4],4))  // 2
       console.log(this.count3([1,2,3,4,4],4))  //2
  },

  methods:{
    //第一种 
   count(arr, item) {
     var count = 0;
     arr.forEach(function(e){
         //e为arr中的每一个元素，与item相等则count+1
         e == item ? count++ : 0;
     });
     return count;
 },

    //第二种
    count2(arr, item) {
            var count = 0;
            arr.map(function(a) {
                if(a === item) {
                    count++;
                }
            });
            return count;
    },

    //第三种
    count3(arr, item) {
            var count = 0;
            for(var i=0; i<arr.length; i++) {
                if(arr[i] === item) {
                    count++;
                }
            }
            return count;
    }

  }

找出数组 arr 中重复出现过的元素

 mounted(){
       //找出数组 arr 中重复出现过的元素
       console.log(this.duplicates([1,2,3,4,4],4))  // 4
  },

  methods:{
    //第一种 
   duplicates(arr) {
     //声明两个数组，a数组用来存放结果，b数组用来存放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;
 },

    

  }

为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组

  mounted(){
      console.log(this.square([1,2,3,4]))  //[1, 4, 9, 16]
  },

  methods:{
    //为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组
    //第一种
       square(arr) {
        return arr.map(function(item,index,array){
        return item*item;
    })
  },
  //第二种
    square2(arr) {
      //声明一个新的数组存放结果
        var a = [];
        arr.forEach(function(e){
            //将arr中的每一个元素求平方后，加入到a数组中
            a.push(e*e);
        });
     return a;
 }
}