Comment écrire du code JS de haute qualité

Cet article vous explique principalement comment suivre 12 méthodes pour écrire du code JS de haute qualité. Les amis qui ont besoin de cette commodité peuvent s'y référer. J'espère que vous pourrez écrire un meilleur code js après avoir étudié cette section.

L'écriture de code JS de haute qualité rend non seulement les programmeurs confortables à regarder, mais améliore également la vitesse d'exécution du programme. Voici la méthode utilisée par l'éditeur pour l'organiser :

1. pour écrire du code maintenable

Lorsqu'un bug survient, il est préférable que vous puissiez le corriger immédiatement. À l'heure actuelle, les quatre façons de résoudre le problème sont encore très claires dans votre esprit. Sinon, vous passez à d'autres tâches ou le bug apparaît après un certain temps, et vous oubliez ce code spécifique au bout d'un moment. Regarder le code nécessite :

1. Passer du temps à apprendre et à comprendre 2. Le. le temps pour résoudre ce problème est de comprendre le code du problème qui doit être résolu

Il y a un autre problème, surtout pour les grands projets ou les entreprises, le gars qui corrige le bug n'est pas la personne qui a écrit le code (et le le gars qui a trouvé le bug et ce n'est pas la même personne qui corrige le bug). Par conséquent, il est important de réduire le temps nécessaire à la compréhension du code, qu’il s’agisse d’un code que vous avez écrit il y a quelque temps ou d’un code écrit par d’autres membres de l’équipe. Il s'agit du résultat net (revenus) et du bonheur des développeurs, car nous devrions créer des choses nouvelles et passionnantes au lieu de passer des heures et des jours à maintenir le code existant. Par conséquent, il est crucial de créer du code maintenable. Généralement, le code maintenable répond aux principes suivants :

Lisibilité

Cohérence

Prévisibilité

On dirait qu'il a été écrit par la même personne

Enregistré

2 Problèmes avec les variables globales

Le problème avec les variables globales est que celles-ci. Les variables globales sont partagées par tout le code de votre application JavaScript et de la page Web. Elles vivent dans le même espace de noms global, donc lorsque deux parties différentes du programme définissent le même nom mais des fonctions différentes. Lors de l'utilisation de variables globales, les conflits de noms sont inévitables. Il est également courant que les pages Web contiennent du code qui n'a pas été écrit par le développeur de la page, par exemple :

Bibliothèque JavaScript tierce

Code de script de l'annonceur

Code du script de suivi et d'analyse des utilisateurs tiers

Différents types de widgets, drapeaux et boutons

Par exemple, ce script tiers définit une variable globale, appelée A ; définissez ensuite également une variable globale nommée A dans votre fonction. Le résultat est que les dernières variables écrasent les précédentes et que le script tiers devient soudainement invalide ! Et il est difficile de le déboguer.

Donc : il est important d'utiliser le moins possible les variables globales, comme le mode espace de noms ou les fonctions qui sont automatiquement exécutées immédiatement, mais la chose la plus importante pour garder les variables globales au minimum est de toujours utiliser var pour déclarer des variables.

3. Oubliez les effets secondaires de var

Il existe une petite différence entre les variables globales implicites et les variables globales explicitement définies, qui est la possibilité de laisser les variables non définies via l'opérateur de suppression. Les détails sont les suivants :

Les variables globales créées via var (créées dans tout programme autre que les fonctions) ne peuvent pas être supprimées.

Les variables globales implicites non créées via var (qu'elles soient créées ou non dans une fonction) peuvent être supprimées.

Les variables globales implicites ne sont donc pas vraiment des variables globales, mais ce sont des propriétés de l'objet global. Les attributs peuvent être supprimés via l'opérateur delete, mais les variables ne le peuvent pas. Je n'écrirai pas le code spécifique.

4. Accédez à l'objet global

Dans le navigateur, l'objet global est accessible n'importe où dans le code via l'attribut window (sauf si vous faites quelque chose de scandaleux, comme déclarer une variable locale fenêtre nommée). Mais dans d'autres contextes, cette propriété de commodité pourrait être appelée autrement (ou même ne pas être disponible dans le programme). Si vous devez accéder à l'objet global sans identifiant de fenêtre codé en dur, vous pouvez effectuer les opérations suivantes dans la portée de la fonction à n'importe quel niveau :

var global = (function () { return this; }());

5. boucle for

dans Dans une boucle for, vous pouvez parcourir les valeurs d'un tableau ou d'un objet de type tableau, tels que des arguments et des objets HTMLCollection. La forme de boucle habituelle est la suivante :

// Deuxième meilleure boucle for (var i = 0; i < myarray.length; i++) { // Utilisez myarray[i] pour faire quelque chose>

L'inconvénient de cette forme de boucle est que la longueur du tableau doit être obtenue à chaque fois qu'il est bouclé. Cela réduira votre code, surtout lorsque myarray n'est pas un tableau, mais un objet HTMLCollection.

6. N'étendez pas le prototype intégré

Amplifier l'attribut prototype du constructeur est un moyen très puissant d'augmenter les fonctionnalités, mais parfois c'est trop puissant. Il est tentant d'ajouter des prototypes de constructeur intégrés (tels que Object(), Array() ou Function()), mais cela réduit considérablement la maintenabilité car cela rend votre code imprévisible. Les autres développeurs qui utilisent votre code préféreront probablement utiliser les méthodes JavaScript intégrées pour travailler en continu, plutôt que les méthodes que vous ajoutez. De plus, les propriétés ajoutées au prototype peuvent provoquer son affichage dans la boucle lorsque l'attribut hasOwnProperty n'est pas utilisé, ce qui peut prêter à confusion.

7. Évitez la conversion de type implicite

JavaScript的变量在比较的时候会隐式类型转换。这就是为什么一些诸如：false == 0 或 “” == 0 返回的结果是true。为避免引起混乱的隐含类型转换，在你比较值和表达式类型的时候始终使用===和!==操作符。

var zero = 0; if (zero === false) { // 不执行，因为zero为0, 而不是false } // 反面示例 if (zero == false) { // 执行了... }

八、避免eval()

如果你现在的代码中使用了eval()，记住该咒语“eval()是魔鬼”。此方法接受任意的字符串，并当作JavaScript代码来处理。当有 问题的代码是事先知道的（不是运行时确定的），没有理由使用eval()。如果代码是在运行时动态生成，有一个更好的方式不使用eval而达到同样的目 标。例如，用方括号表示法来访问动态属性会更好更简单：

// 反面示例 var property = "name"; alert(eval("obj." + property)); // 更好的 var property = "name"; alert(obj[property]);

使用eval()也带来了安全隐患，因为被执行的代码（例如从网络来）可能已被篡改。这是个很常见的反面教材，当处理Ajax请求得到的JSON 相应的时候。在这些情况下，最好使用JavaScript内置方法来解析JSON相应，以确保安全和有效。若浏览器不支持JSON.parse()，你可 以使用来自JSON.org的库。

同样重要的是要记住，给setInterval(), setTimeout()和Function()构造函数传递字符串，大部分情况下，与使用eval()是类似的，因此要避免。在幕后，JavaScript仍需要评估和执行你给程序传递的字符串：

// 反面示例 setTimeout("myFunc()", 1000); setTimeout("myFunc(1, 2, 3)", 1000); // 更好的 setTimeout(myFunc, 1000); setTimeout(function () { myFunc(1, 2, 3); }, 1000);

使用新的Function()构造就类似于eval()，应小心接近。这可能是一个强大的构造，但往往被误用。如果你绝对必须使用eval()，你 可以考虑使用new Function()代替。有一个小的潜在好处，因为在新Function()中作代码评估是在局部函数作用域中运行，所以代码中任何被评估的通过var 定义的变量都不会自动变成全局变量。另一种方法来阻止自动全局变量是封装eval()调用到一个即时函数中。

考虑下面这个例子，这里仅un作为全局变量污染了命名空间。

console.log(typeof un); // "undefined" console.log(typeof deux); // "undefined" console.log(typeof trois); // "undefined" var jsstring = "var un = 1; console.log(un);"; eval(jsstring); // logs "1" jsstring = "var deux = 2; console.log(deux);"; new Function(jsstring)(); // logs "2" jsstring = "var trois = 3; console.log(trois);"; (function () { eval(jsstring); }()); // logs "3" console.log(typeof un); // number console.log(typeof deux); // "undefined" console.log(typeof trois); // "undefined"

另一间eval()和Function构造不同的是eval()可以干扰作用域链，而Function()更安分守己些。不管你在哪里执行 Function()，它只看到全局作用域。所以其能很好的避免本地变量污染。在下面这个例子中，eval()可以访问和修改它外部作用域中的变量，这是 Function做不来的（注意到使用Function和new Function是相同的）。

(function () { var local = 1; eval("local = 3; console.log(local)"); // logs "3" console.log(local); // logs "3" }()); (function () { var local = 1; Function("console.log(typeof local);")(); // logs undefined

九、编码规范

建立和遵循编码规范是很重要的，这让你的代码保持一致性，可预测，更易于阅读和理解。一个新的开发者加入这个团队可以通读规范，理解其它团队成员书写的代码，更快上手干活。

十、缩进

代码没有缩进基本上就不能读了。唯一糟糕的事情就是不一致的缩进，因为它看上去像是遵循了规范，但是可能一路上伴随着混乱和惊奇。重要的是规范地使用缩进。

十一、注释

你必须注释你的代码，即使不会有其他人向你一样接触它。通常，当你深入研究一个问题，你会很清楚的知道这个代码是干嘛用的，但是，当你一周之后再回来看的时候，想必也要耗掉不少脑细胞去搞明白到底怎么工作的。

很显然，注释不能走极端：每个单独变量或是单独一行。但是，你通常应该记录所有的函数，它们的参数和返回值，或是任何不寻常的技术和方法。要想到注 释可以给你代码未来的阅读者以诸多提示；阅读者需要的是（不要读太多的东西）仅注释和函数属性名来理解你的代码。例如，当你有五六行程序执行特定的任务， 如果你提供了一行代码目的以及为什么在这里的描述的话，阅读者就可以直接跳过这段细节。没有硬性规定注释代码比，代码的某些部分（如正则表达式）可能注释 要比代码多。

十二、花括号{}

花括号（亦称大括号，下同）应总被使用，即使在它们为可选的时候。技术上将，在in或是for中如果语句仅一条，花括号是不需要的，但是你还是应该总是使用它们，这会让代码更有持续性和易于更新。

相关推荐：

如何编写高质量JS代码_基础知识

如何编写高质量JS代码(续)_javascript技巧

Comment rendre votre code JS plus beau et plus facile à lire_Connaissances de base