js能力测评经典题分析（二）函数

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

//看返回值 getValue()，原本的函数定义便不符合需求，以变量的形式存储，方便调用
function functions(flag) {
    if (flag) {
      var getValue=function(){return 'a';}//function getValue() { return 'a'; }
    } else {
      var getValue=function(){return 'b';}//function getValue() { return 'b'; }
    }

    return getValue();
}

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

如输入：'12px'，输出：12

function parse2Int(num) {
   var i=0;
   while(num[i]>='0' && num[i]<='9'){
       i++;    
   }
    return parseInt(num.slice(0,i));
}

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

方法一：setInterval和clearInterval，setInterval方法主要是调用函数执行
function count(start, end) {
    console.log(start++);
    var st=setInterval(function(){
        if(start<=end)
            console.log(start++);
    },100);
    return {
        cancel: function(){clearInterval(st);}
    }
}
方法二：setTimeout和clearTimeout，setTimeout方法主要是采用递归的方式执行
function count(start, end) {
    if(start<=end){
        console.log(start++);
        st=setTimeout(function(){//此处有一点，st的定义，不能用var st=……
            count(start,end);
        },100);
    }
    return {
        cancel: function(){clearTimeout(st);}
    }
}

4、实现 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%15==0){
        return 'fizzbuzz';
    }else if(num%5==0) return 'buzz';
     else if(num%3==0) return 'fizz';
    return num;
}

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

输入：function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']

输出：Hello, Ellie!

//函数名.apply(上下文,数组名)
//函数名.call(上下文,各参数)
function argsAsArray(fn, arr) {
    return fn.apply(this,arr);
}

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

输入：function () {return this.greeting + ', ' + this.name + '!!!';}, {greeting: 'Hello', name: 'Rebecca'}

输出：Hello, Rebecca!!!

//方法一：利用bind绑定函数的上下文，再调用函数
function speak(fn, obj) {
    return fn.bind(obj)();
}
//方法二：call第一个参数为函数的上下文，对第一个参数进行赋值即可
function speak(fn, obj) {
    return fn.call(obj);
}
//方法三：apply与call同，第一个参数为函数的上下文，对第一个参数进行赋值即可
function speak(fn, obj) {   
    return fn.apply(obj);
}

7、实现函数 functionFunction，调用之后满足如下条件：
（1）返回值为一个函数 f
（2）调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', '
（3）所有函数的参数数量为 1，且均为 String 类型

输入：functionFunction('Hello')('world')

输出：Hello, world

//此函数仅限案例中输入输出的格式，函数名(参数一)(参数二)
function functionFunction(str) {
    return function(s){
        return str+', ' +s;
    }
}

8、实现函数 makeClosures，调用之后满足如下条件：
（1）返回一个函数数组 result，长度与 arr 相同
（2）运行 result 中第 i 个函数，即 result[i]()，结果与 fn(arr[i]) 相同

输入：[1, 2, 3], function (x) { return x * x; }

输出：4

//此题主要考察的是数组内如何存放函数，将函数压入到数组内，直接将数组返回即可。
function makeClosures(arr, fn) {
    var newArray=[];
    arr.forEach(function(e){
        newArray.push(function(){
            return fn(e);
        })
    })
    return newArray;
}

9、已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
（1）返回一个函数 result，该函数接受一个参数
（2）执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致

输入：var sayIt = function(greeting, name, punctuation) {     return greeting + ', ' + name + (punctuation || '!'); };  partial(sayIt, 'Hello', 'Ellie')('!!!');

输出：Hello, Ellie!!!

//此题主要是partial对fn的一个二次封装函数
function partial(fn, str1, str2) {
    var result=function(str3){
        return fn(str1, str2,str3);
    }
    return result;
}

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

输入：1, 2, 3, 4

输出：10

//此题的重点是利用函数的arguments，获取此函数传递的参数
function useArguments() {
    var sum=0;
    for(i=0;i<arguments.length;i++){
        sum+=arguments[i];
    }
    return sum;
}

11、实现函数 callIt，调用之后满足如下条件
（1）返回的结果为调用 fn 之后的结果
（2）fn 的调用参数为 callIt 的第一个参数之后的全部参数

//对于函数的arguments是不能进行处理的，arguments.slice会无效，甚至产生错误，因此采用下面这种方式产生新的数组
function callIt(fn) {
   return fn.apply(this,[].slice.call(arguments,1)) ;
}

12、实现函数 partialUsingArguments，调用之后满足如下条件：
（1）返回一个函数 result
（2）调用 result 之后，返回的结果与调用函数 fn 的结果一致
（3）fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

//利用arguments获取调用函数时传递的参数，此处需要注意，arguments在哪个函数内部，便获取该函数调用时参数
function partialUsingArguments(fn) {
    var arg=[].slice.call(arguments,1);
    function result(){
        return fn.apply(this,arg.concat([].slice.call(arguments)));
    }
    return result;
}

13、已知 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 的调用参数

输入：var fn = function (a, b, c) {return a + b + c}; curryIt(fn)(1)(2)(3);

输出：6

//方法一：利用局部递归的方式执行内部函数，直至函数内部return
function curryIt(fn) {
    var n=fn.length;
    var arr=[];
    var result=function(x){
        arr.push(x);
        if(arr.length==n) return fn.apply(this,arr);
        return result;
    }
    return result;
}
//方法二：利用函数签到函数的方式进行，此方法仅限三个括号即函数名(fn)(参数一)(参数二)(参数三)
function curryIt(fn) {
    return function(x){
        return function(y){
            return function(z){
                return fn.call(this,x,y,z);
            }
        }
    }
}

结束语：

考察函数的题目前就到这儿，我仅将我的理解和解法贴出来，希望对自己和大家有所借鉴和参考。