Qual è la differenza tra tilde (~) e caret (^) in package.json?

Dopo che ho aggiornato a più stabile nodee npm, ho provato npm install moment --save. Salva la voce nel package.jsoncon il ^prefisso caret . In precedenza, era un ~prefisso tilde .

1. Perché vengono apportate queste modifiche npm?
2. Qual'è la differenza tra tilde ~e caret ^?
3. Quali sono i vantaggi rispetto agli altri?

Vedi i documenti NPM e i documenti semver :

• ~ versione "Approssimativamente equivalente alla versione", ti aggiornerà a tutte le future versioni di patch, senza incrementare la versione minore. ~1.2.3utilizzerà le versioni da 1.2.3 a <1.3.0.

• ^ versione "Compatibile con la versione", ti aggiornerà a tutte le future versioni minori / patch, senza incrementare la versione principale. ^2.3.4utilizzerà le versioni da 2.3.4 a <3.0.0.

Vedere i commenti di seguito per le eccezioni, in particolare per le versioni precedenti, come ^ 0.2.3

Vorrei aggiungere anche la documentazione ufficiale di npmjs che descrive tutti i metodi per la specificità della versione inclusi quelli a cui si fa riferimento nella domanda -

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

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

• ~version"Approssimativamente equivalente alla versione" Vedi npm semver - Tilde Ranges & semver (7)
• ^version"Compatibile con la versione" Vedi npm semver - Caret Ranges & semver (7)
• version Deve corrispondere esattamente alla versione
• >version Deve essere maggiore della versione
• >=version eccetera
• <version
• <=version
• 1.2.x 1.2.0, 1.2.1, ecc., Ma non 1.3.0
• http://sometarballurl (questo potrebbe essere l'URL di un tarball che verrà scaricato e installato localmente
• * Abbina qualsiasi versione
• latest Ottiene l'ultima versione

L'elenco sopra non è esaustivo. Altri identificatori di versione includono URL GitHub e repository utente GitHub, percorsi locali e pacchetti con tag npm specifici

npm consente l'installazione di una versione più recente di un pacchetto rispetto a quella specificata. L'uso di tilde ( ~) ti dà rilasci di bug fix e caret ( ^) ti dà anche nuove funzionalità compatibili con le versioni precedenti.

Il problema è che le vecchie versioni di solito non ricevono così tante correzioni di bug, quindi npm usa caret ( ^) come predefinito per --save.

Secondo: "Semver ha spiegato - perché c'è un cursore (^) nel mio package.json?" .

Si noti che le regole si applicano alle versioni precedenti alla 1.0.0 e non tutti i progetti seguono il controllo delle versioni semantico. Per le versioni 0.xx il cursore consente solo gli aggiornamenti delle patch , ovvero si comporta come la tilde. Vedi "Caret Ranges"

Ecco una spiegazione visiva dei concetti:

Fonte: "Cheatsheet di versione semantica" .

Semver

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

• Utilizzare il calcolatore sempm npm per i test. (Sebbene le spiegazioni per ^ (includa tutto ciò che è maggiore di una determinata versione nello stesso intervallo principale) e ~ (includa tutto ciò che è maggiore di una versione particolare nello stesso intervallo minore) non siano corrette al 100%, la calcolatrice sembra funzionare correttamente )
• In alternativa, utilizzare SemVer Check , che non richiede di scegliere un pacchetto e offre anche spiegazioni.

Consentire o impedire modifiche

• Versione Pin: 1.2.3.
• Usa ^(come la testa). Consente aggiornamenti al secondo livello diverso da zero da sinistra: ^0.2.3significa 0.2.3 <= v < 0.3.
• Usa ~(come la coda). Blocca generalmente il livello più a destra o imposta zero se omesso:
  • ~1 si intende 1.0.0 <= v < 2.0.0
  • ~1.2significa 1.2.0 <= v < 1.3.0.
  • ~1.2.4significa 1.2.4 <= v < 1.3.0.
• Ommit livello più a destra: 0.2significa 0.2 <= v < 1. Differisce da ~perché:
  • L'avvio della versione di livello omesso è sempre 0
  • È possibile impostare l'avvio della versione principale senza specificare i livelli secondari.

Tutte (possibilmente) possibilità

Impostare l'avvio a livello principale e consentire gli aggiornamenti verso l'alto

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

Congelare il livello principale

~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

Blocco di livello secondario

^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

Congela a livello di 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)

Non consentire aggiornamenti

1.2.3             1.2.3
^0.0.3 (0.0.3)    0.0.3

Avviso : mancante maggiore, minore, patch o specifica betasenza numero, è lo stesso anydel livello mancante.

Avviso : quando installi un pacchetto che ha 0il livello principale, l'aggiornamento installerà solo la nuova versione del livello beta / pr! Questo perché npmimposta ^come predefinito in package.jsone quando la versione installata è simile 0.1.3, congela tutti i livelli principali / minori / patch.

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

~corregge numeri maggiori e minori. Viene utilizzato quando si è pronti ad accettare correzioni di errori nella propria dipendenza, ma non si desidera apportare modifiche potenzialmente incompatibili.

^corregge solo il numero principale. Viene utilizzato quando si osservano da vicino le proprie dipendenze e si è pronti a modificare rapidamente il codice se la versione minore sarà incompatibile.

Inoltre, non^ è supportato dalle vecchie versioni di npm e deve essere usato con cautela.

Quindi, ^è un buon default, ma non è perfetto. Suggerisco di scegliere con cura e configurare l'operatore semver che ti è più utile.

~: Ragionevolmente vicino a

   ~1.1.5: 1.1.0 <= accepted < 1.2.0

^: Compatibile con

   ^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. [qualsiasi]. [qualsiasi] (ultima versione minore)
~è 1.2. [qualsiasi] (ultima patch)

Una buona lettura è questo post sul blog su come si applica semver a npm
e cosa stanno facendo per farlo corrispondere allo standard semver
http://blog.npmjs.org/post/98131109725/npm-2-0-0

Cappello di corrispondenza può essere considerato "spezzato" perché non ci vorrà modificare ^0.1.2a 0.2.0. Quando il software sta emergendo, utilizzare le 0.x.yversioni e la corrispondenza del cappello corrisponderanno solo all'ultima cifra variabile ( y). Questo è fatto apposta. Il motivo è che mentre il software si sta evolvendo l'API cambia rapidamente: un giorno hai questi metodi e l'altro giorno hai quei metodi e quelli vecchi se ne sono andati. Se non vuoi rompere il codice per le persone che stanno già utilizzando la tua libreria, vai e incrementa la versione principale: ad es. 1.0.0-> 2.0.0-> 3.0.0. Quindi, quando il tuo software sarà finalmente completo al 100% e pieno di funzionalità, sarà come una versione 11.0.0e questo non sembra molto significativo e in realtà sembra confuso. Se lo fosse, invece, usi 0.1.x->0.2.x-> 0.3.xversioni quindi quando il software è finalmente completo al 100% e full-optional viene rilasciato come versione 1.0.0e significa "Questa versione è di lunga durata, puoi procedere e utilizzare questa versione della libreria nella tua produzione codice e l'autore non cambierà tutto domani o il mese prossimo e non abbandonerà il pacchetto ".

La regola è: usa il controllo delle 0.x.yversioni quando il tuo software non è ancora maturato e rilascialo con l'incremento della cifra media quando l'API pubblica cambia (quindi le persone che ^0.1.0non avranno l' 0.2.0aggiornamento e non romperanno il loro codice). Quindi, quando il software matura, rilascialo sotto 1.0.0e incrementa la cifra più a sinistra ogni volta che cambia l'API pubblica (quindi le persone che ^1.0.0non avranno l' 2.0.0aggiornamento e non romperanno il loro codice).

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 i numeri maggiori e minori.
• Viene utilizzato quando si è pronti ad accettare correzioni di errori nella propria dipendenza, ma non si desidera apportare modifiche potenzialmente incompatibili.
• La tilde corrisponde alla versione minore più recente (il numero medio).
• ~ 1.2.3 corrisponderà a tutte le versioni 1.2.x, ma mancherà 1.3.0.
• Tilde (~) ti dà le versioni di correzione dei bug

^ Caret:

• ^ blocca solo il numero principale.
• Viene utilizzato quando si osservano da vicino le proprie dipendenze e si è pronti a modificare rapidamente il codice se la versione minore sarà incompatibile.
• Ti aggiornerà alla versione principale più recente (il primo numero).
• ^ 1.2.3 corrisponderà a qualsiasi versione 1.xx inclusa 1.3.0, ma rimarrà bloccata su 2.0.0.
• Caret (^) offre anche nuove funzionalità compatibili con le versioni precedenti.

Tilde ~ corrisponde alla versione secondaria, se hai installato un pacchetto che ha 1.4.2 e dopo l'installazione, sono disponibili anche le versioni 1.4.3 e 1.4.4 se nel tuo pacchetto. Json è usato come ~ 1.4.2 quindi npm install nel progetto dopo l'aggiornamento verrà installato 1.4.4 nel progetto. Ma è disponibile 1.5.0 per quel pacchetto, quindi non verrà installato da ~. Si chiama versione secondaria.

Caret ^ corrisponde alla versione principale, se il pacchetto 1.4.2 è installato nel progetto e dopo il rilascio dell'installazione 1.5.0, ^ installerà la versione principale. Non consentirà di installare 2.1.0 se si dispone di ^ 1.4.2 .

Versione fissa se non si desidera modificare la versione del pacchetto su ciascuna installazione, quindi utilizzare la versione fissa senza caratteri speciali, ad es. "1.4.2"

Ultima versione * Se si desidera installare l'ultima versione, utilizzare solo * davanti al nome del pacchetto.

Una spiegazione di copertina

Il sistema di versione standard è major.minor.build (ad es. 2.4.1)

npm controlla e corregge la versione di un determinato pacchetto in base a questi caratteri

~ : la versione principale è fissa, la versione secondaria è fissa, corrisponde a qualsiasi numero di build

es: ~ 2.4.1 significa che controllerà 2.4.x dove x è qualcosa

^ : la versione principale è fissa, corrisponde a qualsiasi versione minore, corrisponde a qualsiasi numero di build

es: ^ 2.4.1 significa che controllerà 2.xx dove x è qualcosa

Probabilmente hai visto tilde (~) e caret (^) in package.json. Qual'è la differenza tra loro?

Quando si esegue npm install moment --save, salva la voce in package.json con il prefisso caret (^).

La tilde (~)

In parole povere, la tilde (~) corrisponde alla versione minore più recente (il numero medio). ~ 1.2.3 corrisponderà a tutte le versioni 1.2.x ma mancherà 1.3.0.

The caret (^)

Il cursore (^), d'altra parte, è più rilassato. Ti aggiornerà alla versione principale più recente (il primo numero). ^ 1.2.3 corrisponderà a qualsiasi versione 1.xx inclusa 1.3.0, ma rimarrà disattivata su 2.0.0.

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

semver è separato in 3 sezioni principali che è rotto da punti.

major.minor.patch
1.0.0

Queste differenti major, minor e patch stanno usando per identificare diverse versioni. tide (~) e caret (^) stanno usando per identificare quale versione minore e patch usare nella versione del pacchetto.

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

la versione principale è fissa, la versione secondaria è fissa, corrisponde a qualsiasi numero di build

"express": "~4.13.3" 

~4.13.3 significa che controllerà 4.13.x dove x è qualcosa e 4.14.0

Caret (^)

la versione principale è fissa, corrisponde a qualsiasi versione minore, corrisponde a qualsiasi numero di build

"supertest": "^3.0.0"

^3.0.0 significa che controllerà 3.xx dove x è qualcosa

Il numero di versione è in sintassi che designa ogni sezione con significato diverso. la sintassi è suddivisa in tre sezioni separate da un punto.

major.minor.patch 1.0.2

Major, minor e patch rappresentano le diverse versioni di un pacchetto.

npm usa tilde (~) e caret (^) per designare quale patch e versioni minori usare rispettivamente.

Quindi, se vedi ~ 1.0.2 significa installare la versione 1.0.2 o l'ultima versione della patch come 1.0.4. Se vedi ^ 1.0.2 significa installare la versione 1.0.2 o l'ultima versione minore o patch come 1.1.0.

carati ^ includono tutto ciò che è maggiore di una versione particolare nella stessa gamma principale.

tilde ~ include tutto ciò che è maggiore di una versione particolare nella stessa gamma minore.

Ad esempio, per specificare intervalli di versioni accettabili fino alla 1.0.4, utilizzare la sintassi seguente:

• Rilasci di patch: 1.0 o 1.0.xo ~ 1.0.4
• Rilasci minori: 1 o 1.xo ^ 1.0.4
• Rilasci principali: * o x

Per ulteriori informazioni sulla sintassi del versioning semantico, consultare il calcolatore del semver npm .

Altro dalla documentazione di npm Informazioni sul controllo delle versioni semantico

Non una risposta di per sé, ma un'osservazione che sembra essere stata trascurata.

La descrizione per le gamme di carati:

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

Consente modifiche che non modificano la cifra diversa da zero più a sinistra nella tupla [maggiore, minore, patch].

Mezzi che ^10.2.3corrispondono10.2.3 <= v < 20.0.0

Non penso sia quello che volevano dire. L'estrazione delle versioni da 11.xx a 19.xx interromperà il tuo codice.

Penso che intendessero left most non-zero number field. Non c'è nulla in SemVer che richiede che i campi numerici siano a una cifra.

~ specifica alle versioni di versioni minori ^ specifica alle versioni di versioni principali

Ad esempio, se la versione del pacchetto è 4.5.2, in Aggiornamento ~ 4.5.2 verrà installata la versione 4.5.x più recente (VERSIONE MINORE) ^ 4.5.2 verrà installata la versione 4.xx più recente (VERSIONE MAGGIORE)

In relazione a questa domanda puoi consultare la documentazione di Composer sulle versioni , ma qui in breve:

• Intervallo versione Tilde ( ~ ) - ~ 1.2.3 è equivalente a> = 1.2.3 < 1.3.0
• Intervallo versione Caret ( ^ ) - ~ 1.2.3 è equivalente a> = 1.2.3 < 2.0.0

Quindi, con Tilde otterrai aggiornamenti automatici delle patch, ma le versioni minori e principali non verranno aggiornate. Tuttavia, se usi Caret otterrai patch e versioni secondarie, ma non otterrai versioni principali (modifiche non funzionanti).

La versione di Tilde è considerata un approccio "più sicuro", ma se si utilizzano dipendenze affidabili (librerie ben mantenute) non si dovrebbero riscontrare problemi con la versione Caret (poiché le modifiche minori non devono interrompere le modifiche.

Probabilmente dovresti rivedere questo post di StackOverflow sulle differenze tra l'installazione del compositore e l'aggiornamento del compositore .