Question

这听起来有点不寻常，我以前从来不需要用这种方式使用方括号表示法，绞尽脑汁我想不出能产生预期结果的方法。

我正在实现一个回调包装器，以便在将方法作为回调传递时维护this的引用

e.g。

foo.prototype.wrap = function(name){
    var wrapper,
        self = this;

    wrapper = function(){
        self[name](arguments);
    };

    return wrapper;
};

// usage

foo.wrap('bar');

// executes foo.bar maintaining 'this' as a reference to foo

我遇到的问题是foo有一些嵌套方法

e.g。

foo.bar.close();

我正试图想办法让wrap方法支持嵌套方法

e.g。

foo.wrap('bar.close')

// or

foo.wrap('bar','close');

因此foo.wrap函数需要动态添加与传入的长度或参数对应的方括号。

e.g。

self[x][y][z](arguments);

我想不出办法做到这一点。有任何想法吗？

我有一种潜行的怀疑，但这是不可能的。

Answer 1

我必须有一天忘记一切：）

虽然@ NilColor的答案是正确的，但我确实知道，我只是没想到正确的帽子。

无论如何，我决定我仍然喜欢有一个包装器的想法，当你将它附加到你的对象时需要更少的特异性。并且有点不那么冗长。

所以我把它和我原来的想法一起写下来，你可能会喜欢它。

myObj.wrap = function(path, context){ 
    var wrapper,
        method = ( typeof path != 'string' && context )? path : this,
        context =  (typeof path === 'object' && context === undefined)? 
            path : (context || this);

    if (typeof path === 'string'){
        path = path.split('.');

        for ( var i = 0; i < path.length; i++ ){
            method = method[path[i]];
            if ( context === true  )
                context = ( i === path.length - 2 )? method : context; 
        };
    };

    wrapper = function(){
        method.apply(context, arguments);
    };

    return wrapper;
}

用法：

将任意数量的嵌套方法绑定到myObj

    myObj.wrap('foo') //binds myObj.foo to myObj

// or

    myObj.wrap('foo.bar') //binds myObj.foo.bar to myObj

//or if myObj is a function

    myFunc.wrap() // binds myFunc to myFunc

将myObj的方法绑定到另一个对象

    myObj.wrap('foo.bar', someObj) //binds myObj.foo.bar to someObj

//or if myObj is a function

    myFunc.wrap(someObj) //Binds myFunc to someObj

将嵌套方法绑定到它的父

    myObj.wrap('foo.bar', true) // binds myObj.foo.bar to myObj.foo

用作帮助

    myObj.wrap(someFunc, someObj) //binds someFunc to someObj

如果您不是在方法绑定的上下文中寻找原始问题的答案。

myObj.getProps = function(path, context){
var context = context || this;
    path = path.split('.');


for ( var i = 0; i < path.length; i++ ){
            context = context[path[i]];
    };

    return context;
};

用法：

附加到对象或作为独立函数

获取属性

myObj.getProps('foo.bar') // returns mayObj.foo.bar

给它一个上下文对象

myObj.getProps('user.name', myAccounts) // returns myAccounts.user.name

将其用作独立功能替换

myObj.getProps = function(path,context){....}

与

function getProps(path,context){....}

注意

如果将它用作独立功能，您需要记住它将从this的范围开始查看。因此，如果它在全局范围内定义，则需要提供完整路径。

e.g。

getProps('myObj.foo.bar')

您仍然可以使用上下文选择器来更改参考对象。

Answer 2

“绑定”this的一般概念是这样的：

function bind(method, context) {
      var args = Array.prototype.slice.call(arguments, 2);
      return function() {
            var a = args.concat(
                               Array.prototype.slice.call(arguments, 0));
            return method.apply(context, a);
      }
}

通过这种方式，您可以获得带有method（this）的context的引用。这样您可以绑定嵌套方法，如下所示：

> foo = {}
> foo.a = function(){console.log('a'); console.log(this)}
> bar = {bar: 'yeah'}
> f = bind(foo.a, bar)
> f()
-> a
-> {bar: 'yeah', __proto__: Object}

这是你要找的东西吗？

Javascript方括号表示法多个动态属性

2 个答案: