JS能力测评试题

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

function indexOf(arr, item) {
   return arr.indexOf(item);
}

function indexOf(arr, item){
    var index = -1;
    arr.forEach(function(res,i){
        if(res === item && index === -1){
            index = i;
        }
    });
    return index;
}

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

function indexOf(arr, item) {
    var len = arr.length;
    for(var i = 0; i<len; 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，结果返回新的数组 

//1.splice()
function 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;
}
//2.push()
function remove(arr,item){
    var newarr = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i] != item){
            newarr.push(arr[i]);
        }
    }
    return newarr;
}
//3.Array y.prototype.filter()
function remove(arr,item){
    return arr.filter(function(ele){
         return ele != item;
    })
}

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

splice(index,len,[item])    注释：该方法会改变原始数组。
splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值
index:数组开始下标        len: 替换/删除的长度       item:替换的值，删除操作的话 item为空
如：arr = ['a','b','c','d']

删除 ----  item不设置
arr.splice(1,1)   //['a','c','d']         删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变
arr.splice(1,2)  //['a','d']          删除起始下标为1，长度为2的一个值，len设置的2

替换 ---- item为替换的值
arr.splice(1,1,'ttt')        //['a','ttt','c','d']         替换起始下标为1，长度为1的一个值为‘ttt’，len设置的1
arr.splice(1,2,'ttt')        //['a','ttt','d']         替换起始下标为1，长度为2的两个值为‘ttt’，len设置的1

添加 ----  len设置为0，item为添加的值
arr.splice(1,0,'ttt')        //['a','ttt','b','c','d']         表示在下标为1处添加一项‘ttt’
function removeWithoutCopy(arr, item) {
    for (var i=0; i<arr.length; i++) {
        if (item == arr[i]) {
            arr.splice(i,1);
            i--;
        }
    }
    return arr;
}

function removeWithoutCopy(arr, item) {
    while(arr.indexOf(item) != -1){
        arr.splice(arr.indexOf(item),1);
    }
    return arr;
}

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

/**
 * 普通的迭代拷贝
 * @param arr
 * @param item
 * @returns {Array}
 */
var append = function(arr, item) {
    var length = arr.length,
        newArr = [];
 
    for (var i = 0; i < length; i++) {
        newArr.push(arr[i]);
    }
 
    newArr.push(item);
 
    return newArr;
};
 
/**
 * 使用slice浅拷贝+push组合
 * @param arr
 * @param item
 * @returns {Blob|ArrayBuffer|Array.<T>|string}
 */
var append2 = function(arr, item) {
    var newArr = arr.slice(0);  // slice(start, end)浅拷贝数组
    newArr.push(item);
    return newArr;
};
 
/**
 * 使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回
 * @param arr
 * @param item
 * @returns {Array.<T>|string}
 */
var append3 = function(arr, item) {
    return arr.concat(item);
};

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

function truncate(arr) {
    return arr.slice(0, -1);
 }
 
//slice()可以返回数组的一段，且返回的仍然是数组。

//pop方法可以删除数组的最后一个元素。
function truncate(arr) {
    var a = [];
    a = arr.slice(0);
    a.pop(arr[arr.length-1]);
    return a;
}

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

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.合并数组 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;
}

10.在数组 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;
}

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

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

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

13.求二次方(为数组 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 newarr = arr.slice(0);
        //复制一个arr数组
    for (var i=0;i<newarr.length;i++){
        newarr[i]= newarr[i]* newarr[i];
    }
    return newarr;
}

14.给定字符串 str，检查其是否符合美元书写格式
1、以 $ 开始
2、整数部分，从个位起，满 3 个数字用 , 分隔
3、如果为小数，则小数部分长度为 2
4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3 

function isUSD(str) {
    var re = /^\$([1-9]\d{0,2}(,\d{3})*|0)(\.\d{2})?$/;
    return re.test(str);
}

15.给定字符串 str，检查其是否符合如下格式
1、XXX-XXX-XXXX
2、其中 X 为 Number 类型 

function matchesPattern(str) {
    var reg = /^(\d{3}\-){2}\d{4}$/;
    return reg.test(str);
}

16.给定字符串 str，检查其是否包含 连续3个数字 
1、如果包含，返回最新出现的 3 个数字的字符串
2、如果不包含，返回 false 

function captureThreeNumbers(str) {
    var reg;
    if (reg = str.match(/(\d{3})/)) {
        return reg[0];
    } else {
        return false;
    }
}

17.给定字符串 str，检查其是否以元音字母结尾
1、元音字母包括 a，e，i，o，u，以及对应的大写
2、包含返回 true，否则返回 false 

function endsWithVowel(str) {
    var reg = /[aeiou]$/gi;
    return reg.test(str);
}

18.给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false 

function containsRepeatingLetter(str) {
    return /([a-zA-Z])\1/.test(str);
}

19.给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false 

function containsNumber(str) {
    var reg = /\d/gi;
    return reg.test(str);
}

20.找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
1、返回数组，格式为 key: value
2、结果数组不要求顺序 

function iterate(obj) {
     var arr = [];
     //使用for-in遍历对象属性
     for(var key in obj){
         //判断key是否为对象本身的属性
         if(obj.hasOwnProperty(key)){
             //将属性和值按格式存入数组
             arr.push(key+": "+obj[key]);
         }
     }
     return arr;
 }

21.给定一个构造函数 constructor，请完成 alterObjects 方法，将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量。

function alterObjects(constructor, greeting) {
  constructor.prototype.greeting = greeting;
 }

22.将函数 fn 的执行上下文改为 obj，返回 fn 执行后的值 

function alterContext(fn, obj) {
  return fn.bind(obj)();//.bind()返回的是一个函数，所以需要立即执行。 }
 
function alterContext(fn, obj) {
  return fn.call(obj);
}
 
function alterContext(fn, obj) {
  return fn.apply(obj);
}

23.求 a 和 b 相乘的值，a 和 b 可能是小数，需要注意结果的精度问题 

function multiply(a, b) {
    return a*b;
}

24.将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。 

function convertToBinary(num) {
    var str = num.toString(2);
    while(str.length < 8) {
        str = "0" + str;
    }
     
    return str;
}

function convertToBinary(num) {
       var toBit = num.toString(2);
       return  ( toBit / Math.pow(10, 8) ).toFixed(8).substr(2);
}

function convertToBinary(num) {
  return ('00000000'+num.toString(2)).substr(-8);
}

function convertToBinary(num) {
  return ('00000000' + num.toString(2)).slice(-8);
}

 function convertToBinary(num) {
        var num2=num.toString(2);
            for(num2.length;num2.length<8;){
                num2='0'+num2
            }
            return num2;
    }

function convertToBinary(num) {
     //转换为2进制格式
     var s = num.toString(2);
     //获得2进制数长度
     var l = s.length;
     if(l<8){
         //声明一个字符串用于补满0
         var s1 = "0000000";
         var s2 = s1.slice(0,8-l);
         s = s2+s; 
     }
     return s;
 }

25.