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!

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.

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 

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

• npm desatualizado

• npm-check-updates

• npm shrinkwrap

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

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;)

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

Isso funciona a partir da NPM 1.3.15.

"dependencies": {
  "foo": "latest"
}

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"
},

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 

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

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):

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

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.

Insira o regex acima e verifique se ele corresponde ao texto correto.

Substitua todas as correspondências por um asterisco.

Corre npm update --save

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

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):

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

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

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

Eu uso npm-checkpara conseguir isso.

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

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

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

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

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.

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

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

atualização npm --save

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.

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

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.

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()))"

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

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.

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.

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.

• 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.