npm, le gestionnaire de packages de nœuds: Guide du débutant

Node.js permet d'écrire des applications en JavaScript sur le serveur. Il est basé sur le moteur d'exécution JavaScript V8 et écrit en C ++ – donc c'est rapide. À l'origine, il était conçu comme un environnement serveur pour les applications, mais les développeurs ont commencé à l'utiliser pour créer des outils pour les aider dans l'automatisation des tâches locales. Depuis lors, un tout nouvel écosystème d'outils basés sur Node (tels que Grunt Gulp et webpack ) a évolué pour transformer le visage du développement front-end

Pour utiliser ces outils (ou packages) dans Node.js, nous devons être capables de les installer et de les gérer de manière utile. C'est là qu'intervient npm, le gestionnaire de paquets Node. Il installe les paquets que vous souhaitez utiliser et fournit une interface utile pour travailler avec eux.

Dans ce guide, nous allons examiner les bases du travail avec npm. Nous allons vous montrer comment installer des packages en mode local et global, ainsi que supprimer, mettre à jour et installer une certaine version d'un package. Nous allons également vous montrer comment utiliser package.json pour gérer les dépendances d'un projet. Si vous préférez la vidéo, pourquoi ne pas vous inscrire à SitePoint Premium et regarder notre screencast gratuit: Qu'est-ce que npm et comment puis-je l'utiliser?

Mais avant de pouvoir commencer à utiliser npm, nous devons d'abord installer Node.js sur notre système. Faisons-le maintenant.

Installation de Node.js

Accédez à la page de téléchargement de Node.js et récupérez la version dont vous avez besoin. Des programmes d'installation Windows et Mac sont disponibles, ainsi que des binaires Linux pré-compilés et du code source. Pour Linux, vous pouvez également installer Node via le gestionnaire de paquets, comme indiqué ici .

Pour ce didacticiel, nous allons utiliser la v12.15.0. Au moment de la rédaction de cet article, il s'agit de la version actuelle Long Term Support (LTS) de Node .

Conseil: Vous pouvez également envisager d'installer Node à l'aide d'un gestionnaire de version . Cela annule le problème d’autorisation soulevé dans la section suivante.

Voyons où le nœud a été installé et vérifions la version:

 $  quel  nœud
/ usr / bin / node
$ node --version
v12.15.0

Pour vérifier que votre installation a réussi, essayons le REPL de Node:

 $ node
>  console.log  ( 'Node is running' ) ; 
Le nœud est en cours d'exécution
>  .help
.break Parfois, vous êtes coincé, cela vous fait sortir
.clear Alias ​​ pour  .break
.editor Entrer en mode éditeur
.exit Quitter le repl
.help Imprimer ce message d'aide  
.load Charger JS depuis un fichier   dans la session REPL
.save Sauvegarde toutes les commandes évaluées  dans  cette session REPL dans un fichier  

Appuyez sur ^ C pour abandonner l'expression actuelle, ^ D pour  quitter  le repl

L'installation de Node.js a fonctionné, nous pouvons donc maintenant concentrer notre attention sur npm, qui était inclus dans l'installation:

 $  which   npm 
/ usr / bin / npm
$  npm  --version
 6,13  0,7

La mise à jour de npm

npm, qui signifiait à l'origine Node Package Manager, est un projet distinct de Node.js. Il a tendance à être mis à jour plus fréquemment. Vous pouvez consulter la dernière version disponible de npm sur cette page . Si vous vous rendez compte que vous avez une version plus ancienne, vous pouvez mettre à jour comme suit.

Pour les utilisateurs Linux et Mac, utilisez la commande suivante:

  npm   install  -g npm @ latest

Pour les utilisateurs de Windows, le processus peut être légèrement plus compliqué. Voici ce qui est indiqué sur la page d’accueil du projet :

De nombreuses améliorations ont été apportées aux utilisateurs de Windows dans npm 3 – vous aurez une meilleure expérience si vous exécutez une version récente de npm. Pour mettre à niveau, utilisez l'outil de mise à niveau de Microsoft téléchargez une nouvelle version de Node ou suivez les instructions de mise à niveau de Windows dans le post Installing / upgrade npm .

] Pour la plupart des utilisateurs, l'outil de mise à niveau sera le meilleur choix. Pour l'utiliser, vous devez ouvrir PowerShell en tant qu'administrateur et exécuter la commande suivante:

 Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force

Cela garantira que vous pouvez exécuter des scripts sur votre système. Ensuite, vous devrez installer l’outil npm-windows-upgrade . Après avoir installé l'outil, vous devez l'exécuter afin qu'il puisse mettre à jour npm pour vous. Faites tout cela dans la console PowerShell surélevée:

  npm   install  --global --production npm-windows-upgrade
npm-windows-upgrade - dernière version de npm

Node Packaged Modules

npm peut installer des packages en mode local ou global. En mode local, il installe le package dans un dossier node_modules dans votre répertoire de travail parent. Cet emplacement appartient à l'utilisateur actuel.

Si vous n'utilisez pas de gestionnaire de versions (ce que vous devriez probablement être), les packages globaux sont installés dans {prefix} / lib / node_modules / qui appartient à root (où {prefix} est généralement / usr / ou / usr / local ). Cela signifie que vous devrez utiliser sudo pour installer les packages globalement, ce qui pourrait provoquer des erreurs d'autorisation lors de la résolution de dépendances tierces, ainsi que constituer un problème de sécurité.

Changeons cela!

Modification de l'emplacement des packages globaux

Voyons ce que la sortie npm config nous donne:

 $  npm  config list
;  cli configs
metrics-registry  =   "https://registry.npmjs.org/" 
portée  =   "" 
user-agent  =   "npm / 6.13.7 node / v12.15.0 linux x64" 

;  node bin location  =  / usr / bin / nodejs
;  cwd  =  / home / sitepoint
;   HOME   =  / home / sitepoint
;   "npm config ls -l"  pour afficher toutes les valeurs par défaut.

Cela nous donne des informations sur notre installation. Pour le moment, il est important d’obtenir l’emplacement global actuel:

 $  npm  config get prefix
/ usr

C'est le préfixe que nous voulons changer, afin d'installer des packages globaux dans notre répertoire personnel. Pour ce faire, créez un nouveau répertoire dans votre dossier personnel:

 $  cd  ~  &&   mkdir  .node_modules_global
$  npm  config  set   prefix  =  $ HOME  /. Node_modules_global

Avec ce simple changement de configuration, nous avons modifié l'emplacement d'installation des packages Node globaux. Cela crée également un fichier .npmrc dans notre répertoire personnel:

 $  npm  config get prefix
/home/sitepoint/.node_modules_global
$  chat  .npmrc
 prefix  =  /home/sitepoint/.node_modules_global

Nous avons toujours npm installé dans un emplacement appartenant à root. Mais parce que nous avons changé notre emplacement global de colis, nous pouvons en profiter. Nous devons réinstaller npm, mais cette fois dans le nouvel emplacement appartenant à l'utilisateur. Cela installera également la dernière version de npm:

  npm   install  npm @ latest -g

Enfin, nous devons ajouter .node_modules_global / bin à notre variable d'environnement $ PATH afin de pouvoir exécuter des packages globaux à partir de la ligne de commande. Pour ce faire, ajoutez la ligne suivante à votre .profile .bash_profile ou .bashrc et redémarrez votre terminal:

  export    PATH   =  " $ HOME  /. Node_modules_global / bin:  $ PATH " 

Maintenant, notre .node_modules_global / bin sera trouvé en premier et la version correcte de npm sera utilisée:

 $  qui   npm 
/home/sitepoint/.node_modules_global/bin/npm
$  npm  --version
 6,13  0,7

Astuce: vous pouvez éviter tout cela si vous utilisez un gestionnaire de version Node. Consultez ce didacticiel pour découvrir comment: Installer plusieurs versions de Node.js à l'aide de nvm .

Installer des packages en mode global

Pour le moment, nous n'avons qu'un seul package installé globalement – le npm paquet lui-même. Modifions cela et installons UglifyJS (un outil de minification JavaScript). Nous utilisons l'indicateur - global mais il peut être abrégé en -g :

 $  npm   install  uglify-js --global
/home/sitepoint/.node_modules_global/bin/uglifyjs - >  /home/sitepoint/.node_modules_global/lib/node_modules/uglify-js/bin/uglifyjs
+ uglify-js@3.7.7
ajouté  3  packages de  38  contributors  in   0  .259s

Comme vous pouvez le voir dans la sortie, des packages supplémentaires sont installés. Ce sont les dépendances d'UglifyJS.

Liste des packages globaux

Nous pouvons lister les packages globaux que nous avons installés avec la commande npm list :

 $  npm  list - global
accueil / sitepoint / .node_modules_global / lib
├─┬ npm@6.9.0
│ ├── abbrev@1.1.1
│ ├── ansicolors@0.3.2
│ ├── ansistyles@0.1.3
│ ├── aproba@2.0.0
│ ├── archy@1.0.0
 ..  ..  ..  ..  ..  ..  ..  ..  ..  .. 
└─┬ uglify-js@3.5.3
  ├── commander@2.19.0
  └── source-map@0.6.1

La sortie, cependant, est plutôt verbeuse. Nous pouvons changer cela avec l'option - depth = 0 :

 $  npm  list -g --depth  =  0 
/home/sitepoint/.node_modules_global/lib
├── npm@6.13.7
└── uglify-js@3.7.7

C’est mieux; maintenant nous ne voyons que les packages que nous avons installés avec leurs numéros de version.

Tous les packages installés dans le monde deviendront disponibles à partir de la ligne de commande. Par exemple, voici comment vous utiliseriez le package Uglify pour réduire example.js en example.min.js :

 $ uglifyjs example.js -o example.min.js

Installation de packages en mode local

Lorsque vous installez des packages localement, vous le faites normalement en utilisant un fichier package.json . Créons-en un:

 $  mkdir  project  &&   cd  project

$  npm  init
nom du package:  ( project ) 
version:  ( 1.0  .0 ) 
description: Démo de package.json
point d'entrée:  ( index.js ) 
 test  commande:
 git  référentiel:
mots clés:
auteur:
licence:  ( ISC ) 

Appuyez sur Retour pour accepter les valeurs par défaut, puis appuyez à nouveau pour confirmer vos choix. Cela créera un fichier package.json à la racine du projet:

 {
   "name" :   "project" 
   "version ":  " 1.0.0 "
  " description ":  " "
  " main ":  " index.js "
  " scripts ":   {
    " test ":  " echo  "Erreur: aucun test spécifié " && exit 1 " 
  } 
   "auteur" :   "" 
   "licence" :   "ISC" 
} 

Astuce: Si vous voulez un moyen plus rapide de générer un fichier package.json utilisez npm init --y .

Les champs sont, espérons-le assez explicite, à l'exception des scripts principaux et . Le champ main est le point d'entrée principal de votre programme et le champ scripts vous permet de spécifier des commandes de script exécutées à différents moments du cycle de vie de votre package. Nous pouvons les laisser tels quels pour le moment, mais si vous souhaitez en savoir plus, consultez la documentation package.json sur npm et cet article sur utilisant npm comme outil de construction .

Essayons maintenant d'installer Underscore :

 $  npm   install  underscore
L'avis  npm  a créé un fichier de verrouillage sous la forme package-lock.json. Vous devez valider ce fichier.
 npm  WARN project@1.0.0 Aucun champ de référentiel.

+ soulignement@1.9.2
ajouté  1  package de  1  contributor and audited  1  package  in   0  .412s
trouvé  0  vulnérabilités

Notez qu'un fichier de verrouillage est créé. Nous y reviendrons plus tard.

Maintenant, si nous regardons dans package.json nous verrons qu'un champ dependencies a été ajouté :

 {
   ... 
   "dépendances" :   {
     "underscore" :   "^ 1.9.2" 
  } [19659133]} 

Gérer les dépendances avec package.json

Comme vous pouvez le voir, Underscore v1.9.2 a été installé dans notre projet. Le signe caret ( ^ ) à l'avant du numéro de version indique que lors de l'installation, npm récupérera la version la plus élevée du package qu'il pourra trouver là où seule la version majeure doit correspondre (à moins qu'un package-lock.json est présent). Dans notre cas, ce serait tout ce qui est en dessous de la v2.0.0. Cette méthode de contrôle de version des dépendances (major.minor.patch) est connue sous le nom de versioning sémantique . Pour en savoir plus, cliquez ici: Versioning sémantique: pourquoi vous devriez l'utiliser .

Notez également que Underscore a été enregistré comme propriété du champ dependencies . Ceci est devenu la valeur par défaut dans la dernière version de npm et est utilisé pour les packages (comme Underscore) requis pour l'exécution de l'application. Il serait également possible de sauvegarder un paquet en tant que devDependency en spécifiant un indicateur - save-dev . devDependencies sont des packages utilisés à des fins de développement, par exemple pour exécuter des tests ou transpiler du code.

Astuce: vous pouvez également ajouter private: true au package .json pour empêcher la publication accidentelle de référentiels privés, ainsi que pour supprimer les avertissements générés lors de l'exécution de npm install .

De loin, la principale raison d'utiliser le package . json pour spécifier les dépendances d'un projet est la portabilité. Par exemple, lorsque vous clonez le code d'une autre personne, il vous suffit d'exécuter npm i à la racine du projet et npm résoudra et récupérera tous les packages nécessaires pour que vous puissiez exécuter l'application. Nous examinerons cela plus en détail plus tard.

Avant de terminer cette section, vérifions rapidement que Underscore fonctionne. Créez un fichier appelé test.js dans la racine du projet et ajoutez ce qui suit:

 const  _  =   require  ( "underscore"  ]) ; 
 console .  log  ( _ .  range  ( 5 ) ) ; 

Exécutez le fichier en utilisant node test.js et vous devriez voir la sortie [0, 1, 2, 3, 4] à l'écran.

Uninstalling Local Packages

npm est un gestionnaire de paquets, il doit donc être en mesure de supprimer un paquet. Supposons que le package Underscore actuel nous pose des problèmes de compatibilité. Nous pouvons supprimer le package et installer une version plus ancienne, comme ceci:

 $  npm  uninstall underscore
supprimé  1  package  dans   0  .386s

$  npm  liste
project@1.0.0 / home / sitepoint / projet
└──  ( vide ) 

Installation d'une version spécifique d'un paquet

Nous pouvons maintenant installer le paquet Underscore dans la version que nous voulons. Nous faisons cela en utilisant le signe @ pour ajouter un numéro de version:

 $  npm   install  underscore@1.9.1
+ soulignement@1.9.1
ajouté  1  package  dans   1  .574s

$  npm  liste
project@1.0.0 / home / sitepoint / projet
└── soulignement@1.9.1

Mise à jour d'un package

Vérifions s'il existe une mise à jour pour le package Underscore:

 $  npm  obsolète
Package Current Wanted Dernier emplacement
soulignement  1,9  .1  1,9  .2  1.9  .2 projet

La colonne Current nous montre la version qui est installée localement. La colonne Latest nous indique la dernière version du paquet. Et la colonne Wanted nous indique la dernière version du paquet vers laquelle nous pouvons mettre à jour sans casser notre code existant.

Vous vous souvenez du fichier package-lock.json de plus tôt? Introduit dans npm v5, le but de ce fichier est de s'assurer que les dépendances restent exactement les mêmes sur toutes les machines sur lesquelles le projet est installé. Il est généré automatiquement pour toutes les opérations où npm modifie le dossier node_modules ou le fichier package.json .

Vous pouvez essayer ceci si vous le souhaitez. Supprimez le dossier node_modules puis réexécutez npm i (abréviation de npm install ). npm réinstallera Underscore v1.9.1, même si nous venons de voir que la v1.9.2 est disponible. En effet, nous avons spécifié la version 1.9.1 dans le fichier package-lock.json :

 {
   "name" :   "project" 
   ] "version" :   "1.0.0" 
   "lockfileVersion" :   1 
   "requires" : [19659206] true 
   "dependencies" :   {
     "underscore" :   {
       "version" :   "1.9. 1 "
      " résolu ":  " https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz "
      " intégrité ":  " sha512-5 / 4etnCkd9c8gwgowi5 / om / mYO5ajCaOgdzj / oW + 0eQV9WxKBDZw5 + ycmKmeaTXjInS / W0BzpGLo2xR2aBwZdg = 1965259} [1965259} [1965259} "

Avant l'émergence du fichier package-lock.json les versions de package incohérentes se sont avérées un gros casse-tête pour les développeurs. Ce problème était normalement résolu en utilisant un fichier npm-shrinkwrap.json qui devait être créé manuellement.

Maintenant, supposons que la dernière version de Underscore corrige le bogue que nous avions précédemment et que nous voulons mettre à jour notre paquet vers cette version:

 $  npm  mise à jour de soulignement
+ soulignement@1.9.2
mis à jour  1  package  dans   0  .236s

$  npm  liste
project@1.0.0 / home / sitepoint / projet
└── soulignement@1.9.2

Astuce: pour que cela fonctionne, Underscore doit être répertorié comme une dépendance dans package.json . Nous pouvons également exécuter npm update si nous avons de nombreux modules obsolètes que nous voulons mettre à jour.

Recherche de packages

Nous avons utilisé la commande mkdir plusieurs fois dans ce tutoriel. Existe-t-il un package Node doté de cette fonctionnalité? Utilisons npm search :

 $  npm  search  mkdir 
NOM  |  DESCRIPTION  |  AUTEUR  |  DATE
 mkdir                       |  Création du répertoire…  |   =  joehewitt  |   2012  -04-17
fs-extra  |  fs-extra contient…  |   =  jprichardson…  |   2019  -06-28
mkdirp  |  Récursivement mkdir,…  |   =  isaacs…  |   2020  -01-24
make-dir  |  Créer un répertoire…  |   =  sindresorhus  |   2019  -04-01
 .. .

Il y a ( mkdirp ). Installons-le:

 $  npm   install  mkdirp
+ mkdirp@1.0.3
ajouté  1  package et audité  2  packages  in   0  .384s

Maintenant, créez un fichier mkdir.js et copiez-collez ce code:

 const  mkdirp  =   require  ( 'mkdirp' [19659014]) ; 

 const  made  =  mkdirp .  sync  ( '/ tmp / foo / bar / baz' [19659014]) ; 
 console .  log  ( ` made directory, commençant par  $ { made }  « ) ; 

Ensuite, exécutez-le depuis le terminal:

 $ node mkdir.js
répertoires créés, en commençant par / tmp / foo

Réinstallation des dépendances du projet

Commençons par installer un autre package:

 $  npm   install  request
+ demande@2.88.0
ajouté  48  packages de  59  contributeurs et audité  65  packages  in   2  .73s
trouvé  0  vulnérabilités

Vérifiez le package.json :

 "dependencies" :   {
   "mkdirp" :   "^ 1.0.3" [19659014]
   "request" :   "^ 2,88.0" 
   "underscore" :   "^ 1.9.2" 
} [19659014]

Notez que la liste des dépendances a été mise à jour automatiquement. Si vous vouliez installer un paquet sans l'enregistrer dans package.json utilisez simplement l'argument - no-save .

Supposons que vous ayez cloné le code source de votre projet sur une autre machine et nous voulons installer les dépendances. Supprimons d'abord le dossier node_modules puis exécutons npm install :

 $  rm  -R node_modules
$  npm  list --depth  =  0 
project@1.0.0 / home / sitepoint / projet
├── DÉPENDANCE INÉGALÉE mkdirp@1.0.3
├─┬ DÉPENDANCE INÉGALÉE request@2.88.0
   .. .
└── DÉPENDANCE INÉGALÉE underscore@1.9.2

 npm  ERR !  manquant: mkdirp@1.0.3, requis par project@1.0.0
 npm  ERR !  manquant: request@2.88.0, requis par project@1.0.0
 npm  ERR !  manquant: underscore@1.9.2, requis par project@1.0.0
 .. .

$  npm   install 
ajouté  50  packages de  60  contributeurs et audités  65  packages  in   1  .051s
trouvé  0  vulnérabilités

Si vous regardez votre dossier node_modules vous verrez qu'il est recréé à nouveau. De cette façon, vous pouvez facilement partager votre code avec d'autres personnes sans alourdir votre projet et vos référentiels sources avec des dépendances.

Gestion du cache

Lorsque npm installe un paquet, il en conserve une copie, donc la prochaine fois que vous voulez l'installer package, il n'a pas besoin de toucher le réseau. Les copies sont mises en cache dans le répertoire .npm de votre chemin d'accès personnel:

 $  ls  ~ / .npm
anonymous-cli-metrics.json _cacache index-v5 _locks _logs node-sass

Ce répertoire sera encombré d'anciens paquets au fil du temps, il est donc utile de le nettoyer de temps en temps:

 $  npm  cache clean --force

Vous pouvez également purger tous les dossiers node_module de votre espace de travail si vous avez plusieurs projets de nœuds sur votre système que vous souhaitez nettoyer:

  find  .  -name  "node_modules"  -type d -exec  rm  -rf  '{}'  +

Audit

Avez-vous remarqué que toutes ces ont trouvé 0 vulnérabilités dispersées dans la sortie CLI? La raison en est qu'une nouvelle fonctionnalité a été introduite dans npm qui permet aux développeurs d'analyser les dépendances à la recherche de vulnérabilités de sécurité connues.

Essayons cette fonctionnalité en installant une ancienne version de express :

 $  npm   install  express@4.8.0

express@4.8.0
ajouté  36  packages de  24  contributeurs et  123  packages  in   2  .224s
trouvé  21  vulnérabilités  ( 8  faible,  9  modérée,  4  élevée ) 
  exécutez  ` npm  audit fix `   pour les corriger, ou  " npm  audit "    for  détails

Dès que nous avons terminé l'installation, nous obtenons un rapport rapide indiquant que plusieurs vulnérabilités ont été trouvées. Vous pouvez exécuter la commande npm audit pour afficher plus de détails:

 $  npm  audit

  ==  =   npm  rapport d'audit de sécurité  ==  = 


- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Élevé │ Déni de service d'expression régulière │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Paquet │ négociateur │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Dépendance de │ express │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Chemin │ express >  accepte >  négociateur │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Plus d'infos │ https://nodesecurity.io/advisories/106 │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Modéré │ Timing Attack │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Package │ cookie-signature │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Dépendance de │ express │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Chemin │ express >  cookie-signature │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
│ Plus d'infos │ https://nodesecurity.io/advisories/134 │
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Vous obtiendrez une liste détaillée des packages présentant des vulnérabilités. Si vous regardez le champ Path il affiche le chemin des dépendances. Par exemple, le chemin express> accepte> négociateur signifie qu'Express dépend du paquetage Accepte . Le paquetage Accepte dépend du paquetage négociateur qui contient la vulnérabilité.

Il y a deux façons de résoudre tous ces problèmes. Nous pouvons soit exécuter la commande npm install express@4.17.1 comme suggéré, soit exécuter npm audit fix . Let’s do the latter:

$ npm audit fix

+ express@4.17.1
added 20 packages from 14 contributors, removed 7 packages and updated 29 packages in 1.382s
fixed 21 of 21 vulnerabilities in 122 scanned packages

The command npm audit fix automatically installs any compatible updates to vulnerable dependencies. While this might seem like magic, do note that vulnerabilities can’t always be fixed automatically. This could happen if you’re using a package that’s undergone a major change which could break your current project if updated. For situations such as this, you’ll have to review your code and manually apply the fix.

You can also run npm audit fix --force if you don’t mind upgrading packages with breaking changes. After you’ve executed the command, run npm audit to ensure that all vulnerabilities have been resolved.

Aliases

As you may have noticed, there are multiple ways of running npm commands. Here’s a brief list of some of the commonly used npm aliases:

• npm i : install local package
• npm i -g : install global package
• npm un : uninstall local package
• npm up: npm update packages
• npm t: run tests
• npm ls: list installed modules
• npm ll or npm la: print additional package information while listing modules

You can also install multiple packages at once like this:

$ npm i express momemt lodash mongoose body-parser webpack

If you want to view all the common npm commands, just execute npm help for the full list. You can also learn more in our article 10 Tips and Tricks That Will Make You an npm Ninja.

npx

You might also hear talk of npx on your travels. Don’t confuse this with npm. As we’ve learned, npm is a tool for managing your packages, whereas npx is a tool for executing packages. It comes bundled with npm version 5.2+.

A typical use of npx is for executing one-off commands. For example, imagine you wanted to spin up a simple HTTP server. You could install the http-server package globally on your system, which is great if you’ll be using http-server on a regular basis. But if you just want to test the package, or would like to keep your globally installed modules to a minimum, you can change into the directory where you’d like to run it, then execute the following command:

npx http-server

And this will spin up the server without installing anything globally.

You can read more about npx here.

Conclusion

In this tutorial, we’ve covered the basics of working with npm. We’ve demonstrated how to install Node.js from the project’s download page, how to alter the location of global packages (so we can avoid using sudo), and how to install packages in local and global mode. We also covered deleting, updating and installing a certain version of a package, as well as managing a project’s dependencies.

With every new release, npm is making huge strides into the world of front-end development. According to its co-founderits user base is changing and most of those using it are not using it to write Node at all. Rather, it’s becoming a tool that people use to put JavaScript together on the front end (seriously, you can use it to install just about anything) and one which is becoming an integral part of writing modern JavaScript.

Are you using npm in your projects? If not, now might be a good time to start.