recherche

Maison  >  Article  >  interface Web  >  Accélérez l'efficacité du chargement et de l'exécution de JavaScript

Accélérez l'efficacité du chargement et de l'exécution de JavaScript

黄舟
黄舟original
2017-02-21 11:22:001200parcourir



Les performances JavaScript dans les navigateurs sont devenues le problème d'utilisabilité le plus important auquel sont confrontés les développeurs. Ce problème est compliqué par la nature bloquante de JavaScript, ce qui signifie que lorsque le navigateur exécute du code JavaScript, il ne peut rien faire d'autre en même temps. Cet article explique comment charger et exécuter correctement du code JavaScript pour améliorer ses performances dans le navigateur.

Vue d'ensemble

Peu importe si le code JavaScript actuel est intégré ou dans un fichier de lien externe, le téléchargement et le rendu de la page doivent s'arrêter et attendre la fin de l'exécution du script. Plus le processus d'exécution de JavaScript est long, plus le navigateur attend pour répondre aux entrées de l'utilisateur. La raison pour laquelle les navigateurs bloquent lors du téléchargement et de l'exécution de scripts est que le script peut modifier l'espace de noms de la page ou JavaScript, ce qui affecte le contenu des pages suivantes. Un exemple typique consiste à utiliser document.write() sur la page.

Exemple de code JavaScript en ligne

<html>
<head>
    <title>Source Example</title>
</head>
<body>
    <p>
    <script type="text/javascript">
        document.write("Today is " + (new Date()).toDateString());
    </script>
    </p>
</body>
</html>

Lorsque le navigateur rencontre la balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a, la page html actuelle n'a aucun moyen de savoir si JavaScript ajoutera du contenu à la balise e388a4556c0f65e1904146cc1a846bee balise, ou Introduisez d’autres éléments, ou même supprimez la balise. Par conséquent, le navigateur arrêtera de traiter la page à ce moment-là, exécutera d'abord le code JavaScript, puis continuera à analyser et à afficher la page. La même situation se produit lors du chargement de JavaScript à l'aide de l'attribut src. Le navigateur doit d'abord passer du temps à télécharger le code dans le fichier de lien externe, puis à l'analyser et à l'exécuter. Au cours de ce processus, le rendu des pages et l'interaction de l'utilisateur sont complètement bloqués.

Emplacement du script

La spécification HTML 4 indique que la balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a peut être placée dans le 93f0f5c25f18dab9d176bd4f6de5d30e fois. Les développeurs Web sont généralement habitués à charger le JavaScript des liens externes dans 93f0f5c25f18dab9d176bd4f6de5d30e, puis à utiliser la balise 2cdf5bf648cf2f33323966d7f58a7f3f pour charger les fichiers CSS des liens externes ou d'autres informations de page.

Exemple d'emplacement de script inefficace

<html>
<head>
    <title>Source Example</title>
    <script type="text/javascript" src="script1.js"></script>
    <script type="text/javascript" src="script2.js"></script>
    <script type="text/javascript" src="script3.js"></script>
    <link rel="stylesheet" type="text/css" href="styles.css">
</head>
<body>
    <p>Hello world!</p>
</body>
</html>

Cependant, cette pratique courante cache de sérieux problèmes de performances. Dans l'exemple du listing 2, lorsque le navigateur analyse la balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a (ligne 4), le navigateur arrêtera d'analyser le contenu qui suit et téléchargera d'abord le fichier de script et exécutera le code qu'il contient, ce qui signifie : les styles suivants. .css et la balise 6c04bd5ca3fcae76e30b72ad730ca86d ne peuvent pas être chargées. Étant donné que la balise 6c04bd5ca3fcae76e30b72ad730ca86d Par conséquent, la page restera vide jusqu'à ce que le code JavaScript soit complètement exécuté.

Étant donné que les scripts bloquent le téléchargement d'autres ressources sur la page, il est recommandé de placer toutes les balises 3f1c4e4b6b16bbbd69b2ee476dc4f83a aussi loin que possible en bas de la balise 6c04bd5ca3fcae76e30b72ad730ca86d téléchargement de la page entière.

Exemple d'emplacement de code recommandé

<html>
<head>
    <title>Source Example</title>
    <link rel="stylesheet" type="text/css" href="styles.css">
</head>
<body>
    <p>Hello world!</p>

    <!-- Example of efficient script positioning -->
    <script type="text/javascript" src="script1.js"></script>
    <script type="text/javascript" src="script2.js"></script>
    <script type="text/javascript" src="script3.js"></script>
</body>
</html>

Ce code montre l'emplacement recommandé de la balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a Même si le téléchargement du script bloque un autre script, la plupart du contenu de la page est déjà téléchargé et affiché à l'utilisateur, le téléchargement de la page ne semble donc pas trop lent. C'est la première règle d'optimisation de JavaScript : placez vos scripts en bas.

Organisation des scripts

Étant donné que chaque balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a bloque le rendu de la page lors de son téléchargement initial, la réduction du nombre de balises 3f1c4e4b6b16bbbd69b2ee476dc4f83a Cela s'applique non seulement aux scripts de liens externes, mais également au nombre de scripts intégrés. Chaque fois que le navigateur rencontre une balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a pendant le processus d'analyse de la page HTML, cela entraînera un certain retard en raison de l'exécution du script. Par conséquent, minimiser le délai améliorera considérablement les performances globales de la page.

Ce problème est légèrement différent lorsqu'il s'agit de fichiers JavaScript externes. Compte tenu de la surcharge de performances supplémentaire associée aux requêtes HTTP, le téléchargement d'un seul fichier de 100 Ko sera plus rapide que le téléchargement de cinq fichiers de 20 Ko. Cela dit, réduire le nombre de scripts externes sur une page améliorera les performances.

Habituellement, un grand site Web ou une application repose sur plusieurs fichiers JavaScript. Vous pouvez fusionner plusieurs fichiers en un seul afin de n'avoir besoin de référencer qu'une seule balise 3f1c4e4b6b16bbbd69b2ee476dc4f83a, ce qui peut réduire la consommation de performances. La fusion de fichiers peut être réalisée via des outils de packaging hors ligne ou certains services en ligne en temps réel.

Un rappel spécial est que le fait de placer un script en ligne après un 53edb03e1e358f1f14be244f83a17952 faisant référence à une feuille de style externe entraînera le blocage de la page en attendant le téléchargement de la feuille de style. Ceci est fait pour garantir que le script en ligne obtient les informations de style les plus précises lors de son exécution. Par conséquent, il est recommandé de ne pas placer de scripts en ligne immédiatement après la balise 2cdf5bf648cf2f33323966d7f58a7f3f

Scripts non bloquants

Réduire la taille des fichiers JavaScript et limiter le nombre de requêtes HTTP n'est pas toujours réalisable sur les applications Web riches en fonctionnalités ou les grands sites Web. Plus une application Web est riche en fonctionnalités, plus elle nécessite de code JavaScript, et bien que le téléchargement d'un seul fichier JavaScript plus volumineux ne génère qu'une seule requête HTTP, cela peut bloquer le navigateur pendant une longue période. Pour éviter cela, des techniques spécifiques sont nécessaires pour charger progressivement les fichiers JavaScript dans la page sans bloquer le navigateur.

无阻塞脚本的秘诀在于，在页面加载完成后才加载 JavaScript 代码。这就意味着在 window 对象的 onload 事件触发后再下载脚本。有多种方式可以实现这一效果。

延迟加载脚本

HTML 4 为 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签定义了一个扩展属性： defer 。 Defer 属性指明本元素所含的脚本不会修改 DOM，因此代码能安全地延迟执行。 defer 属性只被 IE 4 和 Firefox 3.5 更高版本的浏览器所支持，所以它不是一个理想的跨浏览器解决方案。在其他浏览器中， defer 属性会被直接忽略，因此 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签会以默认的方式处理，也就是说会造成阻塞。然而，如果您的目标浏览器支持的话，这仍然是个有用的解决方案。

defer 属性使用方法示例

<script type="text/javascript" src="script1.js" defer></script>

带有 defer 属性的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签可以放置在文档的任何位置。对应的 JavaScript 文件将在页面解析到 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签时开始下载，但不会执行，直到 DOM 加载完成，即 onload 事件触发前才会被执行。当一个带有 defer 属性的 JavaScript 文件下载时，它不会阻塞浏览器的其他进程，因此这类文件可以与其他资源文件一起并行下载。

任何带有 defer 属性的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素在 DOM 完成加载之前都不会被执行，无论内嵌或者是外链脚本都是如此。清单 5 的例子展示了 defer 属性如何影响脚本行为：

defer 属性对脚本行为的影响

<html>
<head>
    <title>Script Defer Example</title>
</head>
<body>
    <script type="text/javascript" defer>
        alert("defer");
    </script>
    <script type="text/javascript">
        alert("script");
    </script>
    <script type="text/javascript">
        window.onload = function(){
            alert("load");
        };
    </script>
</body>
</html>

这段代码在页面处理过程中弹出三次对话框。不支持 defer 属性的浏览器的弹出顺序是：“defer”、“script”、“load”。而在支持 defer 属性的浏览器上，弹出的顺序则是：“script”、“defer”、“load”。请注意，带有 defer 属性的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素不是跟在第二个后面执行，而是在 onload 事件被触发前被调用。

如果您的目标浏览器只包括 Internet Explorer 和 Firefox 3.5，那么 defer 脚本确实有用。如果您需要支持跨领域的多种浏览器，那么还有更一致的实现方式。

HTML 5 为 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签定义了一个新的扩展属性： async 。它的作用和 defer 一样，能够异步地加载和执行脚本，不因为加载脚本而阻塞页面的加载。但是有一点需要注意，在有 async 的情况下，JavaScript 脚本一旦下载好了就会执行，所以很有可能不是按照原本的顺序来执行的。如果 JavaScript 脚本前后有依赖性，使用 async 就很有可能出现错误。

动态脚本元素

文档对象模型（DOM）允许您使用 JavaScript 动态创建 HTML 的几乎全部文档内容。 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素与页面其他元素一样，可以非常容易地通过标准 DOM 函数创建：

通过标准 DOM 函数创建3f1c4e4b6b16bbbd69b2ee476dc4f83a元素

var script = document.createElement ("script");
   script.type = "text/javascript";
   script.src = "script1.js";
   document.getElementsByTagName("head")[0].appendChild(script);

新的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素加载 script1.js 源文件。此文件当元素添加到页面之后立刻开始下载。此技术的重点在于：无论在何处启动下载，文件的下载和运行都不会阻塞其他页面处理过程。您甚至可以将这些代码放在 93f0f5c25f18dab9d176bd4f6de5d30e 部分而不会对其余部分的页面代码造成影响（除了用于下载文件的 HTTP 连接）。

当文件使用动态脚本节点下载时，返回的代码通常立即执行（除了 Firefox 和 Opera，他们将等待此前的所有动态脚本节点执行完毕）。当脚本是“自运行”类型时，这一机制运行正常，但是如果脚本只包含供页面其他脚本调用调用的接口，则会带来问题。这种情况下，您需要跟踪脚本下载完成并是否准备妥善。可以使用动态 3f1c4e4b6b16bbbd69b2ee476dc4f83a 节点发出事件得到相关信息。

Firefox、Opera, Chorme 和 Safari 3+会在 3f1c4e4b6b16bbbd69b2ee476dc4f83a 节点接收完成之后发出一个 onload 事件。您可以监听这一事件，以得到脚本准备好的通知：

通过监听 onload 事件加载 JavaScript 脚本

var script = document.createElement ("script")
script.type = "text/javascript";

//Firefox, Opera, Chrome, Safari 3+
script.onload = function(){
    alert("Script loaded!");
};

script.src = "script1.js";
document.getElementsByTagName("head")[0].appendChild(script);

Internet Explorer 支持另一种实现方式，它发出一个 readystatechange 事件。 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素有一个 readyState 属性，它的值随着下载外部文件的过程而改变。 readyState 有五种取值：

微软文档上说，在 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素的生命周期中， readyState 的这些取值不一定全部出现，但并没有指出哪些取值总会被用到。实践中，我们最感兴趣的是“loaded”和“complete”状态。Internet Explorer 对这两个 readyState 值所表示的最终状态并不一致，有时 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素会得到“loader”却从不出现“complete”，但另外一些情况下出现“complete”而用不到“loaded”。最安全的办法就是在 readystatechange 事件中检查这两种状态，并且当其中一种状态出现时，删除 readystatechange 事件句柄（保证事件不会被处理两次）：

通过检查 readyState 状态加载 JavaScript 脚本

var script = document.createElement("script")
script.type = "text/javascript";

//Internet Explorer
script.onreadystatechange = function(){
     if (script.readyState == "loaded" || script.readyState == "complete"){
           script.onreadystatechange = null;
           alert("Script loaded.");
     }
};

script.src = "script1.js";
document.getElementsByTagName("head")[0].appendChild(script);

大多数情况下，您希望调用一个函数就可以实现 JavaScript 文件的动态加载。下面的函数封装了标准实现和 IE 实现所需的功能：

通过函数进行封装

function loadScript(url, callback){
    var script = document.createElement ("script")
    script.type = "text/javascript";
    if (script.readyState){ //IE
        script.onreadystatechange = function(){
            if (script.readyState == "loaded" || script.readyState == "complete"){
                script.onreadystatechange = null;
                callback();
            }
        };
    } else { //Others
        script.onload = function(){
            callback();
        };
    }
    script.src = url;
    document.getElementsByTagName("head")[0].appendChild(script);
}

此函数接收两个参数：JavaScript 文件的 URL，和一个当 JavaScript 接收完成时触发的回调函数。属性检查用于决定监视哪种事件。最后一步，设置 src 属性，并将 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素添加至页面。此 loadScript() 函数使用方法如下：

loadScript()函数使用方法

loadScript("script1.js", function(){
    alert("File is loaded!");
});

您可以在页面中动态加载很多 JavaScript 文件，但要注意，浏览器不保证文件加载的顺序。所有主流浏览器之中，只有 Firefox 和 Opera 保证脚本按照您指定的顺序执行。其他浏览器将按照服务器返回它们的次序下载并运行不同的代码文件。您可以将下载操作串联在一起以保证他们的次序，如下：

通过 loadScript()函数加载多个 JavaScript 脚本

loadScript("script1.js", function(){
    loadScript("script2.js", function(){
        loadScript("script3.js", function(){
            alert("All files are loaded!");
        });
    });
});

此代码等待 script1.js 可用之后才开始加载 script2.js，等 script2.js 可用之后才开始加载 script3.js。虽然此方法可行，但如果要下载和执行的文件很多，还是有些麻烦。如果多个文件的次序十分重要，更好的办法是将这些文件按照正确的次序连接成一个文件。独立文件可以一次性下载所有代码（由于这是异步进行的，使用一个大文件并没有什么损失）。

动态脚本加载是非阻塞 JavaScript 下载中最常用的模式，因为它可以跨浏览器，而且简单易用。

使用 XMLHttpRequest(XHR)对象

此技术首先创建一个 XHR 对象，然后下载 JavaScript 文件，接着用一个动态 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素将 JavaScript 代码注入页面。清单 12 是一个简单的例子：

通过 XHR 对象加载 JavaScript 脚本

var xhr = new XMLHttpRequest();
xhr.open("get", "script1.js", true);
xhr.onreadystatechange = function(){
    if (xhr.readyState == 4){
        if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304){
            var script = document.createElement ("script");
            script.type = "text/javascript";
            script.text = xhr.responseText;
            document.body.appendChild(script);
        }
    }
};
xhr.send(null);

此代码向服务器发送一个获取 script1.js 文件的 GET 请求。 onreadystatechange 事件处理函数检查 readyState 是不是 4，然后检查 HTTP 状态码是不是有效（2XX 表示有效的回应，304 表示一个缓存响应）。如果收到了一个有效的响应，那么就创建一个新的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素，将它的文本属性设置为从服务器接收到的 responseText 字符串。这样做实际上会创建一个带有内联代码的 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素。一旦新 3f1c4e4b6b16bbbd69b2ee476dc4f83a 元素被添加到文档，代码将被执行，并准备使用。

这种方法的主要优点是，您可以下载不立即执行的 JavaScript 代码。由于代码返回在 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签之外（换句话说不受 3f1c4e4b6b16bbbd69b2ee476dc4f83a 标签约束），它下载后不会自动执行，这使得您可以推迟执行，直到一切都准备好了。另一个优点是，同样的代码在所有现代浏览器中都不会引发异常。

此方法最主要的限制是：JavaScript 文件必须与页面放置在同一个域内，不能从 CDN 下载（CDN 指"内容投递网络（Content Delivery Network）"，所以大型网页通常不采用 XHR 脚本注入技术。

总结

减少 JavaScript 对性能的影响有以下几种方法：

通过以上策略，可以在很大程度上提高那些需要使用大量 JavaScript 的 Web 网站和应用的实际性能。

原文来自：http://www.php.cn/

补充js加载函数：

function loadJs(url, callback, charset) {
    var head = document.getElementsByTagName("head")[0];
    var script = document.createElement("script");
    if ( !!charset) script.charset = "utf-8";
    script.src = url;
    script.onload = script.onreadystatechange = function() {
        var f = script.readyState;
        if (f && f != "loaded" && f != "complete") return;
        script.onload = script.onreadystatechange = null;
        head.removeChild(script) if (callback) {
            callback() || callback
        };
    };
    head.appendChild(script);
}
// js同步加载
function getScripts(i, linkArray, fn) {
    env || getEnv();
    var script = document.createElement(&#39;script&#39;);
    script.type = &#39;text/javascript&#39;;
    script.src = linkArray[i];
    var head = document.head || document.getElementsByTagName(&#39;head&#39;)[0];
    head.appendChild(script);

    if (env.ie && &#39;onreadystatechange&#39; in script && !(&#39;draggable&#39; in script)){ //ie浏览器使用以下方式加载
        script.onreadystatechange = function () {
          if (/loaded|complete/.test(script.readyState)) {
            script.onreadystatechange = null;
            if(i === linkArray.length-1) {
                if (fn) {
                    fn();
                }
            } else {
                getScripts(++i, linkArray, fn);
            }
          }
        };
    }else{
        script.onload = function() {
            if(i === linkArray.length-1) {
                if (fn) {
                    fn();
                }
            } else {
                getScripts(++i, linkArray, fn);
            }
        };
    }
}
// js存在依赖关系 依次加载
getScripts(0, [
    &#39;http://caibaojian.com/demo/base.js&#39;,
    &#39;http://caibaojian.com/demo/reset.js&#39;], function() {
     alert(&#39;callback&#39;);
});

以上就是加快JavaScript加载和执行效率的内容，更多相关内容请关注PHP中文网（www.php.cn）！

 

Déclaration：
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Article précédent：Compréhension approfondie de l'héritage prototype javascriptArticle suivant：Compréhension approfondie de l'héritage prototype javascript

Articles Liés

Voir plus