Introduction à NodeJS

Node.js est un moteur d'exécution JavaScript puissant et populaire basé sur le moteur JavaScript V8 de Chrome.

Caractéristiques

1) Architecture événementielle :
Node.js utilise un modèle d'E/S non bloquant et piloté par les événements

Opérations de blocage :
L'exécution du programme s'arrête ou attend la fin de l'opération. Pendant ce temps, le système ou le thread n'est pas disponible pour d'autres tâches.
Les opérations de blocage sont généralement synchrones car elles arrêtent l'exécution du code suivant jusqu'à ce qu'il soit terminé

Synchrone :
Le programme attend la fin de l'opération avant de passer à la tâche suivante.
Ex. Lire un fichier de manière synchrone dans Node.js :

Opérations non bloquantes :
Le programme n'attend pas la fin de l'opération. Au lieu de cela, il poursuit d'autres tâches tandis que l'opération se poursuit en arrière-plan.

Asynchrone :
Le programme peut effectuer d'autres tâches en attendant la fin de l'opération. Plus complexe, nécessitant des mécanismes de gestion des résultats asynchrones (par exemple, rappels, promesses, async/await).

Boucle d'événement
La boucle d'événements est responsable de la gestion et de l'exécution des rappels pour les opérations asynchrones.

2) Asynchrone et non bloquant :

La boucle d'événements est un composant essentiel de Node.js qui gère et coordonne l'exécution des opérations asynchrones.

Composants de la boucle d'événements :

Pile d'appels :
La pile d'appels garde une trace des fonctions en cours d'exécution. Il s'agit d'une structure de données de pile où les fonctions sont ajoutées lorsqu'elles sont appelées et supprimées une fois terminées.

File d'attente de rappel :
Cette file d'attente contient les rappels pour les opérations asynchrones (telles que les opérations d'E/S, les minuteries ou les requêtes réseau) qui sont terminées et en attente d'exécution.

File d'attente des événements :
Semblable à la file d'attente de rappel, elle contient les événements et leurs rappels associés. Les événements sont des éléments tels que les interactions des utilisateurs, les expirations de minuterie ou les réponses du réseau.

File d'attente des microtâches (ou file d'attente des ticks suivants) :
Cette file d'attente contient des microtâches, qui sont généralement des promesses et leurs rappels .then(). Les microtâches ont une priorité plus élevée que les rappels et sont traitées avant la file d'attente des événements.

Minuteurs :
La boucle d'événements gère les minuteries à l'aide de setTimeout() et setInterval(). Ceux-ci sont programmés pour s'exécuter après un délai spécifié ou à intervalles réguliers.

Opérations d'E/S :
La boucle d'événements gère les opérations d'E/S telles que les lectures de fichiers, les requêtes réseau et les requêtes de base de données. Il permet à Node.js de gérer ces opérations de manière asynchrone sans bloquer le thread principal.

const fs = require('fs');

// Asynchronous file read
fs.readFile('file.txt', 'utf8', (err, data) => {
  console.log('File read complete:', data);
});

// Synchronous operation
console.log('This prints first');

// Timer
setTimeout(() => {
  console.log('Timeout executed');
}, 0);

console.log('This prints second');

Ordre d'exécution :

Le code synchrone (console.log('This prints first') et console.log('This prints second')) s'exécute en premier, car il est ajouté à la pile d'appels.

Le rappel fs.readFile et le rappel setTimeout sont ajoutés à leurs files d'attente respectives (file d'attente de rappel et file d'attente du minuteur).

Après l'exécution du code synchrone, la boucle d'événements traite la file d'attente du minuteur et exécute le rappel setTimeout. Ensuite, il traite la file d'attente de rappel et exécute le rappel fs.readFile.

Création de serveur

const fs = require('fs');

// Asynchronous file read
fs.readFile('file.txt', 'utf8', (err, data) => {
  console.log('File read complete:', data);
});

// Synchronous operation
console.log('This prints first');

// Timer
setTimeout(() => {
  console.log('Timeout executed');
}, 0);

console.log('This prints second');

Rappels

Un rappel est une fonction transmise à une autre fonction en tant qu'argument, qui est ensuite invoquée à l'intérieur de la fonction externe pour effectuer une sorte de routine ou d'action.

var http = require('http');

const server = http.createServer(function(req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
})

server.listen(8080, () => {
  console.log('Server running at http://127.0.0.1:8080/');
});

Promesses

Un objet représentant l'achèvement (ou l'échec) éventuel d'une opération asynchrone et sa valeur résultante.

function downloadFile(url, callback) {
    console.log(`Starting to download file from ${url}`);
    setTimeout(() => {
        console.log('File downloaded successfully');
        callback('File content');
    }, 2000); 
}

function processFile(content) {
    console.log(`Processing file with content: ${content}`);
}

downloadFile('http://example.com/file', processFile);

Restez connecté !
Si vous avez apprécié cet article, n'oubliez pas de me suivre sur les réseaux sociaux pour plus de mises à jour et d'informations :

Twitter : madhavganesan
Instagram : madhavganesan
LinkedIn : madhavganesan

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!