Como atualizo cada dependência no package.json para a versão mais recente?

2012

Copiei o package.json de outro projeto e agora quero adicionar todas as dependências às suas versões mais recentes, pois esse é um projeto novo e não me importo de consertar algo se quebrar.

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

A melhor maneira que conheço agora é executar npm info express versione atualizar o package.json manualmente para cada um. Deve haver uma maneira 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"
  }
}

ATUALIZAÇÃO 5/1/19 : Seis anos depois, eu continuo mantendo o npm-check-updates como uma solução abrangente para esse problema. Aproveitar!

Raine Revere
fonte
2
É bom ver outra abordagem para esse problema. Eu realmente gosto da produção de Salita. Alguns recursos interessantes para os quais a ferramenta que eu contribuo agora, github.com/tjunnone/npm-check-updates, são a preservação da semântica de versão (como 1.x ou> 2.1.0) e a filtragem por nome / regex / devDeps-only.
Raine Revere
1
NECESSIDADE de haver respostas melhores aqui. Obviamente, com a resolução de dependências, você nem sempre pode ter a versão mais recente de tudo. Maximizar o maior número de versões mais recentes dos módulos é apenas isso, algum tipo de problema de otimização. Mas o NPM não sabe quais módulos você deseja que sejam mais recentes do que outros. Seria legal se houvesse algo assim: npm update --latest xyz, onde xyz são os módulos que você deseja que sejam os mais recentes possíveis e todos os outros módulos sigam com sua versão compatível mais recente.
Alexander Mills
2
O npm manipulará corretamente os conflitos de versão entre dependências compartilhadas baixando o correto para cada um. Portanto, se o Dep A depender do Dep C v1.0.0 e o Dep B depender do Dep C v2.0.0, cada um deles será instalado e usado adequadamente. Portanto, você é livre para instalar os pacotes mais recentes que desejar.
Raine Revere
Tente isso para forçar a atualização:npm outdated | sed '1d; s/ .*/@latest/' | xargs npm i --save
miorey 23/08/19
Estou sempre checando esta resposta. Mas vejo que ele caiu nos resultados do Google. Espero que este comentário ajude a aumentar sua relevância!
Zach Smith

Respostas:

2393

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

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

No npm <3.11:

Simplesmente altere a versão de todas as dependências para *e execute npm update --save. ( Nota: quebrada nas 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"
  }

Obviamente, este é o martelo direto da atualização de dependências. Tudo bem se - como você disse - o projeto estiver vazio e nada puder 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 dependências antes da atualização.

Para ver quais módulos estão desatualizados, basta executar npm outdated. Ele listará quaisquer dependências instaladas que tenham versões mais recentes disponíveis.

josh3736
fonte
13
@ thefourtheye: você geralmente não deve sair * no package.json, pois pode acabar instalando automaticamente uma nova versão do módulo com alterações que quebram o aplicativo. Como estamos usando --saveaqui, o *é substituído pela versão atual de cada pacote.
Josh3736
50
Não consigo fazer isso funcionar. Alguma coisa mudou com o npm desde que esta resposta foi publicada? Quando uso o curinga e npm install --saveo curinga é deixado no meu package.json.
Davidtheclark
15
Infelizmente, o uso updatetambém não funciona para mim. Ainda estou com os curingas. Existe alguma documentação sobre isso que você conheça ou quaisquer outros recursos que eu possa consultar?
Davidtheclark
120
Um pouco velho, mas isso pode ajudar outras pessoas: github.com/tjunnone/npm-check-updates | Use npm install -g npm-check-updatespara instalar e, em seguida, npm-check-updatesverifique se suas dependências possuem atualizações e npm-check-updates -upara atualizar as versões do package.json. Então é só npm installe ele fará o download de novas versões.
precisa saber é o seguinte
5
Seu problema provavelmente vem do fato de você tentar atualizar pacotes dev digitando em npm update --savevez de npm update --save-dev.
adriendenat 19/08/2014
1035

npm-check-updates é um utilitário que ajusta automaticamente um package.json à versão mais recente de todas as dependências

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

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

[EDIT] Uma maneira um pouco menos intrusiva (evita uma instalação global) de fazer isso se você tiver uma versão moderna do npmis:

$ npx npm-check-updates -u
$ npm install 
Etienne
fonte
135
Isso deve estar disponível nativamente através do próprio comando npm, na verdade a melhor solução até agora para atualizar as dependências.
Mohammad Arif
7
Deve fazer parte do npm nativamente, concordo plenamente. No entanto, não é e esta solução vem como uma brisa. Obrigado.
23414 Stefan
2
Presumo que vocês estão pressionando [HARD] para colocar isso no núcleo da NPM?
enorl76
3
@ Batman Sim, se você não instalou antes. Caso contrário, use npm update. O ncu apenas atualiza o package.json. Não instala nem atualiza 'node_modules'.
Muzaffer
1
pacote inútil, atualizando apenas parte dos pacotes com ncu -a, não atualizando o package.json também.
Alexander Kim
385

Atualizado para o NPM mais recente

npm 2+ (Nó 0,12+):


npm outdated
npm update
git commit package-lock.json

Npm antiga (por volta de 2014):

npm install -g npm-check-updates
npm-check-updates
npm shrinkwrap
git commit package-lock.json

Certifique-se de encolher os seus deps, ou você pode acabar com um projeto morto. Puxei um projeto outro dia e ele não funcionou porque meus departamentos estavam desatualizados / atualizados / uma bagunça. Se eu tivesse encolhido, o npm teria instalado exatamente o que eu precisava.


Detalhes

Para os curiosos que chegam até aqui, eis o que recomendo:

Use npm-check-updatesou npm outdatedpara 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

Em seguida, faça uma instalação limpa (sem a rm, recebi alguns avisos de dependência)

$ rm -rf node_modules
$ npm install 

Por fim, salve as versões exatas em npm-shrinkwrap.jsoncomnpm shrinkwrap

$ rm npm-shrinkwrap.json
$ npm shrinkwrap

Agora, npm installagora usaremos versões exatas emnpm-shrinkwrap.json

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

Essa é 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).

ps O Yarn está enviando sua lista de pacotes para o Facebook .

Michael Cole
fonte
13
esta é a resposta correta real. com dezenas de deps instalados, este é def uma maneira melhor
Angel S. Moreno
6
Por experiência, o conselho para sempre atualizar todos os pacotes de uma só vez pode ser perigoso.
314:
1
Com certeza. Se você criar e npm-shrinkwrap.jsonentrar no código-fonte e confirmar sempre que atualizar, poderá sempre 'voltar para onde estava'. Eu negligenciei o recurso shrinkwrap quando comecei.
Michael Cole
21
isso não responde à pergunta. A questão é como atualizar a versão mais recente. npm updateapenas atualizações para a versão semver, não a mais recente.
gman
1
Você pode responder se existe uma alternativa para yarn upgrade package@version?
Ben Sinclair
201

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

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

ie

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 ao mesmo tempo desta maneira:

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

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


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

laconbass
fonte
8
Esta solução é ótima. Maneira rápida e fácil de atualizar explicitamente um único pacote para a versão mais recente sem instalar novos módulos. Eu gosto do npm-check-updates, mas depois ele tenta manter todos os pacotes atualizados, o que nem sempre é o que você deseja.
03/15/18
isso não funciona para mimnpm install react-native-image-picker@* --save
Harry Moreno
1
@ Chev: ncu pode facilmente direcionar um ou vários pacotes com ncu express mocha chai. Você também pode excluir pacotes com ncu -x mocha. Concordo que o acima é a solução mais simples para atualizar um único pacote.
Raine Revere
2
Eu apenas usei algo semelhante que trabalhou, a partir de docs possivelmente mais recentes ... usos "mais recente" em vez de "*"npm install {package-name}@latest {save flags}
de Drew Thomas
1
Muito obrigado, esta solução é ótima e exatamente o que estou procurando. Ele permite que você atualize um pacote específico sem a necessidade de atualizar todas as outras dependências, o que pode levar a problemas imprevistos!
Dany Wehbe
90

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

Version Lens

insira a descrição da imagem aqui

GollyJer
fonte
2
Há uma versão sublime do texto 3 aqui: github.com/yavorsky/Bump , embora um pouco lenta.
Alexander Kim
4
Funcionou lindamente, caso não esteja claro para ninguém, isso simplesmente verifica as versões do seu package.json com relação às versões mais recentes do repositório npm e permite que você clique em uma versão para atualizar o conteúdo do texto no package.json. Você precisa executar o "npm update" para informar ao npm para instalar as novas versões.
MattG
2
Observe que já é possível ver a versão mais recente das dependências do pacote com uma breve descrição no código do Visual Studio
interno
1
Observe que ele não instala pacotes automaticamente ao clicar em um link de lente de código! Ele simplesmente atualiza o texto da versão package.json.
RA.
59

Isso funciona a partir da NPM 1.3.15.

"dependencies": {
  "foo": "latest"
}
Tobiasz Cudnik
fonte
10
Bom saber. Meu palpite é que isso geralmente seria uma prática ruim em qualquer site de produção, pois será atualizado automaticamente para versões potencialmente incompatíveis com versões anteriores. As '~ 2' sintaxe fechamentos você em um determinado número de versão principal, que segue semver vai ser compatível.
Raine Revere
1
Você sempre pode congelar os deps no prod. Há um comando para isso. -2 parece ok.
Tobiasz Cudnik 20/02
5
Eu gosto de usar isso junto com npm shrinkwrappara congelar deps.
Daniellmb
Se fizermos isso, como saberemos a versão real desse pacote? Digamos que eu tenha chamado uma entrada "react": "16.9.0"e, em seguida, adicionei a mais recente e executei npm i; depois disso, como localizo qual versão do react está agora no meu projeto? desde "react":"latest"que é o que resta no meu package.json, não um número mesmo depois que eu fiznpm i
theprogrammer
52
  1. Use *como a versão para as versões mais recentes, incluindo instável
  2. Use latestcomo definição de versão para a versão estável mais recente
  3. Modifique o package.json com exatamente o número da versão estável mais recente 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"
},
Mr. Sun Lin
fonte
2
Esta é a melhor resposta.
Peza
1
isto deveria ter sido a resposta aceita
EigenFool
ainda é a abordagem mais segura a ser adotada. Boa resposta.
klewis 21/01
43

A única ressalva que encontrei com a melhor resposta acima é que ele atualiza os módulos para a versão mais recente. Isso significa que ele pode ser atualizado para uma versã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 isso:

$ npm install -g npm-check-updates
$ npm-check-updates -u
$ npm install 
Tyler Davis
fonte
3
rm -rf node_modulesantes npm installse livrou de alguns avisos de dependência para mim.
Michael Cole
1
Caso você tenha "*" no pacote.json, simplesmente mude para "0" ou "0.0" ou "0.0.0" antes de executar o npm-check-updates.
Igorpavlov #
Essa é a maneira mais fácil de fazer isso. Sem problemas, sem problemas. Funciona como um encanto. Todos os seus departamentos são atualizados e instalados corretamente. Thx
Yoraco Gonzales
38

Para ver quais pacotes têm versões mais recentes 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 package.jsonarquivo tem dependência:

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

então eu deveria escrever:

npm install @progress/kendo-angular-dateinputs@latest --save
Um passo adiante
fonte
Bom, mas parece que --save (ou --save-dev) não é obrigatório para atualização.
Burrich 27/07
35

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

Aqui está uma captura de tela do que acontece após a execução npm-upgradena raiz do seu projeto (ao lado do package.jsonarquivo):

exemplo de atualização npm

Para cada dependência, você pode optar por atualizar, ignorar, exibir o registro de alterações ou concluir o processo. Até agora, funcionou muito bem para mim.

EDIT: Para ficar claro, este é um pacote de terceiros que precisa ser instalado antes que o comando funcione. Ele não vem com o próprio npm:

npm install -g npm-upgrade

A partir da raiz de um projeto que possui um arquivo package.json:

npm-upgrade
manncito
fonte
Olhando para os docs parece que só foi construído para trabalhar com dependências locais
manncito
2
sim, apenas mencionado para os outros. Nenhuma queixa contra a resposta :)
Martin Schneider
2
Hmm, npm-upgradenão funcionou para mim, mas npm upgradefuncionou e atualizou meu arquivo package.json, que era exatamente o que eu estava procurando.
Grandizer
Hmm interessante, houve um erro? A idéia por trás do uso npm-upgradeé que você possa ver exatamente o que está sendo atualizado e escolher quais serão atualizados. npm upgradepode funcionar bem para a maioria das pessoas, mas às vezes você precisa ter um pouco mais de controle ao atualizar.
Manncito 24/05
1
Você também pode usar isso com npx: npx npm-upgrade- muito legal! :)
raio-x
22

Aqui está um regex básico para corresponder aos números das versões semânticas, 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 deseja substituir no arquivo JSON.

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

Insira o regex acima e verifique se ele corresponde 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

Corre npm update --save

daniellmb
fonte
não ocorre quando há número no nome de um pacote. ou seja: babel-preset-es2015, babel-preset-stage-0, hex2rgba. Talvez pesquise aspas / aspas duplas no início:('|")([>|<|=|~|^|\s])*?(\d+\.)?(\d+\.)?(\*|\d+)
rofrol 15/09/17
1
em qualquer editor que suporte múltiplos sinais de intercalação (ej Sublime Text), você pode selecionar o primeiro :e pressionar ctrl+dvárias vezes até selecionar todos eles, depois acessar o número da versão (pressionar a seta para a direita 2 vezes) e pressionar ctrl espaço, e escrever"*"
Ivan Castellanos
15

Recentemente, tive que atualizar vários projetos que estavam usando o npm e o package.json para a mágica do gruntfile.js. O seguinte comando bash (comando multilinha) 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 npm outdatedsaída como json, para jq
(jq é uma ferramenta de análise / consulta de linha de comando json)
(observe o uso do --depthargumento para npm outdated)
jq reduz 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-devcomando

A descrição acima é o que funcionou para mim em uma máquina executando: 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, acredito)
e
jq http://stedolan.github.io/jq/ (eu o instalei com brew install jq)

Nota: Apenas salvei as bibliotecas atualizadas no package.json dentro da chave json devDependanciesusando --save-dev, isso era um requisito dos meus projetos, muito possivelmente não o seu.

Depois, verifico que está tudo bem com um simples

npm outdated --depth=0

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

npm list --depth=0
andxyz
fonte
Eu amo jq e usá-lo quase todos os dias, mas para esta finalidade eu uso simples awkem vez disso:npm outdated --depth=0 | grep -v "^Package" | awk '{print $1}' | xargs npm install $1 --save-dev
Qorbani
1
Estou usando #cat package.json|jq -r '.devDependencies|keys|map(.+"@latest")|@sh'|xargs npm install --save-dev
Richard Ayotte
15

Se você quiser usar uma abordagem suave por meio de uma interface de relatório interativa bonita (para terminal), sugiro usar o npm-check .

É menos um martelo e fornece a você mais conhecimento conseqüente e controle sobre suas atualizações de dependência.

Para dar uma amostra do que aguarda, aqui está uma captura de tela (extraída da página git para npm-check):

insira a descrição da imagem aqui

TWright
fonte
14

Este recurso foi introduzido no npm v5. atualizar para npm usando npm install -g npm@lateste

atualizar package.json

  1. excluir /node_modulesepackage-lock.json (if you have any)

  2. correr npm update. isso atualizará as dependências package.json para as mais recentes, com base no semver .

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

Sibiraj
fonte
13

Se você usar o yarn, o comando a seguir atualiza todos os pacotes para sua versão mais recente:

yarn upgrade --latest

Dos documentos deles :

O upgrade --latestcomando 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 (potencialmente atualizando os pacotes nas principais versões).

fotijr
fonte
1
Não atualiza as dependências em package.json- github.com/yarnpkg/yarn/issues/4390
Vandesh
13

A partir da versão 5.2.0 do npm, existe uma maneira de executar isso em uma única linha sem instalar nenhum pacote adicional no registro global do npm nem localmente no aplicativo. Isso pode ser feito aproveitando o novo npxutilitário que acompanha o npm. ( Clique aqui para saber mais. )

Execute o seguinte comando na raiz do seu projeto:

npx npm-check-updates -u && npm i
ilyakam
fonte
Eu apenas tentei isso e funciona ... exceto que eu tive que correr npm installpara realmente baixar as novas dependências. Então eu acho que isso só atualiza o package.json a menos que eu estou faltando alguma coisa
owsega
@owsega, você está absolutamente certo, obrigado! Modifiquei minha resposta para também executar npm installdepois que as dependências foram atualizadas.
Ilyakam
13

Eu uso npm-checkpara conseguir 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 úteis que manterá os números exatos das versões 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
goksel
fonte
É ncu -ue não ncu -uana segunda última linha. Não consigo editar porque uma alteração de caractere não é permitida. Muito útil por sinal.
Sohail Ahmed
10

Updtr!

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

https://github.com/peerigon/updtr

David Braun
fonte
9

Comandos que eu tinha que usar para atualizar package.jsonpara NPM 3.10.10:

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

Fundo:

Eu estava usando o comando mais recente do @ josh3736, mas o meu package.jsonnão foi atualizado. Notei o texto da descrição ao executar npm-check-updates -u:

A dependência a seguir é satisfeita pelo seu intervalo de versões declarado, mas a versão instalada está atrasada. Você pode instalar a versão mais recente sem modificar o arquivo do pacote usando o npm update. Se você deseja atualizar a dependência no seu arquivo de pacote, execute ncu -a.

Lendo a documentação para 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 dependências cuja versão mais recente satisfaz a dependência declarada semver

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

[INFO]: You can also use ncu as an alias
Ogglas
fonte
No npm-check-updates v3, -aé o comportamento padrão e a substituição do package.json é deixada apenas para a -uopção
Raine Revere
8

Se você estiver usando yarn, yarn upgrade-interactiveé uma ferramenta realmente elegante que permite exibir suas dependências desatualizadas e depois selecionar quais você deseja atualizar.

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

Yangshun Tay
fonte
O fio está se movendo rapidamente, atingiu um 1,0 e já é um prazer de usar. Essa deve ser a nova resposta selecionada.
Josh Habdas
1
Não atualiza as dependências em package.json- github.com/yarnpkg/yarn/issues/4390
Vandesh
5

Os comandos acima são inseguros porque você pode interromper seu módulo ao alternar versões. Em vez disso, recomendo o seguinte

  • Defina a versão atual dos módulos do nó atual em package.json usando o npm shrinkwrapcomando
  • Atualize cada dependência para a versão mais recente SE NÃO DISTRIBUIR OS SEUS TESTES usando a https://github.com/bahmutov/next-update ferramenta de linha de comando
npm install -g próxima atualização
// do seu pacote
próxima atualização
gleb bahmutov
fonte
1
Alterações incompatíveis com versões anteriores precisam ser protegidas contra projetos ativos. O OP está mais preocupado em iniciar um novo projeto no qual você deseja interromper as coisas agora e não mais tarde e ter as versões mais recentes para trabalhar.
Raine Revere
3

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

atualização npm --save

krunal shah
fonte
2
O updatecomando não parece aumentar as dependências além da definição original. Se package.jsondeclara "1.2.3"exatamente você não receberá 1.2.4. Isso pode ser bom ou ruim :)
Álvaro González
3

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

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

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

Copiei uma lista como esta (apenas muito mais) das dependências de desenvolvimento do meu package.jsonpara o editor de texto do bloco de notas ++:

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

Defino o modo de pesquisa como expressão regular, usei o ^\s*"([^"]+)".*$padrão para obter o nome do pacote e o substitui npm uninstall \1 --save-dev \nnpm install \1 --save-dev. Clicou em "substituir tudo". O otput 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

Copiei de volta para o bash e apertei 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 isso seja importante, já que você precisa fazer isso de vez em quando, mas pode escrever facilmente um script que analise package.jsone atualize 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 uma lib.

inf3rno
fonte
1
Com o npm-check-updates, o terminal suspenso é um problema conhecido no Windows. Tente adicionar --packageFile package.jsonpara que você não espere pelo stdin.
Raine Revere
@RaineRevere Thanks!
Inf3rno 01/05/19
3

Resolvi isso vendo as instruções em 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
Sunil
fonte
3

Encontrei outra solução para a versão recente do NPM. O que eu quero fazer é substituir todas as dependências "*" pelo número explícito da última versão. Nenhum dos métodos discutidos funcionou para mim.

O que eu fiz:

  1. Substitua todos "*" por "^ 0.0.0"
  2. Corre npm-check-updates -u

Tudo no package.json agora é atualizado para a última versão.

miqrc
fonte
3

Se você não deseja instalar o npm-check-updates global, basta executar o seguinte:

node -e "const pk = JSON.parse(require('fs').readFileSync('package.json', 'utf-8'));require('child_process').spawn('npm', ['install', ...Object.keys(Object.assign({},pk.dependencies, pk.devDependencies)).map(a=>a+'@latest')]).stdout.on('data', d=>console.log(d.toString()))"
Yukulélé
fonte
2

Alternativa é

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

sempre que você usa o npm update, ele é atualizado automaticamente para a versão mais recente. Para obter mais sintaxe da versão, você pode conferir aqui: https://www.npmjs.org/doc/misc/semver.html

Refúgio
fonte
Uma razão para o controle de versão é impedir alterações incompatíveis com versões anteriores das versões principais mais recentes. Eu recomendaria contra este ou números de versão '*'. O OP está relacionado a facilitar o processo, mantendo o controle sobre quando ele ocorre.
precisa saber é o seguinte
2

Solução sem pacotes adicionais

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

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

Então corra npm update --save.

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

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

Essa é a parte complicada, significa que sua versão local de "react" foi menor que a mais recente. Nesse caso, o npm baixou e atualizou o pacote "react". No entanto, sua versão local do "react-google-maps" é a mesma que a mais recente.

Se você ainda deseja "atualizar" inalterado *, é necessário excluir esses módulos da node_modulespasta.

por exemplo, excluir node_modules/react-google-maps.

Finalmente corra novamente npm update --save.

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

Não se esqueça de executar npm update --save-devse desejar atualizar as dependências de desenvolvimento.

Alexey Volodko
fonte
1

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

É uma integração ao Github e incrivelmente fácil de configurar. Quando instalado, ele cria automaticamente solicitações pull nos repositórios especificados (ou todos, se desejado) e mantém seu código sempre atualizado, sem forçar você a fazer algo manualmente. Os PRs devem acionar uma compilação em um serviço de IC e, dependendo de uma verificação bem-sucedida ou com falha, você pode continuar descobrindo o que está causando o problema ou quando a aprovação do IC simplesmente mescla o PR.

greenkeeper PR 1 greenkeeper PR 2

Na parte inferior, você pode ver que a primeira compilação falhou no início e após uma confirmação ("atualização para o nó v6.9"), os testes passam para que eu possa finalmente mesclar o PR. Também vem com muitos emoji.

Outra alternativa seria https://dependencyci.com/ , no entanto, não testei intensivamente. Após uma primeira olhada, o Greenkeeper parece melhor em geral na IMO e possui melhor integração.

Luca Steeb
fonte
1
  • npm desatualizado
  • atualização npm

Você deve obter as versões desejadas mais recentes compatíveis com o seu aplicativo. Mas não as versões mais recentes.

webkitfanz
fonte