Como encontrar a versão de um pacote node.js / npm instalado ?

Isso imprime a versão do próprio npm:

npm -v <package-name>

Isso imprime um erro enigmático:

npm version <package-name>

Isso imprime a versão do pacote no registro (ou seja, a versão mais recente disponível):

npm view <package-name> version

Como obtenho a versão instalada ?

npm listpara pacotes locais ou npm list -gpara pacotes instalados globalmente.

Você pode encontrar a versão de um pacote específico, passando seu nome como argumento. Por exemplo, npm list gruntresultará em:

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

Como alternativa, você pode simplesmente executar npm listsem passar um nome de pacote como argumento para ver as versões de todos os seus pacotes:

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

Você também pode adicionar --depth=0argumento para listar pacotes instalados sem suas dependências.

Outra maneira rápida de descobrir quais pacotes estão instalados localmente e sem suas dependências é usar:

npm list --depth=0

O que lhe dá algo como

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

Obviamente, o mesmo pode ser feito globalmente npm list -g --depth=0.

Este método é mais claro caso você tenha instalado muitos pacotes.

Para descobrir quais pacotes precisam ser atualizados, você pode usar npm outdated -g --depth=0.

npm view <package> version - retorna a versão mais recente disponível no pacote.

npm list --depth=0 - retorna versões de todos os módulos instalados sem dependências.

npm list - retorna versões de todos os módulos e dependências.

E, finalmente, para obter a versão do nó: node -v

npm info YOUR_PACKAGE version

por exemplo

npm info grunt version
0.4.5

Eu apenas usei

npm list | grep <package name>

e funcionou muito bem

No Windows, execute:

npm list | find <package name>

No PowerShell, execute:

npm list | sls <package name>

Na raiz do pacote, faça:

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

EDIT : (então você precisa cdentrar no diretório inicial do módulo, se ainda não estiver lá. Se você instalou o módulo npm install, ele estará em node_modules/<module_name>)

EDIT 2 : atualizado conforme resposta de @ jeff-dickey

Para pacotes locais

npm list --depth=0

Para pacotes globais

npm list  -g --depth=0

Combinar algumas das respostas acima e produzir uma pesquisa super simples e super rápida.
Execute a partir da raiz do projeto. Não é necessário cdentrar em nenhuma pasta, apenas 1 linha:

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

Você também pode verificar a versão com este comando:

npm info <package name> version

Se você concordar em instalar o jq , poderá usar a saída JSON de npm list.

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

ou, se você quiser ser detalhado

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

Por exemplo:

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

Além disso, o formato JSON é um pouco diferente para pacotes globais, portanto, você precisará alterar a consulta.

Por exemplo:

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

Se você for corajoso o suficiente (e tiver nodeinstalado), sempre poderá fazer algo como:

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

Isso imprimirá a versão do pacote atual. Você também pode modificá-lo para ficar louco, assim:

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

Isso imprimirá a versão do WHATEVER_PACKAGE_NAMEpacote, vista por npm version.

Para ver todos os pacotes instalados local ou globalmente, use estes comandos:

1. npm listpara pacotes locais ou npm list -gpara pacotes instalados globalmente.
2. npm list --depth=0
3. npm list | sls <package name>
4. node -v

Tente com:

npm list --depth 1 --global packagename

Eu construí uma ferramenta que faz exatamente isso - qnm

qnm - Um utilitário CLI simples para consultar o node_modulesdiretório.

Instale-o usando:

npm i --global qnm

e corra:

qnm [module]

por exemplo:

> qnm lodash

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

Que significa que temos lodashinstalado na raiz do node_modulese duas outras cópias nos node_modulesde cli-table2e karma.

É muito rápido e possui alguns recursos interessantes, como a conclusão de guias e a pesquisa por correspondência.

Para listar pacotes locais com o número da versão, use:

npm ls --depth=0

Para listar pacotes globais com o número da versão, use:

npm ls -g --depth=0

Você pode usar a versão do npm view [module] , a versão do npm info [module] , a versão do npm show [module] ou a versão do npm v [module] para verificar a versão em um módulo npm instalado.

Vamos supor que a versão do meu módulo grunt seja a 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 é o comando que mostra todas as bibliotecas com versão, mas você pode usar npm-check

O npm-check é uma boa biblioteca para gerenciar todas as coisas relacionadas ao evento do sistema de versões. Ele mostrará versões de bibliotecas, atualização de nova versão e versão não utilizada e muito mais.

para instalá-lo basta executar

npm install -g npm-check

e simplesmente corra

npm-check

verifique a captura de tela que está mostrando tudo sobre a versão do pacote, a nova atualização e a versão não utilizada.

Também funciona globalmente. De uma chance. Espero que isso ajude alguém.

Aqui está um Unix portátil (usando grepe sed) uma linha que retorna a string de versão de um pacote npm instalado globalmente (remova o gde -pgpara consultar os pacotes locais):

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

• as npm llsaídas de uma corda parseable formatados como: /usr/lib/node_modules/npm:npm@2.14.8:;
• o grepcomando extrai o valor entre @e :, inclusive;
• o sedcomando remove os caracteres ao redor.

Adicionei isso ao meu .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

Agora tudo o que tenho a fazer é digitar:

• npmv para a versão do npm, por exemplo:NPM version is: 4.2.0
• npmv <nome do pacote> para a versão local, por exemplo:0.8.08
• npmv <nome do pacote> g para a versão global, por exemplo:0.8.09
• npmv <nome do pacote> l para a versão mais recente, por exemplo:0.8.10

Nota -d no comando de corte significa delimitar por, seguido de @, então f significa campo o 2 significa o segundo campo, pois haverá um dos lados do símbolo @.

Você pode tentar o seguinte: npm show {package} versionmostra a versão mais recente do pacote. E se o seu pacote estiver desatualizado, ele npm outdatedserá exibido com informações da versão.

Esta é uma pergunta simples e deve ter uma resposta mais simples do que a que vejo acima.

Para ver os pacotes npm instalados com sua versão, o comando é npm ls --depth=0, que, por padrão, exibe o que está instalado localmente. Para ver os pacotes instalados globalmente, adicione o -globalargumento: npm ls --depth=0 -global.

--depth=0 retorna uma lista de pacotes instalados sem suas dependências, que é o que você deseja fazer na maioria das vezes.

lsé o nome do comando e list é um alias para ls.

Acesse o package.json

Você pode acessar o package.jsonou bower.jsondo pacote com:

notepad ./node_modules/:packageName/package.json

Isso abrirá o package.jsonarquivo notepadque contém version numbero :packageNamearquivo incluído no arquivo command.

Por exemplo :

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

Boa sorte.

Podemos usar o npm view any-promessa (o nome do seu módulo) -v

npm list package-name fornece a versão atualmente instalada

É muito simples .. Basta digitar abaixo da linha

npm view < package-name > version

** Exemplo **

npm view redux version

Eu tenho a versão 7.2.0 do redux