Differenza tra "git add -A" e "git add".

Il comando git add [--all|-A]sembra essere identico a git add .. È corretto? In caso contrario, come differiscono?

Questa risposta si applica solo alla versione 1.x di Git . Per Git versione 2.x, vedi altre risposte.

Sommario:

• git add -Amette in scena tutti i cambiamenti

• git add .mette in scena nuovi file e modifiche, senza eliminazioni

• git add -umette in scena modifiche ed eliminazioni, senza nuovi file

Dettaglio:

git add -Aè equivalente a git add .; git add -u.

Il punto importante git add .è che guarda l'albero di lavoro e aggiunge tutti quei percorsi alle modifiche organizzate se vengono cambiate o sono nuove e non ignorate, non mette in scena alcuna azione "rm".

git add -uesamina tutti i file già tracciati e mette in scena le modifiche a tali file se sono diverse o se sono state rimosse. Non aggiunge nuovi file, ma mette in scena solo modifiche a file già tracciati.

git add -A è una scorciatoia utile per fare entrambe.

Puoi testare le differenze con qualcosa del genere (nota che per Git versione 2.x il tuo output git add . git status sarà diverso):

git init
echo Change me > change-me
echo Delete me > delete-me
git add change-me delete-me
git commit -m initial

echo OK >> change-me
rm delete-me
echo Add me > add-me

git status
# Changed but not updated:
#   modified:   change-me
#   deleted:    delete-me
# Untracked files:
#   add-me

git add .
git status

# Changes to be committed:
#   new file:   add-me
#   modified:   change-me
# Changed but not updated:
#   deleted:    delete-me

git reset

git add -u
git status

# Changes to be committed:
#   modified:   change-me
#   deleted:    delete-me
# Untracked files:
#   add-me

git reset

git add -A
git status

# Changes to be committed:
#   new file:   add-me
#   modified:   change-me
#   deleted:    delete-me

Ecco una tabella per una rapida comprensione:

Versione Git 1.x :

Git versione 2.x :

Bandiere di forma lunga:

• git add -A è equivalente a git add --all
• git add -u è equivalente a git add --update

Ulteriori letture:

• Git per principianti: la guida pratica definitiva
• Hai 15 minuti e vuoi imparare Git? (in modo interattivo)
• Scopri Git Branching
• Spiega Git con D3

Con Git 2.0 git add -Aè l'impostazione predefinita: git add .uguale agit add -A . .

git add <path>è lo stesso di " git add -A <path>" adesso, quindi " git add dir/" noterà i percorsi rimossi dalla directory e registrerà la rimozione.
Nelle versioni precedenti di Git, " git add <path>" ha ignorato le rimozioni.

Puoi dire " git add --ignore-removal <path>" per aggiungere solo percorsi aggiunti o modificati <path>, se lo desideri.

git add -Aè come git add :/( aggiungi tutto dalla cartella top repository git ).
Nota che git 2.7 (novembre 2015) ti permetterà di aggiungere una cartella chiamata " :"!
Vedi commit 29abb33 (25 ott 2015) di Junio ​​C Hamano ( gitster) .

Nota che a partire da git 2.0 (Q1 o Q2 2014) , quando parli git add .(percorso corrente all'interno dell'albero di lavoro), devi usare ' .' anche negli altri git addcomandi.

Questo significa:

" git add -A ." equivale a " git add .; git add -u ."

(Nota il extra ' .' per git add -Ae git add -u)

Perché git add -Ao git add -ufunzionerebbe (solo avviando git 2.0) sull'intero albero di lavoro e non solo sul percorso corrente.

Questi comandi funzioneranno sull'intero albero in Git 2.0 per coerenza con " git commit -a" e altri comandi . Poiché non ci sarà alcun meccanismo per far " git add -u" comportarsi come se " git add -u .", è importante per coloro che sono abituati a " git add -u" (senza pathspec) aggiornare l'indice solo per i percorsi nella sottodirectory corrente per iniziare ad allenare le dita per dire esplicitamente "" git add -u ."quando lo significano prima che arrivi Git 2.0.

Viene emesso un avviso quando questi comandi vengono eseguiti senza pathspec e quando sono presenti modifiche locali all'esterno della directory corrente , poiché il comportamento in Git 2.0 sarà diverso dalla versione odierna in tale situazione.

Dalle istruzioni di Charles , dopo aver verificato la mia comprensione proposta sarebbe la seguente:

# For the next commit
$ git add .   # Add only files created/modified to the index and not those deleted
$ git add -u  # Add only files deleted/modified to the index and not those created
$ git add -A  # Do both operations at once, add to all files to the index

Questo post sul blog potrebbe anche essere utile per capire in quale situazione potrebbero essere applicati quei comandi: Rimozione dei file eliminati dalla directory di lavoro di Git .

Le cose sono cambiate con Git 2.0 ( 28/05/2014 ):

• -A è ora l'impostazione predefinita
• Il vecchio comportamento è ora disponibile con --ignore-removal.
• git add -ue git add -Ain una sottodirectory senza percorsi sulla riga di comando operare sull'intero albero.

Quindi per Git 2 la risposta è:

• git add .e git add -A .aggiungere nuovi file / modificati / eliminati nella directory corrente
• git add --ignore-removal . aggiunge i file nuovi / modificati nella directory corrente
• git add -u . aggiunge i file modificati / eliminati nella directory corrente
• Senza il punto, aggiungi tutti i file nel progetto indipendentemente dalla directory corrente.

Una risposta rapida più distillata:

Fa entrambi sotto (lo stesso di git add --all )

git add -A

Mette in scena i nuovi file + modificati

git add .

Fasi modificate + file eliminati

git add -u

In Git 2.x :

• Se ti trovi direttamente nella directory di lavoro , quindi git add -Ae git add .lavora senza la differenza.

• Se ci si trova in una sottodirectory della directory di lavoro , git add -Averranno aggiunti tutti i file dell'intera directory di lavoro e git add .verranno aggiunti i file dalla directory corrente .

E questo è tutto.

Spero che ciò possa aggiungere un po 'più di chiarezza.

!The syntax is
git add <limiters> <pathspec>
! Aka
git add (nil/-u/-A) (nil/./pathspec)

I limitatori possono essere -u o -A o zero.

Pathspec può essere un percorso file o punto, '.' per indicare la directory corrente.

Conoscenze di base importanti su come Git 'aggiunge':

• I file invisibili, quelli preceduti da un punto, (dotfile) non vengono mai riconosciuti automaticamente da Git. Non sono mai nemmeno elencati come "non tracciati".
• Le cartelle vuote non vengono mai aggiunte da Git. Non sono mai nemmeno elencati come "non tracciati". (Una soluzione alternativa consiste nell'aggiungere un file vuoto, possibilmente invisibile, ai file tracciati.)
• Lo stato di Git non visualizzerà le informazioni sulle sottocartelle, ovvero i file non tracciati, a meno che non venga tracciato almeno un file in quella sottocartella. Prima di allora, Git considera l'intera cartella al di fuori dell'ambito, come una 'vuota'. È privo di elementi tracciati.
• Specifica di filespec = '.' (punto), o la directory corrente, non è ricorsivo a meno che non -Asia specificato anche. Il punto si riferisce strettamente alla directory corrente - omette i percorsi trovati sopra e sotto.

Ora, data questa conoscenza, possiamo applicare le risposte sopra.

I limitatori sono i seguenti.

• -u= --update= sottoinsieme di file tracciati => Aggiungi = No; Modifica = Sì; Elimina = Sì. => se l'elemento viene tracciato.
• -A = --all (Tale -a, che dà errore di sintassi) = superset di tutti i file non monitorate / rintracciato, a meno che in Git prima di 2.0, in cui se il punto filespec è dato, allora solo quella particolare cartella viene considerato. => se l'elemento viene riconosciuto, git add -Alo troverà e lo aggiungerà.

Pathspec è il seguente.

• In Git prima della 2.0, per i due limitatori (aggiornamento e tutti), il nuovo valore predefinito è quello di operare sull'intero albero di lavoro, anziché sul percorso corrente (Git 1.9 o precedente),
• Tuttavia, nella versione 2.0, l'operazione può essere limitata al percorso corrente: basta aggiungere il suffisso punto esplicito (che è valido anche in Git 1.9 o precedente);

git add -A .

git add -u .

In conclusione, la mia politica è:

1. Assicurati che tutti gli hunk / file da aggiungere siano considerati in git status.
2. Se mancano elementi a causa di file / cartelle invisibili, aggiungerli separatamente.
3. Avere una buona .gitignore file in modo che normalmente solo i file di interesse non vengano tracciati e / o non riconosciuti.
4. Dal livello superiore del repository, "git add -A" per aggiungere tutti gli elementi. Funziona in tutte le versioni di Git.
5. Rimuovere gli elementi desiderati dall'indice, se desiderato.
6. Se c'è un grosso bug, fai 'git reset' per cancellare completamente l'indice.

git add . è uguale a git add -A . aggiunge i file da indicizzare solo dalle cartelle correnti e secondarie.

git add -A aggiunge i file all'indice da tutte le cartelle nell'albero di lavoro.

PS: le informazioni si riferiscono a Git 2.0 (28-05-2014).

Entrambi git add .e git add -Ametteranno in scena tutti i file nuovi, modificati ed eliminati nelle versioni più recenti di Git.

La differenza è che mette in git add -Ascena i file in "directory superiori, attuali e secondarie" che appartengono al tuo repository Git funzionante. Ma eseguendo git add .solo i file di fase nella directory corrente e nelle sottodirectory che seguono ( non i file che si trovano all'esterno, ovvero le directory superiori).

Ecco un esempio:

/my-repo
  .git/
  subfolder/
    nested-file.txt
  rootfile.txt

Se la tua directory di lavoro corrente è /my-repo, e lo fai rm rootfile.txt, quindi cd subfolder, seguita da git add ., allora il file cancellato non verrà messo in scena. Ma fare git add -Acertamente metterà in scena questo cambiamento, indipendentemente da dove esegui il comando.

L' -Aopzione aggiunge, modifica e rimuove le voci di indice in modo che corrispondano all'albero di lavoro.

In Git 2 l' -Aopzione è ora predefinita.

Quando .viene aggiunto un che limita l'ambito dell'aggiornamento alla directory in cui ci si trova attualmente, secondo la documentazione di Git

Se non <pathspec>viene fornita alcuna opzione quando viene utilizzata l'opzione -A, vengono aggiornati tutti i file nell'intero albero di lavoro (le vecchie versioni di Git venivano utilizzate per limitare l'aggiornamento alla directory corrente e alle sue sottodirectory).

Una cosa che aggiungerei è che se viene utilizzata la modalità --interactiveo -p, git addsi comporterà come se -ufosse utilizzato il flag update ( ) e non aggiungesse nuovi file.