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


3387

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?

42
FYI você pode evitar prefixos ou usar um costume fazendo: npm config set save-prefix=''. (Coloque ~as aspas, se preferir.) Pessoalmente, faço isso e encolho as coisas na produção.
Fncomp 22/01/15

19
Todos os pequenos pormenores de como til e trabalho acento circunflexo e diferenças: github.com/npm/node-semver#tilde-ranges-123-12-1
Jeffrey Martinez

11
Esta ferramenta é um grande auxiliar para testar o semver.npmjs.com
chaiyachaiya

@fncomp só queria esclarecer se eu entendi o seu comentário .. você usa apenas versões específicas de dependências no seu projeto? nossa equipe hesita em atualizar as dependências. você recomendaria o uso de versões específicas ou o prefixo '~' para as dependências?
blogs4t

@fncomp você poderia detalhar o que você quer dizer com "eu pessoalmente faço isso e encolho as coisas na produção". obrigado!
blogs4t

Respostas:


3848

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.


325
Poste aqui para, esperançosamente, capturar pessoas que não pensam sobre isso, mas ^ e ~ supõem que você possa confiar em lançamentos menores e pontuais de suas dependências. Se você estiver publicando uma biblioteca e quiser que outras pessoas confiem em você, NÃO ACEITE DEPENDENCIAS A BAIXO DO CÉREBRO. Uma liberação de ponto ruim da sua dependência pode causar uma reação em cadeia a montante e fará com que as pessoas batam à SUA porta quando as coisas derem errado. Esse é outro grande motivo para usar o npm shrinkwrap em seu código de produção.
Tehfoo

8
Você também pode simplesmente acabar com toda a bobagem do npm acrescentando suas versões com a ^ou a ~. Defina este se você quer ter um controlo apertado sobre as suas versões: npm config set save-prefix=''
kumarharsh

5
@prasanthv está certo: em docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4 : intervalos de sinal de intercalação ^ 1.2.3 ^ 0.2.5 ^ 0.0 .4. Permite alterações que não modificam o dígito diferente de zero, à esquerda, na tupla [maior, menor, do patch]. Em outras palavras, isso permite atualizações de patch e pequenas para as versões 1.0.0 e posteriores, atualizações de patch para as versões 0.X> = 0.1.0 e nenhuma atualização para as versões 0.0.X.
Rofrol 11/10/2015

15
@jgillich sempre que você usa 0.2.x, 2não é um major version. É por isso que docs.npmjs.com usou as palavras específicas: the left-most non-zero digit. Também o que sobre este caso: ^ 0.0.4 meios 0.0.4
rofrol

11
@FagnerBrack: O exemplo específico que você forneceu está correto, mas geralmente sua maneira de pensar está errada. Um exemplo: Vamos dizer que você tem pacote Aem 3 versões: 0.0.1, 0.0.2e 0.0.3. Há um erro no 0.0.1que você deseja ter pelo menos 0.0.2no seu pacote B. Se você escrever , 0.0.xreceberá 0.0.3, o que é bom. Mas se algum outro pacote Cexigir os dois Be Aalém disso tiver restrições, "A": "<0.0.2"você obterá 0.0.1sem mostrar nenhum problema de conflito, que não é o que você deseja. O uso do til ~0.0.2deve ajudar a evitar esse problema.
Maciej Sz

863

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


8
Também é possível especificar um intervalo exato de versões, como 1.2.0 || >=1.2.2 <1.3.0: Exatamente 1.2.0 ou tudo, de 1.2.2 a 1.3.0 (inclusive), mas não 1.2.1, ou 1.3.1 e acima, e também não 1.1 .xe abaixo.
CodeManX

Um link mais específico forma o acima -> docs.npmjs.com/files/package.json#dependencies
Toby

"Approximately equivalent to version"e "Compatible with version"são maneiras frustrantemente inespecíficas de descrever comportamentos. Obrigado @jgillich por fornecer uma resposta real!
Scott Stafford

636

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.

mesa semver

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:

semver diagrama

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


2
Que tal ^ 0.2.5? de docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4 : intervalos de sinal de intercalação ^ 1.2.3 ^ 0.2.5 ^ 0.0.4. Permite alterações que não modificam o dígito diferente de zero, à esquerda, na tupla [maior, menor, do patch]. Em outras palavras, isso permite atualizações de patch e pequenas para as versões 1.0.0 e posteriores, atualizações de patch para as versões 0.X> = 0.1.0 e nenhuma atualização para as versões 0.0.X.
Rofrol 11/10/2015

11
@rofrol qualquer versão antes 1.0.0 é considerada instável e estas regras não se aplicam
IPPE

2
Portanto, sua explicação não é completa
rofrol

5
@rofrol sim, omitir a legibilidade às vezes é bom, as chances de ter algo abaixo de 1.0.0 para uma dependência no pacote json são bem baixas. ver também 20/80 princípio, é uma grande regra para se concentrar no que importa
IPPE

1
@pspi Ter versões abaixo da 1.0.0 é "improvável"? Dos 60, temos ~ 15, e a maioria deles não é obscura.
Dave Newton

99

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.


Dizer às pessoas para evitar o início de projetos a partir do zero, porque os desenvolvedores de bibliotecas e consumidores não entendem o sistema é uma solução terrível. Eu acho que o @asdfasdfads tem informações muito melhores.
ProLoser 22/09/16

@ ProLoser Apenas acho que o sistema deve ser simplificado e não devemos usar as versões 0.x.
Rofrol 23/09/16

1
O caso de uso em torno do desenvolvimento do ciclo de vida inicial e da v0 faz muito sentido. Aprender como a v0 se comporta corretamente me fez esperar por outros projetos do ciclo de vida inicial. Isso significa que você pode ter uma API que muda rapidamente com muitas incompatibilidades anteriores sem ser forçado a declarar seu projeto como 1.x (aka: stable) quando realmente não é.
ProLoser 23/09/16

Eu entendo isso, mas eu só não gosto de como ele funciona com semver e qualificadores
rofrol

2
Parece mais uma opinião e não deve ser enquadrada como uma abordagem geralmente aceita. E ^ 0.1.x obtém os patches perfeitamente bem.
ProLoser 11/11

93

~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ê.


13
Não é verdade: intervalos de sinal de intercalação ^ 1,2,3 ^ 0,2,5 ^ 0,0,4. Permite alterações que não modificam o dígito diferente de zero, à esquerda, na tupla [maior, menor, do patch]. Em outras palavras, isso permite atualizações de patch e pequenas para as versões 1.0.0 e posteriores, atualizações de patch para as versões 0.X> = 0.1.0 e nenhuma atualização para as versões 0.0.X. docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4
rofrol 11/10/2015

6
Esta resposta está completamente errada (como muitas outras aqui). Nada disso fixa um número importante! Como o @rofrol disse, ^ simplesmente mantém inalterado o dígito mais diferente de zero à esquerda. ~ por outro lado, permite apenas atualizações de patch se a versão secundária for especificada (por exemplo, ~ 1.2.3 ou ~ 1.2) e permite atualizações menores se a versão secundária não for especificada (por exemplo, ~ 1).
21717 TheBaj

2
@TheBaj Eles significam "consertar" como "definir" ("fixar") em vez de "ajustar", então todos concordam em como o número principal é tratado.
Maaartinus

1
Sim, essa resposta parecia totalmente invertida, até que percebi que o atendedor queria dizer "consertar", como em "tornar fixo, estacionário ou imutável".
NattyC

57

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

17
@kytwb - não. No caso especial dos números de versão com liberação zero, o quilate é equivalente ao til. Portanto, ^0.1.3apenas aceita versões 0.1.xe não aceita 0.2.0, mesmo que seja um pequeno incremento. Esse comportamento é equivalente a ~0.1.3. O raciocínio por trás desse comportamento se deve ao fato de os pacotes de liberação do zeroth ainda serem considerados instáveis; nas palavras do semver.org , nº 4, "qualquer coisa pode mudar a qualquer momento" (incluindo alterações incompatíveis com versões anteriores).
chharvey

31

^ é 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


2
Não é verdade: intervalos de sinal de intercalação ^ 1,2,3 ^ 0,2,5 ^ 0,0,4. Permite alterações que não modificam o dígito diferente de zero, à esquerda, na tupla [maior, menor, do patch]. Em outras palavras, isso permite atualizações de patch e pequenas para as versões 1.0.0 e posteriores, atualizações de patch para as versões 0.X> = 0.1.0 e nenhuma atualização para as versões 0.0.X. docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4
rofrol

28

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.

Este comentário foi ridiculamente útil e não parece estar muito bem documentado. Você tem um link para a documentação sobre esse comportamento? Essa resposta sobre os projetos v0 me ajudou muito.
ProLoser 22/09/16

Eu não tenho um link: Eu encontrei esta informação também por googling e brincar com npm versão semântica calculadora semver.npmjs.com
catamphetamine

2
Precisa ser adicionado à documentação de maneira mais formal. Eu dei uma palestra na Sony para minha equipe de engenharia, porque parece tão facilmente esquecido. slides.com/proloser/semver-v0
ProLoser #

24

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

1
O til corresponde à versão mais recente do patch (o último número). O sinal de intercalação corresponde à versão secundária mais recente (o número do meio).
Abdul Rauf

"congela" é a melhor explicação.
Mrabiee # 4/19

O Caret congela o número principal e o atualiza para a versão principal mais recente (o primeiro número)? O número principal é o primeiro, então isso não faz sentido.
NattyC 29/01

19

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.


3
Esta resposta é enganosa. SemVer afirma claramente: Um número de versão normal DEVE tomar o formato XYZ [onde] X é a versão principal, Y é a versão secundária e Z é a versão do patch.
Leo

15

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


5
Vejo 7 linhas nesta resposta
FluxLemur

11

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


Novamente, esta resposta é enganosa. SemVer afirma claramente: Um número de versão normal DEVE tomar o formato XYZ [onde] X é a versão principal, Y é a versão secundária e Z é a versão do patch.
Leo

5

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

4

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


Você pode explicar como essa resposta é diferente da mesma resposta postada há 4 anos ?
31560 Franklin Franklin Yu

2

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.


1
Você pode explicar como essa resposta é diferente da mesma resposta postada há 4 anos ?
Franklin Yu

2

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 .

versões semânticas do npm em pacotes publicados§

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


1

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.


0

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


8
Você pode explicar como essa resposta é diferente da mesma resposta postada há 4 anos ?
31560 Franklin Franklin Yu

0

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 .

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.