牛客网 JS能力测评经典题

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

function indexOf(arr, item) {

    var len = arr.length;

    for(var i = 0; i<len; i++) {

        if(arr[i] == item) {

            returni;

        }

    }

    return-1;

}

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

function sum(arr) {

    var arrn=arr.length;

    var nsum=0;

    for(var i=0;i<arr.length;i++){

        nsum=nsum+arr[i];

         

    }

    returnnsum;

}

• 添加笔记

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

function remove(arr, item) {

var arrn=arr.length;

var narr=[];    

    for(var i=0;i<arrn;i++){

        if(arr[i]!=item){

            narr.push(arr[i]);

        }

    }

    returnnarr;

}

 

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

function removeWithoutCopy(arr, item) {

var arrn=arr.length;

    for(var i=0;i<arrn;i++){

        if(arr[i]==item){

            arr.splice(i,1);

            i--;

        }

    }

    returnarr;

}

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

function append(arr, item) {

var arrn=arr.length;

var narr=[];

    narr=arr.slice(0);

    narr.push(item);

    returnnarr;

     

}

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

function truncate(arr) {

var narr=arr.slice(0);

    narr.pop();

    returnnarr;

}

• 添加笔记
• 
  

 

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

function prepend(arr, item) {

var narr=arr.slice(0);

  narr.unshift(item);

    returnnarr;

}

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

function curtail(arr) {

var narr=arr.slice(0);

narr.shift();

    returnnarr;

}

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

function concat(arr1, arr2) {

var arr3=arr1.concat(arr2);

    returnarr3;

}

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

function insert(arr, item, index) {

var narr=arr.length;

var newarr=[];

    for(var i=0;i<narr;i++){

        if(i==index){

            newarr.push(item);

        }

        newarr.push(arr[i])

    }

    returnnewarr;

}

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

function count(arr, item) {

    var n=0;

for(var i=0;i<arr.length;i++){

    if(arr[i]==item){

        n++;

    }

}

    returnn;

}

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

function duplicates(arr) {

 var j=[];   

 var narr=arr.sort();

   for(var i=0;i<arr.length;i++)

       {

    if(narr[i]==narr[i+1]&&j.indexOf(narr[i])==-1){

        j.push(narr[i]);

    }

       }

    returnj;

}

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

function square(arr) {

    var newarr=[];

     for(var i=0;i<arr.length;i++){

         newarr.push(arr[i]*arr[i]);

     }

    returnnewarr;

}

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

function findAllOccurrences(arr, target) {

var narr=[];

    for(var i=0;i<arr.length;i++){

    if(arr[i]==target){

        narr.push(i);

    }

}

    returnnarr;

}

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

function globals() {

    var myObject = {

      name : 'Jory'

    };

 

    returnmyObject;

}

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

function functions(flag) {

  

      function getValue() { return'a'; }

    

 

    returngetValue();

}

修改 js 代码中 parseInt 的调用方式，使之通过全部测试用例

function parse2Int(num) {

    returnparseInt(num,10);

}

判断 val1 和 val2 是否完全等同

function identity(val1, val2) {

 returnval1===val2

   

}

实现一个打点计时器，要求

1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1

2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作

3、第一个数需要立即输出

function count(start, end) {

    console.log(start);

    start++;

    var timer=setInterval(function(){

    if(start<=end){

    console.log(start);

    start++;

    }},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%3==0&&num%5==0){

    var str="fizzbuzz";

}

    elseif(num%3==0){

   var str="fizz";

   

    }

    elseif(num%5==0){var str="buzz";}

    elseif(num==null||isNaN(num)){

        var str=false;

    }

    else{var str=num;}

    returnstr;

}

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

function argsAsArray(fn, arr) {

returnfn.apply(this,arr);

}

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

function speak(fn, obj) {

returnfn.call(obj,obj);

}

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

1、返回值为一个函数 f

2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', '

3、所有函数的参数数量为 1，且均为 String 类型

function functionFunction(str) {

var f=function(a){

     

    returnstr+", "+a;

}

returnf;

}

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

1、返回一个函数数组 result，长度与 arr 相同

2、运行 result 中第 i 个函数，即 result[i]()，结果与 fn(arr[i]) 相同

function makeClosures(arr, fn) {

var result=[];

    for(var i=0;i<arr.length;i++){

        result[i]=(function(i){

            returnfunction()

                          {returnfn(arr[i]);

                                        }

                             }

  )(i)

}

      returnresult;

已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：

1、返回一个函数 result，该函数接受一个参数

2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致

function partial(fn, str1, str2) {

var result=function(str3){

     

    returnfn.call(this,str1,str2,str3);

}

returnresult;

}

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。

function useArguments() {

var a=Array.prototype.slice.call(arguments);

    var n=0;

    for(var i=0;i<a.length;i++){

        n+=a[i];

    }

    returnn;

}

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。

function useArguments() {

var a=Array.prototype.slice.call(arguments);

    var n=0;

    for(var i=0;i<a.length;i++){

        n+=a[i];

    }

    returnn;

}

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

1、返回的结果为调用 fn 之后的结果

2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {

var a=Array.prototype.slice.call(arguments,1);

    returnfn.apply(this,a);

}

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

1、返回的结果为调用 fn 之后的结果

2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {

  var a=Array.prototype.slice.call(arguments,1);

    returnfn.apply(null,a);

}

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

1、返回一个函数 result

2、调用 result 之后，返回的结果与调用函数 fn 的结果一致

3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {

var a=Array.prototype.slice.call(arguments,1);

    var result=function(){

            returnfn.apply(this,a.concat(Array.prototype.slice.call(arguments)));

        }

     

    returnresult;

}

已知 fn 为一个预定义函数，实现函数 curryIt，调用之后满足如下条件：

1、返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）

2、调用 a 之后，返回一个函数 b, b 的 length 属性值为 1

3、调用 b 之后，返回一个函数 c, c 的 length 属性值为 1

4、调用 c 之后，返回的结果与调用 fn 的返回值一致

5、fn 的参数依次为函数 a, b, c 的调用参数

function curryIt(fn) {

    var a=function(a){

        returnb=function(b){

            returnc=function(c){

                returnfn(a,b,c);

            }

        }

    }    

returna;

}

返回参数 a 和 b 的逻辑或运算结果

function or(a, b) {

        returna||b;

}

返回参数 a 和 b 的逻辑且运算结果

function and(a, b) {

returna&&b;

}

完成函数 createModule，调用之后满足如下要求：

1、返回一个对象

2、对象的 greeting 属性值等于 str1， name 属性值等于 str2

3、对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ' + name属性值

function createModule(str1, str2) {

 var obj = {

        greeting:str1,

        name:str2,

        sayIt:function(){

            returnthis.greeting+', '+this.name;

        }

    }

    returnobj;

}

获取数字 num 二进制形式第 bit 位的值。注意：

1、bit 从 1 开始

2、返回 0 或 1

3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

function valueAtBit(num, bit) {

var newbit=num.toString(2);

    returnnewbit[newbit.length-bit];

}

给定二进制字符串，将其换算成对应的十进制数字

function base10(str) {

var num=parseInt(str,2);

returnnum;

}

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

function convertToBinary(num) {

var str=num.toString(2);

    while(str.length<8){

        str="0"+str;

    }

    returnstr;

}

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

function multiply(a, b) {

returna*b;

}

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

function alterContext(fn, obj) {

returnfn.apply(obj);

}

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

function alterObjects(constructor, greeting) {

constructor.prototype.greeting=greeting;

    returnthis.greeting;

     

}

找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)

1、返回数组，格式为 key: value

2、结果数组不要求顺序

function iterate(obj) {

var arr=[];

    for(var k in obj){

        if(obj.hasOwnProperty(k)){

        var str=k+": "+obj[k];

        arr.push(str);

        }

         

    }

    returnarr;

}

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

function containsNumber(str) {

    var d=/\d/;

returnd.test(str);

}

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

function containsRepeatingLetter(str) {

    var reg = /([a-z])\1/ig;

    returnreg.test(str);

}

给定字符串 str，检查其是否以元音字母结尾

1、元音字母包括 a，e，i，o，u，以及对应的大写

2、包含返回 true，否则返回 false

function endsWithVowel(str) {

var g=/[a,e,i,o,u]$/i;

    returng.test(str);

}

给定字符串 str，检查其是否包含 3 个连续的数字

1、如果包含，返回最新出现的 3 个数字的字符串

2、如果不包含，返回 false

function captureThreeNumbers(str) {

    var a;

    if(str.match(/\d{3}/)){

       a=str.match(/\d{3}/);

        returna[0];

         

    }

    else{

        returnfalse;

    }

}

给定字符串 str，检查其是否符合如下格式

1、XXX-XXX-XXXX

2、其中 X 为 Number 类型

function matchesPattern(str) {

    var d=/^\d{3}-\d{3}-\d{4}$/;

     

        returnd.test(str);

     

    

}

给定字符串 str，检查其是否符合美元书写格式

1、以 $ 开始

2、整数部分，从个位起，满 3 个数字用 , 分隔

3、如果为小数，则小数部分长度为 2

4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3

function isUSD(str) {

    var d=/^\$\d{1,3}(\,\d{3})*(\.\d{2})?$/;

    returnd.test(str);

}