Nodejs : 9 Actions Rapides Pour Apprendre Les Bases

il y a un mois

Je t'écris cet article sur Nodejs depuis le salon de mon appartement de Lubumbashi.

J'ai installé mon ordinateur sur la table de la salle à manger. Pas question de le placer sur mes genoux !

Pendant ce temps, je me tape des croquettes, j'écoute de la bonne musique et il y a aussi un verre d'eau à ma droite. L'eau c'est la vie !.

Comment débuter avec Nodejs en 9 actions rapides ?

Peut-être que tu voudrais me dire :

  • 🔴 Nodejs, c'est une grosse plateforme, il est impossible tout maitrise en 9 actions !
  • 🔴 Nodejs, c'est un monstre, Il est encore pas possible d'apprendre à créer une application web en 9 actions rapides !
  • 🔴 Nodejs, c'est des milliers de développeurs qui l'enrichi chaque jour avec fonctionnalités, c'est complètement idiot de prétendre l'apprendre en 9 actions rapide.

Prétendre que c'est possible d'apprendre à créer une application web NodeJs en 9 actions rapide, n'est-ce pas là une exagération ?

Tu as absolument raison, je peux pas me permettre d'écrire ce genre des choses.

Je serais pas celui qui va manquer du respect au concepteur du nodejs.

Cependant, les développeurs professionnels en Nodejs qui semblent maitriser beaucoup des concepts Hyper-compliqués ont commencé quelque part.

Alors, Comment les développeurs professionnels ont-ils fait pour débuter avec Nodejs ?

Dans cet article, Je vais te montrer le 9 actions qui une fois maitriser te permettrons d'évoluer plus vite avec Nodejs.

Si tu souhaites installer et gérer facilement Nodejs :

Comment Installer Et Gérer Facilement Nodejs ?

1. Utiliser le node shell REPL

Une fois appelé sans argument, Nodejs demarre le REPL (Read-Eval-Print-Loop) très connue comme “Le Node shell”.

Dans ta ligne de commande tu vas taper :

$ node

Dans le shell nodejs.

  • 🔹1. Tu peux taper cette commande :
"Salut Trakode!"

Résultat de la commande :

'Salut Trakode!'

  • 🔹 2. Tu peux aussi essayer cette commande :
7*7

Résultat de la commande :

49

  • 🔹 3. Ou encore celle-ci:
.help

Résultat de la commande :

.clear Alias for .break .editor Enter editor mode .exit Exit the repl .help Print this help message .load Load JS from a file into the REPL session .save Save all evaluated commands in this REPL session to a file

Press ^C to abort current expression, ^D to exit the repl

2. Creer une ligne de commande utilitaire

Node.js peut également être utilisé pour créer des utilitaires de ligne de commande.

Les utilitaires de commande sont utilisés pour automatiser certaines tâches trop répétives en développement web.

L'exemple ci-dessous lit le premier argument de la ligne de commande et imprime un message Salut ....

Pour exécuter ce code sur un système Unix:

  • 🔹 Tu vas créer un nouveau fichier et coller le code ci-dessous. Le nom de fichier n'est pas pertinent.
  • 🔹 Transforme ce fichier en exécutable avec chmod 700 FILE_NAME
  • 🔹 Exécute l'application avec ./APP_NAME TARDIS : Exemple ./salut.js TARDIS

 Sous Windows, tu vas effectuer l'étape 1 et l'exécuter avec le nœud APP_NAME TARDIS

 #!/usr/bin/env node
  'use strict';
  /*
      Les arguments de la ligne de commande sont stockés dans le tableau `process.argv`,
         qui a la structure suivante:
         [0] Le chemin de l'exécutable qui a démarré le processus Node.js
         [1] Le chemin vers cette application
         [2-n] les arguments de la ligne de commande
         Exemple: ['/ bin / node', '/ path / to / yourscript', 'arg1', 'arg2', ...]
         src: https://nodejs.org/api/process.html#process_process_argv
  */
  // Stocke le premier argument comme nom d'utilisateur.
  var username = process.argv[2];
  // Vérifie si le nom d'utilisateur n'a pas été fourni.
  if (!username) {
      // Extraire le nom de fichier
      var appName = process.argv[1].split(require('path').sep).pop();
      // Donne à l'utilisateur un exemple sur la façon d'utiliser l'application.
      console.error('Missing argument! Example: %s YOUR_NAME', appName);
      // Quitte l'application (succès: 0, erreur: 1).
        // Une erreur arrêtera la chaîne d'exécution. Par exemple:
        // ./salut.js && ls -> n'exécute pas ls
        // ./salut.js David && ls -> exécutera ls
      process.exit(1);
  }
  // Print the message to the console.
  console.log('Salut %s!', username);

3. Creer un serveur Http

Dans cet exemple, tu découvriras comment créer un serveur HTTP à l'écoute sur le port 7777, qui envoie un petit message Bravo ! Tu es sur un serveur http nodejs. au navigateur.

Je te signale qu'au lieu d'utiliser le port 7777, tu peux utiliser n'importe quel numéro de port de ton choix qui n'est actuellement utilisé par aucun autre service.

Le module http est un module de base Node.js (un module inclus dans la source de Node.js, qui ne nécessite pas l'installation de ressources supplémentaires).

Le module http fournit la fonctionnalité pour créer un serveur HTTP à l'aide de la méthode http.createServer().

Dans ce cadre, j'ai choisi de nommer le ficher myhttp.js, tu vas écrire le code JavaScript suivant :

const http = require('http'); // tu charges le module http
http.createServer((request, response) => {
    // 1. Signaler au navigateur que tout va bien (code d'état 200) et que les données sont en texte brut
    response.writeHead(200, {
    'Content-Type': 'text/plain'
    });
    // 2. Prévoir un texte qui sera affiché dans le corps de la page
    response.write('Bravo ! Tu es sur un serveur http nodejs. \n');
    // 3. Dire au serveur que tous les en-têtes et corps de réponse ont été envoyés
    response.end();
}).listen(7777); 

Pour exécuter le code, tu vas enregistrer le fichier sous n'importe quel nom de fichier.

Dans ce cas, j'avais choisi précedement le nom myhttp.js.

Tu peux exécuter l'application en accédant au répertoire dans lequel se trouve le fichier et en utilisant la commande suivante:

node myhttp.js

Le serveur est ensuite accessible avec l'URL http://localhost:7777 ou http://127.0.0.1:777 dans le navigateur.

Une simple page Web apparaîtra avec un Bravo ! Tu es sur un serveur http nodejs. texte en haut.

Teste pour voir le résultat !

4. Utiliser le système de routage basique

Dans ton application web nodejs, les internautes doivent naviguer des pages en pages pour consulter différentes informations.

Tu vas ajouter à ton serveur Nodejs HTTP la possibilité de d'afficher les informations en fonctions des liens consulter par un internaute.

Ce phénomène formidable est appelé «routage».

L'exemple le plus simple serait de vérifier si l'adresse demandé par un internaute dans sa réquête(request.url === 'certains/chemin/ici'), puis d'appeler une fonction qui répond pour afficher les informations.

Un exemple de cela peut être vu ici :

const http = require('http');
function index (request, response) {
   response.writeHead(200);
   response.end('Hello, World!');
}
http.createServer(function (request, response) {
	if (request.url === '/') {
       //retourne la fonction index
		return index(request, response);
	}
	response.writeHead(404);
	response.end(http.STATUS_CODES[404]);
}).listen(7777);

Si tu continues à définir tes "routes" comme ceci, cependant, tu te retrouveras avec une fonction de rappel massive, et nous ne voulons pas d'un gâchis géant comme ça, alors voyons si nous pouvons améliorer le code.

Tout d'abord, stockons tous nos itinéraires dans un objet.

< Code :

var routes = {
   '/': function index (request, response) {
       response.writeHead(200);
       response.end('Bravo !');
   },
   '/info': function foo (request, response) {
       response.writeHead(200);
       response.end('Bravo ! tu es sur la route "info"');
   },
   '/contact': function foo (request, response) {
       response.writeHead(200);
       response.end('Bravo ! tu es sur la route "contact"');
   },
   '/blog': function foo (request, response) {
       response.writeHead(200);
       response.end('Bravo ! tu es sur la route "blog"');
   }
}

Maintenant que nous avons stocké 4 routes dans un objet, nous pouvons maintenant les vérifier dans notre fonction de rappel principal.

< Code :

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }
    
    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);
    
}).listen(7777);

> Un code beaucoup plus complet :

const http = require('http')

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Bravo !');
    },
    '/info': function foo (request, response) {
        response.writeHead(200);
        response.end('Bravo ! tu es sur la route "info"');
    },
    '/contact': function foo (request, response) {
        response.writeHead(200);
        response.end('Bravo ! tu es sur la route "contact"');
    },
    '/blog': function foo (request, response) {
        response.writeHead(200);
        response.end('Bravo ! tu es sur la route "blog"');
    }
}

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }
    
    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);
    
}).listen(7777,()=>{
        console.log(`Le serveur tourne sur :http://localhost:7777/`)
});

Comme d'habitude tu vas lancer le serveur :

node myhttp.js

Le code n'est jamais théorique, Tu peux essayer par toi même pour voir le résultat.

Maintenant, chaque fois que tu essayes de naviguer sur ton application Web, le code du serveur vérifiera l'existence de chaque url et il va appeler la fonction respective.

Si aucune route n'est trouvée, le serveur répondra par un 404 (Not Found).

Et voilà, le routage avec l'API HTTP Server Nodejs est très simple.

5. Installer un paquet externe avec npm

Il existe un certain nombre de cas d'utilisation universel déjà résoulu par ceux(la communauté) qui ont le privilège de le rencontrer en premier avec le Nodejs. Avant toi et moi !

Par exemple :

  • La possibilité d'envoyer les emails propres;
  • La possibilité de créer un serveur beaucoup simple;
  • La possibilité de crypté un mot de passe;
  • La possibilité de créer des applications mobiles;
  • etc, ...

Pour installer un ou plusieurs packages, tu utiliseras les éléments suivants:

npm install <package-name>

ou

npm i <package-name>...

Par exemple pour installer lodash and express :

npm install lodash express

Remarque :

Cela installera le package dans le répertoire dans lequel se trouve actuellement la ligne de commande, il est donc important de vérifier si le répertoire approprié a été choisi Si tu as déjà un fichier package.json dans ton répertoire de travail actuel et que les dépendances sont définies dedans, alors npm install résoudra et installera automatiquement toutes les dépendances listées dans le fichier.

Tu peux également utiliser la version abrégée de la commande npm install qui est: npm i si tu souhaites installer une version spécifique d'un package, utilise simplement :

npm install <name>@<version>

Par exemple, pour installer une très anciènne version 4.11.1 du paquet lodash.

Tu peux simplement écrire ceci :

npm install lodash@4.11.1

Si tu souhaites installer une version qui correspond à une plage de versions spécifique, utilise simplement:

npm install <name>@<version range>

Par exemple, pour installer une version qui correspond à "version> = 4.10.1" et "version <4.11.1" du paquet lodash.

Tu peux simplement écrire ceci :

npm install lodash@">=4.10.1 <4.11.1"

Si tu souhaites installer la dernière version, utilise tranquillement :

npm install <name>@latest

6. Débogage des erreurs

C'est très important de déboger les erreurs de ton code, stp ! ne vient pas me demander pourquoi ton code ne marche pas. Nodejs à tout prévu !

Pour débogeur les erreurs dans ton application web, Tu peux utiliser l'inspecteur de nœuds.

**D'abord, exécute cette commande pour l'installer via npm: **

npm install -g node-inspector

En suite, tu peux exécuter cette commande pour déboger ton application :

node-debug myhttp.js

Le dépot officiel github de node inspector peut être trouvé ici: node inspector

Débogage natif

Tu peux déboger ton application node.js sans installer node-inspector.

En démarrant ton application comme ceci :

node debug myhttp.js

Pour stopper ton débogueur exactement dans une ligne de code que tu souhaites, utilises ceci:

.exit

Pour plus d'informations, voir ici.

Depuis l'apparution de node.js 8, tu peux utiliser cette commande:

node --inspect-brk myhttp.js

Dans mon expérience, En consultant le lien ws://127.0.0.1:9229/, tu as la possibilité d'acceder aux informations de déboguage via l'inspecteur Google Chrome en faisant CTRL+Maj+i ou clique-droit--inspecter.

clique sur le petit logo nodejs qui va apparaitre dans les onglets

7. Capturer les erreures

Gestion des erreurs de base

Dans un cadre ou tu utilises Expressjs, tu dois savoir que cette gestion se fait par défaut.

Par défaut, Express recherchera une vue «erreur» dans le répertoire/views à restituer.

Créee simplement le fichier de la vue «erreur» et place-le dans le répertoire des vues pour gérer les erreurs.

Les erreurs sont écrites avec le message d'erreur, l'état et la trace de la pile,

Par exemple :

views/error.pug

html
body
h1= message
h2= error.status
p= error.stack

Gestion avancée des erreurs

Nodejs te donne la possibilité de créer tes propres fonctions de gestion des erreurs que tu serras à mésure d'injecter dans le code de ton application web.

C'est sont des fonctions middleware.

Ceux-ci ont quatre arguments au lieu de trois (err, req, res, next)

Par exemple :

app.js

// attraper 404 et transmettre au gestionnaire d'erreurs
app.use(function(req, res, next) {
	var err = new Error('Not Found');
	err.status = 404;
	//transmettre l'erreur au prochain itinéraire correspondant.
	next(err);
});
// erreur de gestion, trace de pile d'impression
app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
    	message: err.message,
    	error: err
    });
});

Tu peux définir plusieurs fonctions middleware de gestion des erreurs, comme tu peux le faire avec des fonctions middleware classiques.

8. Deployement de ton application web en ligne

Lorsque tu déploies ton application web dans un environnement hébergé (spécifique à Node.js), cet environnement propose généralement une variable d'environnement PORT que tu peux utiliser pour exécuter ton serveur en ligne.

Changer le numéro de port en process.env.PORT te permet d'accéder à l'application.

Par exemple :

http.createServer(function(request, response) {
// your server code
}).listen(process.env.PORT);

De plus, si tu souhaites accéder à cela hors ligne pendant le débogage.

Tu peux utiliser ceci :

http.createServer(function(request, response) {
// le code de ton serveur
}).listen(process.env.PORT || 7777);

où 7777 est le numéro de port hors ligne.

9. Connaitre le fonctionnement de core module

Node.js fait tourner un moteur Javascript (moteur V8 de Google pour Chrome, écrit en C ++) qui permet d'exécuter Javascript en dehors du navigateur.

Alors que de nombreuses bibliothèques sont disponibles pour étendre les fonctionnalités de Node, le moteur est livré avec un ensemble de modules de base implémentant des fonctionnalités de base.

Cette liste peut être obtenue à partir de l'API de documentation Node : api node ou le fichier JSON.

Conclusion

Je viens de donner quelques actions essentielles pour débuter avec Nodejs.

Tu as peut-être :

  • Utilisé la console nodejs ;
  • Créée ta commande Nodejs et installer un paquet externe ;
  • Créée ton premier serveur Http Nodejs avec un système de routes basique ;
  • Cherché les erreurs dans ton code Nodejs ;
  • Tu connais aussi le nécessaire pour déployer un code Nodejs en ligne ;
  • Tu as un lien vers la documentation du chaque module Nodejs ;

il reste cas même pas mal des concepts qui n'ont pas été abordés dans cet article.

Je te parle des concepts qui seront abordés dans un prochain article.

Comment créer une application web fonctionnelle avec Nodejs ?

Avec ces actions de base, ajouté a ce qui va suivre dans un prochain article.

Le Nodejs n'aura plus des secrets pour toi.

Tu as aimé cet article ? Partage-le avec tes collègues ou ami(e)s :

Hey oh ! , Ne rate rien !

1527 développeurs ont reçus mes conseils privés révolutionnaires

Reçois le guide gratuit "les 5 Façons de gagner sa vie avec le code"




Ecris avec le par BC DIBWE