NodeJS: démarrage rapide



Bonjour à tous! Très bientôt, le cours de développeur Node.js va commencer , dans le cadre duquel nous avons mené une leçon ouverte traditionnelle . Le webinaire a examiné les forces et les faiblesses de Node, et a également discuté pour quelles tâches cette plate-forme logicielle est la mieux adaptée et pour quels autres langages et cadres devraient être choisis. Et, bien sûr, non sans pratique. Pour exécuter les exemples et les logiciels nécessaires à l' installation Node.js .

Conférencier - Alexander Korzhikov , Dev IT Engineer chez ING Group (Pays-Bas).






Quelques mots sur Node.js


Node.js est un runtime JavaScript asynchrone basé sur des concepts tels que la boucle d'événements et l'architecture orientée événements. La plateforme Node.js et le gestionnaire de packages NPM standard vous permettent de créer des applications efficaces pour divers domaines - du Web au Machine Learning.

L'exemple de serveur Web le plus simple ( node server.js):

const http = require('http')
const hostname = '127.0.0.1'
const port = 3000
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`)
})

En regardant le code ci-dessus, les fonctionnalités suivantes de Node.js peuvent être notées:

  1. Nous pouvons exécuter du code JavaScript directement sur le serveur, c'est-à-dire qu'il est possible d'exécuter des fichiers JavaScript à l'aide de la commande node.
  2. Le format CommonJS des modules pour le chargement des dépendances et des modules ES est pris en charge et les deux formats peuvent être utilisés.
  3. Une bibliothèque de modules standard est prise en charge, dont HTTP fait partie.
  4. L'API est basée sur le modèle de rappels asynchrones, mais Promise est également pris en charge.
  5. La syntaxe ES2015 est prise en charge. À propos, voici un lien utile avec lequel vous pouvez toujours voir dans quelle version de Node quelles fonctionnalités JS sont prises en charge . En cas de problème, vous pouvez comparer et comprendre le problème.

Aussi ne manquez pas la petite démo (VSCode + Chrome Debug).

Une brève excursion dans l'histoire


La plateforme Node.js est apparue en 2009, le principal développeur et créateur du projet était Ryan Dahl. Son idée principale était de créer une E / S non bloquante (entrée-sortie) pour le serveur, en plus, en utilisant JavaScript. À cette époque, de telles approches n'étaient pas très courantes et JavaScript était l'une des meilleures solutions.

Node.js utilise le moteur Chromium à l'intérieur de lui-même, ou plutôt, la partie de celui-ci qui interprète JavaScript - V8 . Du fait que l'interprète s'est séparé à un moment donné dans un projet V8 distinct, il est devenu possible de simplement créer un écosystème autour de lui. À proprement parler, c'est exactement ce qu'a fait le créateur de Node.js Ryan Dahl. Soit dit en passant, il y a aujourd'hui la Fondation Node.js, une organisation qui soutient le projet.



Structure


Tout d'abord, la bibliothèque est écrite en C ++ et JavaScript. Le projet lui-même repose sur GitHub , donc si vous êtes curieux, vous pouvez vous familiariser avec son code source. Vous pouvez vous plonger dans son étude pendant très longtemps)).

Deuxièmement, comme déjà mentionné, il inclut V8 (la plate-forme d'exécution JavaScript de Google) et libuv dans le cadre de la boucle d'événement (boucle d'événement asynchrone).

Bien sûr, il existe différents modules pour travailler avec le système d'exploitation qui vous permettent d'effectuer les tâches professionnelles dont vous avez besoin.

Il convient également de mentionner les principaux modèles de conception couramment utilisés dans Node.js:

  • Rappel (il a déjà été mentionné);
  • Observateur (modèle d'événement plus simple);
  • Module (bien qu'il soit maintenant organisé dans le langage JavaScript lui-même, dans Node.js, il est toujours pertinent);
  • Reactor (modèle d'interaction asynchrone avec certaines ressources lorsque vous ne bloquez pas le flux principal de code). Ce modèle est familier aux développeurs JS. Par exemple, si nous travaillons dans un navigateur et écrivons une interface, nous ne bloquons pas tout le travail du navigateur, mais nous nous abonnons simplement aux événements de l'utilisateur, et lorsque l'événement se produit (après un «clic», «entrée», etc.), nous exécutons notre code.

Soit dit en passant, voici un petit concours que nous avons eu lors du webinaire)). Et avance.

Modules de distribution standard de nœud




Savez-vous quels modules sont inclus dans la distribution standard des nœuds? Autrement dit, nous parlons de modules qui sont déjà intégrés, par conséquent, ils ne peuvent pas être installés. En général, il y en a environ 50, listons les principaux. Pour faciliter la perception, nous les classons classiquement en 5 points:

1. Principal (pour les opérations ordinaires):

  • fs;
  • minuteries;
  • streams (pour travailler avec des streams).

2. Utilitaires:

  • chemin (pour travailler avec des chemins);
  • util;
  • zlib (archivage et décompression);
  • crypto (pour les fonctions cryptographiques).

3. Processus (tout ce qui concerne le multitraitement et le parallélisme):

  • child_process (le module principal pour le lancement de modules mineurs, offre de grandes opportunités pour démarrer et surveiller les processus);
  • cluster (similaire au premier, mais vous permet de paralléliser les tâches sur les cœurs de votre processeur);
  • worker_threads (implémentation de threads ou de threads, mais ce n'est pas entièrement thread-safe, mais pourquoi, il est préférable de lire la documentation).

4. Protocoles (toutes sortes de protocoles):

  • http (s);
  • net;
  • DNS.

5. Système (respectivement, modules système, y compris le débogage):

  • os
  • v8;
  • async_hooks;
  • perf_hooks;
  • trace_events

Quoi d'autre à ajouter:

- objet globals - analogue de window;
- tous les objets JavaScript disponibles dans le navigateur sont également disponibles dans Node.js;
- délais d'attente - presque comme dans un navigateur;
- processus - représentation du processus actuel;
- la console est disponible.

Rappels


Rappel - une fonction passée en argument au code, ce qui implique de l'exécuter à un moment donné. Soit dit en passant, les gens pensent rarement que leur exécution peut être synchrone ou asynchrone.

const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`)
})

Dans Node, par défaut, le rappel est exécuté avec une "erreur" et le résultat est asynchrone:

fs.readFile('/etc/passwd', (err, data) => {
if (err) throw err
console.log(data)
})

Et voici à quoi ressemble l'antipattern - un bon exemple de la façon d'utiliser incorrectement les rappels. Comme on dit, le classique Callback Hell :

fs.readdir(source, function (err, files) {
if (err) {
console.log('Error finding files: ' + err)
} else {
files.forEach(function (filename, fileIndex) {
console.log(filename)
gm(source + filename).size(function (err, values) {
if (err) {
console.log('Error identifying file size: ' + err)
} else {
console.log(filename + ' : ' + values)
aspect = (values.width / values.height)
widths.forEach(function (width, widthIndex) {
height = Math.round(width / aspect)
console.log('resizing ' + filename + 'to ' + height + 'x' + height)
this.resize(width, height).write(dest + 'w' + width + '_' + filename, function(err) {
if (err) console.log('Error writing file: ' + err)
})
}.bind(this))
}
})
})
}
})

Voyons maintenant comment créer un serveur Web simple et rendre l'index HTML comme réponse du client:

const http = require('http')
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})

Pour lire le fichier html local:

const fs = require('fs')
fs.readFile('./index.html', (err, text) => {
console.log(text)
})

En terminant le sujet des rappels, je voudrais mentionner les types de rappels. Il existe des rappels qui ne renvoient qu'une erreur s'il y a une erreur:

fs.access('/etc/passwd', fs.constants.R_OK, (err) => {
console.log(err ? 'no access!' : 'read')
})

De plus, de plus en plus de modules et d'API utilisent des promesses prêtes à l'emploi, ce qui est bien. Node prend en charge les promesses:

util.promisify()
fs.promises.*

Type de retour:

http.request('https://example.com', (error, response, body) => {
...
})

Questions et réponses sur les nœuds


Lors de l'écriture de serveurs Web, Express est souvent utilisé, bien qu'il existe de nombreuses autres bibliothèques et frameworks qui implémentent des fonctionnalités similaires. Néanmoins, Express est le plus populaire et le plus stable. On pourrait dire que c'est la norme pour écrire des serveurs.

import express from "express";
const app = express();
const port = 3000;
app.get("/", (req, res) => {
res.send("Hello World!");
});
app.listen(port, () => {
console.log(`Example app listening
});



Eh bien, vous pouvez maintenant essayer de créer vous-même un serveur Web avec un générateur Express :

  • utilisation de jade, cookie-session;
  • faire une déconnexion de connexion naïve.

Ou regardez simplement comment le professeur l'a fait, qui a préparé la solution prête à l'emploi dans TypeScript.

C'est tout. Enfin - quelques liens utiles:


Et à bientôt sur le parcours .

All Articles