Node.js pour les débutants

La programmation axée sur les événements pour Node.js peut être délicate pour les débutants, mais cela ne signifie pas qu'il est difficile de commencer. Cet article présentera les bases de Node.js et expliquera pourquoi elle est populaire.

Introduction

Pour commencer avec Node.js, vous devez d'abord comprendre la différence entre Node.js et les environnements de script côté serveur traditionnels tels que PHP, Python ou Ruby.

Programmation asynchrone

Vous connaissez probablement la programmation asynchrone; après tout, c'est "A" dans Ajax. Chaque fonction dans le nœud est asynchrone. Par conséquent, toutes les opérations qui bloquent généralement les threads sont exécutées en arrière-plan en utilisant la promesse. C'est la chose la plus importante à propos du nœud. Par exemple, si vous lisez un fichier sur un système de fichiers, une fonction asynchrone sera utilisée.

Si vous utilisez une version des fonctions de nœud, utilisez des fonctions de rappel, qui ont été conçues avant que la promesse n'apparaisse. La plupart des fonctions de nœud ont désormais des équivalents de promesses, il est donc préférable de convertir la fonction de rappel utilisée ici en un équivalent basé sur les promesses et de comparer la syntaxe.

Contrôler l'ensemble du processus

Avec Node, vous devez faire beaucoup de travail vous-même. Par exemple, les modules HTTP sont très rationalisés et ne s'en tiennent pas à des styles spécifiques. Cela peut être écrasant pour les débutants, mais l'avantage est la possibilité de créer des applications Web haute performance (bien que les performances de JavaScript soient largement attribuées au moteur optimisé par V8). Un script gère toutes les communications avec tous les clients. Cela réduit considérablement la quantité de ressources utilisées par l'application. Par exemple, voici un simple code d'application Node.js:

 const i, a, b, c, max;
max = 1000000000;
var d = date.now ();
pour (i = 0; i <max i a="1234" b="1234" c="1234/2" console.log d><p> Voici le code équivalent écrit en PHP:</p>
<pre class="brush:php;toolbar:false"> $ a = null;
$ b = null;
$ c = null;
$ i = null;
$ max = 100000000;

$ start = microtime (true);

pour ($ i = 0; $ i <p> Regardons maintenant les données de référence. Le tableau suivant répertorie les temps de réponse en millisecondes pour ces deux applications simples:</p><pre class="brush:php;toolbar:false"> const http = requis ('http');

Variable HTTP.

Dans le code ci-dessus, nous passons le nom du module à l'objet d'exportation et remplissons ses propriétés et méthodes avec l'extrait de code à exposer. Considérez l'exemple du module suivant:

 export.area = fonction (r) {
  return math.pi * r ** 2;
};

export.Circumference = fonction (r) {
  retour 2 * Math.pi * r;
};

Ce code crée un objet d'exportation. Ces fonctions sont accessibles à l'extérieur du module car elles sont définies sur le PI et sont complètement protégées contre les interférences externes. Ainsi, vous pouvez être assuré que Circuitference () fonctionnera toujours comme prévu (offrez simplement une valeur pour le mot-clé d'importation):

 // déposer
Importer du mymodule de "./mymodule.js"
// Node intégré / Package Import http à partir de "http"

Dans un navigateur, ESM ne peut rechercher qu'avec des chemins de fichier relatifs, comme indiqué ci-dessus. Cependant, dans le nœud, vous pouvez passer des chemins sans le nœud: préfixe.

Cependant, la méthode précédente ne fonctionne que pour les exportations par défaut. Si vous utilisez des exportations nommées (plus à ce sujet plus tard), vous devrez utiliser une syntaxe légèrement différente.

 import {exportone, exporttwo} depuis "./mymodule.js"

Pour exporter du contenu, utilisez le mot-clé d'exportation par défaut. L'exportation est utilisée pour les exportations nommées et l'exportation par défaut est utilisée pour les exportations par défaut. Exportation nommée vous permet d'exporter différents contenus et d'utiliser un seul d'entre eux dans différents modules à l'aide de la syntaxe d'import ci-dessus. Si vous exportez un seul contenu, il sera plus facile d'exporter par défaut.

 // Nom Export Fonction ExportOne () {
    ...
}
fonction d'exportation exporttwo () {
    ...
}
// Fonction par défaut par défaut par défaut defaultFunction () {
    ...
}

Dans le reste de ce tutoriel, nous utiliserons ESM.

Portée mondiale

Le nœud est un environnement JavaScript exécutant dans le moteur JavaScript V8 de Google. Par conséquent, nous devons suivre les meilleures pratiques que nous utilisons dans le développement des clients. Par exemple, nous devons éviter de mettre quoi que ce soit dans la portée mondiale. Cependant, ce n'est pas toujours possible. La portée globale dans le nœud est (fenêtre dans le navigateur), et vous pouvez facilement créer des variables globales d'une fonction en omettant VAR lors de la déclaration des variables.

Installer

Naturellement, nous devons installer le nœud avant d'écrire et d'exécuter l'application. Si vous utilisez Windows ou MacOS, l'installation est très simple; Pour Linux, utilisez n'importe quel gestionnaire de packages. Par exemple, si vous utilisez une distribution qui prend en charge APT, ouvrez un terminal et type:

 Mise à jour Sudo apt-get
Node d'installation Sudo apt-get

ou:

 Mise à jour de Sudo Aptitude
Node d'installation de Sudo Aptitude

Node.js est situé dans le référentiel SID;

 sudo echo deb https://ftp.us.debian.org/debian/ sid main> /etc/apt/sources.list.d/sid.list

Mais sachez que l'installation du package SID sur les systèmes plus anciens peut endommager votre système. Soyez prudent et supprimez module_name.

Hello World App

Bien sûr, notre premier script Node.js imprimera le texte "Hello World!"

Serveur http

Allons de l'avant et ayons une application plus avancée; ce n'est pas aussi compliqué que vous le pensez. Commençons par le code suivant. Lisez les commentaires, puis lisez l'explication ci-dessous:

 // comprend le module HTTP.
import {CreateServer} à partir de "http"

// Créer un serveur. La fonction transmise comme un paramètre est appelée chaque fois que la demande est faite.
// La variable de demande enregistre tous les paramètres de demande // La variable de réponse vous permet d'effectuer toute action sur la réponse envoyée au client.
createServer (fonction (request, réponse) {
    // attache l'auditeur à l'événement final.
    // Cet événement est appelé lorsque le client envoie toutes les données et attend une réponse.
    request.on ("end", function () {
        // Écrivez l'en-tête à la réponse.
        // 200 est le code d'état HTTP (ce code indique le succès)
        // Le deuxième paramètre enregistre le champ d'en-tête dans l'objet // Nous envoyons du texte brut, donc le type de contenu doit être du texte / simple
        réponse.Writehead (200, {
            «Type de contenu»: «Texte / Plain»
        });
        // Envoyez des données et terminez la réponse.
        Response.end («Hello Http!»);
    });
// Écoutez le port 8080.
}). écouter (8080);

Ce code est très simple. Vous pouvez envoyer plus de données au client en utilisant Response.end (). Enregistrez ce code sous Http.js et saisissez la commande suivante dans la console:

 nœud http.js

Ouvrez le navigateur et accédez à https://www.php.cn/link/7232a90ea7d391905f9ee07bcc7c5967 . Vous devriez voir le texte bonjour http! Sur la page.

Traiter les paramètres de l'URL

Comme mentionné précédemment, nous devons faire tout le travail dans le nœud nous-mêmes, y compris l'analyse des paramètres de demande. Cependant, c'est assez simple. Jetez un œil au code suivant:

 // Inclure CreateServer
import {CreateServer} à partir de "http"
// et les modules d'URL, qui sont très utiles dans les paramètres de demande d'analyse.
url = require ("url");

// Créer un serveur.
createServer (fonction (request, réponse) {
    // attache l'auditeur à l'événement final.
    request.on ('end', function () {
        // Analyser les paramètres de demande et les stocker dans la variable _get.
        // Cette fonction analyse l'URL de la demande et renvoie la représentation de l'objet.
        var _get = url.parse (request.url, true) .Query;
        // Écrivez l'en-tête à la réponse.
        réponse.Writehead (200, {
            «Type de contenu»: «Texte / Plain»
        });
        // Envoyez des données et terminez la réponse.
        Response.end ('Voici vos données:' _get ['data']);
    });
// Écoutez le port 8080.
}). écouter (8080);

Ce code utilise l'attribut de requête, qui récupère les paramètres de l'URL. Enregistrez ce fichier comme get.js et exécutez-le avec la commande suivante:

 nœud get.js

Ensuite, la navigation vers le paramètre de données n'interrompt pas le script.

Lire et écrire des fichiers

Pour gérer les fichiers dans Node, nous utilisons le module FS (module de base). Nous utilisons la méthode Fs.WriteFile () pour lire et écrire des fichiers respectivement. J'expliquerai les paramètres après le code suivant:

 // inclut CreateServer,
import {CreateServer} à partir de "http"
// et fs fonction import {readfile, writefile} à partir de "fs"

// Créer un serveur HTTP.
createServer (fonction (request, réponse) {
    // attache l'auditeur à l'événement final.
    request.on ("end", function () {
        // Lisez le fichier.
        readFile ("test.txt", 'utf-8', fonction (erreur, données) {
            // Écrivez à l'en-tête.
            réponse.Writehead (200, {
                «Type de contenu»: «Texte / Plain»
            });
            // Incrément le nombre obtenu à partir du fichier.
            data = parseInt (données) 1;
            // Écrivez des nombres incréments dans le fichier.
            writeFile ('test.txt', données);
            // terminer la réponse avec de beaux messages.
            Response.end («Cette page a été rafraîchie« Data »Times!»);
        });
    });
// Écoutez le port 8080.
}). écouter (8080);

Enregistrez ceci sous Files.js . Avant d'exécuter ce script, créez un fichier nommé test.txt dans le même répertoire que files.js .

Ce code démontre la méthode fs.writefile (). Chaque fois que le serveur reçoit une demande, le script lit un numéro à partir du fichier, incréments ce nombre et écrit le nouveau numéro dans le fichier. La méthode fs.writefile () accepte le nom et les données du fichier comme paramètres. Il accepte également les troisième et quatrième arguments (les deux facultatifs), spécifiant respectivement les fonctions de codage et de rappel.

Exécutons maintenant ce script avec la commande suivante:

 Node files.js

Ouvrez-le dans le navigateur à https://www.php.cn/link/7232a90ea7d391905f9ee07bcc7c5967 et actualisez-le plusieurs fois. Maintenant, vous pourriez penser qu'il y a une erreur dans votre code car il semble être incrémenté deux fois. Ce n'est pas une erreur. Chaque fois que cette URL est demandée, deux demandes sont envoyées au serveur. La première demande est automatiquement émise par le navigateur, qui demande FAVICON.ICO , et bien sûr, la deuxième demande concerne l'URL ( https://www.php.cn/link/7232a90ea7d391905f9ee07bcc7c5967 ).

Même si ce comportement n'est pas techniquement mauvais, ce n'est pas le comportement que nous voulons. Nous pouvons facilement résoudre ce problème en vérifiant l'URL de demande. Ce qui suit est le code modifié:

 // inclut CreateServer,
import {CreateServer} à partir de "http"
// et fs fonction import {readfile, writefile} à partir de "fs"

// Créer un serveur HTTP.
createServer (fonction (request, réponse) {
    // attache l'auditeur à l'événement final.
    request.on ('end', function () {
        // Vérifiez si les demandes de l'utilisateur /
        if (request.url == '/') {
            // Lisez le fichier.
            readFile ('test.txt', 'utf-8', fonction (erreur, données) {
                // Écrivez à l'en-tête.
                réponse.Writehead (200, {
                    «Type de contenu»: «Texte / Plain»
                });
                // Incrément le nombre obtenu à partir du fichier.
                data = parseInt (données) 1;
                // Écrivez des nombres incréments dans le fichier.
                writeFile ('test.txt', données);
                // terminer la réponse avec de beaux messages.
                Response.end («Cette page a été rafraîchie« Data »Times!»);
            });
        } autre {
            // indique que le fichier demandé n'a pas été trouvé.
            Response.Writehead (404);
            // et terminer la demande sans envoyer de données.
            réponse.end ();
        }
    });
// Écoutez le port 8080.
}). écouter (8080);

Maintenant, testez-le;

Accès à la base de données MySQL

La plupart des technologies traditionnelles côté serveur ont des méthodes intégrées pour se connecter et interroger la base de données. Avec Node.js, vous devez installer une bibliothèque. Dans ce tutoriel, j'ai choisi le nœud stable et facile à utiliser. Le nom complet de ce module est mysql@2.0.0-alpha2 (tout le contenu après @ est le numéro de version). Ouvrez la console, accédez au répertoire où vous avez stocké les scripts et exécutez la commande suivante:

 NPM Installer MySQL

Cela téléchargera et installera le module, il créera également le dossier Node_Modules dans le répertoire actuel. Voyons maintenant comment l'utiliser dans votre code; voir l'exemple suivant:

 // comprend le module HTTP,
import {CreateServer} à partir de "http"
// et le module MySQL que vous venez d'installer.
Importer * comme mysql à partir de "mysql"

// Créez une connexion.
// Les données par défaut sont la nouvelle installation MySQL et doivent être modifiées en fonction de votre configuration.
const Connection = mysql.createConnection ({{
    utilisateur: "racine",
    mot de passe: "",
    base de données: "db_name"
});

// Créer un serveur HTTP.
createServer (fonction (request, réponse) {
    // attache l'auditeur à l'événement final.
    request.on ('end', function () {
        // interroge la base de données.
        connection.Query ('select * from your_table;', fonction (erreur, lignes, champs) {
            réponse.Writehead (200, {
                «Content-Type»: «X-Application / JSON»
            });
            // Envoi des données en tant que chaîne JSON.
            // La variable des lignes enregistre le résultat de la requête.
            Response.end (JSON.Stringify (lignes));
        });
    });
// Écoutez le port 8080.
}). écouter (8080);

Interroger une base de données à l'aide de cette bibliothèque est facile; entrez simplement la chaîne de requête et la fonction de rappel. Dans une application réelle, vous devez vérifier les erreurs (non définies si une erreur se produit) et envoyer le code de réponse en fonction du succès ou de l'échec de la requête. Notez également que nous avons défini X-Application / JSON, qui est un type MIME valide pour JSON. Utilisez JSON.stringify() pour convertir les lignes en structure JSON.

Enregistrez ce fichier en tant que mysql.js et exécutez-le (si vous avez installé MySQL):

 node mysql.js

Accédez à https://www.php.cn/link/7232a90ea7d391905f9ee07bcc7c5967 dans votre navigateur et vous devriez recevoir une invite pour télécharger le fichier de format JSON.

en conclusion

Node.js nécessite un travail supplémentaire, mais les récompenses d'une application rapide et puissante en valent la peine. Si vous ne voulez pas faire tout le travail au plus bas niveau, vous pouvez toujours choisir un cadre (comme Express) pour simplifier le développement de votre application.

Node.js est une technologie prometteuse et un excellent choix pour les applications à haute charge. Des entreprises comme Microsoft, eBay et Yahoo l'ont prouvé. Si vous n'êtes pas sûr d'héberger votre site Web ou votre application, vous pouvez toujours utiliser une solution VPS bon marché ou une variété de services basés sur le cloud tels que Microsoft Azure et Amazon EC2. Les deux services offrent des environnements évolutifs à des prix raisonnables.

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!