10 concepts JavaScript que chaque développeur Node.js doit maîtriser

Rahul Mhatre est chef d'équipe de développeurs chez Software AG.

Avec JavaScript et le moteur V8 au cœur, une architecture événementielle et une évolutivité prête à l'emploi, Node.js est rapidement devenu la norme de facto pour la création d'applications Web et de produits SaaS. Les frameworks Node.js tels que Express, Sails et Socket.IO permettent aux utilisateurs de démarrer rapidement des applications et de se concentrer uniquement sur la logique métier.

Node.js doit beaucoup à JavaScript pour son énorme popularité. JavaScript est un langage multiparadigme qui prend en charge de nombreux styles de programmation différents, y compris la programmation fonctionnelle, la programmation procédurale et la programmation orientée objet. Cela permet au développeur d'être flexible et de tirer parti des différents styles de programmation.

Mais JavaScript peut être une épée à double tranchant. La nature multiparadigme de JavaScript signifie que presque tout est modifiable. Ainsi, vous ne pouvez pas ignorer la probabilité de mutation d'objet et de portée lors de l'écriture de code Node.js. Parce que JavaScript manque d'optimisation des appels de queue (qui permet aux fonctions récursives de réutiliser les cadres de pile pour les appels récursifs), il est dangereux d'utiliser la récursivité pour les grandes itérations. En plus des pièges comme ceux-ci, Node.js est à thread unique, il est donc impératif pour les développeurs d'écrire du code asynchrone.

JavaScript peut être une aubaine s'il est utilisé avec précaution - ou un fléau si vous êtes imprudent. Suivre des règles structurées, des modèles de conception, des concepts clés et des règles de base vous aidera à choisir l'approche optimale d'un problème. Quels concepts clés les programmeurs de Node.js doivent-ils comprendre? Ci-dessous, je vais partager les 10 concepts JavaScript qui, à mon avis, sont les plus essentiels pour écrire du code Node.js. efficace et évolutif.

Vidéo connexe: trucs et astuces Node.js

Dans cette vidéo explicative, découvrez plusieurs techniques qui peuvent améliorer votre expérience de développement de nœuds.

JavaScript IIFEs: expressions de fonction immédiatement appelées

Une expression de fonction immédiatement invoquée (IIFE) est une fonction qui est exécutée dès sa création. Il n'a aucun lien avec les événements ou l'exécution asynchrone. Vous pouvez définir un IIFE comme indiqué ci-dessous:

(fonction() {

// tout votre code ici

// ...

}) ();

La première paire de parenthèses function(){...}convertit le code entre parenthèses en une expression. La seconde paire de parenthèses appelle la fonction résultant de l'expression. Un IIFE peut également être décrit comme une fonction anonyme auto-appelante. Son utilisation la plus courante est de limiter la portée d'une variable faite via varou d'encapsuler le contexte pour éviter les collisions de noms.

Fermetures JavaScript

Une fermeture en JavaScript est une fonction interne qui a accès à la portée de sa fonction externe, même après que la fonction externe a renvoyé le contrôle. Une fermeture rend les variables de la fonction interne privées. Un exemple simple de fermeture est présenté ci-dessous:

var count = (fonction () {

    var _counter = 0;

    return function () {return _counter + = 1;}

}) ();

compter();

compter();

compter();

> // le compteur est maintenant 3

Une countfonction externe est attribuée à la variable . La fonction externe s'exécute une seule fois, ce qui définit le compteur à zéro et renvoie une fonction interne. La _countervariable n'est accessible que par la fonction interne, ce qui la fait se comporter comme une variable privée.

Prototypes JavaScript

Chaque fonction JavaScript a une propriété prototype qui est utilisée pour attacher des propriétés et des méthodes. Cette propriété n'est pas énumérable. Il permet au développeur d'attacher des méthodes ou des fonctions membres à ses objets. JavaScript prend en charge l'héritage uniquement via la propriété prototype. Dans le cas d'un objet hérité, la propriété prototype pointe vers le parent de l'objet. Une approche courante pour attacher des méthodes à une fonction consiste à utiliser des prototypes comme indiqué ci-dessous:

function Rectangle (x, y) {

    this._length = x;

    this._breadth = y;

}

Rectangle.prototype.getDimensions = function () {

    return {longueur: this._length, width: this._breadth};

};

Rectangle.prototype.setDimensions = function (len, bred) {

    this._length = len;

    this._breadth = élevé;

};

Propriétés privées JavaScript, utilisant des fermetures

JavaScript vous permet de définir des propriétés privées en utilisant le préfixe de soulignement, comme indiqué dans l'exemple ci-dessus. Cependant, cela n'empêche pas un utilisateur d'accéder ou de modifier directement une propriété qui est censée être privée.

La définition de propriétés privées à l'aide de fermetures vous aidera à résoudre ce problème. Les fonctions membres qui ont besoin d'accéder aux propriétés privées doivent être définies sur l'objet lui-même. Vous pouvez créer des propriétés privées en utilisant des fermetures comme indiqué ci-dessous:

function Rectangle (_length, _breadth) {

     this.getDimensions = function () {

     return {longueur: _length, largeur: _breadth};

     };

     this.setDimension = function (len, bred) {

     _length = len;

    _breadth = élevé

    };

}

Modèle de module JavaScript

Le modèle de module est le modèle de conception le plus fréquemment utilisé en JavaScript pour obtenir un code faiblement couplé et bien structuré. Il vous permet de créer des niveaux d'accès publics et privés. Une façon d'obtenir un modèle de module est illustrée ci-dessous:

var Direction = (fonction () {

  var _direction = 'avant'

  var changeDirection = fonction (d) {

          _direction = d;

  }

  return {setDirection: function (d) {

          changeDirection (d);

          console.log (_direction);

          }

  };

}) ();

Direction.setDirection ('arrière'); // Sorties: 'en arrière'

console.log (Direction._direction);

Le modèle de module de révélation est similaire au modèle de module dans lequel les variables et les méthodes qui doivent être exposées sont renvoyées dans un littéral d'objet. L'exemple ci-dessus peut être écrit en utilisant le modèle de module de révélation comme suit:

var Direction = (fonction () {

  var _direction = 'avant';

  var _privateChangeDirection = fonction (d) {

_direction = d;

  }

  revenir {

          setDirection: _privateChangeDirection

  };

}) ();

Levage JavaScript

JavaScript déplace les variables et les déclarations de fonction vers le haut de leur portée avant l'exécution du code. C'est ce qu'on appelle le levage. Quel que soit l'endroit où vous placez la déclaration des fonctions et des variables dans votre code, elles sont déplacées vers le haut de leur portée par l'interpréteur. Cela peut ou non être là où vous les voulez. Sinon, votre programme aura des erreurs.

Les déclarations de variables sont traitées avant l'exécution de tout code. Ironiquement, les variables non déclarées n'existent pas tant qu'on ne leur attribue pas de valeur. Ainsi, toutes les variables non déclarées deviennent des variables globales. Bien que les déclarations de fonction soient hissées, les expressions de fonction ne sont pas hissées. JavaScript a un ordre de priorité lors du levage des variables et des fonctions.

La priorité est donnée ci-dessous du plus haut au plus bas:

  • Affectation des variables
  • Déclaration de fonction
  • Déclarations de variables

Pour éviter les bogues, vous devez déclarer vos variables et fonctions au début de chaque portée. 

Curry JavaScript

Le curry est une méthode pour rendre les fonctions plus flexibles. Avec une fonction curry, vous pouvez transmettre tous les arguments attendus par la fonction et obtenir le résultat, ou vous pouvez transmettre uniquement un sous-ensemble d'arguments et recevoir une fonction qui attend le reste des arguments. Un exemple simple de curry est donné ci-dessous:

var myFirstCurry = function (mot) {

  fonction de retour (utilisateur) {

            return [mot, ",", utilisateur] .join ("");

  };

};

var HelloUser = myFirstCurry ("Bonjour");

HelloUser ("Rahul"); // Sortie: "Bonjour, Rahul"

La fonction curry d'origine peut être appelée directement en passant chacun des paramètres dans un ensemble séparé de parenthèses l'un après l'autre, comme indiqué ci-dessous:

myFirstCurry ("Hey, wassup!") ("Rahul"); // Sortie: "Hey, wassup !, Rahul"

Méthodes d'application, d'appel et de liaison JavaScript

Il est impératif pour tout développeur JavaScript afin de comprendre la différence entre les call, applyet les bindméthodes. Les trois fonctions sont similaires en ce que leur premier argument est toujours la valeur «this», ou contexte, que vous voulez donner à la fonction sur laquelle vous appelez la méthode.

Des trois, callc'est le plus simple. C'est la même chose que d'appeler une fonction tout en spécifiant son contexte. Voici un exemple:

var user = {

     nom: "Rahul Mhatre",

     whatIsYourName: function () {

     console.log (this.name);

     }

};

user.whatIsYourName (); // Sortie: "Rahul Mhatre",

var user2 = {

     nom: "Neha Sampat"

};

user.whatIsYourName.call (user2); // Sortie: "Neha Sampat"

Notez que applyc'est presque le même que call. La seule différence est que vous transmettez les arguments sous forme de tableau et non séparément. Les tableaux sont plus faciles à manipuler en JavaScript, ouvrant un plus grand nombre de possibilités pour travailler avec des fonctions. Voici un exemple utilisant applyet call:

var user = {

     saluer: "Bonjour!",

     greetUser: function (userName) {

     console.log (this.greet + "" + userName);

     }

};

var greet1 = {

     greet: "Hola"

};

user.greetUser.call (greet1, "Rahul") // Sortie: "Hola Rahul"

user.greetUser.apply (greet1, ["Rahul"]) // Sortie: "Hola Rahul"

La bindméthode vous permet de passer des arguments à une fonction sans l'invoquer. Une nouvelle fonction est renvoyée avec des arguments délimités avant tout autre argument. Voici un exemple:

var user = {

     saluer: "Bonjour!",

     greetUser: function (userName) {

     console.log (this.greet + "" + userName);

}

};

var greetHola = user.greetUser.bind ({saluer: "Hola"});

var greetBonjour = user.greetUser.bind ({saluer: "Bonjour"});

greetHola ("Rahul") // Sortie: "Hola Rahul"

greetBonjour ("Rahul") // Sortie: "Bonjour Rahul"

Mémorisation JavaScript

La mémorisation est une technique d'optimisation qui accélère l'exécution des fonctions en stockant les résultats d'opérations coûteuses et en renvoyant les résultats mis en cache lorsque le même ensemble d'entrées se produit à nouveau. Les objets JavaScript se comportent comme des tableaux associatifs, ce qui facilite la mise en œuvre de la mémorisation en JavaScript. Par exemple, nous pouvons convertir une fonction factorielle récursive en une fonction factorielle mémorisée comme indiqué ci-dessous:

function memoizeFunction (func) {

  var cache = {};

  fonction de retour () {

          var clé = arguments [0];

          if (cache [clé]) {

          return cache [clé];

          }

          autre {

          var val = func.apply (ceci, arguments);

          cache [clé] = val;

          return val;

          }

  };

}

var fibonacci = memoizeFunction (fonction (n)

  retour (n === 0);

Surcharge de méthode JavaScript

La surcharge de méthode permet à plusieurs méthodes d'avoir le même nom mais des arguments différents. Le compilateur ou l'interpréteur détermine la fonction à appeler en fonction du nombre d'arguments transmis. La surcharge de méthode n'est pas directement prise en charge dans JavaScript. Mais vous pouvez réaliser quelque chose de très similaire, comme indiqué ci-dessous:

function overloadMethod (objet, nom, fn) {

     if (! object._overload) {

    object._overload = {};

     }

     if (! object._overload [nom]) {

    object._overload [nom] = {};

    }

     if (! object._overload [nom] [fn.length]) {

object._overload [nom] [fn.length] = fn;

    }

     objet [nom] = fonction () {

         if (this._overload [nom] [arguments.longueur])

         return this._overload [nom] [arguments.length] .apply (this, arguments);

     };

function Etudiants () {

  overloadMethod (this, "find", function () {

          // Trouver un étudiant par son nom

  });

overloadMethod (this, "find", function (first, last) {

          // Trouver un étudiant par prénom et nom

  });

}

var étudiants = nouveaux étudiants ();

étudiants.find (); // Trouve tout

étudiants.find ("Rahul"); // Recherche les élèves par leur nom

étudiants.find ("Rahul", "Mhatre"); // Recherche les utilisateurs par prénom et nom

Au fur et à mesure que vous vous familiariserez avec Node.js, vous remarquerez qu'il existe de nombreuses façons de résoudre presque tous les problèmes. Mais il est essentiel d'adopter la bonne approche. Une mauvaise approche entraînera de multiples effets secondaires tels que des applications inégales ou boguées ou des régressions qui vous obligeront à réécrire toute la logique. D'un autre côté, la bonne approche jettera les bases d'une application robuste, efficace et évolutive.

Les 10 concepts JavaScript décrits dans cet article sont des notions de base que tout développeur Node.js devrait connaître. Mais ils sont la pointe de l'iceberg. JavaScript est puissant et complexe. Plus vous l'utilisez, plus vous comprendrez à quel point JavaScript est vraiment vaste. Une meilleure compréhension d'une langue aussi étendue vous aidera certainement à éviter les erreurs. En attendant, maîtrisez les bases et vous obtiendrez d'excellents résultats.

Rahul Mhatre est chef d'équipe de développeurs chez Software AG. Auparavant, il était architecte technique chez Built.io, qui a été acquis par Software AG. 

-

Le New Tech Forum offre un lieu pour explorer et discuter des technologies d'entreprise émergentes avec une profondeur et une ampleur sans précédent. La sélection est subjective, basée sur notre choix des technologies que nous pensons importantes et qui intéressent le plus les lecteurs. n'accepte pas les supports marketing pour la publication et se réserve le droit de modifier tout le contenu fourni. Envoyez toutes vos demandes à [email protected]