Wie ruft jQuery seine selbstaufrufende anonyme Funktion auf?

In diesem Artikel erfahren Sie, wie jQuery selbstaufrufende anonyme Funktionen aufruft. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.

Öffnen Sie zunächst den jQuery-Quellcode:

(function(window,undefined ){
})();

Dies ist eine selbstaufrufende anonyme Funktion. Welches Zeug? Erstellen Sie in der ersten Klammer eine anonyme Funktion. Führen Sie sie in der zweiten Klammer sofort aus.

Warum eine solche „selbstaufrufende anonyme Funktion“ erstellen?
Durch die Definition einer anonymen Funktion wird ein „privater“ Namespace erstellt. Die Variablen und Methoden dieses Namespace zerstören nicht den globalen Namespace. Dies ist sehr nützlich und eine Funktion, die ein JS-Framework in Tausenden von JavaScript-Programmen unterstützen muss. Es muss sichergestellt werden, dass die von jQuery erstellten Variablen nicht mit den Variablen in Konflikt geraten, die von dem Programm verwendet werden, das sie importiert.
Als nächstes schauen wir uns an, welche Funktionen in selbstaufrufenden anonymen Funktionen implementiert sind, in der Reihenfolge des Codes:

(function( window, undefined ) {
// 构造jQuery对象
var jQuery = function( selector, context ) {
    return new jQuery.fn.init( selector, context, rootjQuery );
}
// 工具函数 Utilities
// 异步队列 Deferred
// 浏览器测试 Support
// 数据缓存 Data
// 队列 queue
// 属性操作 Attribute
// 事件处理 Event
// 选择器 Sizzle
// DOM遍历
// DOM操作
// CSS操作
// 异步请求 Ajax
// 动画 FX
// 坐标和大小
window.jQuery = window.$ = jQuery;
})(window);

Anonyme Funktionen werden syntaktisch als Funktionsliterale bezeichnet Tatsächlich gibt es zwei Möglichkeiten, selbstaufrufende anonyme Funktionen zu schreiben:

(function() {
console.info( this );
console.info( arguments );
}( window ) );

(function() {
console.info( this );
console.info( arguments );
})( window );

Warum müssen Sie ein Fenster übergeben?

Durch die Übergabe der Fenstervariablen ändert sich das Fenster von einer globalen Variablen in eine lokale Variable. Beim Zugriff auf das Fenster im jQuery-Codeblock ist es nicht erforderlich, die Bereichskette auf die oberste Ebene zurückzusetzen Umfang, der schneller sein kann. Dies ist nicht der Schlüssel, der das Übergeben des Fensters als Parameter beim Komprimieren des Codes ermöglicht (a,b){} )(window); // window ist so optimiert, dass es ein
Durch die obige Einführung verstehen wir ungefähr, dass () einen Funktionsausdruck sofort ausführen kann.

Anonyme Funktion dient als „Container“. Das Innere des „Containers“ kann auf externe Variablen zugreifen, aber die externe Umgebung kann nicht auf die Variablen innerhalb des „Containers“ zugreifen.
Also ( function(){ ...} )() Intern definierte Variablen stehen nicht in Konflikt mit externen Variablen, die allgemein als „anonyme Wrapper“ oder „Namespaces“ bekannt sind.

(function () {
// ... 所有的变量和function都在这里声明，并且作用域也只能在这个匿名闭包里
// ...但是这里的代码依然可以访问外部全局的对象
}());

Dasselbe wie unten
(function () {/interner Code/})();

Laienhaft ausgedrückt wird () verwendet, um Folgendes auszuwerten: Daher kann this () zu keinem Zeitpunkt leer sein, da es berechnet werden muss. Beim Parsen von Funktionen wird nur auf {} geparst, nicht auf ().

Das Einfügen des Ausdrucks in () gibt den Wert des Ausdrucks zurück.
Das Einfügen der Funktion in () gibt die Funktion selbst zurück (function(){}());
Wenn ( ) unmittelbar nach der Funktion bedeutet, dass die Funktion aufgerufen wird, das heißt, die Funktion wird ausgewertet: (function(){})();

(function() {
//自执行函数中的内部变量，外部是无法访问的
var name = 'kevin';
})( window );

name //undefiniert, der Wert von name kann nicht abgerufen werden

Während der Ausführung des Codes werden [bereits deklarierte Funktionen] zuerst analysiert;

        und der Funktionsausdruck wird erst analysiert, wenn er ausgeführt wird;  
            Anonyme Funktionen werden nicht analysiert Separat geschrieben, daher erfordert seine Ausführung den Aufruf anderer Funktionen. Die normalerweise angezeigten anonymen Funktionen werden als Parameter übergeben. Die sofortige Ausführungsfunktion selbst ist eine anonyme Funktion.
        Die Reihenfolge der JS-Codeausführung:                                                                                                                                                                                out //Funktionsausdruck var test = function(){}
                                                                         //                                                                                                                                                              , es gibt ein paar Punkte zu verstehen:

1. Wenn Sie nach dem Funktionskörper Klammern hinzufügen möchten, um ihn sofort aufzurufen, muss die Funktion ein Funktionsausdruck und keine Funktionsdeklaration sein.
2. Führen Sie die Funktion sofort aus Auf externe Variablen kann innerhalb des Bereichs zugegriffen werden, die externe Umgebung kann jedoch nicht auf Variablen innerhalb des Bereichs zugreifen. Daher ist die Funktion zur sofortigen Ausführung ein geschlossener Bereich und interagiert nicht mit dem externen Bereich.

JQuery verwendet diese Methode. Wickeln Sie den JQuery-Code in (function (window, undefined){...jquery code...} (window) ein. Wenn Sie den JQuery-Code im globalen Bereich aufrufen, können Sie interne JQuery-Variablen schützen .

3. Der Modulmodus ist ein erweiterter Modus für selbstausführende Funktionen. Es ist sehr praktisch, Abschlussfunktionen als globale Objekte in jedem anonymen Abschluss aufzurufen a. Erstellen Sie einen anonymen Funktionsausdruck, der sofort aufgerufen wird

b. Geben Sie eine Variable zurück, die das anzuzeigende Objekt enthält

(function () {
var i = 0;
return {
    get: function () {
        return i;
    },
    set: function (val) {
        i = val;
    },
    increment: function () {
        return ++i;
    }
};
} (window));

rreee
/


Das Obige ist die Analyse selbstaufrufender anonymer Funktionen. Wie heißt eine solche Funktion

*
/

/ 🎜>

Im Folgenden geht es um den Aufruf globaler Variablen, also den Aufruf anonymer Abschlussfunktionen*/ Verschieben Sie den Modulmodus erneut
Modulmodus, d. h. die Erstellung und den Aufruf anonymer Schließungen:

   a.创建一个立即调用的匿名函数表达式
   b.return一个变量，其中这个变量里包含你要暴露的东西
      c.返回的这个变量将赋值给window

window（或者是任意一个全局对象）作为一个带有多个属性的全局对象，也可以把window当成一个参数,以对象的方式，在其它函数中实现调用。用下面的例子说明：

(function ($, YAHOO) {
// 这里，我们的代码就可以使用全局的jQuery对象了，YAHOO也是一样
$.aa = function(){
    //code
}
} (jQuery, YAHOO));
//调用 jQuery.aa();

下面是一个标准的Module模式，通过匿名函数的返回值来返回这个全局变量：

var blogModule = (function () {
var my = {}, privateName = "博客园";

function privateAddTopic(data) {
    // 这里是内部处理代码
}

my.Name = privateName;
my.AddTopic = function (data) {
    privateAddTopic(data);
};

return my;
} ());
//调用 blogModule.my();

在一些大型项目里，将一个功能分离成多个文件是非常重要的，因为可以多人合作易于开发。再回头看看上面的全局参数导入例子，我们能否把blogModule自身传进去呢？答案是肯定的，我们先将blogModule传进去，添加一个函数属性，然后再返回就达到了我们所说的目的：

var blogModule = (function (my) {
my.AddPhoto = function () {
    //添加内部代码  
};
return my;
} (blogModule || {}));

或

(function (my){
my.AddPhoto = function () {
    //添加内部代码  
};
return my;
})(blogModule || {}));
//调用 blogModule.AddPhoto();

那么，多个自执行函数间是怎么调用的呢？

(function(owner) {
//第一个匿名闭包
owner.debug = true;
//Ajax相关参数配置
owner.ajax = {
    timeout: 10000,
    type: 'post',
    dataType: 'json',
};
})(window.C = {}));

如果第二个函数想调用 全局变量为C中的 对象呢？要怎么写？

(function($, owner) {
//这里调用上面全局变量为C 中的对象呢
if(!C.debug) return false;
var url = 'aaa.html';
mui.ajax({
    url: url,
    dataType: C.ajax.dataType,
    type: C.ajax.type,
});
})(mui, window.app = {});

再举个例子，同样的，不同自执行闭包函数间的调用方法：

(function($, owner) {
//获取语言闭包
owner.getLanguage = function() {
    var language = localStorage.getItem(C.state.field.language);
    if(typeof language == "undefined" || language === null || language == '') {
        var currentLang = navigator.language;
        if(!currentLang)
            currentLang = navigator.browserLanguage;
        language = currentLang.toLowerCase();
        language = language.replace(/-/g, '_');

        if(language != 'en_us' && language != 'zh_cn')
            language = 'en_us';

        localStorage.setItem(C.state.field.language, language);
    }

    //在上面的解析中有说过，Module模式，return 一个变量，这个变量就是要爆露的东西。通过这个函数的全局变量，这个  language  可以在任何地方调用   
    //return一个变量，其中这个变量里包含你要暴露的东西 
    //全局调用  storage.language                                  
    return language;
};
})(mui, window.storage = {}));

(function($, owner) {
owner.language = {};
owner.preload = function(settings){
    var defaults = {
        name: 'i18n',
        language: '',
        path: '/',
        cache: true,
        encoding: 'UTF-8',
        autoReplace: true,
        success: null,
        error: null,
    };
    
    settings = $.extend(defaults, settings);
    if(settings.language === null || settings.language == '') {
        //全局调用  storage.language                                                                            
        settings.language = storage.getLanguage();
    }
}   
})(mui, window.i18n = {});

所以 匿名闭包的调用规则是这样的，立即执行(最后一个括号) (window)，如果把window作为一个参数进行传递，那么就把它以对象的方式，在其它函数中实现全局调用。

相关推荐：

js实现模态窗口增加与删除案例分享（纯代码）

js对象类型怎么判断？详解js里的基本类型转换

Das obige ist der detaillierte Inhalt vonWie ruft jQuery seine selbstaufrufende anonyme Funktion auf?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!