Comment trouver la version d'un package node.js / npm installé ?

Ceci imprime la version de npm elle-même:

npm -v <package-name>

Cela imprime une erreur cryptique:

npm version <package-name>

Cela imprime la version du package sur le registre (c'est-à-dire la dernière version disponible):

npm view <package-name> version

Comment obtenir la version installée ?

npm listpour les packages locaux ou npm list -gpour les packages installés globalement.

Vous pouvez trouver la version d'un package spécifique en passant son nom comme argument. Par exemple, npm list gruntentraînera:

projectName@projectVersion /path/to/project/folder
└── grunt@0.4.1

Alternativement, vous pouvez simplement exécuter npm listsans passer un nom de package comme argument pour voir les versions de tous vos packages:

├─┬ cli-color@0.1.6 
│ └── es5-ext@0.7.1 
├── coffee-script@1.3.3 
├── less@1.3.0 
├─┬ sentry@0.1.2 
│ ├── file@0.2.1 
│ └── underscore@1.3.3 
└── uglify-js@1.2.6 

Vous pouvez également ajouter un --depth=0argument pour répertorier les packages installés sans leurs dépendances.

Un autre moyen rapide de découvrir quels packages sont installés localement et sans leurs dépendances consiste à utiliser:

npm list --depth=0

Ce qui vous donne quelque chose comme

├── bower@0.8.6
├── grunt@0.4.1
├── grunt-bower-requirejs@0.4.3
├── grunt-contrib-clean@0.4.1
├── grunt-contrib-coffee@0.7.0
├── grunt-contrib-copy@0.4.1
├── grunt-contrib-imagemin@0.1.4
├── grunt-contrib-jshint@0.1.1
├── grunt-contrib-livereload@0.1.2
├── grunt-contrib-requirejs@0.4.1
├── grunt-regarde@0.1.1
└── grunt-svgmin@0.1.0

Évidemment, la même chose peut être faite globalement avec npm list -g --depth=0.

Cette méthode est plus claire si vous avez installé un grand nombre de packages.

Pour savoir quels packages doivent être mis à jour, vous pouvez utiliser npm outdated -g --depth=0.

npm view <package> version - renvoie la dernière version disponible sur le package.

npm list --depth=0 - renvoie les versions de tous les modules installés sans dépendances.

npm list - renvoie les versions de tous les modules et dépendances.

Et enfin pour obtenir la version du nœud: node -v

npm info YOUR_PACKAGE version

par exemple

npm info grunt version
0.4.5

Je viens d'utiliser

npm list | grep <package name>

et cela a très bien fonctionné

Sous Windows, exécutez:

npm list | find <package name>

Dans l'exécution de PowerShell:

npm list | sls <package name>

Depuis la racine du package:

node -p "require('./package.json').version"

EDIT : (vous devez donc cdentrer dans le répertoire personnel du module si vous n'y êtes pas déjà. Si vous avez installé le module avec npm install, il sera sous node_modules/<module_name>)

EDIT 2 : mis à jour selon la réponse de @ jeff-dickey

Pour les packages locaux

npm list --depth=0

Pour les packages globaux

npm list  -g --depth=0

La combinaison de certaines des réponses ci-dessus et produit une recherche super simple et super rapide.
Exécuter à partir de la racine du projet. Pas besoin de rentrer cddans un dossier, juste 1 ligne:

node -p "require('SOMEPACKAGE/package.json').version"

Vous pouvez également vérifier la version avec cette commande:

npm info <package name> version

Si vous acceptez d'installer jq , vous pouvez utiliser la sortie JSON de npm list.

npm -j ls <package-name> | jq -r .version

ou, si vous voulez être verbeux

npm --json list <package-name> | jq --raw-output '.version'

Par exemple:

$ npm -j ls ghost | jq -r .version
0.4.2

En outre, le format JSON est légèrement différent pour les packages globaux, vous devrez donc modifier la requête.

Par exemple:

$ npm -j -g ls | jq -r .dependencies.ghost.version
0.4.2

Si vous êtes assez courageux (et avez nodeinstallé), vous pouvez toujours faire quelque chose comme:

echo "console.log(require('./package.json').version);" | node

Cela imprimera la version du package actuel. Vous pouvez également le modifier pour devenir fou, comme ceci:

echo "eval('var result='+require('child_process').execSync('npm version',{encoding:'utf8'})); console.log(result.WHATEVER_PACKAGE_NAME);" | node

Cela imprimera la version du WHATEVER_PACKAGE_NAMEpaquet, qui est vue par npm version.

Pour voir tous les packages installés localement ou globalement, utilisez ces commandes:

1. npm listpour les packages locaux ou npm list -gpour les packages installés globalement.
2. npm list --depth=0
3. npm list | sls <package name>
4. node -v

Essayez avec:

npm list --depth 1 --global packagename

J'ai construit un outil qui fait exactement cela - qnm

qnm - Un utilitaire CLI simple pour interroger le node_modulesrépertoire.

Installez-le en utilisant:

npm i --global qnm

et courir:

qnm [module]

par exemple:

> qnm lodash

lodash
├── 4.17.5
├─┬ cli-table2
│ └── 3.10.1
└─┬ karma
  └── 3.10.1

Ce qui signifie que nous avons lodashinstallé dans la racine du node_moduleset deux autres exemplaires dans le node_modulesde cli-table2et karma.

C'est très rapide et a de belles fonctionnalités comme la complétion des onglets et la recherche de correspondance.

Pour répertorier les packages locaux avec le numéro de version, utilisez:

npm ls --depth=0

Pour répertorier les packages globaux avec le numéro de version, utilisez:

npm ls -g --depth=0

Vous pouvez utiliser vue NPM la version [module] , informations NPM Version [module] , NPM affichage de la version [module] ou NPM v la version [module] pour vérifier la version sur un module NPM installé.

Supposons que ma version du module grunt soit la 0.4.5:

npm view grunt version => 0.4.5
npm info grunt version => 0.4.5
npm show grunt version => 0.4.5
npm v grunt version    => 0.4.5

npm list --depth 0 est la commande qui affiche toutes les bibliothèques avec la version mais vous pouvez utiliser npm-check

npm-check est une bonne bibliothèque pour gérer toutes ces choses concernant l'événement système de version, il affichera les versions des bibliothèques, la mise à jour de la nouvelle version, la version inutilisée et bien d'autres.

pour l'installer il suffit d'exécuter

npm install -g npm-check

et exécutez simplement

npm-check

vérifiez la capture d'écran qui montre tout sur la version du package, la mise à jour de la nouvelle version et la version inutilisée.

Cela fonctionne aussi à l'échelle mondiale. Essaie. J'espère que cela aidera quelqu'un.

Voici un Unix portable ( en utilisant grepet sed) une doublure qui renvoie la chaîne de version d'un paquet NPM globalement installé (retirer les gde -pgrecherche de paquetages locaux à la place):

$ npm ll -pg --depth=0 grunt | grep -o "@.*:" | sed 's/.$//; s/^.//'
0.4.5

• les npm llsorties une chaîne analysable en forme comme: /usr/lib/node_modules/npm:npm@2.14.8:;
• la grepcommande extrait la valeur entre @et :, inclusivement;
• la sedcommande supprime les personnages environnants.

J'ai ajouté ceci à mon .bashrc

function npmv {
    case $# in # number of arguments passed
    0) v="$(npm -v)" ; #store output from npm -v in variable
        echo "NPM version is: $v"; #can't use single quotes 
                                   #${v} would also work
    ;;   
    1) s="$(npm list --depth=0 $1 | grep $1 | cut -d @ -f 2)";
       echo "$s";
    ;;
    2) case "$2" in # second argument
        g) #global|#Syntax to compare bash string to literal
             s="$(npm list --depth=0 -g $1 | grep $1 | cut -d @ -f 2)";
        echo "$s";
        ;;
        l) #latest
             npm view $1 version; #npm info $1 version does same thing
       ;;
       *) echo 'Invalid arguments';
       ;;
       esac;
    ;;
    *) echo 'Invalid arguments';
    ;;
    esac;
}
export -f npmv

Il ne me reste plus qu'à taper:

• npmv pour la version de npm par exemple:NPM version is: 4.2.0
• npmv <package-name> pour la version locale, par exemple:0.8.08
• npmv <package-name> g pour la version globale, par exemple:0.8.09
• npmv <package-name> l pour la dernière version, par exemple:0.8.10

Remarque -d sur la commande de coupe signifie délimiter par, suivi de @, puis f signifie champ le 2 signifie deuxième champ car il y aura un côté ou l'autre du symbole @.

Vous pouvez essayer ceci: npm show {package} versionaffiche la dernière version du package. Et si votre package est obsolète, npm outdatedl'affichera avec les informations de version.

C'est une question simple, et devrait avoir une réponse plus simple que ce que je vois ci-dessus.

Pour voir les packages npm installés avec leur version, la commande est npm ls --depth=0, qui, par défaut, affiche ce qui est installé localement. Pour voir les paquets installés globalement, ajoutez l' -globalargument: npm ls --depth=0 -global.

--depth=0 renvoie une liste des packages installés sans leurs dépendances, ce que vous souhaitez faire la plupart du temps.

lsest le nom de la commande et list est un alias pour ls.

Accéder au package.json

Vous pouvez accéder au package.jsonou bower.jsondu package avec:

notepad ./node_modules/:packageName/package.json

Cela ouvrira le package.jsondans notepadlequel a le version numberdu :packageNamevous inclus dans le command.

Par exemple :

notepad ./node_modules/vue-template-compiler/package.json

Bonne chance.

Nous pouvons utiliser npm view any-promise (le nom de votre module) -v

npm list package-name donne la version actuellement installée

Son très simple..Type juste en dessous de la ligne

npm view < package-name > version

** Exemple **

npm view redux version

J'ai la version 7.2.0 de redux