Qual é a diferença entre til (~) e circunflexo (^) no package.json?

Depois de fazer o upgrade para o último estável nodee npm, tentei npm install moment --save. Ele salva a entrada no package.jsoncom o sinal de intercalação^ prefixo de . Anteriormente, era um ~prefixo til .

1. Por que essas mudanças são feitas no npm ?
2. Qual é a diferença entre til ~ e caret ^?
3. Quais são as vantagens sobre os outros?

Consulte os documentos do NPM e os documentos semver :

• ~ version “Aproximadamente equivalente à versão”, atualizará você para todas as versões futuras do patch, sem incrementar a versão secundária. ~1.2.3usará as versões 1.2.3 a <1.3.0.

• ^ version “Compatible with version”, atualizará você para todas as versões secundárias / patches futuras, sem aumentar a versão principal. ^2.3.4usará as versões 2.3.4 a <3.0.0.

Veja os comentários abaixo.

Gostaria de adicionar também a documentação oficial do npmjs, que descreve todos os métodos para a especificidade da versão, incluindo os mencionados na pergunta -

https://docs.npmjs.com/files/package.json

https://docs.npmjs.com/misc/semver#x-ranges-12x-1x-12-

• ~version"Aproximadamente equivalente à versão" Ver npm semver - Tilde Ranges & semver (7)
• ^version"Compatível com a versão" Ver npm sempre - Caret Ranges & semver (7)
• version Deve corresponder exatamente à versão
• >version Deve ser maior que a versão
• >=version etc
• <version
• <=version
• 1.2.x 1.2.0, 1.2.1, etc., mas não 1.3.0
• http://sometarballurl (pode ser o URL de um tarball que será baixado e instalado localmente
• * Corresponde a qualquer versão
• latest Obtém a versão mais recente

A lista acima não é exaustiva. Outros especificadores de versão incluem URLs do GitHub e repositórios de usuários do GitHub, caminhos locais e pacotes com tags npm específicas

O npm permite instalar uma versão mais recente de um pacote que o especificado. O uso de tilde ( ~) fornece versões de correção de bugs e o sinal de intercalação ( ^) também oferece novas funcionalidades compatíveis com versões anteriores.

O problema é que as versões antigas geralmente não recebem correções de erros tanto, então o npm usa caret ( ^) como padrão para --save.

De acordo com: "Semver explicou - por que há um sinal de intercalação (^) no meu package.json?" .

Observe que as regras se aplicam a versões acima da 1.0.0 e nem todo projeto segue o controle de versão semântico. Para as versões 0.xx, o cursor permite apenas atualizações de patch , ou seja, se comporta da mesma forma que o til. Consulte "Intervalos de sinal de intercalação"

Aqui está uma explicação visual dos conceitos:

Fonte: "Cheatsheet de versões semânticas" .

Semver

<major>.<minor>.<patch>-beta.<beta> == 1.2.3-beta.2

• Use a calculadora npm semver para testar. (Embora as explicações para ^ (inclua tudo maior que uma versão específica no mesmo intervalo principal) e ~ (inclua tudo maior que uma versão específica no mesmo intervalo menor) não sejam 100% corretas, a calculadora parece funcionar bem )
• Como alternativa, use o SemVer Check , que não exige que você escolha um pacote e também oferece explicações.

Permitir ou proibir alterações

• Pin versão: 1.2.3.
• Use ^(como cabeça). Permite atualizações no segundo nível diferente de zero a partir da esquerda: ^0.2.3significa 0.2.3 <= v < 0.3.
• Use ~(como cauda). Geralmente congele o nível mais à direita ou defina zero se omitido:
  • ~1 significa 1.0.0 <= v < 2.0.0
  • ~1.2meios 1.2.0 <= v < 1.3.0.
  • ~1.2.4meios 1.2.4 <= v < 1.3.0.
• Omita o nível mais à direita: 0.2significa 0.2 <= v < 1. É diferente de~ porque:
  • Iniciar a versão de nível omitido é sempre 0
  • Você pode definir a versão principal inicial sem especificar subníveis.

Todas as possibilidades (espero)

Defina o início do nível principal e permita atualizações para cima

*  or "(empty string)   any version
1                         v >= 1

Congelar em nível principal

~0 (0)            0.0 <= v < 1
0.2               0.2 <= v < 1          // Can't do that with ^ or ~ 
~1 (1, ^1)        1 <= v < 2
^1.2              1.2 <= v < 2
^1.2.3            1.2.3 <= v < 2
^1.2.3-beta.4     1.2.3-beta.4 <= v < 2

Congelar em nível menor

^0.0 (0.0)        0 <= v < 0.1
~0.2              0.2 <= v < 0.3
~1.2              1.2 <= v < 1.3
~0.2.3 (^0.2.3)   0.2.3 <= v < 0.3
~1.2.3            1.2.3 <= v < 1.3

Congelar nível de patch

~1.2.3-beta.4     1.2.3-beta.4 <= v < 1.2.4 (only beta or pr allowed)
^0.0.3-beta       0.0.3-beta.0 <= v < 0.0.4 or 0.0.3-pr.0 <= v < 0.0.4 (only beta or pr allowed)
^0.0.3-beta.4     0.0.3-beta.4 <= v < 0.0.4 or 0.0.3-pr.4 <= v < 0.0.4 (only beta or pr allowed)

Proibir atualizações

1.2.3             1.2.3
^0.0.3 (0.0.3)    0.0.3

Aviso : Faltando major, minor, patch ou especificando betasem número, é o mesmo que anypara o nível ausente.

Aviso : Quando você instala um pacote com o 0nível principal, a atualização instala apenas a nova versão beta / pr! Isso ocorre porque npmdefine ^como padrão na package.jsonversão instalada e quando é semelhante 0.1.3, congela todos os níveis principais / secundários / patches.

• https://docs.npmjs.com/misc/semver
• https://docs.npmjs.com/files/package.json#dependencies

~corrige números maiores e menores. É usado quando você está pronto para aceitar correções de erros em sua dependência, mas não deseja nenhuma alteração potencialmente incompatível.

^corrige apenas o número principal. É usado quando você está observando atentamente suas dependências e está pronto para alterar rapidamente seu código, se uma versão menor for incompatível.

Além disso, não^ é suportado por versões antigas do npm e deve ser usado com cuidado.

Portanto, ^é um bom padrão, mas não é perfeito. Sugiro escolher e configurar cuidadosamente o operador semver mais útil para você.

~: Razoavelmente perto de

   ~1.1.5: 1.1.0 <= accepted < 1.2.0

^: Compatível com

   ^1.1.5: 1.1.5 <= accepted < 2.0.0

   ^0.1.3: 0.1.3 <= accepted < 0.2.0

   ^0.0.4: 0.0.4 <= accepted < 0.1.0

^ é 1. [qualquer]. [qualquer] (última versão menor)
~ é 1.2. [qualquer] (última atualização)

Uma ótima leitura é esta postagem no blog sobre como o semver se aplica ao npm
e o que eles estão fazendo para torná-lo compatível com o padrão do semver
http://blog.npmjs.org/post/98131109725/npm-2-0-0

A correspondência de chapéu pode ser considerada "quebrada" porque não será atualizada ^0.1.2para 0.2.0. Quando o software estiver emergindo, use 0.x.yversões e a correspondência de chapéu corresponderá apenas ao último dígito variável ( y). Isso é feito de propósito. O motivo é que, enquanto o software está evoluindo, a API muda rapidamente: um dia você tem esses métodos e, outro dia, esses métodos e os antigos desaparecem. Se você não deseja quebrar o código para as pessoas que já estão usando sua biblioteca, você incrementa a versão principal: por exemplo 1.0.0- -> 2.0.0-> 3.0.0. Assim, quando seu software finalmente estiver 100% pronto e com todos os recursos, será semelhante à versão 11.0.0e isso não parece muito significativo e, na verdade, parece confuso. Se você estava, por outro lado, usando ->0.1.x->0.2.x0.3.x versões da Quando o software estiver finalmente 100% pronto e com todos os recursos, ele será lançado como versão1.0.0 e significa "Esta versão é um serviço de longo prazo, você pode prosseguir e usar esta versão da biblioteca em seu código de produção, e o autor não mudará tudo amanhã ou no próximo mês e não abandonará o pacote".

A regra é: use o 0.x.ycontrole de versão quando o software ainda não amadurecer e libere-o incrementando o dígito do meio quando a API pública for alterada (portanto, as pessoas que ^0.1.0não receberem 0.2.0atualizações não receberão o código). Em seguida, quando o software amadurecer, libere-o abaixo 1.0.0e aumente o dígito mais à esquerda cada vez que sua API pública for alterada (portanto, as pessoas que ^1.0.0não tiverem 2.0.0atualizações serão atualizadas e o código não será quebrado).

Given a version number MAJOR.MINOR.PATCH, increment the:

MAJOR version when you make incompatible API changes,
MINOR version when you add functionality in a backwards-compatible manner, and
PATCH version when you make backwards-compatible bug fixes.

~ Tilde:

• ~congela números maiores e menores.
• É usado quando você está pronto para aceitar correções de erros em sua dependência, mas não deseja nenhuma alteração potencialmente incompatível.
• O til corresponde à versão secundária mais recente (o número do meio).
• ~ 1.2.3 corresponderá a todas as versões 1.2.x, mas perderá a 1.3.0.
• Tilde (~) fornece versões de correção de bugs

^ Circunflexo:

• ^ congela apenas o número principal.
• É usado quando você está observando atentamente suas dependências e está pronto para alterar rapidamente seu código, se uma versão menor for incompatível.
• Ele atualizará você para a versão principal mais recente (o primeiro número).
• ^ 1.2.3 corresponderá a qualquer versão 1.xx incluindo a 1.3.0, mas a versão 2.0.0 será adiada.
• O sinal de intercalação (^) também oferece novas funcionalidades compatíveis com versões anteriores.

Tilde ~ corresponde à versão secundária, se você instalou um pacote que possui 1.4.2 e após a instalação, as versões 1.4.3 e 1.4.4 também estarão disponíveis se no seu package.json for usado como ~ 1.4.2, em seguida, npm install no seu projeto após a atualização instalará o 1.4.4 no seu projeto. Mas há 1.5.0 disponível para esse pacote e ele não será instalado pelo ~. É chamado de versão secundária.

Caret ^ corresponde à versão principal, se o pacote 1.4.2 estiver instalado no seu projeto e após a instalação da instalação 1.5.0, o ^ instalará a versão principal. Não permitirá a instalação do 2.1.0 se você tiver ^ 1.4.2 .

Versão fixa, se você não quiser alterar a versão do pacote em cada instalação, use a versão fixa sem nenhum caractere especial, por exemplo, "1.4.2"

Versão mais recente * Se você deseja instalar a versão mais recente, use apenas * na frente do nome do pacote.

Explicação de um forro

O sistema de versão padrão é major.minor.build (por exemplo, 2.4.1)

O npm verifica e corrige a versão de um pacote específico com base nesses caracteres

~ : a versão principal é corrigida, a versão secundária é corrigida, corresponde a qualquer número de compilação

por exemplo: ~ 2.4.1 significa que ele procurará 2.4.x onde x é qualquer coisa

^ : a versão principal é corrigida, corresponde a qualquer versão secundária, corresponde a qualquer número de compilação

por exemplo: ^ 2.4.1 significa que ele procurará 2.xx onde x é qualquer coisa

Você provavelmente já viu o til (~) e o sinal de intercalação (^) no package.json. Qual a diferença entre eles?

Quando você instala o npm moment --save, ele salva a entrada no package.json com o prefixo caret (^).

O til (~)

Nos termos mais simples, o til (~) corresponde à versão secundária mais recente (o número do meio). ~ 1.2.3 corresponderá a todas as versões 1.2.x, mas perderá a 1.3.0.

O sinal de intercalação (^)

O sinal de intercalação (^), por outro lado, é mais relaxado. Ele atualizará você para a versão principal mais recente (o primeiro número). ^ 1.2.3 corresponderá a qualquer versão 1.xx incluindo a 1.3.0, mas a versão 2.0.0 será adiada.

Referência: https://medium.com/@Hardy2151/caret-and-tilde-in-package-json-57f1cbbe347b

O semver é separado em três seções principais, que são quebradas por pontos.

major.minor.patch
1.0.0

Esses diferentes principais, secundários e patches estão sendo usados ​​para identificar diferentes lançamentos. maré (~) e circunflexo (^) estão usando para identificar qual versão secundária e de patch será usada no controle de versão de pacotes.

~1.0.1
 Install 1.0.1 or **latest patch versions** such as 1.0.2 ,1.0.5
^1.0.1
 Install 1.0.1 or **latest patch and minor versions** such as 1.0.2 ,1.1.0 ,1.1.1

Tilde (~)

versão principal é fixa, versão menor é fixa, corresponde a qualquer número de compilação

"express": "~4.13.3" 

~4.13.3 significa que ele procurará por 4.13.x onde x é qualquer coisa e 4.14.0

Circunflexo (^)

versão principal é fixa, corresponde a qualquer versão secundária, corresponde a qualquer número de compilação

"supertest": "^3.0.0"

^3.0.0 significa que ele procurará 3.xx onde x é qualquer coisa

O número da versão está na sintaxe que designa cada seção com significado diferente. sintaxe é dividida em três seções separadas por um ponto.

major.minor.patch 1.0.2

Major, minor e patch representam os diferentes lançamentos de um pacote.

O npm usa o til (~) e o sinal de intercalação (^) para designar qual patch e versões secundárias usar respectivamente.

Portanto, se você vir ~ 1.0.2, significa instalar a versão 1.0.2 ou a versão mais recente do patch, como 1.0.4. Se você vir ^ 1.0.2, significa instalar a versão 1.0.2 ou a versão menor ou mais recente, como a 1.1.0.

quilate ^ inclui tudo maior que uma versão específica na mesma faixa principal.

til ~ inclui tudo maior que uma versão específica no mesmo intervalo menor.

Por exemplo, para especificar intervalos de versões aceitáveis ​​até 1.0.4, use a seguinte sintaxe:

• Versões de patch: 1.0 ou 1.0.x ou ~ 1.0.4
• Versões secundárias: 1 ou 1.x ou ^ 1.0.4
• Principais lançamentos: * ou x

Para obter mais informações sobre sintaxe de versão semântica, consulte a calculadora npm semver .

Mais sobre a documentação do npm Sobre versão semântica

Não é uma resposta, por si só, mas uma observação que parece ter sido negligenciada.

A descrição para intervalos de quilates:

consulte: https://github.com/npm/node-semver#caret-ranges-123-025-004

Permite alterações que não modificam o dígito diferente de zero, à esquerda, na tupla [maior, menor, do patch].

Significa que ^10.2.3corresponde10.2.3 <= v < 20.0.0

Eu não acho que foi isso que eles quiseram dizer. Ao puxar as versões 11.xx a 19.xx, o código será quebrado.

Eu acho que eles quiseram dizer left most non-zero number field. Não há nada no SemVer que exija que os campos numéricos sejam de um dígito.

~ especificações para versões secundárias ^ especifica para versões principais

Por exemplo, se a versão do pacote for 4.5.2, na Atualização ~ 4.5.2 será instalada a versão 4.5.x mais recente (VERSÃO MINOR) ^ 4.5.2 será instalada a versão 4.xx mais recente (VERSÃO PRINCIPAL)

Relacionado a esta pergunta, você pode revisar a documentação do Composer nas versões , mas aqui em resumo:

• Intervalo de versões til ( ~ ) - ~ 1.2.3 é equivalente a> = 1.2.3 < 1.3.0
• Intervalo de versão de sinal de intercalação ( ^ ) - ~ 1.2.3 é equivalente a> = 1.2.3 < 2.0.0

Portanto, com o Tilde, você receberá atualizações automáticas de patches, mas as versões menor e maior não serão atualizadas. No entanto, se você usar o Caret , receberá patches e versões secundárias, mas não obterá versões principais (que quebram alterações).

A Tilde Version é considerada uma abordagem "mais segura", mas se você estiver usando dependências confiáveis ​​(bibliotecas bem mantidas), não deverá ter problemas com a Caret Version (porque pequenas alterações não devem interromper as alterações.

Você provavelmente deve revisar esta postagem do stackoverflow sobre as diferenças entre a instalação e a atualização do compositor .