Como faço para atualizar cada dependência em package.json para a versão mais recente?

Copiei package.json de outro projeto e agora quero aumentar todas as dependencies de suas versões mais recentes, já que este é um projeto novo e não me importo de consertar algo se ele quebrar.

Qual é a maneira mais fácil de fazer isso?

A melhor maneira que eu conheço agora é rodar npm info express version e atualizar package.json manualmente para cada um. Deve haver um caminho melhor.

 { "name": "myproject", "description": "my node project", "version": "1.0.0", "engines": { "node": "0.8.4", "npm": "1.1.65" }, "private": true, "dependencies": { "express": "~3.0.3", // how do I get these bumped to latest? "mongodb": "~1.2.5", "underscore": "~1.4.2", "rjs": "~2.9.0", "jade": "~0.27.2", "async": "~0.1.22" } } 

Agora sou colaborador do npm-check-updates , que é uma ótima solução para esse problema.

Parece que o npm-check-updates é a única maneira de fazer isso acontecer agora.

 npm i -g npm-check-updates ncu -u npm install 

Na npm <3.11:

Simplesmente mude a versão de cada dependência para * , então execute npm update --save . ( Nota: quebrado em versões recentes (3.11) do npm ).

Antes:

  "dependencies": { "express": "*", "mongodb": "*", "underscore": "*", "rjs": "*", "jade": "*", "async": "*" } 

Depois de:

  "dependencies": { "express": "~3.2.0", "mongodb": "~1.2.14", "underscore": "~1.4.4", "rjs": "~2.10.0", "jade": "~0.29.0", "async": "~0.2.7" } 

Claro, este é o martelo contundente de atualização de dependencies. Tudo bem se – como você disse – o projeto está vazio e nada pode quebrar.

Por outro lado, se você estiver trabalhando em um projeto mais maduro, provavelmente desejará verificar se não há alterações significativas em suas dependencies antes da atualização.

Para ver quais módulos estão desatualizados, apenas execute npm outdated . Ele listará todas as dependencies instaladas que tiverem versões mais recentes disponíveis.

npm-check-updates é um utilitário que ajusta automaticamente um pacote.json com a versão mais recente de todas as dependencies

veja https://www.npmjs.org/package/npm-check-updates

 $ npm install -g npm-check-updates $ ncu -u $ npm install 

TLDR; (atualizado para versões mais recentes do NPM)

As coisas mudaram um pouco desde que essas respostas foram originalmente escritas.

npm 2+: npm outdated + npm update + npm shrinkwrap

NPM mais antigo: npm-check-updates + npm shrinkwrap

Certifique-se de encolher seus deps, ou você pode acabar com um projeto morto. Eu retirei um projeto no outro dia e não funcionaria porque meus deps estavam desatualizados / atualizados / bagunçados. Se eu tivesse encolhido, o npm teria instalado exatamente o que eu precisava.


Detalhes

Para os curiosos que chegam até aqui, aqui está o que eu recomendo:

Use npm-check-updates ou npm outdated para sugerir as versões mais recentes.

 # `outdated` is part of newer npm versions (2+) $ npm outdated # If you agree, update. $ npm update # OR # Install and use the `npm-check-updates` package. $ npm install -g npm-check-updates # Then check your project $ npm-check-updates # If you agree, update package.json. $ npm-check-updates -u 

Então faça uma instalação limpa (sem o rm eu recebi alguns avisos de dependência)

 $ rm -rf node_modules $ npm install 

Por fim, salve as versões exatas para npm-shrinkwrap.json npm shrinkwrap com npm shrinkwrap

 $ rm npm-shrinkwrap.json $ npm shrinkwrap 

Agora, o npm install agora usará as versões exatas em npm-shrinkwrap.json

Se você marcar npm-shrinkwrap.json no git, todas as instalações usarão exatamente as mesmas versões.

Esta é uma maneira de fazer a transição do desenvolvimento (todas as atualizações, o tempo todo) para a produção (ninguém toca em nada).

  • npm desatualizado

  • npm-check-updates

  • npm shrinkwrap

Para atualizar uma dependência para sua versão mais recente sem precisar abrir manualmente o package.json e alterá-la, você pode executar

 npm install {package-name}@* {save flags?} 

ou seja

 npm install express@* --save 

Para referência, npm-install


Conforme observado pelo usuário Vespakoen em uma edição rejeitada, também é possível atualizar vários pacotes de uma só vez dessa maneira:

 npm install --save package-nave@* other-package@* whatever-thing@* 

Ele também apporta um one-liner para o shell baseado em npm outdated . Veja a edição do código e explicação.


PS: Eu também odeio ter que editar manualmente package.json para coisas assim;)

Se você estiver usando o Visual Studio Code como seu IDE, essa é uma pequena extensão divertida para tornar a atualização package.json um processo de um clique.

Versão Lense

insira a descrição da imagem aqui

Isso funciona a partir do npm 1.3.15.

 "dependencies": { "foo": "latest" } 
  1. Use * como a versão dos últimos lançamentos, incluindo instável
  2. Use o latest como definição de versão para a versão estável mais recente
  3. Modifique o pacote.json com exatamente o último número de versão estável usando LatestStablePackages

Aqui está um exemplo:

 "dependencies": { "express": "latest" // using the latest STABLE version , "node-gyp": "latest" , "jade": "latest" , "mongoose": "*" // using the newest version, may involve the unstable releases , "cookie-parser": "latest" , "express-session": "latest" , "body-parser": "latest" , "nodemailer":"latest" , "validator": "latest" , "bcrypt": "latest" , "formidable": "latest" , "path": "latest" , "fs-extra": "latest" , "moment": "latest" , "express-device": "latest" }, 

A única ressalva que eu encontrei com a melhor resposta acima é que ele atualiza os módulos para a versão mais recente. Isso significa que pode atualizar para uma construção alfa instável.

Eu usaria esse utilitário npm-check-updates. Meu grupo usou essa ferramenta e funcionou efetivamente instalando as atualizações estáveis.

Como Etienne afirmou acima: instale e execute com isto:

 $ npm install -g npm-check-updates $ npm-check-updates -u $ npm install 

Para ver quais pacotes têm versões mais novas disponíveis, use o seguinte comando:

 npm outdated 

Para atualizar apenas uma dependência, use o seguinte comando:

 npm install yourPackage@latest --save 

Por exemplo:

Meu arquivo package.json tem dependência:

 "@progress/kendo-angular-dateinputs": "^1.3.1", 

então eu deveria escrever:

 npm install @progress/kendo-angular-dateinputs@latest --save 

Aqui está um regex básico para combinar números de versão semântica, para que você possa substituí-los rapidamente por um asterisco.

Versão semântica Regex

 ([>|< |=|~|^|\s])*?(\d+\.)?(\d+\.)?(\*|\d+) 

Como usar

Selecione as versões do pacote que você deseja replace no arquivo JSON.

captura de tela: selecione o texto que você deseja substituir

Insira o regex acima e verifique se ele está correspondendo ao texto correto.

captura de tela: insira o regex semver acima

Substitua todas as correspondências por um asterisco.

captura de tela: substitua as versões do pacote por um asterisco

Executar npm update --save

Eu realmente gosto de como funciona o npm-upgrade . É um utilitário de linha de comando simples que passa por todas as suas dependencies e permite que você veja a versão atual em comparação com a versão mais recente e atualize-a se desejar.

Aqui está uma captura de canvas do que acontece depois de executar o npm-upgrade na raiz do seu projeto (ao lado do arquivo package.json ):

exemplo de upgrade npm

Para cada dependência, você pode escolher atualizar, ignorar, visualizar o changelog ou finalizar o processo. Tem funcionado muito bem para mim até agora.

Eu recentemente tive que atualizar vários projetos que estavam usando npm e package.json para a magia gruntfile.js. O seguinte comando bash (comando multiline) funcionou bem para mim:

 npm outdated --json --depth=0 | \ jq --ascii-output --monochrome-output '. | keys | .[]' | \ xargs npm install $1 --save-dev 

A idéia aqui: Para canalizar a saída npm outdated como json, para jq
(jq é uma ferramenta parser / query da linha de comando json)
(observe o uso do argumento npm outdated para npm outdated )
jq irá remover a saída apenas para o nome do pacote de nível superior.
finalmente xargs coloca cada LIBRARYNAME um de cada vez em um npm install LIBRARYNAME --save-dev

O acima é o que funcionou para mim em uma máquina rodando: node = v0.11.10 osx = 10.9.2 npm = 1.3.24

isso é necessário:
xargs http://en.wikipedia.org/wiki/Xargs (nativo da minha máquina eu acredito)
e
jq http://stedolan.github.io/jq/ (eu instalei com brew install jq )

Nota: Eu só devDependancies as bibliotecas atualizadas em package.json dentro da chave json devDependancies usando --save-dev , que era uma exigência dos meus projetos, bem possível não sua.

Depois eu verifico que tudo é molho com um simples

 npm outdated --depth=0 

Além disso, você pode verificar as versões atuais da biblioteca instalada de nível superior

 npm list --depth=0 

Updtr!

Com base no npm desatualizado, o updtr instala a versão mais recente e executa o teste npm para cada dependência. Se o teste for bem-sucedido, o updtr salvará o novo número da versão em seu pacote.json. Se o teste falhar, no entanto, updtr reverterá suas alterações.

https://github.com/peerigon/updtr

Eu uso o npm-check para arquivar isso.

 npm i -g npm npm-check npm-check -ug #to update globals npm-check -u #to update locals 

insira a descrição da imagem aqui

Outra lista de comandos útil que manterá os números exatos da versão em package.json

 npm cache clean rm -rf node_modules/ npm i -g npm npm-check-updates ncu -g #update globals ncu -ua #update locals npm i 

Comandos que eu tive que usar para atualizar o package.json para o NPM 3.10.10 :

 npm install -g npm-check-updates ncu -a npm install 

Fundo:

Eu estava usando o último comando de @ josh3736 mas meu pacote.json não foi atualizado. Então notei o texto da descrição ao executar o npm-check-updates -u :

A dependência a seguir é satisfeita pelo seu intervalo de versão declarado, mas a versão instalada está por trás. Você pode instalar a versão mais recente sem modificar seu arquivo de pacote usando a atualização do npm. Se você quiser atualizar a dependência no seu arquivo de pacote, execute ncu -a.

Lendo a documentação do npm-check-updates você pode ver a diferença:

https://www.npmjs.com/package/npm-check-updates

-u, –upgrade: sobrescreve o arquivo do pacote

-a, –upgradeAll: inclui até mesmo as dependencies cuja versão mais recente satisfaz a dependência de semver declarada

O ncu é um alias para npm-check-updates conforme visto na mensagem ao digitar npm-check-updates -u :

 [INFO]: You can also use ncu as an alias 

Uma resposta muito tardia. mas pode ajudar alguém.

esse recurso foi introduzido no npm v5 . atualizar para npm usando npm install -g npm@latest e

atualizar o package.json

  1. delete /node_modules e package-lock.json (if you have any)

  2. execute a npm update . isto irá atualizar o package.json para a última versão com dependencies instaladas.

para atualizar para a versão mais recente. você pode ir com npm-check-updates

O Ncu é um novo alias para verificar atualizações. Ao fazer isso você não precisa atualizar manualmente os números de versão do ur em package.json ncu faz isso para você. Siga o método abaixo se você estiver em uma máquina Linux

 sudo npm i -g npm-check-updates // decide between -u or -a ncu -u, --upgrade and overwrite package file ncu -a, --upgradeAll include even those dependencies whose latest version satisfies the declared server dependency sudo npm install 

Os comandos acima são inseguros porque você pode quebrar seu módulo ao trocar de versão. Em vez disso eu recomendo o seguinte

  • Defina a versão atual dos módulos do nó atual no npm shrinkwrap usando o comando npm shrinkwrap .
  • Atualize cada dependência para a versão mais recente SE NÃO QUEBRAR SEUS TESTES usando a ferramenta de linha de comando https://github.com/bahmutov/next-update
 npm install -g next-update
 // do seu pacote
 próxima atualização

Se você estiver usando o yarn , o yarn upgrade-interactive é uma ferramenta realmente elegante que pode permitir que você visualize suas dependencies desatualizadas e, em seguida, selecione quais você deseja atualizar.

Mais razões para usar o Yarn over npm . Heh

Um passo fácil:

 $ npm install -g npm-check-updates && ncu -a && npm i 

Tente seguir o comando se você estiver usando o npm 5 e o nó 8

npm update –save

Alternativa é

 "dependencies":{ "foo" : ">=1.4.5" } 

toda vez que você usar a atualização npm, ela será atualizada automaticamente para a versão mais recente. Para mais syntax de versão, você pode verificar aqui: https://www.npmjs.org/doc/misc/semver.html

Solução sem pacotes adicionais

Altere a versão de cada dependência para * :

 "dependencies": { "react": "*", "react-google-maps": "*" } 

Em seguida, execute npm update --save .

Alguns de seus pacotes foram atualizados, mas outros não?

 "dependencies": { "react": "^15.0.1", "react-google-maps": "*" } 

Esta é a parte complicada, significa que sua versão local de “reagir” foi menor que a mais nova. Neste caso, npm baixou e atualizou o pacote “react”. No entanto, sua versão local de “react-google-maps” é a mesma que a mais nova.

Se você ainda quiser “atualizar” inalterado * , terá que excluir esses módulos da pasta node_modules .

Por exemplo, delete node_modules/react-google-maps .

Finalmente execute novamente npm update --save .

 "dependencies": { "react": "^15.0.1", "react-google-maps": "^4.10.1" } 

Não se esqueça de executar o npm update --save-dev se você quiser atualizar dependencies de desenvolvimento.

  • npm desatualizado
  • atualização npm

Deve obter as últimas versões desejadas compatíveis para o seu aplicativo. Mas não as versões mais recentes.

Isto é o que eu fiz para atualizar todas as dependencies em package.json para o mais recente:

 npm install -g npm-check-updates ncu -u --packageFile package.json 

Greenkeeper se você estiver usando o Github. https://greenkeeper.io/

É uma integração do Github e incrivelmente fácil de configurar as coisas. Quando instalado, ele cria automaticamente solicitações pull em repositorys que você especifica (ou todos, se desejado) e mantém seu código sempre atualizado, sem forçá-lo a fazer nada manualmente. Os PRs devem então desencadear uma compilation em um serviço de IC e, dependendo de uma verificação bem-sucedida ou com falha, você pode continuar tentando descobrir o que está provocando o problema ou quando o IC passa simplesmente mesclar o PR.

greenkeeper PR 1 greenkeeper PR 2

Na parte inferior, você pode ver que a primeira compilation falhou no início e após uma confirmação (“atualizar para o nó v6.9”) os testes foram aprovados para que eu pudesse mesclar o PR. Vem com muito emoji também.

Outra alternativa seria https://dependencyci.com/ , no entanto não testei intensivamente. Depois de um primeiro olhar, Greenkeeper parece melhor em geral e tem melhor integração.

O código a seguir (que foi aceito) me escreveu algo como “demora muito blá-blá” e não fez nada. Provavelmente, usando a bandeira global foi o problema, idk.

 npm i -g npm-check-updates ncu -u npm install 

Eu decidi usar meu editor de texto e seguir uma abordagem semi-manual.

Eu copiei uma lista como esta (apenas muito mais) das dependencies dev do meu package.json para o editor de texto do notepad ++:

 "browserify": "10.2.6", "expect.js": "^0.3.1", "karma": "^0.13.22", "karma-browserify": "^5.2.0", 

Defina o modo de pesquisa para expressão regular, usei o padrão ^\s*"([^"]+)".*$ Para obter o nome do pacote e o substitui por npm uninstall \1 --save-dev \nnpm install \1 --save-dev Clicou em “replace all”. O resultado foi este:

 npm uninstall browserify --save-dev npm install browserify --save-dev npm uninstall expect.js --save-dev npm install expect.js --save-dev npm uninstall karma --save-dev npm install karma --save-dev npm uninstall karma-browserify --save-dev npm install karma-browserify --save-dev 

Eu copiei de volta para bater e aperte enter. Tudo foi atualizado e funcionando bem. Isso é tudo.

 "browserify": "^16.1.0", "expect.js": "^0.3.1", "karma": "^2.0.0", "karma-browserify": "^5.2.0", 

Eu não acho que é um grande negócio, já que você tem que fazê-lo apenas de vez em quando, mas você pode facilmente escrever um script, que analisa o package.json e atualiza seus pacotes. Eu acho que é melhor assim, porque você pode editar sua lista se precisar de algo especial, por exemplo, mantendo a versão atual de um lib.

Se você usar fio, o seguinte comando atualizará todos os pacotes para a versão mais recente:

yarn upgrade --latest

De seus documentos :

O upgrade --latest comando mais upgrade --latest atualiza os pacotes da mesma forma que o comando upgrade, mas ignora o intervalo de versões especificado em package.json. Em vez disso, a versão especificada pela tag mais recente será usada (possivelmente atualizando os pacotes nas principais versões).

Eu resolvi isso vendo as instruções de https://github.com/tjunnone/npm-check-updates

 $ npm install -g npm-check-updates $ ncu $ ncu -u # to update all the dependencies to latest $ ncu -u "specific module name" #in case you want to update specific dependencies to latest 

npm-check-updates

https://www.npmjs.com/package/npm-check-updates

O npm-check-updates permite que você atualize suas dependencies do package.json para as versões mais recentes, independentemente das restrições de versão existentes.

 $ npm install -g npm-check-updates $ ncu -u 

dependencies atualizadas! Isso é tudo!