1

初心者の質問です。検討

var foo = function(func) {
console.log(func.arguments);
}

「foo」関数は、関数である 1 つの引数を取ります。実行時に「func」関数とともに渡される引数にアクセスするにはどうすればよいですか?

編集: 引数を動的に func に設定したくありません。func で渡された引数を調べて、それらを使って何か他のことができるようにしたいのです。基本的には、func に渡された引数をキーとして格納し、その func の結果を値として格納し、それらをハッシュ オブジェクトに格納したいと考えています。引数が渡されます。今のところ、これらの引数にアクセス/保存する方法について好奇心がそそられます。

4

6 に答える 6

2

foorun が呼び出されていないときのように、foo実行時にそれらにアクセスすることはできませんfunc

foo(function(){
    console.log('This is never executed');
});

func内で実行する場合はfoo、その時点で引数にアクセスできる必要があります。

var foo = function(func) {
    func(1, 2, 3); // Now func is called, and you know what the arguments are
}
于 2013-08-12T17:49:55.083 に答える
0
//
//     var
//         base_fn    = function(){}, 
//         tracer_fn  = tracer( base_fn );
//
function tracer( fn ) { 

   return ( function( argsCache, F, _s ){ 


               // define new fn that will have that capability
               // it's a wrapper for original fn

               var
                   fn2    = function(/*...params*/) {

                              var

                                // temporary stores original fn's result
                                out, 

                                // capture passed arguments
                                theArgs = _s.call( arguments ), 


                                //
                                //  you can implement 'memo' functionality here
                                //  if that's your goal, 
                                //  by 'scaning' already processed inputs
                                //  in argsCache array
                                //  and optionaly runing original fn, 
                                //  if no match is found
                                //

                                // save input and output of fn as h-map
                                argsIO  = {
                                            input  : theArgs, 
                                            output : null
                                          };

                                // execute original fn 
                                // pass it captured arguments
                                // 'remember' it's result
                                out = F.apply( this, theArgs );

                                // save calculated value
                                argsIO.output = out;

                                // 'push' fn input-output record on the cache
                                argsCache.push( argsIO );

                                // return whatever original fn returned
                                return out;

                            };

                  // provide 'static' access to 'closured' cache
                  // use the array to inspect 'arguments history'
                  fn2.args = argsCache;

                  // provide a way to empty cache
                  fn2.clear = function () { 
                      fn2.args.splice( 0, fn2.args.length );
                      return fn2.args;
                  };

                  // return fn 'upgrade'
                  return fn2;

   } )( [], fn, Array.prototype.slice );

}


function basefn() {

   // doStuff( arguments );
   // returning value, as well as arguments, 
   // are recorded by tracer fn

   return arguments.length;
}


// get the 'tracer' fn
var
   fn = tracer( basefn );



// run it couple of times 
// passing arbitrary arguments
fn( 12345, new XMLHttpRequest() );
fn('a', 'z', /^[a-z]+$/ );
fn( {}, [1,2,3] );
fn( location, document );
fn( Math );

//
// access 'args history' through fn.args ( array ) property
//
//   var
//       lastCallIO = fn.args[ fn.args.length - 1 ];
//

console.log( fn.args );

//
// empty cache, free some memory
//
//   fn.clear();
//
//
于 2013-08-12T19:40:11.890 に答える
0

このようなものが欲しいですか?

var foo = function(func) {
    return func.args;
},
bar = function(){
    bar.args = arguments;
};
bar('a','b');
foo(bar); // Arguments object ['a','b']
于 2013-08-12T18:01:23.240 に答える
0

func が呼び出されたときにその引数にアクセスすることはできませんが、func をラップし、その関数が呼び出されたときに追加の処理を行う新しい関数を返すことができます。foo のローカル変数は、返される関数のすべての呼び出し間で共有されるため、メモ化の実装に使用できます。

var foo = function(func) {
    return function() {
        // Get arguments from func.
        console.log("Calling func", arguments);
        // Call func with arguments.
        return func.apply(null, arguments);
    };
};

var bar = function(x) {
    return x * 2;
};

var foobar = foo(bar);

console.log(foobar(10));
console.log(foo(bar)(20));
于 2013-08-12T20:46:42.443 に答える
0

関数を引数として渡す場合、関数には引数が渡​​されません。関数内で呼び出される必要がある関数への参照を渡している場合、引数があります。

関数をまだ呼び出していないため、 funcisの引数はほとんどと言っても過言ではありません。undefinedのスコープからfoo、引数を好きなように設定できます。

于 2013-08-12T17:50:02.787 に答える