En savoir plus sur certaines fonctionnalités de Node.js

Node.js est un langage backend émergent conçu pour aider les programmeurs à créer rapidement des applications évolutives. Node.js possède de nombreuses fonctionnalités attrayantes, et il existe d'innombrables rapports à ce sujet. Cet article analysera et discutera de fonctionnalités telles que EventEmitter, Streams, Coding Style, Linting et Coding Style pour aider les utilisateurs à mieux comprendre Node.js.

En tant que plate-forme construite sur le runtime JavaScript Chrome, notre connaissance de JavaScript semble être applicable aux applications de nœuds ; sans extensions ou modifications de langage supplémentaires, nous pouvons appliquer notre expérience de programmation frontale à la programmation backend.

EventEmitter (émetteur d'événement)

Tout d'abord, vous devez comprendre le modèle EventEmitter. Il peut envoyer un événement et permettre aux consommateurs de s'abonner à des événements qui les intéressent. Nous pouvons le considérer comme une extension du modèle de livraison de rappel à une fonction asynchrone. En particulier, EventEmitter sera plus avantageux lorsque plusieurs rappels sont nécessaires.

Par exemple, un appelant envoie une requête « lister les fichiers » à un serveur distant. Vous souhaiterez peut-être regrouper les résultats renvoyés et effectuer un rappel pour chaque groupe. Le modèle EventEmitter vous permet d'envoyer un rappel "fichier" sur chaque groupe et d'effectuer un traitement "de fin" lorsque toutes les opérations sont terminées.

Lorsque vous utilisez EventEmitter, il vous suffit de définir les événements et paramètres pertinents.

Copier le code Le code est le suivant :

var EventEmitter = require('events').EventEmitter 

var util = require('util'); 

function MaClasse() { 

if (!(this instanceof MyClass)) return new MyClass(); 

EventEmitter.call(ce); 

var soi = ceci 

setTimeout(fonction timeoutCb() { 

Self.emit('myEvent', 'hello world', 42);
}, 1000); 

} 

util.inherits(MaClasse, EventEmitter);

Le constructeur MyClass crée un déclencheur temporel avec un délai de déclenchement de 1 s et un événement déclencheur de myEvent. Pour utiliser les événements associés, vous devez exécuter la méthode on() :

Copier le code Le code est le suivant :

var monObj = new MaClasse(); 

var start = Date.now(); 

monObj.on('myEvent', function myEventCb(str, num) { 

console.log('myEvent triggered', str, num, Date.now() - start 
);
}); 

Il convient de noter ici que bien que l'événement EventEmitter souscrit soit un événement asynchrone, lorsque l'heure est déclenchée, les actions de l'auditeur seront synchronisées. Par conséquent, si l'événement myEvent ci-dessus comporte 10 écouteurs, tous les écouteurs seront appelés dans l'ordre sans attendre la boucle d'événement.

Si une sous-classe de EventEmitter génère un événement submit('error'), mais qu'aucun auditeur ne s'y abonne, alors la classe de base EventEmitter lèvera une exception, provoquant le déclenchement d'une exception uncaughtException lorsque l'objet de processus est exécuté.

erreur

verror est une extension de la classe de base Error, qui nous permet de définir des messages de sortie en utilisant le format de caractères printf.

Flux

S'il y a un fichier très volumineux qui doit être traité, la méthode idéale devrait être d'en lire une partie et d'en écrire une partie. Quelle que soit la taille du fichier, tant que le temps le permet, le traitement se poursuivra toujours. être complété. La notion de flux doit être utilisée ici. Les flux sont un autre modèle largement utilisé dans Node, qui est l'implémentation d'EventEmitter. Fournit des interfaces lisibles, inscriptibles ou full-duplex. Il s'agit d'une interface abstraite qui fournit des événements de fonctionnement réguliers, notamment : lisible, inscriptible, drain, données, fin et fermeture. Si nous pouvons utiliser des pipelines pour intégrer efficacement ces événements, des opérations interactives plus puissantes seront réalisées.

En utilisant .pipe(), Note peut communiquer avec la contre-pression via le pipeline. La contre-pression signifie : ne lire que ceux qui peuvent être écrits, ou écrire uniquement ceux qui peuvent être lus.

Par exemple, nous envoyons maintenant des données depuis stdin vers un fichier local et un serveur distant :

Copier le code Le code est le suivant :

var fs = require('fs');
var net = require('net');
var localFile = fs.createWriteStream('localFile.tmp');

net.connect('255.255.255.255', 12345, fonction(client) {

process.stdin.pipe(client);
process.stdin.pipe(localFile);
});

Et si nous voulons envoyer des données vers un fichier local et utiliser gunzip pour compresser le flux, nous pouvons faire ceci :

Copier le code Le code est le suivant :

var fs = require('fs');
var zlib = require('zlib');

process.stdin.pipe(zlib.createGunzip()).pipe(fs.createWriteStream('localFile.tar'));

Si vous souhaitez en savoir plus sur le streaming, veuillez cliquer ici.

Flux de contrôle

Étant donné que JS possède des objets, des fermetures et d'autres concepts fonctionnels de première classe, les autorisations de rappel peuvent être facilement définies. Ceci est très pratique lors du prototypage et peut intégrer des autorisations logiques selon les besoins. Mais cela facilite également l’utilisation de fonctions intégrées maladroites.

Par exemple, nous voulons lire une série de fichiers dans l'ordre puis effectuer une certaine tâche :

Copier le code Le code est le suivant :

fs.readFile('firstFile', 'utf8', fonction firstCb(err, firstFile) {

faireQuelquechose(premierFichier);

fs.readFile('secondFile', 'utf8', fonction secondCb(err, secondFile) {

faireQuelque chose(secondFile);

fs.readFile('thirdFile', 'utf8', functionthirdCb(err,thirdFile) {

faireQuelquechose(troisièmeFichier);

});

});

});

Le problème avec ce modèle est :

1. La logique de ces codes est très dispersée et désordonnée, et les processus opérationnels associés sont difficiles à comprendre.
2. Aucune gestion des erreurs ou des exceptions.
3. Les fuites de mémoire de fermeture dans JS sont très courantes et difficiles à diagnostiquer et à détecter.

Si nous voulons effectuer une série d'opérations asynchrones sur un ensemble d'entrées, utiliser une bibliothèque de contrôle de flux est un choix plus judicieux. Vasync est utilisé ici.

vasync est une bibliothèque de contrôle de processus dont l'idée vient des opérations asynchrones. Sa particularité est qu'il permet aux consommateurs de visualiser et d'observer le traitement d'une certaine tâche. Ces informations sont très utiles pour étudier le processus d’apparition d’une erreur.

Style de codage

Le style de programmation peut être considéré comme le sujet le plus controversé, car il est souvent décontracté. Carottes et choux, à chacun ses préférences. L’important est de trouver un style qui convient à la fois à l’individu et à l’équipe. Un certain héritage traditionnel peut améliorer le parcours de développement de Node.

1. Nommez la fonction
2. Essayez de nommer toutes les fonctions.
3. Évitez les fermetures
4. Ne définissez pas d'autres fonctions au sein d'une fonction. Cela peut réduire de nombreux accidents de fuite de mémoire de fermeture inattendus.
5. Des fonctions de plus en plus petites

Bien que le V8 JIT soit un moteur puissant, des fonctions plus petites et rationalisées s'intégreront mieux au V8. De plus, si nos fonctions sont petites et exquises (environ 100 lignes), nous nous remercierons lorsque nous les lirons et les maintiendrons.

Vérifiez le style par programmation : maintenez la cohérence du style et appliquez-le à l'aide d'un outil d'inspection. Nous utilisons jsstyle.

Peluchage (inspection du code)

L'outil Lint peut effectuer une analyse statique du code sans l'exécuter et vérifier les erreurs et les risques potentiels, tels que les instructions break manquantes dans les cas de commutation. Lint n’est pas simplement équivalent à la vérification de style, il vise davantage une analyse objective des risques plutôt qu’une sélection subjective de style. Nous utilisons javascriptlint, qui contient de riches éléments de vérification.

Journalisation

Lorsque nous programmons et codons, nous devons avoir une perspective à long terme. En particulier, réfléchissez aux outils à utiliser pour le débogage. Une excellente première étape est une journalisation efficace. Nous devons identifier les informations pour voir ce qui mérite une attention particulière lors du débogage et ce qui est utilisé pour l'analyse et la recherche pendant l'exécution. Il est recommandé d'utiliser Bunyan, une bibliothèque de journalisation directe Node.js. Le format de sortie des données est JSON.

Client Serveur

Si une application dispose de capacités de traitement distribué, elle sera plus attractive sur le marché. Des interfaces similaires peuvent être décrites à l’aide de l’API HTTP RESTFul ou du TCP JSON brut. Cela permet aux développeurs de combiner leur expérience Node avec des environnements réseau asynchrones et l'utilisation de flux avec des systèmes distribués et évolutifs.

Outils couramment utilisés :

1. restifier

En termes simples, il s'agit d'un outil pour créer des services REST. Il offre une bonne prise en charge du traitement de visualisation et de débogage, et prend en charge Bunyan et DTrace.

2. vite

fast est un outil léger qui utilise TCP pour traiter les messages JSON. Fournit la prise en charge de DTrace, nous permettant d'identifier rapidement les caractéristiques de performances du client serveur.

3. flux de travail

Workflow est basé sur Restify et peut définir des processus métier pour une série de services et d'API distants. Par exemple : état d’erreur, délai d’attente, reconnexion, gestion des congestions, etc.

En savoir plus sur certaines fonctionnalités de Node.js_node.js