Come trovare la versione di un pacchetto node.js / npm installato ?

Questo stampa la versione stessa di npm:

npm -v <package-name>

Questo stampa un errore criptico:

npm version <package-name>

Questo stampa la versione del pacchetto sul registro (ovvero l'ultima versione disponibile):

npm view <package-name> version

Come ottengo la versione installata ?

npm listper pacchetti locali o npm list -gper pacchetti installati a livello globale.

Puoi trovare la versione di un pacchetto specifico passando il suo nome come argomento. Ad esempio, npm list gruntcomporterà:

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

In alternativa, puoi semplicemente eseguire npm listsenza passare il nome di un pacchetto come argomento per vedere le versioni di tutti i tuoi pacchetti:

├─┬ 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 

È inoltre possibile aggiungere --depth=0argomenti per elencare i pacchetti installati senza le relative dipendenze.

Un altro modo rapido per scoprire quali pacchetti sono installati localmente e senza le loro dipendenze è usare:

npm list --depth=0

Che ti dà qualcosa di simile

├── 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

Ovviamente, lo stesso può essere fatto a livello globale con npm list -g --depth=0.

Questo metodo è più chiaro nel caso in cui siano stati installati molti pacchetti.

Per scoprire quali pacchetti devono essere aggiornati, è possibile utilizzare npm outdated -g --depth=0.

npm view <package> version - restituisce l'ultima versione disponibile sul pacchetto.

npm list --depth=0 - restituisce le versioni di tutti i moduli installati senza dipendenze.

npm list - restituisce le versioni di tutti i moduli e le dipendenze.

E infine per ottenere la versione del nodo: node -v

npm info YOUR_PACKAGE version

per esempio

npm info grunt version
0.4.5

Ho appena usato

npm list | grep <package name>

e ha funzionato alla grande

Su Windows Run:

npm list | find <package name>

In esecuzione PowerShell:

npm list | sls <package name>

Dalla radice del pacchetto fai:

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

EDIT : (quindi è necessario cdaccedere alla home directory del modulo se non si è già lì. Se si è installato il modulo con npm install, allora sarà sotto node_modules/<module_name>)

EDIT 2 : aggiornato secondo la risposta di @ jeff-dickey

Per i pacchetti locali

npm list --depth=0

Per i pacchetti globali

npm list  -g --depth=0

Combinando alcune delle risposte di cui sopra e produce una ricerca super semplice e super veloce.
Esegui dalla radice del progetto. Non c'è bisogno di accedere a cdnessuna cartella, solo 1 riga:

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

Puoi anche controllare la versione con questo comando:

npm info <package name> version

Se si accetta di installare jq , è possibile utilizzare l'output JSON di npm list.

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

o, se vuoi essere prolisso

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

Per esempio:

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

Inoltre, il formato JSON è leggermente diverso per i pacchetti globali, quindi dovrai cambiare la query.

Per esempio:

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

Se sei abbastanza coraggioso (e hai nodeinstallato), puoi sempre fare qualcosa del tipo:

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

Questo stamperà la versione del pacchetto corrente. Puoi anche modificarlo per diventare pazzo, in questo modo:

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

Che stamperà la versione del WHATEVER_PACKAGE_NAMEpacchetto, che è visto da npm version.

Per vedere tutti i pacchetti installati localmente o globalmente, usare questi comandi:

1. npm listper pacchetti locali o npm list -gper pacchetti installati a livello globale.
2. npm list --depth=0
3. npm list | sls <package name>
4. node -v

Prova con:

npm list --depth 1 --global packagename

Ho creato uno strumento che fa esattamente questo: qnm

qnm - Una semplice utility CLI per l'interrogazione della node_modulesdirectory.

Installalo usando:

npm i --global qnm

e corri:

qnm [module]

per esempio:

> qnm lodash

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

Ciò significa che abbiamo lodashinstallato nella radice di node_modulese altre due copie in node_modulesdi cli-table2e karma.

È davvero veloce e ha alcune belle funzioni come il completamento delle schede e la ricerca delle corrispondenze.

Per elencare i pacchetti locali con il numero di versione usare:

npm ls --depth=0

Per elencare i pacchetti globali con il numero di versione usare:

npm ls -g --depth=0

È possibile utilizzare vista NPM versione [modulo] , informazioni NPM versione [modulo] , spettacolo NPM versione [modulo] o v NPM versione [modulo] per verificare la versione su un modulo NPM installato.

Supponiamo che la mia versione del modulo grunt sia 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 è il comando che mostra tutte le librerie con versione ma che puoi usare npm-check

npm-check è una buona libreria per gestire tutte quelle cose riguardanti l'evento del sistema versione che mostrerà le versioni delle librerie, l'aggiornamento di una nuova versione, la versione inutilizzata e molte altre.

per installarlo basta eseguire

npm install -g npm-check

e semplicemente corri

npm-check

controlla lo screenshot che mostra tutto sulla versione del pacchetto, l'aggiornamento della nuova versione e la versione inutilizzata.

Funziona anche a livello globale. Provaci. Spero che questo aiuti qualcuno.

Ecco un portatile Unix (using grepe sed) one-liner che restituisce la stringa di versione di un pacchetto npm installato globalmente (rimuovi invece il gda -pgper interrogare i pacchetti locali):

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

• le npm lluscite una stringa parseable formattato come: /usr/lib/node_modules/npm:npm@2.14.8:;
• il grepcomando estrae il valore tra @e :, compreso;
• il sedcomando rimuove i caratteri circostanti.

Ho aggiunto questo al mio .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

Ora tutto ciò che devo fare è digitare:

• npmv per la versione di npm ad es .:NPM version is: 4.2.0
• npmv <nome-pacchetto> per la versione locale, ad esempio:0.8.08
• npmv <nome-pacchetto> g per versione globale ad es .:0.8.09
• npmv <nome-pacchetto> l per l'ultima versione, ad es .:0.8.10

Nota -d sul comando di taglio significa delimitare da, seguito da @, quindi f indica il campo 2 significa il secondo campo poiché ci sarà uno dei due lati del simbolo @.

Puoi provare questo: npm show {package} versionmostra l'ultima versione del pacchetto. E se il tuo pacchetto è obsoleto, npm outdatedlo mostrerà con le informazioni sulla versione.

Questa è una domanda semplice e dovrebbe avere una risposta più semplice di quella che vedo sopra.

Per vedere i pacchetti npm installati con la loro versione, il comando è npm ls --depth=0, che, per impostazione predefinita, visualizza ciò che è installato localmente. Per visualizzare i pacchetti installati a livello globale, aggiungere l' -globalargomento: npm ls --depth=0 -global.

--depth=0 restituisce un elenco di pacchetti installati senza le relative dipendenze, che è ciò che si desidera fare la maggior parte delle volte.

lsè il nome del comando ed list è un alias perls .

Accedi al package.json

Puoi accedere al package.jsono bower.jsondel pacchetto con:

notepad ./node_modules/:packageName/package.json

Questo aprirà il package.jsonin notepadcui ha il version numberdi :packageNamete incluso nelcommand .

Per esempio :

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

In bocca al lupo.

Possiamo usare npm view any-promise (il nome del tuo modulo) -v

npm list nome-pacchetto fornisce la versione attualmente installata

È molto semplice ... basta digitare sotto la riga

npm view < package-name > version

** Esempio **

npm view redux version

Ho la versione 7.2.0 di Redux