Git, aide-mémoire

Ressources

• La documentation officielle : https://git-scm.com/doc
• Pages de manuel importantes :
  • git(1),
  • gittutorial(7),
  • gitglossary(7).
• Le livre Pro Git (disponible en français) : https://git-scm.com/book/
• Une référence visuelle de Git
• (Visual) Git Cheatsheet

Création d'un dépôt

À partir de rien :

git init nom_du_dépôt

ou :

mkdir nom_du_dépôt
cd nom_du_dépôt
git init

À partir d'un dépôt existant :

git clone adresse_du_dépôt

Enregistrer des modifications

Ajouter un fichier non versionné, ou marquer pour commit un fichier modifié :

git add fichier

Ajouter tous les fichiers d'un répertoire (suivis et nouveaux) :

git add répertoire

(git add . est souvent utile.)

Ajouter tous les fichiers suivis qui ont été modifiés :

git add -u

On peut également spécifier un répertoire (par exemple git add -u .).

On peut aussi ajouter des fichiers en mode interactif en utilisant l'option -i, y compris ajouter partiellement des modifications sur un fichier (option -p pour le faire directement) :

git add -i

Démarquer un fichier :

git reset fichier

Tout démarquer :

git reset

Supprimer un fichier (utiliser --cached pour ne pas le supprimer de la copie de travail) :

git rm

Commiter les modifications enregistrées :

git commit

Commiter toutes les modifications (enregistrées ou non, mais pas les nouveaux fichiers) :

git commit -a

Annuler les modifications sur le fichier « fichier » :

git checkout fichier

Observer les changements

Quels fichiers ont été modifiés dans la copie de travail ?

git status

Visualiser le diff entre la copie de travail et la branche courante (HEAD) :

git diff

Visualiser la zone de staging (les fichiers ajoutés), c'est-à-dire ce que contiendra le prochain commit (les deux commandes sont équivalentes) :

git diff --cached
git diff --staged

Visualiser le diff entre deux références (SHA-1, branches, etc.) :

git diff ref1 ref2

Visualiser un commit (remplacer ref par un SHA-1 ou autre référence) :

git show ref

On peut passer grosso modo les mêmes options à git show qu'à git log (--stat, -p, etc., voir ci-dessous).

Visualiser le diff complet d'un commit de fusion (merge) :

git show -m ref

Ajouter --stat pour ne voir que la liste des fichiers modifiés par les deux parents.

Voir l'historique de la branche courante :

git log

Voir l'historique de la branche master :

git log master

Voir l'historique de tout le dépôt :

git log --all

Essayez aussi les options suivantes de git log :

• -p pour visualiser les diffs
• --stat pour afficher le résumé des fichiers modifiés
• --decorate pour afficher les références (tags, branches, etc.)
• --pretty=oneline et --oneline
• --all --graph

Une bonne combinaison pour observer l'historique général du dépôt :

git log --oneline --graph --all --decorate

Ou mieux, après avoir ajouté l'alias suivant, on pourra taper git glog et avoir en plus la date et le nom de l'auteur de chaque commit :

git config --global alias.glog "log --pretty=format:'%C(auto)%h%d %s %C(auto,green)(%ar) %C(auto,bold blue)<%an>%Creset' --date=relative --graph --all"

Interfaces graphiques

Deux interfaces graphiques intéressantes sont fournies avec Git. Gitk permet de visualiser l'historique des changements sur une branche, ou sur toutes les branches du dépôt avec l'option --all :

gitk --all

Git GUI permet de préparer les commits en mode graphique, en visualisant les changements sur chaque fichier. Il est par exemple plus pratique que git add -p pour marquer partiellement un fichier pour commit.

git gui

Branches

Note : en faisant des expériences sur les branches, n'hésitez pas à observer le dépôt avec gitk --all ou la commande git log donnée ci-dessus.

Voir la liste des branches locales :

git branch

Voir la liste des branches distantes :

git branch -r

Voir la liste de toutes les branches :

git branch -a

Créer une nouvelle branche au même point que la branche courante, mais en restant sur la branche courante :

git branch nom_de_la_branche

Changer de branche (si l'on passe l'identifiant d'un commit, une branche temporaire sera créée) :

git checkout branche_ou_commit

Créer une nouvelle branche (éventuellement à partir d'une autre branche ou d'un commit), et se placer dessus :

git checkout -b nom_de_la_branche [ branche_ou_commit ]

Ajouter les commits de la branche « dev » à la branche « master » de manière à avoir un historique linéaire (git se placera automatiquement sur la branche dev) :

git rebase master dev

Ou si on est déjà sur la branche dev :

git rebase master

Fusionner la branche dev dans la branche master (en créant un commit de merge ayant deux parents si les branches ont divergé) :

git checkout master
git merge dev

Supprimer une branche :

git branch -d nom_de_la_branche

Forcer la suppression d'une branche non fusionnée :

git branch -D nom_de_la_branche

Sauvegarder les changements de manière temporaire (stash)

Pour nettoyer la copie de travail de tout changement (par exemple pour permettre le changement de branche) :

git stash

Les modifications seront sauvegardées dans une sorte de commit temporaire (visible par exemple dans gitk --all).

Il est possible d'appeler git stash plusieurs fois. On peut visualiser la liste des changements sauvegardés :

git stash list

Pour réappliquer la dernière sauvegarde, on utilise git stash apply (ce qui conservera la sauvegarde) ou git stash pop (ce qui la supprimera), éventuellement avec l'option --index pour restaurer l'index (changements marqués pour commit) :

git stash pop
git stash pop --index
git stash apply
git stash apply --index

Pour supprimer la dernière sauvegarde sans l'appliquer :

git stash drop

Pour appliquer ou supprimer non pas le dernier état sauvegardé mais une sauvegarde antérieure, il faut noter son numéro dans git stash list et l'indiquer à la suite de la commande. Par exemple, pour supprimer l'état numéro 1 (le deuxième plus récent donc) :

git stash drop 'stash@{1}'

Modifier l'historique du dépôt

Avertissement : il est déconseillé de modifier un dépôt public (git push -f, voir ci-dessous), à moins d'être sûr que personne ne travaille dessus. Toutes les personnes ayant obtenu une copie du dépôt devront forcer la mise à jour de leurs branches locales.

Il est possible de modifier le dernier commit grâce à l'option --amend de git commit :

git commit --amend

Il faut préalablement avoir apporté et marqué des modifications à la copie de travail (git add, git rm…). Si ce n'est pas le cas, git commit --amend permettra simplement de modifier le message de commit.

Il est également possible de modifier l'ordre des commits, de modifier des commits antérieurs, de fusionner ou diviser des commits, d'en supprimer, etc. La commande maîtresse est alors git rebase avec l'option -i ; il faut indiquer la somme de contrôle SHA-1 du commit parent du premier commit sur lequel on veut travailler.

git rebase -i SHA1

Git nous présentera alors un éditeur de texte, et nous permettra de marquer les modifications que l'on veut effectuer (des indications sont données en commentaire dans ce fichier texte).

Par exemple, pour modifier un commit, il faudra le marquer « edit » (ou simplement « e »), enregistrer le fichier texte et quitter l'éditeur. On utilisera ensuite git commit --amend comme vu précédemment, puis git rebase --continue pour terminer.

Pour supprimer un commit, il suffit de supprimer la ligne correspondante (mais voir git revert ci-dessous, parfois plus approprié).

Travailler avec un dépôt distant

Note : les commandes ne spécifiant pas de branche supposent que les branches locales et distantes sont bien configurées dans .git/config, ce qui est normalement le cas du dépôt origin après un git clone.

Visualiser les dépôts distants (-v donne plus de détails) :

git remote -v

Ajouter un dépôt distant nommé depotdistant ; le format de l'URL est documenté dans la page de manuel git-fetch(1) :

git remote add depotdistant URL

Récupérer les modifications du dépôt distant et les fusionner automatiquement (créera un commit de merge si des commits ont été créés en local) :

git pull

Mettre à jour les branches distantes, sans toucher aux branches locales :

git fetch

On préférera souvent utiliser fetch et rebase, plutôt que pull, afin de conserver un historique linéaire, généralement plus clair :

git fetch
git rebase origin/master master

Publier (pousser) ses modifications automatiquement (selon la configuration de .git/config) :

git push

Pousser la branche master sur le dépôt depotdistant :

git push depotdistant master

Pousser la branche locale toto sur la branche master du dépôt depotdistant :

git push depotdistant toto:master

Par défaut, git push refuse d'écraser une branche distante, il accepte uniquement d'y ajouter des commits (fast-forward). Pour écraser la branche distante (et potentiellement perdre des commits), utiliser l'option -f. À noter que l'utilisation de -f peut être interdite dans la configuration du dépôt distant.

Voir aussi les options suivantes de git push : --all, --mirror, --tags.

Exporter et importer un patch

Créer un patch à partir des modification locales non commitées :

git diff >mon_patch.diff

Créer un patch à partir du dernier commit :

git show >mon_patch.diff

À partir d'un commit donné (pointé par ref) :

git show ref >mon_patch.diff

Appliquer un patch :

git apply mon_patch.diff

À noter que ceci applique les changements localement mais ne crée pas de commit.

Pour exporter un commit, ou une série de commits, que l'on pourra ensuite importer automatiquement (création automatique des commits), on utilisera plutôt git format-patch et git am.

Commandes avancées et astuces

Annuler un commit en créant un commit inverse :

git revert SHA1

Comprimer et optimiser le dépôt (gc = garbage collect) ; ajouter --aggressive pour un traitement optimal mais potentiellement très long :

git gc

Voir le journal des références (utile pour récupérer une référence effacée par erreur) :

git reflog

Voir un fichier tel qu'il était dans un commit donné (remplacer ref par un nom de branche, un SHA, etc.) :

git show ref:chemin/complet/du/fichier

Voir les changements d'un fichier sur deux références données :

git diff ref1:chemin/complet/du/fichier ref2:chemin/complet/du/fichier

Revenir à la version d'un fichier d'un commit donné :

git checkout ref -- fichier

Chercher dans les fichiers suivis par Git (équivalent de grep -r, mais seulement sur les fichiers suivis, ignore automatiquement .git, etc.) :

git grep 'regex'

Accepte les mêmes options que grep (-l, -c, etc.).