Différence entre «git add -A» et «git add».

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

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

Sommaire:

• git add -Amet en scène tous les changements

• git add .étapes de nouveaux fichiers et modifications, sans suppressions

• git add -uétapes modifications et suppressions, sans nouveaux fichiers

Détail:

git add -Aest équivalent à git add .; git add -u.

L'important, git add .c'est qu'il regarde l'arborescence de travail et ajoute tous ces chemins aux changements par étapes s'ils sont modifiés ou nouveaux et non ignorés, il ne met en scène aucune action «rm».

git add -uexamine tous les fichiers déjà suivis et organise les modifications apportées à ces fichiers s'ils sont différents ou s'ils ont été supprimés. Il n'ajoute aucun nouveau fichier, il ne fait que transposer les modifications 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 ça (notez que pour Git version 2.x, votre sortie pour git add . git status sera 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

Voici un tableau pour une compréhension rapide:

Git version 1.x :

Git version 2.x :

Indicateurs de forme longue:

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

Lectures complémentaires:

• Git pour les débutants: le guide pratique définitif
• Vous avez 15 minutes et vous voulez apprendre Git? (de manière interactive)
• Learn Git Branching
• Expliquez Git avec D3

Avec Git 2.0, git add -Aest par défaut: git add .égal àgit add -A . .

git add <path>est identique à " git add -A <path>" maintenant, 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, les " git add <path>" ignoraient 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 -Aest comme git add :/( ajouter tout depuis le dossier git repo supérieur ).
Notez que git 2.7 (novembre 2015) vous permettra d'ajouter un dossier nommé " :"!
Voir commit 29abb33 (25 octobre 2015) de Junio ​​C Hamano ( gitster) .

Notez que à partir de git 2.0 (Q1 ou Q2 2014) , lorsque vous parlez de git add .(chemin actuel dans l'arborescence de travail), vous devez également utiliser ' .' dans les autres git addcommandes.

Cela signifie:

" git add -A ." équivaut à " git add .; git add -u ."

(Notez le supplément ' .' pour git add -Aet git add -u)

Parce que git add -Aou git add -ufonctionnerait (à partir de git 2.0 uniquement) sur la totalité de l'arborescence de travail , et pas seulement sur le chemin actuel.

Ces commandes fonctionneront sur l'arborescence entière dans Git 2.0 pour des raisons de cohérence avec " git commit -a" et d'autres commandes . Puisqu'il n'y aura pas de 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 les chemins du sous-répertoire courant pour commencer à entraîner leurs doigts à dire explicitement "git add -u . "quand ils le pensent avant la sortie de Git 2.0.

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

D' après les 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 peut également être utile pour comprendre dans quelle situation ces commandes peuvent être appliquées: Suppression de fichiers supprimés de votre répertoire de travail Git .

Les choses ont changé avec Git 2.0 ( 2014-05-28 ):

• -A est maintenant la valeur par défaut
• L'ancien comportement est désormais disponible avec --ignore-removal .
• git add -uet git add -Adans un sous-répertoire sans chemins sur la ligne de commande opèrent sur la totalité de l'arborescence.

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

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

Une réponse rapide plus distillée:

Fait les deux ci-dessous (comme git add --all )

git add -A

Stades nouveaux fichiers + modifiés

git add .

Étapes fichiers modifiés + supprimés

git add -u

Dans Git 2.x :

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

• Si vous êtes dans un sous-répertoire du répertoire de travail , git add -Aajoutera tous les fichiers de l'ensemble du répertoire de travail et git add .ajoutera des fichiers de votre répertoire actuel .

Et c'est tout.

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

Connaissances de base importantes sur la façon dont Git «ajoute»:

• Les fichiers invisibles, ceux préfixés par un point, (dotfiles) 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 vierge, éventuellement invisible, aux fichiers suivis.)
• L'état Git n'affichera pas les informations de sous-dossier, c'est-à-dire les fichiers non suivis, à moins qu'au moins un fichier de ce sous-dossier ne soit suivi. Avant cela, Git considère que le dossier entier est hors de portée, à la «vide». Il est vide d'éléments suivis.
• Spécification d'un filespec = '.' (point), ou le répertoire courant, n'est pas récursif sauf s'il -Aest également spécifié. Le point se réfère strictement au répertoire courant - il omet les chemins trouvés au-dessus et en dessous.

Maintenant, étant donné ces connaissances, nous pouvons appliquer les réponses ci-dessus.

Les limiteurs sont les suivants.

• -u= --update= sous-ensemble des fichiers suivis => Ajouter = Non; Changement = Oui; Supprimer = Oui. => si l'article est suivi.
• -A= --all(pas de tel -a, ce qui donne une erreur de syntaxe) = surensemble de tous les fichiers non suivis / suivis, sauf dans Git avant 2.0, où si la spécification de fichier dot est donnée, alors seul ce dossier particulier est pris en compte. => si l'élément est reconnu, git add -Ale trouvera et l'ajoutera.

La pathspec est la suivante.

• Dans Git avant 2.0, pour les deux limiteurs (mise à jour et tous), la nouvelle valeur par défaut est d'opérer sur la totalité de l'arborescence de travail, au lieu du chemin actuel (Git 1.9 ou antérieur),
• Cependant, dans v2.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 ou antérieur);

git add -A .

git add -u .

En conclusion, ma politique est la suivante:

1. Assurez-vous que tous les morceaux / fichiers à ajouter sont pris en compte dans git status.
2. Si des éléments manquent en raison de fichiers / dossiers invisibles, ajoutez-les séparément.
3. Avoir une bonne .gitignore fichier pour que normalement seuls les fichiers d'intérêt ne soient pas suivis et / ou non reconnus.
4. Depuis le niveau supérieur du référentiel, "git add -A" pour ajouter tous les éléments. Cela fonctionne dans toutes les versions de Git.
5. Supprimez tous les éléments souhaités de l'index si vous le souhaitez.
6. S'il y a un gros bogue, faites 'git reset' pour effacer entièrement l'index.

git add . équivaut à git add -A . ajoute des fichiers à indexer uniquement à partir des dossiers actuels et enfants.

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

PS: les informations concernent Git 2.0 (2014-05-28).

Les deux git add .et git add -Amettront en scène tous les fichiers nouveaux, modifiés et supprimés dans les nouvelles versions de Git.

La différence est que les git add -Afichiers sont placés dans des "sous-répertoires supérieurs, actuels et" qui appartiennent à votre référentiel Git fonctionnel. Mais faire git add .uniquement des fichiers d'étapes dans le répertoire courant et les sous-répertoires qui le suivent ( pas les fichiers se trouvant à l'extérieur, c'est-à-dire les 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 vous le faites rm rootfile.txt, puis cd subfolder, puis git add ., il ne mettra pas en scène le fichier supprimé. Mais en faisantgit add -A va certainement mettre en scène ce changement, peu importe d'où vous exécutez la commande.

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

Dans Git 2, l' -Aoption est maintenant la valeur par défaut.

Quand un .est ajouté qui limite la portée de la mise à jour au répertoire dans lequel vous vous trouvez actuellement, selon la documentation Git

Si no <pathspec>est indiqué lorsque l'option -A est utilisée, tous les fichiers de l'arborescence de travail entière sont mis à jour (les anciennes versions de Git étaient utilisées pour limiter la mise à jour au répertoire en cours et à ses sous-répertoires).

Une chose que j'ajouterais est que si le mode --interactiveou -pest utilisé, il git addse comportera comme si l' -uindicateur update ( ) était utilisé et n'ajoutait pas de nouveaux fichiers.