js一些练习题

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

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;
　　　　　　}
　　　　}
　　}
　　return -1;
}

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

递归：

function sum(arr) {
    var len = arr.length;
    if(len == 0){
        return 0;
    } else if (len == 1){
        return arr[0];
    } else {
        return arr[0] + sum(arr.slice(1));
    }
}

常规循环：

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

函数式编程 map-reduce：

function sum(arr) {
    return arr.reduce(function(prev, curr, idx, arr){
        return prev + curr;
    });
}

forEach遍历：

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

eval：

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

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

function remove(arr, item) {
　　var arr1 = arr.slice(0);
　　for(var i=arr1.length-1;i>=0;i--){
　　　　if(arr1[i]==item){
　　　　　　arr1.splice(i, 1);
　　　　}
　　}
　　return arr1;
}

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

function remove(arr, item) {
　　var arr1 = [];
　　for(var i=0; i<arr.length;i++){
　　　　if(arr[i]!==item){
　　　　　　arr1.push(arr[i]);
　　　　}
　　}
　　return arr1;
}

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

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

function(arr, item) {
    var length = arr.length,
        newArr = [];
    for (var i = 0; i < length; i++) {
        newArr.push(arr[i]);
    }
    newArr.push(item);
    return newArr;
};

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

var append3 = function(arr, item) {
　　return arr.concat(item);
}

function append(arr, item) {
    var newArr=arr.join().split(',');
    newArr.push(item);
    return newArr;
}

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

//利用slice
function truncate(arr) {
　　return arr.slice(0,-1);
}

function truncate(arr) {
　　var arr1 = arr.slice(0);
　　arr1.pop();
　　return arr1;
}

function truncate(arr) {

var newArr=[];
    [].push.apply(newArr, arr);
    newArr.pop();
    return newArr;
}

function truncate(arr) {

　　return arr.filter(function(v,i,ar) {

return i!==ar.length-1;
    });
}

function truncate(arr) {
    var newArr = arr.join().split(',');
    newArr.pop();
    return newArr;
}

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;
}

//使用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;
}

//使用join+split+unshift/splice组合
function prepend(arr, item) {
    var newArr=arr.join().split(',');
    newArr.unshift(item);//newArr.splice(0,0,item);
    return newArr;
}

6 删除数组 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;
}

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

//利用concat
function concat(arr1, arr2) {
    return arr1.concat(arr2);
}
//利用slice+push.apply
function concat(arr1, arr2) {
    var newArr=arr1.slice(0);
    [].push.apply(newArr, arr2);
    return newArr;
}
//利用slice+push
function concat(arr1, arr2) {
    var newArr=arr1.slice(0);
    for(var i=0;i<arr2.length;i++){
        newArr.push(arr2[i]);
    }
    return newArr;
}
//普通的迭代拷贝
function concat(arr1, arr2) {
    var newArr=[];
    for(var i=0;i<arr1.length;i++){
        newArr.push(arr1[i]);
    }
    for(var j=0;j<arr2.length;j++){
        newArr.push(arr2[j]);
    }
    return newArr;
}

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

//利用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;
}

9 统计数组 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;
        }

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

function duplicates(arr) {

var result = [];
    arr.forEach(function(elem){
       if(arr.indexOf(elem) !=arr.lastIndexOf(elem) && result.indexOf(elem) == -1){
           result.push(elem);
       }
    });
    return result;
}

function duplicates(arr) {
    var a=arr.sort(),b=[];
    for(var i in a){
        if(a[i]==a[i-1] && b.indexOf(a[i])==-1) b.push(a[i]); 
    }
    return b;
}//先排序，如果后一个与前一个相等且未保存，则保存。

function duplicates(arr) {
  return arr.sort().filter((_, i) =>
    arr[i] === arr[i + 1] && arr[i] !== arr[i - 1]
  );
}

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

function square(arr) {
    return arr.map(function(item,index,array){
        return item*item;
    })
}

function square(arr) {
   //声明一个新的数组存放结果
     var a = [];
     arr.forEach(function(e){
         //将arr中的每一个元素求平方后，加入到a数组中
         a.push(e*e);
     });
     return a;
 }

function square(arr) {
　　var arr1 = [];
　　for(var i=0;i<arr.length;i++){
　　　　arr1.push(Math.pow(arr[i],2))
　　}
　　return arr1;
}

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

function findAllOccurrences(arr, target) {
var temp = [];
    arr.forEach(function(val,index){
        val !== target ||  temp.push(index);
    });
    return temp;
}

//filter
function findAllOccurrences(arr, target) {
    var result=[];
    arr.filter(function(item,index){
        return item===target&&result.push(index);
    });
    return result;
}
//for
function findAllOccurrences(arr, target) {
    var result=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]===target){
            result.push(i);
        }
    }
    return result;
}
//lastIndexOf+slice/splice
function findAllOccurrences(arr, target) {
    var result=[],index=arr.lastIndexOf(target);
    while(index>-1){
        result.push(index);
        arr.splice(index,1);//arr=arr.slice(0,index);
        index=arr.lastIndexOf(target);
    }
    return result;
}
//indexOf
function findAllOccurrences(arr, target) {
    var result=[],index=arr.indexOf(target);
    while(index>-1){
        result.push(index);
        index=arr.indexOf(target,index+1);
    }
    return result;
}

13 实现 fizzBuzz 函数，参数 num 与返回值的关系如下：
1、如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
2、如果 num 能被 3 整除，返回字符串 fizz
3、如果 num 能被 5 整除，返回字符串 buzz
4、如果参数为空或者不是 Number 类型，返回 false
5、其余情况，返回参数 num

function fizzBuzz(num) {
　　if(isNaN(num)){
　　　　return false
　　}
　　var res="";
　　if(num%3==0){
　　　　res += 'fizz'
　　}
　　if(num%5==0){
　　　　res += 'buzz'
　　}
　　return res?res:num
}