Question

我不确定我是否正确地表达了问题标题;请考虑以下内容以澄清...

(function() {
    var foo = {
        bar: function() {
            // Is it possible to reference 'this' as the
            // initializing 'object' aka 'e' and not 'foo' ?
            // The easy part, currently because 'this' refers to 'foo',
            // is returning 'this' aka 'foo' so that chaining can occur
            return this;
        },
        other: function() {
            return this;
        }
    };
    Event.prototype.foo = foo; 
}());

// usage
document.onmousemove = function(e) {
    e.foo.bar().other();
};

我如何在this的方法/道具中访问foo，但this引用最初的object又名e和不是foo？

我想出的最好的就是这个

(function() {
    var foo = function() {
        var _foo = this.foo;
        _foo._this = this; //recursive reference that I am VERY worried about
        return _foo;
    };
    foo.bar = function() {
        var _this = this._this; //_this refers to initial 'object', 'e'
        return this; //return 'foo' aka 'this' for function chaining
    };
    foo.other = function() {
        var _this = this._this;
        return this;
    };
    Event.prototype.foo = foo; 
}());

// usage
document.onmousemove = function(e) {
    e.foo().bar().other();
};

我目前的工作方式，但我担心一些事情......

1.将e分配给e.foo._this的递归参考

和

2.将e分配给e.foo._this的冗余，如果this可以作为e而不是foo进行访问，则会使“事情”更具效果，尤其是关于像mousemove事件这样的事情。

jsFiddle Here

另外，我试图避免这样的事情......

document.onmousemove = function(e) {
    e.foo.bar.call(e);
};

感谢所有建议，感谢您的时间。

Answer 1

也许这对你有用：

使用apply方法更改被调用方法中的this上下文，并使用this.foo来引用foo：

(function () {
    var foo = function () {
        console.log(this);
        return this.foo;
    };
    foo.bar = function () {
        console.log(this);
        return this.foo;
    };
    foo.other = function () {
        console.log(this);
        return this.foo;
    };
    Event.prototype.foo = foo;
}());

// usage
document.onclick = function (e) {
    console.log(
        e.foo.apply(e).bar.apply(e).other.apply(e)
    );
};

<强> FIDDLE

Answer 2

通过对您拥有的内容进行微妙的更改，您可以使事情变得更简单：

(function() {
    var foo = function() {
      this.foo.event = this;
      return this.foo;
    };
    foo.bar = function() {
      /// the event can be found in this.event
      return this;
    };
    foo.other = function() {
      /// the event can be found in this.event
      return this;
    };
    Event.prototype.foo = foo;
}());

// usage
document.onmousedown = function(e) {
    e.foo().bar().other();
};

然而，这会对共享对象foo进行更改，您可能希望重写内容，以便e.foo()返回foo的新实例，并将您的其他方法移至foo's原型。

(function() {
    var foo = function(event) {
      this.event = event;
    };
    foo.prototype.bar = function() {
      /// the event can be found in this.event
      return this;
    };
    foo.prototype.other = function() {
      /// the event can be found in this.event
      return this;
    };
    Event.prototype.foo = function() {
      return new foo(this);
    };
}());

这样您每次都会创建一个foo的新实例，但这意味着您添加的event属性已本地化为该实例;原型方法将在所有实例中共享，因此从优化的角度来看，它并不是太糟糕。

Answer 3

将函数绑定到对象可能更简单：

someElement.onEvent = myObject.myHandlerFunction.bind(myObject);

所以当调用这个函数时，它的'this'将是myObject。

然后你可以使用e.target来访问元素。

将`this`的继承扩展到`object`的方法/属性

3 个答案: