lundi, 4 mars 2024

10 concepts JavaScript que tout développeur Node doit maîtriser

Crédit : Nathan Dumlao/ Lagarto Film/ Unsplash

Node.js est passé d’une sortie idée originale à un pilier en un temps record.

Aujourd’hui, c’est une exigence de facto pour la création d’applications Web, de logiciels système, etc. Les structures Node côté serveur comme Express, les outils de chaîne de construction comme Webpack et une multitude d’utilitaires pour chaque besoin font de Node une méthode extrêmement populaire pour exploiter la puissance et l’expressivité de JavaScript sur le back-end.

Bien que Node soit désormais en concurrence avec Deno et Bun, il reste la plateforme JavaScript phare sur le serveur.

Node doit beaucoup à JavaScript pour son énorme popularité. JavaScript est un langage multiparadigme qui prend en charge plusieurs conceptions de spectacles, notamment des programmes pratiques, une programmation réactive et des programmes orientés objet. Il permet au développeur d’être flexible et de bénéficier des nombreux styles de programmes.

JavaScript peut être une arme à double tranchant. La nature multiparadigme de JavaScript indique que presque tout est modifiable.

Par conséquent, vous ne pouvez pas écarter la possibilité d’anomalies d’éléments et de portée lors de l’écriture de code Node.js. Étant donné que JavaScript ne dispose pas d’optimisation des appels finals (qui permet aux fonctions récursives de recycler les cadres de pile pour les appels récursifs), il est dangereux d’utiliser la récursivité pour les versions volumineuses. En plus de ces pièges, Node est monothread, il est donc essentiel pour les concepteurs de composer du code asynchrone. Node souffre également de facepalms typiques de tous les langages, comme les erreurs de déglutition.

JavaScript peut être un avantage s’il est utilisé avec précaution – ou un fléau si vous êtes négligent. Suivre des règles structurées, des modèles de style, des concepts essentiels et des directives fondamentales vous aidera à choisir la technique optimale pour résoudre un problème. Quelles idées cruciales les développeurs Node.js doivent-ils comprendre ? Voici les 10 principes JavaScript qui, à mon avis, sont les plus essentiels pour composer du code Node.js efficace et évolutif.

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 rendu le contrôle. Une fermeture rend les variables de la fonction interne personnelles. Les programmes pratiques ont explosé en popularité, faisant des fermetures une partie importante du package du développeur Node. Voici un exemple basique de fermeture en JavaScript :

let count = (function () )(); compter(); compter(); count();// le compteur est maintenant à 3

La variable count est désignée comme fonction externe. La fonction externe s’exécute uniquement lorsque, ce qui remet le compteur à zéro et renvoie une fonction interne. La variable _ counter n’est accessible que par la fonction interne, ce qui la fait agir comme une variable personnelle.

L’exemple ici est une fonction d’ordre supérieur (ou métafonction, une fonction qui prend ou renvoie une autre fonction). Les fermetures sont découvertes dans de nombreuses autres applications. Une fermeture se produit chaque fois que vous définissez une fonction dans une autre fonction et que la fonction interne obtient à la fois sa propre portée et un accès à la portée maman et papa – c’est-à-dire que la fonction interne peut « voir » les variables externes, mais pas l’inverse.

Cela peut également être trouvé pratique avec des approches pratiques comme map(innerFunction), où innerFunction peut utiliser des variables définies dans la portée externe.

Cela peut également être trouvé pratique avec des approches pratiques comme map(innerFunction), où innerFunction peut utiliser des variables définies dans la portée externe.

p>

Prototypes JavaScript

Chaque fonction JavaScript possède un modèle home qui est utilisé pour attacher des maisons et des techniques. Cette propriété résidentielle ou commerciale n’est pas dénombrable. Il permet au concepteur d’attacher des approches ou des fonctions membres à ses objets. JavaScript prend en charge l’héritage uniquement via la maison modèle. Dans le cas d’un objet acquis, le modèle de propriété résidentielle ou commerciale indique les parents de l’objet. Une méthode typique pour connecter les approches d’une fonction consiste à utiliser des prototypes comme indiqué ici :

function Rectangle(x, y) this.length = x; this.breadth = y; Rectangle.prototype.getDimensions = function () return ;; Rectangle.prototype.setDimensions = function (len, bred) ;

Bien que le JavaScript moderne dispose d’une assistance de classe assez sophistiquée, il utilise toujours le système prototype sous le capot. C’est la source d’une grande partie de la flexibilité du langage.

Définir les propriétés personnelles à l’aide de noms de hachage

Autrefois, la convention consistant à préfixer les variables avec un trait de soulignement était utilisée pour indiquer qu’une variable devait être personnelle. Néanmoins, il s’agissait simplement d’une astuce et non d’une contrainte imposée par la plateforme. Le JavaScript moderne utilise des membres personnels et des techniques de hashtag pour les classes :

class ClassWithPrivate

Les noms de hachage personnels sont une fonctionnalité plus récente et extrêmement bienvenue en JavaScript ! Les versions et navigateurs actuels de Node le prennent en charge, et les outils de développement Chrome vous permettent d’accéder directement aux variables personnelles en guise d’avantage.

Spécifier les propriétés personnelles à l’aide de fermetures

Une autre technique que vous verrez parfois pour contourner l’absence de propriétés privées dans le système de modèle JavaScript consiste à utiliser une fermeture. Le JavaScript moderne vous permet de définir des propriétés personnelles en utilisant le préfixe hashtag, comme le montre l’exemple ci-dessus. Cependant, cela ne fonctionne pas pour le système prototype JavaScript. De plus, c’est une technique que vous trouverez fréquemment dans le code et qui est essentielle pour comprendre ce qu’il fait.

Spécifier des propriétés personnelles à l’aide de fermetures vous permet de simuler une variable privée. 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. Voici la syntaxe pour créer des propriétés privées à l’aide de fermetures :

function Forme rectangulaire (_ longueur, _ largeur) this.getDimensions = function () ; this.setDimension = fonction (len, bred) _ length = len; _ largeur = reproduit ;

Modules JavaScript

Il était une fois, JavaScript n’avait pas de système de modules, et les développeurs ont créé une astuce créative (appelée modèle de module) pour créer quelque chose qui fonctionnerait. Au fur et à mesure du développement de JavaScript, il a généré non pas un mais deux systèmes de modules : la syntaxe CommonJS consist of et la syntaxe ES6 require.

Node utilise traditionnellement CommonJS, tandis que les navigateurs utilisent ES6. Cependant, les versions récentes de Node (au cours des deux dernières années) prennent également en charge ES6. Le modèle consiste désormais à utiliser des modules ES6, et tôt ou tard, nous n’aurons qu’une seule syntaxe de module à utiliser dans JavaScript. ES6 ressemble à ceci (où nous exportons un module par défaut et l’importons ensuite) :

// Module exporté dans file1.js ... export default function Primary() // ... module importé dans file2.js importe le principal depuis "./file1" ;

Vous verrez toujours CommonJS, et vous devrez parfois l’utiliser pour importer un module. Voici comment il cherche à exporter puis à importer un module par défaut à l’aide de CommonJS :

// module exporté dans file1.js ... function main = () module.exports = primaire;// ... module importé dans file2.js

Gestion des erreurs

Quel que soit le langage ou l’environnement dans lequel vous vous trouvez, la gestion des erreurs est nécessaire et incontournable. Le nœud ne fait pas exception. Il existe 3 manières fondamentales de gérer les erreurs : les blocs try/catch, le lancement de nouvelles erreurs et les gestionnaires on().

Page

  • 1
  • 2
  • suivant

.

Toute l’actualité en temps réel, est sur L’Entrepreneur

LAISSER UN COMMENTAIRE

S'il vous plaît entrez votre commentaire!
S'il vous plaît entrez votre nom ici