首页 > 试题广场 >

二次封装函数

[编程题]二次封装函数

热度指数：62543 时间限制：C/C++ 2秒，其他语言4秒空间限制：C/C++ 256M，其他语言512M
算法知识视频讲解

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

示例1

输入

无

输出

无

算法知识视频讲解

云_飘

function partialUsingArguments(fn) {
    var arg = [].slice.call(arguments,1); //此处的arguments为partialUsingArguments的参数
	var result = function(){
        return fn.apply(this,arg.concat([].slice.call(arguments)));//此处的arguments为result的参数
    }        
    return result;
}

编辑于 2016-08-04 17:08:50 回复(0)

更多回答

vaakian

const partialUsingArguments = (fn, ...remains) => {
    return (...args) => fn(...remains, ...args)
}

或者

const partialUsingArguments = (fn, ...remains) => (...args) => fn(...remains, ...args)

编辑于 2021-09-09 12:27:11 回复(1)

webchang

function partialUsingArguments(fn) {
    let args = [...arguments].slice(1);
    return function() {
        let arr = [...arguments];
        return fn.apply(null,args.concat(arr));
    }
}

发表于 2021-03-18 20:28:42 回复(0)

JavaScript

求求offer看看孩子吧

1、bind方法

function partialUsingArguments(fn) {
    return fn.bind(this, ...[...arguments].slice(1));
}

2、call方法

function partialUsingArguments(fn) {
    var arr = [...arguments].slice(1);
    return function() {
        return fn.call(this, ...arr, ...arguments);
    }
}

3、apply方法

function partialUsingArguments(fn) {
    var arr = [...arguments].slice(1);
    return function() {
        return fn.apply(this, arr.concat(...arguments));
    }
}

4、es6

function partialUsingArguments(fn) {
    var [_, ...arr] = arguments;
    return (...args) => fn(...arr, ...args);
    // return (...args) => fn.call(fn, ...arr, ...args);
}

5、bind + apply 方法

function partialUsingArguments(fn) {
    var arr = [...arguments].slice(1);
    arr.unshift(fn);    // fn、null、this都可以
    return fn.bind.apply(fn,arr);   // arr[0]为传给bind的第一个参数
}

发表于 2020-07-16 03:52:26 回复(0)

牛客184739658号

function partialUsingArguments(fn) {
    // ES6
    var [a, ...arr1] = arguments;
    function result(){
        var [...arr2] = arguments;
        return fn(...arr1, ...arr2)
    }
    
    return result;
}

发表于 2019-11-04 22:29:36 回复(0)

Corvey

function partialUsingArguments(fn) {
    var args = Array.prototype.slice.call(arguments, 1);
    args.unshift(this);
    return Function.prototype.bind.apply(fn, args);
}

发表于 2018-03-25 18:05:00 回复(0)

牛客9151364号

function partialUsingArguments(fn){
	//得到partialUsingArguments方法第一个参数后面的参数组成的数组
	var args=Array.prototype.slice.call(arguments,1);  
	var result=function(){
		//将上面的args和result的参数组合成一个数组argss
		var argss=args.concat(Array.prototype.slice.call(arguments));
		//fn调用这个参数数组
		return fn.apply(null,argss);
	}
	return result;
}

这样写好不好？

发表于 2017-07-05 00:19:29 回复(1)

青ツ玉

function partialUsingArguments(fn) {
    var args = Array.prototype.slice.call(arguments,1);
	var result = function(){
        var arr = args.concat(Array.prototype.slice.call(arguments,0));
        return fn.apply(this,arr);
    }
    return result;
}

测试通过！

发表于 2017-04-10 16:15:17 回复(0)

Aurora1

function partialUsingArguments(fn) {
            var slice = Array.prototype.slice;
            var args = slice.call(arguments, 1);
            return function () {
                args = args.concat(slice.call(arguments));
                return fn.apply(this,args);
            }
        }

编辑于 2016-11-18 21:33:47 回复(0)

牛客(Yangfan)

function partialUsingArguments(fn) {
  var args=[].slice.call(arguments,1);
  //fn.apply(null,args);
  var result=function () {
    return  fn.apply(this,args.concat([].slice.call(arguments)));
  };
  return result;
}

发表于 2016-07-16 20:36:52 回复(0)

mingmingcome

function partialUsingArguments(fn){  var args=arguments;  function array(a,n){  return Array.prototype.slice.call(a,n||0);
    }  return function(){  var a=array(args,1);  a= a.concat(array(arguments));  return fn.apply(this,a);
            }
   }  var a = 1;  var b = 2;  var c = 3;  var d = 4;  var test = function (first, second, third, forth) {  return first + second + third + forth;
    };  document.write(partialUsingArguments(test, a, b)(c, d));  /* 题目是二次封装函数，在javascript权威指南第六版p197中说的不完全函数就是这个 是一种函数变换技巧，即把一次完整的函数调用拆成多次函数调用，每次传入的实参都是完整的一部分， 每个分开的函数叫做不完全函数，每次函数调用叫做不完全调用，这种函数调用的特点是每次调用都返回一个函数， 直到得到最终运行结果位置，for example，将对函数f(1,2,3,4,5,6)的调用修改为等价的f(1,2)(3,4)(5,6), 后者包含三次调用，和每次调用相关的函数就是“不完全函数”  */

编辑于 2017-03-27 18:31:00 回复(0)

aidim78

哈哈，看来大家都知道arguments不是真的数组了，需要转化这一步很关键，使用原型调用slice方法生成数组u，concat进行拼接，但是原来的数组不变化，需要赋值另一个数组。

function partialUsingArguments(fn) {

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

return function(){

argument=argument.concat(Array.prototype.slice.call(arguments));

return fn.apply(this,argument);

};

}

编辑于 2016-03-20 19:49:08 回复(1)

牛客260006号

    //第一种
    function partialUsingArguments(fn) {
        var args = Array.prototype.slice.call(arguments,1);
        return fn.bind(this, args[0],args[1]);
    }
   //第二种
   function partialUsingArguments(fn) {
        var slice = Array.prototype.slice;
        var args = slice.call(arguments, 1);
        return function() {
            return fn.apply(this, args.concat(slice.call(arguments)));
        }
    }

编辑于 2016-04-01 15:19:24 回复(4)

ultimanecat

function partialUsingArguments(fn) {

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

return function () {

return fn.apply(null, arr.concat([].slice.call(arguments)));

};

}

var a = 1; var b = 2; var c = 3; var d = 4;

var test = function (first, second, third, forth) {return first + second + third + forth;};

console.log(partialUsingArguments(test, a, b)(c, d));

发表于 2016-12-05 11:43:55 回复(0)

希留

arguments不能用slice方法直接截取，需要先转换为数组，var args = Array.prototype.slice.call(arguments);合并参数可以使用concat方法，并且也需要将arguments先转换为数组才能使用concat进行合并。最用使用apply执行传入的函数即可。

function partialUsingArguments(fn) {
     //先获取p函数第一个参数之后的全部参数
     var args = Array.prototype.slice.call(arguments,1);
     //声明result函数
     var result = function(){
         //使用concat合并两个或多个数组中的元素
         return fn.apply(null, args.concat([].slice.call(arguments)));
     }
     return result;
 }

编辑于 2015-08-19 10:50:20 回复(32)

离暮

function partialUsingArguments(fn) {
    var arr = Array.prototype.slice.call(arguments,1);
    arr.unshift(null);
    return fn.bind.apply(fn,arr);
}

发表于 2017-07-24 14:40:46 回复(10)

hzm0321

function partialUsingArguments(fn) {

const [f,...res] = argument

return (...rest)=>fn(...res,...rest);

}

发表于 2020-03-23 20:41:23 回复(3)

fuff

function partialUsingArguments(fn) {

var a=Array.prototype.slice.call(arguments,1); //获得函数partialUsingArguments() 除第一个参数外的参数数组

var result=function(){

var b=Array.prototype.slice.call(arguments); //获得函数result的参数数组

return fn.apply(this,a.concat(b));

}

return result;

}

发表于 2016-07-22 13:33:37 回复(2)

JavaScript

牛牛abc

function partialUsingArguments(fn) {
    var OuterArgs = Array.prototype.slice.call(arguments, 1);
    var res = function(){
        var resArgs = Array.prototype.slice.call(arguments);
        return fn.apply(null ,OuterArgs.concat(resArgs));
    }
    return res;
}

这么写就清晰了～

发表于 2018-07-05 15:56:53 回复(1)

Kylewwh

function partialUsingArguments(fn) {
	var args = [].splice.call(arguments,1);
    if ( args.length < fn.length ) {
        return function() {
            return fn.apply(null, [].concat.call(args, [].slice.call(arguments)));
        }
    } else {
        return fn.apply(null, args.slice(0,fn.length));
    }
}

发表于 2017-03-14 19:05:15 回复(0)

duginsea

function partialUsingArguments(fn) {
       //外层函数的参数,除了第一个参数fn外,剩下的保存成真正的数组arg1
	var arg1 = Array.prototype.slice.call(arguments,1);
    	return function result(){
            //内层函数的参数arguments保存成数组arg2
            var arg2 =  Array.prototype.slice.call(arguments,0);
            //数组拼贴成一个args,以便传给fn
            var args = arg1.concat(arg2);
            return fn.apply(null,args);
        };
}

发表于 2016-08-05 20:27:58 回复(0)