JS

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

方法一：
function remove(arr, item) {
 var a = [];
     //循环遍历
     for(var i=0; i < arr.length; i++){
         //如果arr[i]不等于item，就加入数组a
         if(arr[i] != item){
             a.push(arr[i]);
         }
     }
     return a;
}

方法二：
function remove(arr, item) {
    var a=[];
    arr.forEach(function(e){
        if(e!==item){
            a.push(e);
        }
    })
    return a;
}

方法三：
function remove(arr,item){
    return arr.filter(function(ele){
         return ele != item;
    })
}

方法四：
function remove(arr,item){
    var a= arr.slice(0);//将arr中的元素赋给a
    for(var i=0;i<a.length;i++){
        if(a[i] == item){
            a.splice(i,1);//删除a中第i个元素
            i--;
        }
    }
    return a;
}

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

function indexOf(arr, item) {
  if (Array.prototype.indexOf){// 判断浏览器是否支持indexOf方法
      return arr.indexOf(item);
  } else {
      for (var i = 0; i < arr.length; i++){
          if (arr[i] === item){
              return i;
          }
      }
  }     
  return -1;
}

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

1，常规循坏
function sum(arr) {
    var s = 0;
    for (var i=arr.length-1; i>=0; i--) {
        s += arr[i];
    }
    return s;
}

2，forEach遍历
function sum(arr) {
    var result = 0;
    arr.forEach(function(item,index) {
        result += item;
    });
  
    return result;
};

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

function removeWithoutCopy(arr, item) {
    for(var i=0;i<arr.length;i++){
        if(arr[i]==item){
            arr.splice(i,1);
            i--;
        }
    }
    return arr;

}

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

function append(arr, item) {
    var newArr = arr.slice(0);
        newArr.push(item);
        return newArr;

}

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

        //第一种方法：使用slice或concat
        function truncate(arr) {
            // var arr1 = arr.concat();
            var arr1 = arr.slice(0);
            arr1.pop(arr1.length-1);
            return arr1;
        }
        //第二种方法：普通迭代方法
        function truncate1(arr) {
            var a = new Array();
            for (var i = 0;i < arr.length-1;i++){
                a.push(arr[i]);
            }
            return a;
        }
        //第三种方法：filter
        function truncate2(arr) {
            //val:当前元素值  i:当前元素索引  arr1:当前数组
            return arr.filter(function (val,i,arr1) {
                return i!=arr1.length-1;
            })
        }
        //第四种方法：单纯使用slice
        function truncate3(arr) {
            // slice方法不会改变原数组数据
            return arr.slice(0,-1);
        }
        //第五种方法：split+join
        function truncate4(arr) {
            var arr1 = arr.join().split(',');
            //删除最后一个元素
            //pop是指删除最后一个元素；shift是指删除第一个元素；两者返回的都是所删除的元素
            arr1.pop();
            return arr1;
        }

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

        //方法一：最普通的循环赋值
        function prepend(arr, item) {
            var a = new Array();
            a.push(item);
            for (var i =0;i<arr.length;i++){
                a.push(arr[i]);
            }
            return a;
        }

        //方法二：使用concat
        function prepend(arr, item) {
            return [item].concat(arr);
        }

        //方法三：使用push.apply
        function prepend(arr, item) {
            var arr1 = [item];
            //使用此方法改变的数组是arr1，arr数组不变
            [].push.apply(arr1,arr);
            return arr1;
        }

        //方法四：使用unshift:在数组头部插入指定元素
        //shift是指在头部移除元素
        function prepend(arr, item) {
            // var arr1 = arr.slice(0);
            var arr1 = arr.join().split(',')
            arr1.unshift(item);
            return arr1;
        }

 

        

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

        //第一种方法：使用slice或concat
        function truncate(arr) {
            // var arr1 = arr.concat();
            var arr1 = arr.slice(0);
            arr1.pop(arr1.length-1);
            return arr1;
        }

        //第二种方法：普通迭代方法
        function truncate(arr) {
            var a = new Array();
            for (var i = 0;i < arr.length-1;i++){
                a.push(arr[i]);
            }
            return a;
        }

        //第三种方法：filter
        function truncate(arr) {
            //val:当前元素值  i:当前元素索引  arr1:当前数组
            return arr.filter(function (val,i,arr1) {
                return i!=arr1.length-1;
            })
        }

        //第四种方法：单纯使用slice
        function truncate(arr) {
            // slice方法不会改变原数组数据
            return arr.slice(0,-1);
        }

        //第五种方法：split+join
        function truncate(arr) {
            var arr1 = arr.join().split(',');
            //删除最后一个元素
            //pop是指删除最后一个元素；shift是指删除第一个元素；两者返回的都是所删除的元素
            arr1.pop();
            return arr1;
        }

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

        //方法一：使用concat
        function concat(arr1, arr2) {
          
            return arr1.concat(arr2);
        }

        //方法二：slice+concat
        function concat1(arr1, arr2) {
            var arr = arr1.slice(0);
            arr = arr.concat(arr2);
            return arr;
        }

        //方法三：slice+push.apply
        function concat2(arr1, arr2){
            var arr = arr1.slice(0);
            [].push.apply(arr,arr2);
            return arr;
        }

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

        //方法一：先复制前两个元素，将插入元素插入之后，再复制后两个元素
        function insert(arr, item, index) {
            var arr1 = arr.slice(0,index);
            arr1.push(item);
            arr1=arr1.concat(arr.slice(index,arr.length));
            return arr1;
        }

         //方法二：使用splice方法插入
        //splice方法可以增加或删除元素
        //arr1.splice(2,0,'z');------>指的是从arr1数组中的第2个位置删除0个元素，且之前2的位置用‘z’表示
        //也可以理解，当第二个参数为0时为插入，为1时为替换，大于1则为删除
        function insert1(arr, item, index) {
            var arr1 = arr.slice(0);//
            arr1.splice(index,0,item);
            return arr1;
        }

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

// 方法一
function count(arr, item) {
   return arr.toString().split(item+"").length-1;
}


// 方法二：foeEach
function count(arr, item) {
    var cnt = 0;
    arr.forEach(function (a) {
        a===item ? cnt++ : cnt;
    })
    return cnt;
}

//方法三：for循环
function count(arr, item) {
   var cnt=0;
   for (var i = 0;i<arr.length;i++){
      if (arr[i]===item){
          cnt++;
       }
   }
   return cnt;
}

//方法四：使用map函数
function count2(arr, item) {
    var cnt = 0;
    arr.map(function (a) {
      if (a===item){
          cnt++;
          }
       })
      return cnt;
 }

//方法五
function count(arr, item) {
    var cnt = arr.reduce(function (init,curr) {
    //如果当前置等于item，该函数值加一
       return curr === item ? init+1:init;
       },0)
    return cnt;
}

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

//方法一
function duplicates(arr) {
  var arr1=[];
  for(var i = 0;i<arr.length;i++){
   for(var j =i+1;j<arr.length-1;j++){
    if(arr[i]===arr[j]&&arr1.indexOf(arr[i]==-1)){
     arr1.push(arr[i]);
    }
  }
}
return arr1.sort();
}

//方法二
function duplicates(arr) {
    var newarr = [];
    for(var j = 0;j < arr.length;j++){
        for(var i = j+1;i < arr.length;i++){
            if(arr[j] == arr[i]){
                newarr.push(arr[i]);
                
            }
        }
    } 
    //return [...new Set(newarr)];
    return Array.from(new Set(newarr));
}

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

//方法一
function square(arr) {
    var arr2 = []
    for(var i=0; i<arr.length; i++) {
        arr2[i] = arr[i]*arr[i]
    }
    return arr2
}

//方法二
 function square(arr) {
    return arr.map(function(elem, index, arr) {
        return elem*elem
    })
}

在数组 arr 中，查找值与 item 相等的元素出现的所有位置 

//方法一
function findAllOccurrences(arr, target){
     var subArr = [];
     for(var i = 0; i < arr.length; i++){
         if(arr[i] === target){
             subArr.push(i);
         }
     }
     return subArr;
}

//方法二
function findAllOccurrences(arr, target) {
    var arr1=[];
    var j=0;
    for(var i=0;i<arr.length;i++){
        if(arr[i]===target){
            arr1.push(arr.indexOf(arr[i],j));
            j++;
        }
    }
    return arr1;
}

给定的 js 代码中存在全局变量，请修复

function globals() {
    myObject = {
      name : 'Jory'
    };

    return myObject;
}


// var
function globals() {
    var myObject = {
      name : 'Jory'
    };

    return myObject;
}

 请修复给定的 js 代码中，函数定义存在的问题

例如：输入true  输出a

//题目
function functions(flag) {
    if (flag) {
      function getValue() { return 'a'; }
    } else {
      function getValue() { return 'b'; }
    }

    return getValue();
}

//答案
function functions(flag) {
   function getValue() { return(flag)?'a':'b'; }
    return getValue();
}

 判断 val1 和 val2 是否完全等同

function identity(val1, val2) {
    return val1===val2?true:false;
}


function identity(val1, val2) {
    if(val1===val2){
        return true;
    }
    return false;
}

 实现一个打点计时器，要求
1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出

function count(start, end) {
    //立即输出第一个值
    console.log(start++);
     var timer = setInterval(function(){
         if(start <= end){
             console.log(start++);
         }else{
             clearInterval(timer);
         }
     },100);
    //返回一个对象
     return {
         cancel : function(){
             clearInterval(timer);
         }
     };
 }

实现 fizzBuzz 函数，参数 num 与返回值的关系如下：

1、如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
2、如果 num 能被 3 整除，返回字符串 fizz
3、如果 num 能被 5 整除，返回字符串 buzz
4、如果参数为空或者不是 Number 类型，返回 false
5、其余情况，返回参数 num

function fizzBuzz(num) {
    if (num == null || typeof num != "number"){
        return false
    }
    if(num % 3 == 0 && num % 5 == 0){
        return "fizzbuzz"
    }else if(num % 3 == 0){
        return "fizz"
    }else if(num % 5 == 0){
        return "buzz"
    }
 
    return num
}

将数组 arr 中的元素作为调用函数 fn 的参数

//调用函数可以使用call或者apply这两个方法，
//区别在于call()需要将参数挨个列出，call需要将传递给函数的参数明确写出来，是多少参数就需要写多少参数。
//apply则将传递给函数的参数放入一个数组中，传入参数数组即可。apply直接传入数组对象。

function argsAsArray(fn, arr) {
   return fn.apply(this, arr);
}

 将函数 fn 的执行上下文改为 obj 对象

function speak(fn, obj) {
   return fn.apply(obj, obj);
}

function speak(fn, obj) {
  return fn.call(obj);
}

function speak(fn, obj) {
  return fn.apply(obj);
}

实现函数 functionFunction，调用之后满足如下条件：

1、返回值为一个函数 f
2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', '
3、所有函数的参数数量为 1，且均为 String 类型 

//闭包
function functionFunction(str) {
    return function(str2){
            return str + ', ' + str2;
        };
}