JavaScript 自执行函数 - 有什么区别?

发布于 2024-12-18 00:02:37 字数 360 浏览 0 评论 0原文

我通过使用 jQuery 非常熟悉自执行函数。

(function($) { /* do stuff */ })(jQuery);

今天我正在阅读backbone.js 源代码,注意到他们这样做:

(function() { /* do stuff */ }).call(this);

这实现了同样的事情吗?下面的两行代码会做同样的事情吗?

(function($) { /* do stuff */ })(jQuery);
(function($) { /* do stuff */ }).call(jQuery);

I am very familiar with self executing functions from working with jQuery.

(function($) { /* do stuff */ })(jQuery);

Today I was reading the backbone.js source and noticed that they do this:

(function() { /* do stuff */ }).call(this);

Is this achieving the same thing? Would the following 2 lines of code do the same thing?

(function($) { /* do stuff */ })(jQuery);
(function($) { /* do stuff */ }).call(jQuery);

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

不必你懂 2024-12-25 00:02:37

第一种形式是传入参数,而第二种形式是在执行函数中设置“this”所指的内容。他们是不同的。

(function(x){ console.log(this,x); })( jQuery );
//--> [window object]
//--> [jQuery object]

(function(x){ console.log(this,x); }).call( jQuery );
//--> [jQuery object]
//--> undefined

(function(x){ console.log(this,x); }).call( jQuery, jQuery );
//--> [jQuery object]
//--> [jQuery object]

有关更多信息,请参阅 Function.prototype.call< /code>Function.prototype.apply

这是您可能想要使用 call 技术的情况

v = 'oh noes!'
var o = {
  v : 42,
  f : function(){
    console.log(this.v);
    (function(){ console.log(this.v) })();
  }
};
o.f();
// --> 42
// --> 'oh noes!'

:通过 call() 获取 this 的值,自调用函数在 Global(窗口)范围内调用,而不是当前对象。

The first form is passing in a parameter, while the second form is setting what 'this' refers to inside the executing function. They are different.

(function(x){ console.log(this,x); })( jQuery );
//--> [window object]
//--> [jQuery object]

(function(x){ console.log(this,x); }).call( jQuery );
//--> [jQuery object]
//--> undefined

(function(x){ console.log(this,x); }).call( jQuery, jQuery );
//--> [jQuery object]
//--> [jQuery object]

For more information, see Function.prototype.call and Function.prototype.apply.

Here's a case where you might want to use the call technique:

v = 'oh noes!'
var o = {
  v : 42,
  f : function(){
    console.log(this.v);
    (function(){ console.log(this.v) })();
  }
};
o.f();
// --> 42
// --> 'oh noes!'

Without setting the value of this via call(), the self-calling function is invoked in the scope of the Global (window), not the current object.

无声无音无过去 2024-12-25 00:02:37

在他们的例子中:

(function() { /* do stuff */ }).call(this);

...他们确保使用 this 的特定值调用该函数(例如,函数中的 thisthis 相同) code>this 在函数之外)。

在您的情况下:

(function($) { /* do stuff */ })(jQuery);

...您的函数中的 this 将是全局对象,因为您调用它时没有执行任何设置 this 的操作,因此 this 默认为全局对象(window,在浏览器上)。

在 JavaScript 中,this 完全由函数的调用方式设置。有两种主要方法:

  1. 通过调用函数作为从对象属性检索函数的表达式的一部分,例如

    obj.foo(); // 或者 `obj["foo"]();
    

    在这种情况下,在对 foo 的调用中,this 将引用 obj

  2. 通过内置的 call 调用该函数 或 应用 方法:

    var obj = {name: "Fred"};
    函数 foo(称呼、标点符号) {
        Alert(称呼 + " " + this.name + 标点符号);
    }
    foo.call(obj, "嗨", "!"); // 提醒“嗨弗雷德!”
    foo.apply(obj, ["嗨", "!"]); // 还提醒“嗨弗雷德!”
    

    callapply 之间的唯一区别在于如何指定要传递到正在调用的函数中的参数:使用 call,您可以只需将它们作为离散参数列出在您想要的 this 值后面即可;使用apply,您可以将它们作为数组提供。

In their case:

(function() { /* do stuff */ }).call(this);

...they're making sure that the function gets called with a specific value for this (e.g., this within the function will be the same as this outside of the function).

In your case:

(function($) { /* do stuff */ })(jQuery);

...this within your function will be the global object, because you've called it without doing anything that sets this, and so this defaults to the global object (window, on browers).

In JavaScript, this is set entirely by how a function is called. There are two chief ways:

  1. By calling the function as part of the expression that retrieves it from an object property, e.g.

    obj.foo(); // Or `obj["foo"]();
    

    In that case, within the call to foo, this will refer to obj.

  2. By calling the function via its built-in call or apply methods:

    var obj = {name: "Fred"};
    function foo(salutation, punctuation) {
        alert(salutation + " " + this.name + punctuation);
    }
    foo.call(obj, "Hi", "!");    // alerts "Hi Fred!"
    foo.apply(obj, ["Hi", "!"]); // Also alerts "Hi Fred!"
    

    The only difference between call and apply is how you specify arguments to pass into the function you're calling: With call, you just list them as discrete arguments following the this value you want; with apply, you supply them as an array.

身边 2024-12-25 00:02:37

第一个将 jQuery 作为参数 $ 传递。第二个使 jQuery 成为函数内的“this”变量。

The first passes jQuery as the parameter $. The second makes jQuery the 'this' variable inside the function.

暖树树初阳… 2024-12-25 00:02:37

.call 将函数置于闭包作用域中。

因此,如果您这样做:

(function($) { /* do stuff */ }).call(jQuery);

$ 将是 undefined

.call puts the function in a closure scope.

So if you did this:

(function($) { /* do stuff */ }).call(jQuery);

$ would be undefined

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文