Tutoriel Node.js - Un guide complet pour les débutants

Ce tutoriel Node.js parlera de l'architecture de base, du fonctionnement et des divers modules de Node.js. Il montrera également une implémentation pratique de Node.js et Express.js.

Si vous avez déjà entendu parler de Node.js, vous savez peut-être qu'il s'agit de l'un des frameworks JavaScript les plus importants et les plus puissants. Depuis sa sortie, il a continué à garder sa mainmise sur le marché informatique. Même avec l'introduction de nouveaux et dynamiques comme , , Meteor etc., la popularité de Node.js ne semble jamais s'arrêter. Vous vous demandez pourquoi? Eh bien, avec l'aide de ce tutoriel Node.js, je vais vous en donner un aperçu complet. Alors, préparez-vous à tomber amoureux de Node.js.



Dans ce didacticiel Node.js, je discuterai des sujets ci-dessous:



Qu'est-ce que Node.js?

Node.js est un framework puissant développé sur Moteur JavaScript V8 de Chrome qui compile le JavaScript directement dans le code machine natif. Il s'agit d'un cadre léger utilisé pour créer des applications Web côté serveur et étend l'API JavaScript pour offrir les fonctionnalités habituelles côté serveur. Il est généralement utilisé pour le développement d'applications à grande échelle, en particulier pour les sites de streaming vidéo, les applications à page unique et d'autres applications Web. Node.js fait du utilisation d'un modèle d'E / S non bloquant, piloté par les événements, ce qui en fait un choix idéal pour les applications en temps réel gourmandes en données.

Comme tous les autres langages de programmation, node.js utilise des packages et des modules. Ce sont les bibliothèques qui contiennent diverses fonctions et sont importées de npm (gestionnaire de paquets de nœuds) dans notre code et utilisées dans les programmes. Certaines des principales fonctionnalités qui définissent Node.js sont répertoriées ci-dessous:



Caractéristiques de Node.js

  1. Open source
    Node.js est une licence MIT de framework open source qui est prise en charge par une énorme communauté. Sa communauté très active a contribué à ajouter de nouvelles fonctionnalités aux applications Node.js.
  2. Simple et rapide
    Étant donné que Node.js est basé sur le moteur JavaScript V8 de Google Chrome, ses bibliothèques sont capables d'exécuter rapidement du code.
  3. Asynchrone
    Toutes les bibliothèques de Node.js sont asynchrones, ce qui signifie que les serveurs basés sur Node.js n'attendent jamais qu'une API renvoie la réponse et passe à l'API suivante.
  4. Haute évolutivité
    En raison du mécanisme d'événement, Node.js est hautement évolutif et aide le serveur dans une réponse non bloquante.
  5. Filetage unique
    Avec l'aide de la boucle d'événements, Node.js est capable de suivre le modèle monothread. Cela permet à un seul programme de gérer plusieurs demandes.
  6. Pas de tampon
    L'une des principales fonctionnalités des applications Node.js est qu'elle ne met jamais en mémoire tampon les données.
  7. Multiplateforme
    Node.js peut être facilement construit et déployé sur diverses plates-formes telles que Windows, MAC et Linux.

Allons maintenant plus loin et voyons comment déployer le code réel sur le navigateur. Mais avant cela, vous devez télécharger et installer dans vos systèmes. Vous pouvez consulter mon autre article pour connaître le complet Processus d'installation de Node.js .

Alors maintenant, allons plus loin dans ce didacticiel Node.js, où je parlerai du composant le plus important de Node.js, c'est-à-dire npm.

NPM (Node Package Manager)

NPM signifie Node Package Manager qui, comme son nom l'indique, est un gestionnaire de packages pour les packages / modules Node.js. À partir de la version 0.6.0 de Node. à partir de là, npm a été ajouté par défaut dans l'installation du nœud. Cela vous évite d'avoir à installer explicitement npm.



NPM aide essentiellement de deux manières:

transférer des fichiers vers l'instance Windows ec2
  1. Fournit et héberge des référentiels en ligne pour les packages / modules node.js qui peuvent être facilement téléchargés et utilisés dans nos projets. Vous pouvez les trouver ici: npmjs.com
  2. Fournit l'utilitaire de ligne de commande pour installer divers packages Node.js, gérer les versions de Node.js et les dépendances des packages.

Mais maintenant, vous devez vous demander ce que sont exactement ces modules et comment ils nous aident à construire les applications Node.js. Eh bien, dans la section suivante de ce didacticiel Node.js, je vais vous donner un aperçu complet des modules Node.js.

Modules Node.js

Les modules de Node.js représentent diverses fonctionnalités regroupées dans un ou plusieurs fichiers JS. Ces modules ont un contexte unique, ainsi, ils n'interfèrent ni ne polluent jamais la portée des autres modules.

Ces modules permettent la réutilisation du code et améliorent la facilité d'utilisation. Node.js fournit essentiellement trois types de modules:

  1. Modules de base
  2. Modules locaux
  3. Modules tiers

Module de base

Puisque Node.js est un très poids léger framework, les modules de base regroupent les fonctionnalités minimales absolues. Ces modules sont généralement chargés lorsque le processus Node démarre son exécution. Tout ce que vous avez à faire est d'importer ces modules de base afin de les utiliser dans votre code.

Ci-dessous, j'ai énuméré quelques-uns des modules de base importants.

Module de base La description
http Contient les classes, méthodes et événements requis pour créer le serveur HTTP Node.js
URL Contient des méthodes de résolution et d'analyse d'URL dans Node
chaîne de requête Contient des méthodes pour traiter une chaîne de requête de Node
chemin Contient des méthodes pour gérer les chemins de fichiers
fs Contient des classes, des méthodes et des événements pour travailler avec les E / S de fichiers
Utile Contient des fonctions utilitaires qui peuvent être utiles pour les programmeurs

Vous pouvez charger votre module principal, en utilisant le code ci-dessous:

var module = require ('nom_module')

Voyons maintenant ce que sont les «modules locaux».

Modules locaux

Les modules locaux de Node.js sont des modules personnalisés qui sont créés localement par l'utilisateur / développeur dans l'application. Ces modules peuvent inclure diverses fonctionnalités regroupées dans des fichiers et des dossiers distincts qui peuvent être facilement distribués dans la communauté Node.js à l'aide de NPM.

Ces modules sont chargés de la même manière que les modules principaux. Laissez-vous montrer, comment le faire en utilisant un exemple de base.

Créez votre fichier module.js personnalisé / local

var detail = {name: function (name) {console.log ('Name:' + name)}, domain: function (domain) {console.log ('Domain:' + domain)}} module.exports = detail

Incluez votre fichier de module dans votre fichier d'application principal.

var myLogModule = require ('./ Local_module.js') myLogModule.name ('Edureka') myLogModule.domain ('Education')

Vous pouvez maintenant exécuter ces fichiers en utilisant la commande ci-dessous:

nœud application.js

Permettez-moi maintenant de vous montrer ce que sont les modules externes.

Modules externes

Vous pouvez utiliser l'externe ou 3rdmodules du parti uniquement en les téléchargeant via NPM. Ces modules sont généralement développés par d'autres développeurs et sont gratuits. Peu des meilleurs modules externes sont express, react, gulp, mangouste, moka, etc.

Chargement global des modules tiers:

npm install --g

Incluez votre fichier de module dans votre fichier d'application principal:

npm installer - enregistrer

Fichier JSON

La fichier package.json dans Node.js est le cœur de toute l'application. Il s'agit essentiellement du fichier manifeste qui contient les métadonnées du projet. Ainsi, comprendre et travailler avec ce fichier devient très important pour un développement de projet Node réussi.

Le fichier package.json se compose généralement des métadonnées de l'application, qui sont ensuite classées en deux catégories:

  1. Identification des propriétés des métadonnées: Cela comprend des propriétés telles que le nom du projet, la version actuelle du module, la licence, l'auteur du projet, la description du projet, etc.
  1. Ecrire directement dans un fichier: Vous pouvez directement écrire les informations nécessaires dans le fichier package.json et les inclure dans votre projet.

A présent, vous vous êtes déjà familiarisé avec les différents composants de l'application Node JS. Dans la section suivante de ce didacticiel Node.js, je partagerai quelques notions de base sur Node Js afin que nous puissions commencer par les mains.

Principes de base de Node.js

Puisque Node.js est un framework JavaScript, il utilise la syntaxe JavaScript. Si vous voulez apprendre JavaScript en détail, vous pouvez vous référer à ceci . Pour l'instant, je vais vous brosser un tableau avec quelques bases de Node.js comme:

Types de données

Comme tout autre langage de programmation, Node.js a divers types de données, qui sont ensuite classés en types de données primitifs et non primitifs.

Les types de données primitifs sont:

  1. Chaîne
  2. Nombre
  3. Booléen
  4. Nul
  5. Indéfini

Les types de données non primitifs sont:

  1. Objet
  2. Date
  3. Tableau

Variables

Les variables sont des entités qui détiennent des valeurs qui peuvent varier au cours d'un programme. Pour créer une variable dans Node.js, vous devez utiliser un mot-clé réservé var. Vous n'êtes pas obligé d'attribuer un type de données, car le compilateur le choisira automatiquement.

Syntaxe:

var varName = valeur

Les opérateurs

Node.js prend en charge les opérateurs ci-dessous:

Type d'opérateur Les opérateurs
Arithmétique +, -, /, *,%, ++, -
Affectation =, + =, - =, * =, / =,% =
Conditionnel =?
Comparaison ==, === ,! = ,! ==,>,> =,<, <=,
Logique &&, || ,!
Bitwise &, |, ^, ~,<>, >>>

Les fonctions

Les fonctions dans Node.js est un bloc de code qui a un nom et est écrit pour accomplir une tâche particulière. Vous devez utiliser la fonction de mot-clé pour le créer. Une fonction est généralement un processus en deux étapes. La première consiste à définir la fonction et la seconde à l'invoquer. Vous trouverez ci-dessous la syntaxe de création et d'appel d'une fonction:

Exemple:

// Définition d'une fonction function display_Name (firstName, lastName) {alert ('Hello' + firstName + '' + lastName)} // Appel de la fonction display_Name ('Park', 'Jimin')

Objets

Un objet est un type de données non primitif qui peut contenir plusieurs valeurs en termes de propriétés et de méthodes. Les objets Node.js sont des entités autonomes car il n'y a pas de concept de classe. Vous pouvez créer un objet de deux manières:

exécuter une requête Hive à partir de la ligne de commande
  1. Utilisation du littéral objet
  2. Utilisation du constructeur d'objets

Exemple:

// objet avec propriétés et méthode var employee = {// propriétés firstName: 'Minho', lastName: 'Choi', age: 35, salaire: 50000, // méthode getFullName: function () {return this.firstName + '' + this.lastName}}

Système de fichiers

Pour accéder au système de fichiers physique, Node.js utilise le fs module qui prend en charge toutes les opérations d'E / S de fichiers asynchrones et synchrones. Ce module est importé à l'aide de la commande ci-dessous:

var fs = exiger ('fs')

Certaines des utilisations générales des modules du système de fichiers sont:

  • Lire les fichiers
    1. fs.readFile ()
var http = require ('http') var fs = require ('fs') http.createServer (function (req, res) {fs.readFile ('script.txt', function (err, data) {res.writeHead ( 200, {'Content-Type': 'text / html'}) res.write (data) res.end ()})}). Listen (8080)
  • Créer des fichiers
    1. appendFile ()
    2. ouvert()
    3. writeFile ()
  • Mettre à jour les fichiers
    1. fs.appendFile ()
    2. fs.writeFile ()
  • Supprimer les fichiers
    1. fs.unlink ()
  • Renommer les fichiers
    1. fs.rename ()

Ainsi, avec ces commandes, vous pouvez pratiquement effectuer toutes les opérations requises sur vos fichiers. Allons maintenant plus loin avec ce didacticiel Node.js et voyons ce que sont les événements et comment ils sont gérés dans Node.js.

Événements

Comme je l'ai déjà mentionné, les applications Node.js sont à thread unique et basées sur les événements. Node.js prend en charge la concurrence car il est piloté par les événements et utilise ainsi des concepts tels que les événements et les rappels. La fonction async appelle aider Node.js à maintenir la concurrence dans toute l'application.

Fondamentalement, dans une application Node.js, il existe une boucle principale qui attend et écoute les événements, et une fois qu'un événement est terminé, il lance immédiatement une fonction de rappel.

Le diagramme ci-dessous représente la façon dont les événements sont gérés dans Node.js.

Modèle de thread - Tutoriel Node.js - Edureka

Une chose que vous devez noter ici est que, même si les événements ressemblent aux fonctions de rappel, la différence réside dans leurs fonctionnalités. Lorsqu'une fonction asynchrone renvoie ses résultats, les rappels sont appelés en revanche, la gestion des événements fonctionne complètement sur le modèle d'observateur. Et dans Node.js, les méthodes qui écoutent les événements sont appelées les observateurs. Au moment où un événement est déclenché, sa fonction d'écoute démarre automatiquement. Les modules d'événements et la classe EventEmitter fournissent plusieurs événements intégrés qui sont utilisés pour lier des événements avec des écouteurs d'événements. Ci-dessous, j'ai écrit la syntaxe pour cela.

Lier un événement à un écouteur d'événements

// Importer le module d'événements var my_Events = require ('events') // Créer un objet eventEmitter var my_EveEmitter = new my_Events.EventEmitter ()

Liaison du gestionnaire d'événements à un événement

// Evénement de liaison et gestionnaire d'événements my_EveEmitter.on ('eventName', eventHandler)

Déclencher un événement

// Déclenche un événement my_EveEmitter.emit ('eventName')

Essayons maintenant de mettre en œuvre les éléments dont j'ai parlé dans cette section Événement Node.js. Le code ci-dessous montre une représentation simple de l'exécution d'événement dans Node.js.

var emitter = require ('events'). EventEmitter function iterateProcessor (num) {var emt = new emitter () setTimeout (function () {for (var i = 1 i & lt = num i ++) {emt.emit ('BeforeProcess' , i) console.log ('Processing Iteration:' + i) emt.emit ('AfterProcess', i)}}, 5000) return emt} var it = iterateProcessor (5) it.on ('BeforeProcess', function ( info) {console.log ('Démarrage du processus pour' + info)}) it.on ('AfterProcess', function (info) {console.log ('Fin du traitement pour' + info)

Dans la section suivante de ce didacticiel Node.js, je vais vous donner un aperçu de l'un des modules les plus importants de Node.js appelé le module HTTP.

Module HTTP

Généralement, Node.js est utilisé pour développer des applications basées sur un serveur. Mais en utilisant le module, vous pouvez facilement créer des serveurs Web capables de répondre aux demandes des clients. Ainsi, il est également appelé module Web et fournit des modules comme HTTP et request qui facilitent Node.js dans le traitement des requêtes du serveur.

Vous pouvez facilement inclure ce module dans votre application Node.js en écrivant simplement le code ci-dessous:

var http = require ('http')

Ci-dessous, j'ai écrit un code qui montre comment un serveur Web est développé dans Node.js.

// appel de la bibliothèque http var http = require ('http') var url = require ('url') // création du serveur var server = http.createServer (function (req, res) {// définition de l'en-tête du contenu res.writeHead ( 200, ('Content-Type', 'text / html')) var q = url.parse (req.url, true) .query var txt = q.year + '' + q.month // envoyer la chaîne à la réponse res.end (txt)}) // affectation de 8082 comme port d'écoute du serveur server.listen (8082)

Dans la section suivante de ce didacticiel Node.js, je parlerai d'Express.js qui est fortement utilisé pour le développement d'applications Web côté serveur.

Express.js

Express.js est un framework construit sur Node.js qui facilite la gestion du flux de données entre le serveur et les routes dans les applications côté serveur. Il s'agit d'un cadre léger et flexible qui fournit un large éventail de fonctionnalités requises pour le Web ainsi que le développement d'applications mobiles.

Express.js est développé sur le module middleware de Node.js appelé relier . Le module de connexion utilise en outre http module pour communiquer avec Node.js. Ainsi, si vous travaillez avec l'un des modules middleware basés sur Connect, vous pouvez facilement l'intégrer à Express.js.

Non seulement cela, mais quelques-uns des principaux avantages d'Express.js sont:

  • Accélère le développement d'applications Web
  • Aide à créer des applications mobiles et Web de types à une page, à plusieurs pages et hybrides
  • Express fournit deux moteurs de création de modèles, à savoir Jade et EJS
  • Express suit l'architecture Model-View-Controller (MVC)
  • Fait l'intégration avec des bases de données telles que MongoDB, Redis, MySQL
  • Définit un middleware de gestion des erreurs
  • Simplifie la configuration et la personnalisation facile pour l'application.

Avec toutes ces fonctionnalités, Express prend la responsabilité de la partie backend de la pile MEAN. Mean Stack est la pile de logiciels JavaScript open source utilisée pour créer des sites Web et des applications Web dynamiques. Ici, SIGNIFIER signifie M ongoDB, EST xpress.js, À ngularJS, et N ode.js.

Voyons maintenant un exemple simple pour comprendre comment Express.js fonctionne avec Node.js pour faciliter notre travail. Mais avant de commencer à travailler avec Express.js, vous devez l'installer sur votre système.

Pour installer Express.js globalement, vous pouvez utiliser la commande ci-dessous:

npm install -g express

Ou, si vous souhaitez l'installer localement dans votre dossier de projet, vous devez exécuter la commande ci-dessous:

npm install express --save

Puisque nous avons terminé toutes les préparations, passons maintenant directement à la mise en œuvre pratique. Ici, je vais montrer une application d'authentification utilisateur simple utilisant Node.js et Express.js.

Tutoriel Node.js Développement d'application étape par étape avec Express.js

Pour cela, nous aurons besoin des fichiers ci-dessous:

  • package.json
  • script.js
  • vues
    • index.jade
    • login.jade
    • secure.jade
    • unauthorized.jade
    • welcome.jade
  • lib
    • routes.js

Alors, commençons par package.json .

{'author': 'Edureka', 'name': 'Express_Demo', 'description': 'Express with Node.js', 'version': '0.0.0', 'scripts': {'start': 'node script.js '},' moteurs ': {' nœud ':' ~ 0.4.12 '},' dépendances ': {' connect-flash ':' ^ 0.1.1 ',' cookie-parser ':' ^ 1.4 .3 ',' express ':' ^ 3.21.2 ',' jade ':' ^ 0.20.3 ',' req-flash ':' 0.0.3 '},' devDependencies ': {}}

Ensuite, vous devez créer le script.js .

var express = require ('express') var http = require ('http') var port = 8999 var app = express () const flash = require ('connect-flash') var cookieParser = require ('cookie-parser') var server = http.createServer (app) function checkAuth (req, res, next) {console.log ('checkAuth' + req.url) // ne sert / sécurise pas à ceux qui ne sont pas connectés if (req.url = == '/ secure' && (! req.session ||! req.session.authenticated)) {res.render ('unauthorized', {status: 403}) return} next ()} app.use (flash () ) app.use (cookieParser ()) app.use (express.session ({secret: 'exemple'})) app.use (express.bodyParser ()) app.use (checkAuth) app.use (app.router) app.set ('view engine', 'jade') app.set ('view options', {layout: false}) require ('./ lib / routes.js') (app) app.listen (port) console .log ('Nœud écoutant sur le port% s', port)

Maintenant, créez un dossier nommé view, sous lequel vous allez ajouter les fichiers jade qui seront responsables des différentes pages vues. Le premier fichier de vue que vous devez créer est index.jade .

!!! 5 html (lang = 'en') head title Exemple d'authentification de l'utilisateur body h1 center Authentification Démo avec Express h3 Accédez à h4 ul li: a (href = '/ secure') Contenu sécurisé li: a (href = '/ welcome') Page d'accueil li: a (href = '/ logout') Déconnexion

Maintenant, créez le login.jade fichier.

!!! 5 html (lang = 'en') head title Exemple d'authentification express body h1 center Connectez-vous à ce centre d'exemples d'authentification express p Utilisation utilisateur pour le nom d'utilisateur et passer pour le mot de passe. form (method = 'post') p label (for = 'username') Email Address input (type = 'text', name = 'username', class = 'form-control', id = 'exampleInputPassword1', placeholder = ' Email ', style =' width: 400px ') p center label (for =' password ') Entrée du mot de passe (type =' password ', name =' password ', class =' ​​form-control ', id =' exampleInputPassword1 ', placeholder = 'Password', style = 'width: 400px') p center Soumettre - chaque message en flash h4 (style = 'color: red') # {message}

La prochaine étape consiste à créer le welcome.jade .

!!! 5 html (lang = 'en') head title Exemple d'authentification de l'utilisateur body h1 center Bienvenue dans le didacticiel Edureka!

Ensuite, créez le secure.jade fichier.

!!! 5 html (lang = 'en') head title Exemple d'authentification express body h1 center Bonjour, utilisateur sécurisé. p Accédez à ul li: a (href = '/ secure') Contenu sécurisé li: a (href = '/ welcome') Page d'accueil li: a (href = '/ logout') Déconnexion

Maintenant, créez le unauthorized.jade fichier.

framework hybride dans sélénium webdriver
!!! 5 html (lang = 'en') head title Exemple d'authentification de l'utilisateur body h1 center Non autorisé p Vous n'êtes pas autorisé à afficher cette page. p S'il vous plaît ' continuer

Maintenant, vous devez créer un dossier et le nommer lib . Maintenant, créez un route.js fichier qui mappera toutes les pages.

var util = require ('util') module.exports = function (app) {app.get ('/', function (req, res, next) {res.render ('index')}) app.get (' / welcome ', function (req, res, next) {res.render (' welcome ')}) app.get (' / secure ', function (req, res, next) {res.render (' secure ')} ) app.get ('/ login', function (req, res, next) {res.render ('login', {flash: req.flash ()})}) app.post ('/ login', function ( req, res, next) {// vous voudrez peut-être faire une recherche dans la base de données ou quelque chose de plus évolutif ici if (req.body.username && req.body.username === 'user' && req.body.password && req.body.password === 'pass') {req.session.authenticated = true res.redirect ('/ secure')} else {req.flash ('error', 'Le nom d'utilisateur et le mot de passe sont incorrects') res. redirect ('/ login')}}) app.get ('/ logout', function (req, res, next) {supprimer req.session.authenticated res.redirect ('/')})}

Maintenant, si vous souhaitez exécuter ce code vous-même, vous pouvez le télécharger à partir d'ici: Tutoriel Node.js PDF .

Avec cela, nous arrivons à la fin de ce didacticiel Node.js. J'espère avoir été en mesure d'expliquer les concepts de Node.js à partir de zéro.

Si vous avez trouvé ce «Tutoriel Node.js 'Pertinent, Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce tutoriel Node.js et nous vous recontacterons.