Mon résumé d'apprentissage NodeJs (1)_node.js

Dans ce premier article, parlons de quelques détails de programmation de NodeJs.

1. Parcourez le tableau

for (var i=0, l=arr.length; i<l; i++)

L'un des avantages d'écrire de cette façon est que chaque boucle enregistre une étape pour obtenir la longueur de l'objet tableau. Plus la longueur du tableau est longue, plus la valeur est évidente.

2. Déterminez si la variable est vraie ou fausse

if (a) {...} //a='', a='0', a=[], a={}

Les résultats du jugement conditionnel if sont : faux, vrai, vrai, vrai. Ce résultat est différent du résultat de PHP, ne vous y trompez pas. Il faut également distinguer les situations proches des jugements de non-identité.

3. Jugement de non-identité de valeur 0

1 if (0 == '0') {...} //true
2 if (0 == []) {...} //true
3 if (0 == [0]) {...} //true
4 if (0 == {}) {...} //false
5 if (0 == null) {...} //false
6 if (0 == undefined) {...} //false

En fait, il existe de nombreux jugements aussi étranges, je n'ai énuméré que les plus courants. Si vous souhaitez comprendre les règles, veuillez vous référer à mon autre article de blog : [JavaScript] Analyse approfondie des opérations relationnelles et des instructions if de JavaScript.

4. Le piège de parseInt

var n = parseInt(s); //s='010'

Une fois cette instruction exécutée, la valeur de n est 8 et non 10. Même si beaucoup de gens le savent, les erreurs sont inévitables en programmation, et je le sais très bien. Par conséquent, il est préférable d’écrire de la manière suivante et vous ne ferez pas d’erreurs.

var n = parseInt(s, 10);

5. Les variables doivent être déclarées avant utilisation

Bien qu'il n'y ait aucune erreur en utilisant directement des variables sans les déclarer, écrire de cette façon est très sujette aux erreurs. Étant donné que l'interpréteur l'interprétera comme une variable globale, elle peut facilement porter le même nom que d'autres variables globales et provoquer des erreurs. Par conséquent, nous devons développer une bonne habitude de déclarer les variables avant de les utiliser.

6. Il y a une situation asynchrone dans la boucle

for (var i=0, l=arr.length; i<l; i++) {
　　 var sql = "select * from nx_user";
  db.query(sql, function(){
    sys.log(i + ': ' + sql);
  }); //db.query为表查询操作，是异步操作
}

Vous constaterez que les résultats de sortie sont les mêmes, et ils constituent le contenu de sortie lorsque i=arr.length-1. Étant donné que JavaScript est monothread, il exécutera d'abord le contenu synchrone de la boucle entière avant d'exécuter les opérations asynchrones. La fonction de rappel anonyme dans le code est un rappel asynchrone. Lorsque cette fonction est exécutée, la boucle for et certaines opérations de synchronisation ultérieures sont terminées. En raison du principe de fermeture, cette fonction conservera le contenu de la variable sql et de la variable i dans la dernière boucle de la boucle for, ce qui conduira à des résultats erronés.

Alors que devons-nous faire ? Il existe deux solutions. La première consiste à utiliser une fonction immédiate, comme suit :

for (var i=0, l=arr.length; i<l; i++) {
　 var sql = "select * from nx_user";
  (function(sql, i){
    db.query(sql, function(){
      sys.log(i + ': ' + sql);
    }); //db.query为表查询操作，是异步操作
  })(sql, i);
}

Une autre méthode consiste à extraire la partie opération asynchrone et à écrire une fonction comme suit :

var outputSQL = function(sql, i){
   db.query(sql, function(){
      sys.log(i + ': ' + sql);
  }); //db.query为表查询操作，是异步操作
}

for (var i=0, l=arr.length; i<l; i++) {
　 var sql = "select * from nx_user";
  outputSQL(sql, i); 
}

7. Lorsque vous traitez de grandes quantités de données, essayez d'éviter les boucles imbriquées.

Étant donné que le temps de traitement des boucles imbriquées augmentera de façon exponentielle à mesure que la quantité de données augmente, cela doit être évité autant que possible. Dans ce cas, s’il n’y a pas de meilleur moyen, la stratégie générale consiste à échanger de l’espace contre du temps, c’est-à-dire à établir une table de cartographie de hachage des données cycliques secondaires. Bien entendu, les circonstances spécifiques doivent être analysées au cas par cas. Un autre point à mentionner est que certaines méthodes elles-mêmes sont un corps de boucle, comme Array.sort() (cette méthode doit être implémentée en utilisant deux couches de boucles), vous devez donc faire attention lorsque vous l'utilisez.

8. Essayez d'éviter les appels récursifs.

L'avantage de l'appel récursif est que le code est concis et la mise en œuvre est simple, mais ses inconvénients sont très importants et s'expliquent comme suit :

(1) La taille de la pile de fonctions augmentera linéairement avec le niveau de récursion, et la pile de fonctions a une limite supérieure. Lorsque la récursion atteint un certain niveau, la pile de fonctions débordera, provoquant des erreurs de programme ;

(2) Chaque niveau récursif ajoutera des opérations supplémentaires de push et pop de pile, c'est-à-dire l'enregistrement de la scène et la restauration de la scène pendant l'appel de fonction.

Par conséquent, les appels récursifs doivent être évités autant que possible.

9. Concernant l'isolation de la portée des fichiers du module.

Lorsque Node compile le fichier du module JavaScript, son contenu a été empaqueté en tête et en queue, comme suit :

(function(exports, require, module, __filename, __dirname){
  你的JavaScript文件代码
});

Cela permet l'isolation de la portée entre chaque fichier de module. Par conséquent, lorsque vous écrivez des fichiers de module NodeJs, vous n'avez pas besoin d'ajouter vous-même une couche d'encapsulation d'isolation de portée. Le format de code suivant ajoute uniquement une couche supplémentaire d'appels de fonctions, ce qui n'est pas recommandé :

(function(){
  ... ...
})();

10. Ne mélangez pas les tableaux et les objets

Voici un exemple de code d'erreur :

var o = [];
o['name'] = 'LiMing';

Le mélange de tableaux et d'objets peut entraîner des erreurs imprévisibles. Un de mes collègues a rencontré un problème très étrange. Regardons d'abord le code :

var o = [];
o['name'] = 'LiMing';
var s = JSON.stringify(o);

Il pensait à l'origine que l'attribut name de l'objet o serait dans la chaîne JSON, mais le résultat était que ce n'était pas le cas. J'ai également été très surpris à l'époque, mais j'avais le pressentiment que c'était un problème de mélange de tableaux et d'objets. Je l'ai essayé et cela s'est avéré être le problème. Plus tard, j'ai découvert dans la spécification ECMA que les tableaux sont sérialisés selon les règles JA. Il est donc nécessaire de développer de bonnes habitudes de programmation, d’utiliser correctement les tableaux et les objets et de ne pas les mélanger.

11. Programmation de promesse élégante

Je pense que quiconque est entré en contact avec nodeJs a eu cette expérience. Lorsque des rappels asynchrones sont imbriqués dans des rappels asynchrones, le code devient confus et manque de lisibilité. Ce dilemme des nodeJ peut être surmonté à l’aide de promesses. La promesse est comme un sculpteur, rendant votre code élégant et beau. Promise a une spécification A et il existe plusieurs méthodes d'implémentation en ligne, vous pouvez vous y référer.