Différence entre "git add -A" et "git add."

Question

La commande git add [--all|-A] semble être identique à git add .. Est-ce correct? Si non, en quoi diffèrent-ils?

Answer 1

Cette réponse ne s'applique qu'à Git version 1.x. Pour Git version 2.x, voir les autres réponses.

---

Résumé:

• git add -A étapes toutes les modifications

• git add . met en scène les nouveaux fichiers et les modifications, sans suppressions

• git add -u met en place les modifications et les suppressions, sans nouveaux fichiers

---

Détail:

git add -A est équivalent à git add .; git add -u.

Le point important à propos de git add . est qu’il examine l’arborescence de travail et ajoute tous ces chemins aux modifications échelonnées si elles sont modifiées ou si elles sont nouvelles et ne sont pas ignorées.

git add -u examine tous les fichiers suivis déjà et met en forme les modifications apportées à ces fichiers si elles sont différentes ou si elles ont été supprimées. Il n'ajoute aucun nouveau fichier, il ne modifie que les modifications apportées aux fichiers déjà suivis.

git add -A est un raccourci pratique pour faire les deux.

Vous pouvez tester les différences avec quelque chose comme ceci (notez que pour Git version 2.x, votre sortie pour git add .git statussera différente):

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

Answer 2

Voici un tableau pour une compréhension rapide:

Git Version 1.x : 

Git Version 2.x : 

Drapeaux longs:

• git add -A est équivalent à git add --all
• git add -u est équivalent à git add --update

Lectures supplémentaires:

• Git pour les débutants: le guide pratique définitif
• Vous avez 15 minutes et vous voulez apprendre Git? (De manière interactive)
• http://pcottle.github.io/learnGitBranching/
• expliquer Git avec D

Answer 3

Avec Git 2.0, _git add -A_ est la valeur par défaut: _git add ._ est égal à _git add -A ._ .

_git add <path>_ est maintenant identique à "_git add -A <path>_", de sorte que "_git add dir/_" remarquera les chemins que vous avez supprimés du répertoire et enregistrera la suppression.
Dans les anciennes versions de Git, "_git add <path>_" était utilisé pour ignorer les suppressions.

Vous pouvez dire "_git add --ignore-removal <path>_" pour ajouter uniquement les chemins ajoutés ou modifiés dans _<path>_, si vous le souhaitez vraiment.

_git add_ est comme _git add :/_ ( ajoutez tout du dossier de dépôt principal git ).
Notez que git 2.7 (nov. 2015) vous permettra d'ajouter un dossier nommé "_:_"!
Voir commit 29abb (25 octobre 2015) par Junio ​​C Hamano (gitster) .

---

Notez que à partir de git 2.0 (Q1 ou Q2 2014) , lorsque vous parlez de git add . (chemin actuel dans le (arbre de travail), vous devez également utiliser '_._' dans les autres commandes _git add_.

Cela signifie:

"_git add -A ._" est équivalent à "_git add .; git add -u ._"

(Notez le '_._' supplémentaire pour _git add -A_ et _git add -u_)

Parce que _git add -A_ ou _git add -u_ fonctionnerait (à partir de git 2.0 uniquement) sur l’arbre de travail entier , et pas uniquement sur l’actuel chemin.

Ces commandes fonctionneront sur l’ensemble de l’arborescence de Git 2.0 pour des raisons de cohérence avec "_git commit -a_" et d’autres commandes . Parce qu'il n'y aura aucun mécanisme pour que "_git add -u_" se comporte comme si "_git add -u ._", il est important pour ceux qui sont habitués à "_git add -u_" (sans pathspec) de mettre à jour l'index uniquement. pour que les chemins du sous-répertoire courant commencent à entraîner leurs doigts à dire explicitement "_git add -u ._" quand ils le veulent vraiment avant la sortie de Git 2.0.

Un avertissement est émis lorsque ces commandes sont exécutées sans pathspec et lorsque des modifications locales sont effectuées en dehors du répertoire en cours , car le comportement dans Git 2.0 sera différent. de la version d'aujourd'hui dans une telle situation.

Answer 4

De instructions de Charles , après avoir testé ma compréhension proposée serait la suivante:

# 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

Ce billet de blog pourrait également être utile pour comprendre dans quelle situation ces commandes peuvent être appliquées: Suppression des fichiers supprimés de votre répertoire de travail Git.

Answer 5

Une réponse rapide plus distillée:

Est-ce que les deux en dessous (même chose que git add --all)

git add -A

Étapes nouveau + fichiers modifiés

git add .

Etapes modifiées + fichiers supprimés

git add -u

Answer 6

Les choses ont changé avec Git 2.0:

• -A est maintenant la valeur par défaut
• l'ancien comportement est maintenant disponible avec --ignore-removal
• git add -u et git add -A dans un sous-répertoire sans chemin sur la ligne de commande agissent sur toute l'arborescence

Donc, pour git 2, la réponse est:

• git add . et git add -A . ajoutent des fichiers nouveaux/modifiés/supprimés dans le répertoire en cours
• git add --ignore-removal . ajoute des fichiers nouveaux/modifiés dans le répertoire en cours
• git add -u . ajoute des fichiers modifiés/supprimés dans le répertoire actuel
• sans le point, ajoute tous les fichiers du projet, quel que soit le répertoire en cours

Answer 7

Dans Git 2.x:

• Si vous vous trouvez directement dans le répertoire de travail , alors git add -A et git add . fonctionnent sans différence.

• Si vous êtes dans n’importe quel sous-répertoire du répertoire de travail , git add -A ajoutera tous les fichiers de l’ensemble répertoire de travail , et git add . ajoutera des fichiers de votre répertoire actuel .

Et c'est tout.

Answer 8

Enfin, je pense que je comprends cela, merci beaucoup à vous tous. J'espère que cela apportera plus de clarté.

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

Les limiteurs peuvent être -u ou -A ou nil.

Pathspec peut être un chemin de fichier ou un point, '.' pour indiquer le répertoire en cours.

Connaissances de base importantes sur la façon dont git "ajoute".

• Les fichiers invisibles, ceux préfixés par un point, ne sont jamais automatiquement reconnus par Git. Ils ne sont même jamais répertoriés comme "non suivis".
• Les dossiers vides ne sont jamais ajoutés par git. Ils ne sont même jamais répertoriés comme "non suivis". (Une solution de contournement consiste à ajouter un fichier vide, éventuellement invisible, aux fichiers suivis.)
• L'état Git n'affichera pas les informations sur les sous-dossiers, c'est-à-dire les fichiers non suivis, sauf si au moins un fichier de ce sous-dossier est suivi. Auparavant, git considérait le dossier entier comme étant "vide". Il est vide d'éléments suivis.
• Spécifier une spécification de fichier = '.' (point), ou le répertoire en cours, n'est pas récursif à moins que -A soit également spécifié. Le point fait strictement référence au répertoire en cours - il omet les chemins trouvés en haut et en bas.

Maintenant, étant donné cette connaissance, nous pouvons appliquer les réponses ci-dessus.

Les limiteurs sont les suivants.

• -u = --update = sous-ensemble de fichiers suivis => Add = No; Changer = Oui; Supprimer = Oui. => ssi l'article est suivi.
• -A = --all (pas de tel -a, ce qui donne une erreur de syntaxe) = sur-ensemble de tous les fichiers non suivis/suivis, sauf dans Git <2.0, où si la spécification de fichier point est donnée, seul ce dossier particulier est considéré. => ssi l'élément est reconnu, git add -A le trouvera et l'ajoutera.

Le pathspec est comme suit.

• Dans Git <2.0, pour les deux limiteurs (update et all), la nouvelle valeur par défaut consiste à opérer sur tout l’arborescence de travail, au lieu du chemin actuel (git <= 1.9),
• Cependant, dans la version 2.0, l'opération peut être limitée au chemin actuel: ajoutez simplement le suffixe de point explicite (qui est également valide dans Git <= 1.9);

git add -A .

git add -u .

En conclusion, ma politique est la suivante:

• 1.Assurez-vous que les éléments/fichiers à ajouter sont comptabilisés dans l'état git.
• 1A.Si des éléments sont manquants, en raison de fichiers/dossiers invisibles, ajoutez-les séparément.
• 2.Utilisez un bon gitignore afin que, normalement, seuls les fichiers d’intérêt ne soient ni suivis ni reconnus.
• 3.À partir du niveau supérieur du référentiel, "git add -A" pour ajouter tous les éléments. Cela fonctionne dans toutes les versions de git.
• 4. Supprimez tous les éléments souhaités de l'index, si vous le souhaitez.
• 6. S'il y a un gros bug, faites 'git reset' pour effacer complètement l'index.

Answer 9

git add . est égal à git add -A . ajoute des fichiers à indexer uniquement à partir des dossiers en cours et enfants.

git add -A ajoute des fichiers à indexer à partir de tous les dossiers de l'arborescence de travail.

P.S .: les informations concernent Git 2.0.

Answer 10

L'option -A ajoute, modifie et supprime les entrées d'index pour correspondre à l'arborescence de travail.

Dans GIT 2, l’option -A est maintenant définie par défaut.

Lorsqu'un . est ajouté, ce qui limite la portée de la mise à jour au répertoire dans lequel vous vous trouvez, comme indiqué dans le documentation Git

Si aucun <pathspec> n'est donné lorsque l'option -A est utilisée, tous les fichiers de l'ensemble de l'arborescence de travail sont mis à jour (les anciennes versions de Git limitaient la mise à jour au répertoire actuel et à ses sous-répertoires).

Une chose que j’ajouterais est que si le mode --interactive ou -p est utilisé, alors git add se comportera comme si le drapeau update (-u) était utilisé et n’ajoutait pas de nouveaux fichiers.

Answer 11

git add . et git add -A organisent tous les fichiers nouveaux, modifiés et supprimés dans les nouvelles versions de git.

La différence est que git add -A organise les fichiers dans les répertoires "upper, current et sub", qui appartiennent à votre référentiel git de travail. Mais faire un git add . ne met en scène que les fichiers du répertoire courant et des sous-répertoires suivants (PAS les fichiers situés en dehors des répertoires supérieurs).

Voici un exemple:

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

Si votre répertoire de travail actuel est /my-repo, et que vous faites rm rootfile.txt, puis cd subfolder, suivi de git add ., il ne mettra PAS en scène le fichier supprimé. Mais faire git add -A organisera certainement ce changement, peu importe où vous exécuterez la commande.

J'espère que cela efface la différence.