Git – Commandes utiles

démarrer une zone de travail (voir aussi : git help tutorial)
   clone      Cloner un dépôt dans un nouveau répertoire
   init       Créer un dépôt Git vide ou réinitialiser un existant

travailler sur la modification actuelle (voir aussi : git help revisions)
   add        Ajouter le contenu de fichiers dans l'index
   mv         Déplacer ou renommer un fichier, un répertoire, ou un lien symbolique
   reset      Réinitialiser la HEAD courante à l'état spécifié
   rm         Supprimer des fichiers de la copie de travail et de l'index

examiner l'historique et l'état (voir aussi : git help revisions)
   bisect     Trouver par recherche binaire la modification qui a introduit un bogue
   grep       Afficher les lignes correspondant à un motif
   log        Afficher l'historique des validations
   show       Afficher différents types d'objets
   status     Afficher le statut de la copie de travail

agrandir, marquer et modifier votre historique
   branch     Lister, créer ou supprimer des branches
   checkout   Basculer de branche ou restaurer la copie de travail
   commit     Enregistrer les modifications dans le dépôt
   diff       Afficher les changements entre les validations, entre validation et copie de travail, etc
   merge      Fusionner deux ou plusieurs historiques de développement ensemble
   rebase     Réapplication des commits sur le sommet de l'autre base
   tag        Créer, lister, supprimer ou vérifier un objet d'étiquette signé avec GPG

collaborer (voir aussi : git help workflows)
   fetch      Télécharger les objets et références depuis un autre dépôt
   pull       Rapatrier et intégrer un autre dépôt ou une branche locale
   push       Mettre à jour les références distantes ainsi que les objets associés

 

 

Clonage local d’un dépôt distant :

git clone URL-repository [/path/to/dst-directory]

Si directory n’existe pas, il sera créé. Cela permet de spécifier un autre nom pour le répertoire cloné.

 

Clonage local d’une branche (ou d’un tag) spécifique d’un dépôt distant :

git clone --branch remote-branchname URL-repository [/path/to/dst-directory]

git clone --branch remote-tagname URL-repository [/path/to/dst-directory]

Si directory n’existe pas, il sera créé. Cela permet de spécifier un autre nom pour le répertoire cloné.

 

Clonage local d’un dépôt local :

git clone /path/to/src-repository /path/to/dst-directory

Si directory n’existe pas, il sera créé. Cela permet de spécifier un autre nom pour le répertoire cloné.

 

Clonage local d’un dépôt distant en bare repository :

Celui-ci pourra alors être l’origin de clients distants.

git clone --bare URL-repository [/path/to/dst-directory]

Si directory n’existe pas, il sera créé. Cela permet de spécifier un autre nom pour le répertoire cloné.
ex :
Clonage d’un dépôt via HTTPS

$ git clone https://github.com/darwinos/repotest.git
Clonage dans 'repotest'...
remote: Counting objects: 12, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 12 (delta 2), reused 5 (delta 1), pack-reused 0
Dépaquetage des objets: 100% (12/12), fait.

Clonage du même dépôt via SSH

$ git clone git@github.com:darwinos/repotest.git
Clonage dans 'repotest'...
remote: Counting objects: 12, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 12 (delta 2), reused 5 (delta 1), pack-reused 0
Réception d'objets: 100% (12/12), 6.24 KiB | 0 bytes/s, fait.
Résolution des deltas: 100% (2/2), fait.

 

 

Créer un dépôt Git local vide ou réinitialiser un dépôt local existant :

Ceci génère un dossier caché .git avec l’arborescence présentée dans l’article Git – Memo configuration.

git init [/path/to/repository]

 

Créer un bare repository :

Celui-ci pourra alors être l’origin de clients distants.

git init --bare [/path/to/repository]

ex :

$ git init
Dépôt Git vide initialisé dans /home/adminsys/git-workspace/newrepo/.git/

 

Réinitialiser un dépôt avec les bonnes permissions :

Les fichiers sont conservés.
Sans l’option --shared les permissions sont définies à partir de l’umask (ou --shared=umask, ou --shared=false).
Avec l’option --shared, les permissions sont définies pour que les ressources soient partagées entre plusieurs utilisateurs appartenant à un même groupe.

git init --bare --shared [/path/to/repository]

Equivaut à :
git init --bare --shared=group [/path/to/repository]
ou
git init --bare --shared=true [/path/to/repository]

 

 

Ajouter le contenu de fichiers spécifiés dans l’index (cache, staging area) :

Ceci génère un snapshot du contenu des fichiers de l’espace de travail à un instant t en vue du prochain commit. Permet de mettre en cache les modifications des fichiers déjà suivis ou de commencer le suivi d’un fichier jusqu’alors non tracké.
Ajouter un fichier défini de l’espace de travail :

$ git add filename

Converse : désindexer un fichier
$ git reset HEAD filename
Ajouter tous les fichiers de l’espace de travail (déconseillé si non précédé d’une simulation) :

$ git add .

$ git add -A

$ git add --all

 

Mode simulation (dry-run) :

$ git add -nA

 

Mode verbeux :

$ git add -v [...]

 

 

Déplacer un fichier dans la copie de travail :

git mv filename destination/

Le fichier est copié et indexé à sa destination et supprimé à la source. Il est prêt à être commité.
Equivaut à :

mv filename destination/
git add destination/filename
git rm filename


 

Faire une simulation de déplacement (mode dry-run) :

git mv -n filename destination/

 

 

Supprimer un fichier de la copie de travail et de l’index :

git rm filename

 

Supprimer un fichier uniquement de l’index :

git rm --cached filename

 

Supprimer récursivement un répertoire et son contenu :

git rm -r directory

 

 

 

Rétablir l’état avant indexation suivant le commit spécifié (mode mixed, par défaut) :

L’historique et la staging area sont écrasés, mais la copie de travail n’est pas touchée. Cela signifie que vos modifications seront en attente dans la copie de travail. C’est le mode par défaut de la commande git reset. Il restera à indexer et commiter les modifications.
Toutes les modifications apportées depuis le commit spécifié sont toujours présentes et en attente d’indexation. Seul l’historique est réinitialisé.
Excellent moyen de réécrire l’historique non pushé sur le dépôt distant sans perdre ses modifications.
Attention, comme pour les 2 autres options (mixed et soft), les commits supprimés de l’historique ne doivent pas avoir été pushés.

$ git reset [--mixed] SHA1

 

Rétablir l’état après indexation suivant le commit spécifié (mode soft) :

L’historique est écrasé pour ressembler à ce qu’il était au commit spécifié, mais la copie de travail et la staging area ne sont pas touchées. Cela signifie que vos modifications ont été indexées et sont en attente dans la staging area. Il restera à commiter les modifications.
Toutes les modifications apportées depuis le commit spécifié sont toujours présentes et indexées. Seul l’historique est réinitialisé.
Excellent moyen de réécrire l’historique non pushé sur le dépôt distant sans perdre ses modifications.
Attention, comme pour les 2 autres options (mixed et soft), les commits supprimés de l’historique ne doivent pas avoir été pushés.

$ git reset --soft SHA1

 

Rétablir la copie de travail d’un hash antérieur (mode hard, destructif) :

Tous les commits plus récents que le hash spécifié seront supprimés de l’historique et la copie de travail sera identique à celle du commit spécifié. Tous les fichiers ajoutés et toutes les modifications depuis le commit spécifié seront supprimés.
Attention, comme pour les 2 autres options (mixed et soft), les commits supprimés de l’historique ne doivent pas avoir été pushés.

$ git reset --hard SHA1

Rmq :
Pour les branches distantes, et donc les commits pushés, voir la commande suivante :
git push --force remotename SHA1:branchname
 

Annuler des modifications indexées :

Les fichiers modifiés ont ici déjà été indexés avec git add.
Dans le cas d’un fichier unique :

$ git reset HEAD filename
$ git checkout -- filename

Ou, si plusieurs fichiers ont été modifiés dans l’espace de travail :

$ git reset HEAD .
$ git checkout -- .

 

 

 

Annuler les changements du dernier commit :

Un nouveau commit, de type Revert, signalant le retour à la version précédente sera créé.

$ git revert HEAD

 

 

Rechercher l’apparition d’un bug par dichotomie :

On démarre l’outil, on signale que le commit courant est bugué mais on spécifie le dernier commit encore non-bugué.

git bisect start
git bisect bad
git bisect good SHA1

Ensuite, par dichotomie, on teste chaque commit median proposé et on signale s’il est bon ou mauvais.

git bisect bad
git bisect bad
git bisect bad
git bisect good

Le commit à partir duquel le bug est apparu est ensuite automatiquement affiché.
Il faut ensuite terminer l’outil de debugage pour rétablir l’état initial, et corriger le bug dans le code.

git bisect reset

 

 

Rechercher un pattern dans un ou plusieurs fichiers :

git grep -n "pattern" [filenames]

Si aucun nom de fichier n’est spécifié, la recherche se fera récursivement dans le répertoire courant et les sous-répertoires.
L’option -n permet de retourner le numéro de ligne où se trouve le pettern.
 

 

Afficher les logs des commits de la branche courante :

git log

 

Afficher les logs des commits de toutes les références (branches, tags, etc.) :

git log --all

Affiche l’ensemble des commits et des messages associés, sous forme d’une pile (dernier en haut). Chaque commit est identifié de manière unique par une empreinte SHA1.
ex :

$ git log
commit 33d105abc0e11abb3d10b8aa9efc4c381d288d6d
Author: darwinos 
           
         
         
          
           
          
          
            
Date:   Tue Jun 12 10:14:10 2018 +0200

    Update local repository


            
          
          
           commit 3c57201603b9d226c1f6d839cfa070d556689f0d
Author: darwinos 
            
          
          
           
             Date: Tue Jun 12 09:04:50 2018 +0100 Create remotefile.txt 
           
           
         
         
          

 

Afficher les logs de manière synthétique :

git log --oneline

ex :

$ git log --oneline
33d105a Update local repository
3c57201 Create remotefile.txt

git log --pretty=oneline

Ici la différence avec la commande précédente est que l’empreinte SHA1 de chaque commit est affichée entièrement.
ex :

$ git log --pretty=oneline
33d105abc0e11abb3d10b8aa9efc4c381d288d6d Update local repository
3c57201603b9d226c1f6d839cfa070d556689f0d Create remotefile.txt

 

Spécifier le nombre de lignes de logs à afficher :

git log -n

ou

git log --max-count=n

Les n plus récents commits seront affichés.
 

Spécifier la date depuis laquelle afficher les logs :

git log --since='n minutes ago'

ou

git log --after='n minutes ago'

La période de temps peut être précisée en seconds, minutes, days, years, etc.
 

Spécifier la date jusqu’à laquelle afficher les logs :

git log --until='n minutes ago'

ou

git log --before='n minutes ago'

ex :

$ git log --after='2018-06-06' --before='2018-06-12' --oneline

La période de temps peut être précisée en seconds, minutes, days, years, etc.
 

Afficher les logs d’un auteur spécifique :

git log --author='authorname'

 

Afficher les logs sous forme pseudo-graphique (ASCII) :

git log --graph

ex :

$ git  --all --oneline log --graph
* 33d105a Update local repository
* 3c57201 Create remotefile.txt
*   e9e274e Merge branch 'testing3'
|\  
| * f3e8819 Update local repository
| * 27d30a0 Update local repository
| * 3719418 Add testfile.txt
* | e6c7009 Update local repository
* | b8f69df Update local repository
* | ae26402 Update local repository
* | f850923 Modif tempfile.txt
|/  
* 3803116 Modif tempfile.txt
* 37acae3 Add tempfile.txt

 

Afficher les statistiques relatives aux fichiers modifiés : deletions et insertions

git log --stat

ex :

$ git --oneline --stat
* 0214035 Update local repository
|  _config.yml                        | 19 ++++++-------------
|  _includes/file01.md                |  1 +
|  _includes/file02.md                |  1 +
|  _includes/file03.md                |  1 +
|  _posts/2018-05-30-1stpost.md       |  6 ------
|  _posts/2018-05-30-Deuxieme_post.md |  1 -
|  _posts/2018-05-30-Premier_post.md  |  6 ------
|  index.md                           |  6 +++++-
|  8 files changed, 14 insertions(+), 27 deletions(-)

ou

git log --numstat

ex :

$ git --oneline --numstat
[...]
0214035 Update local repository
6       13      _config.yml
1       0       _includes/file01.md
1       0       _includes/file02.md
1       0       _includes/file03.md
0       6       _posts/2018-05-30-1stpost.md
0       1       _posts/2018-05-30-Deuxieme_post.md
0       6       _posts/2018-05-30-Premier_post.md
5       1       index.md
[...]

 

Afficher le patch pour chaque fichier modifié de chaque commit :

Les lignes modifiées sont affichées en couleur pour chaque fichier : vert pour les insertions, rouge pour les déletions.

git log -p

 

Afficher les logs d’une branche spécifique :

git log branchname

 

Afficher tous les commits qui incluent une modification d’un fichier spécifié :

git log -- filename

 

Afficher les commits situés entre deux commits spécifiés :

git log oldercommit..newercommit

ex :

$ git log bd7e197..8896f09

$ git log bd7e197..HEAD

$ git log bd7e197..master

$ git log --left-right --graph --cherry-pick testing..master

 

Afficher les commits différentiels entre deux branches :

git log branche1...branche2

ex :

$ git log testing...master

$ git log master...origin/master

 

Afficher des logs formatés et personnalisés :

git log --all --pretty=format:'%h %cd %s (%an)' --since='7 days ago'

ex :

$ git log --all --pretty=format:'%h %cd %s (%an)' --since='7 days ago'
33d105a Tue Jun 12 10:14:10 2018 +0200 Update local repository (darwinos)
3c57201 Tue Jun 12 09:04:50 2018 +0100 Create remotefile.txt (darwinos)
e9e274e Mon Jun 11 18:11:16 2018 +0200 Merge branch 'testing3' (darwinos)
e6c7009 Mon Jun 11 18:10:49 2018 +0200 Update local repository (darwinos)

git log --pretty=format:'%h %ad | %s%d [%an]' --graph --date=short

ex :

$ git log --pretty=format:'%h %ad | %s%d [%an]' --graph --date=short
* 33d105a 2018-06-12 | Update local repository [darwinos]
* 3c57201 2018-06-12 | Create remotefile.txt [darwinos]
*   e9e274e 2018-06-11 | Merge branch 'testing3' [darwinos]
|\  
| * f3e8819 2018-06-11 | Update local repository [darwinos]

git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short

ex :

$ git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short --all
* adc2a9b - (HEAD -> master, tag: v1.3) 2018-06-14 | Modif longueur.sh else if (HEAD -> master, tag: v1.3) [darwinos]
* 089e7b1 - (tag: v1.2) 2018-06-14 | Modif longueur.sh taille oneline (tag: v1.2) [darwinos]
* 159f756 - (tag: v1.1) 2018-06-14 | Add longueur.sh (tag: v1.1) [darwinos]
* fca4aaf - 2018-06-14 | Add file6.txt [darwinos]
* 5cb7f07 - 2018-06-14 | Add file4.txt [darwinos]
* f039fa9 - 2018-06-14 | Modif file1.txt [darwinos]
| * b175110 - (testing1) 2018-06-14 | Add file5.txt (testing1) [darwinos]
| | * 90e995d - (testing2) 2018-06-14 | Add file3.txt (testing2) [darwinos]
| | * 341cb15 - 2018-06-14 | Modif file2.txt [darwinos]
| |/  
| * 8028686 - 2018-06-14 | Add file2.txt [darwinos]
| * e41d877 - 2018-06-14 | Modi file1.txt [darwinos]
|/  
* ef14a78 - 2018-06-14 | Add file1.txt [darwinos]
* 4d75f9a - 2018-06-14 | Add README.md [darwinos]

Avec comme variables :

%h : hash abrégé
%d : les références comme la branche ou le tag
%ad : la date
%s : le commentaire
%an : le nom de l’auteur

 

Afficher les logs jusqu’à une date spécifique :

git log [branchname]@{dateformat}

ex :

$ git log master@{2018-06-14}

$ git log testing1@{two.hours.ago}

 

 

Afficher tous les déplacements de HEAD :

Les SHA1 de tous les changements de HEAD sont référencés, que ce soit via git commit ou git checkout.

git reflog

ex :

$ git reflog
[...]
adc2a9b HEAD@{15}: checkout: moving from 159f75622601942793b74e6a2a8ff9ba07a5019b to master
159f756 HEAD@{16}: checkout: moving from master to 159f756
adc2a9b HEAD@{17}: commit: Modif longueur.sh else if
089e7b1 HEAD@{18}: commit: Modif longueur.sh taille oneline
159f756 HEAD@{19}: commit: Add longueur.sh
fca4aaf HEAD@{20}: checkout: moving from testing2 to master
90e995d HEAD@{21}: checkout: moving from testing1 to testing2
b175110 HEAD@{22}: checkout: moving from master to testing1
[...]

 

Afficher les reflogs jusqu’à une date spécifique :

git reflog [branchname]@{dateformat}

ex :

$ git reflog master@{2018-06-14}

$ git reflog testing1@{two.hours.ago}

 

 

Afficher le détail d’un commit :

git show SHA1

git show tagname

ex :

$ git show 089e7b1
commit 089e7b1961451999cf5120ab7d62dd80af072e4c
Author: darwinos 
           
         
         
          
           
          
          
            
Date:   Thu Jun 14 22:15:00 2018 +0200

    Modif longueur.sh taille oneline


            
          
          
           diff --git a/longueur.sh b/longueur.sh index 20415af..9f87067 100644 --- a/longueur.sh +++ b/longueur.sh

            
          
          
           @@ -2,9 +2,7 @@
 
 import sys
 

            
          
          
           -def taille(s) : - if not s : return 0 - return 1 + taille(s[1:])

            
          
          
           +def taille(s) : return s and 1 + taille(s[1:]) or 0
 
 for x in sys.argv[1:] :
     print(taille(x))

           
         
         
          

 

Pour afficher une version plus synthétique :

git show SHA1 --pretty=oneline

ex :

$ git show 089e7b1
commit 089e7b1961451999cf5120ab7d62dd80af072e4c Modif longueur.sh taille oneline
diff --git a/longueur.sh b/longueur.sh
index 20415af..9f87067 100644
--- a/longueur.sh
+++ b/longueur.sh
@@ -2,9 +2,7 @@
 
 import sys
 
-def taille(s) :
-    if not s : return 0
-    return 1 + taille(s[1:])
+def taille(s) : return s and 1 + taille(s[1:]) or 0
 
 for x in sys.argv[1:] :
     print(taille(x))

 

Pour afficher une version formatée pour un email (envoyer un patch par exemple) :

git show SHA1 --pretty=email

ex :

$ git show 089e7b1
From 089e7b1961451999cf5120ab7d62dd80af072e4c Mon Sep 17 00:00:00 2001
From: darwinos <darwinos@example.com>
Date: Thu, 14 Jun 2018 22:15:00 +0200
Subject: [PATCH] Modif longueur.sh taille oneline


diff --git a/longueur.sh b/longueur.sh
index 20415af..9f87067 100644
--- a/longueur.sh
+++ b/longueur.sh
@@ -2,9 +2,7 @@
 
 import sys
 
-def taille(s) :
-    if not s : return 0
-    return 1 + taille(s[1:])
+def taille(s) : return s and 1 + taille(s[1:]) or 0
 
 for x in sys.argv[1:] :
     print(taille(x))

 

Pour afficher le commit sur HEAD :

git show HEAD

 

 

Générer un fichier patch par commit séparant deux commits ou branches :

Les patches générés seront formatés comme un email afin de pouvoir être envoyés via SMTP.
Ils seront nommés sous la forme :000X-titre-du-commit.patch

git format-patch -M commit1..commit2

git format-patch -M branche1..branche2

 

Générer un fichier patch par commit validé depuis le commit ou la branche mentionnée :

git format-patch -M SHA1

git format-patch -M branchname

Si une seule branche est spécifiée, le différentiel sera généré depuis la branche spécifiée vers la branche courante : branchname..current_branchname
ex :

$ git format-patch -M origin/master

Equivaut à (si on est situé sur master) :

$ git format-patch -M origin/master..master

Pour spécifier un répertoire de destination pour les fichiers patch, à défaut du répertoire courant :

git format-patch -M branchname -o dst-directory

Pour appliquer un patch généré avec git format-patch, voir la commande git am filename.patch.
Pour appliquer un patch généré avec git diff, voir la commande git apply filename.patch (option --check pour simulation).
 

 

Afficher le type d’un objet à partir de son empreinte SHA1 :

git cat-file -t SHA1

ex :

$ git cat-file -t fe23c7d2e36d42a14711a0edd384436ac00ac2e2
commit
$ git cat-file -t e442a3cc10497501f6f7f49b759a61c27cc585e1
tree
$ git cat-file -t 20415af9af697db1a651ef950433b71211988c28
blob

 

Afficher le contenu d’un objet à partir de son empreinte SHA1 :

git cat-file -p SHA1

ex :

$ git cat-file -p fe23c7d2e36d42a14711a0edd384436ac00ac2e2
tree e442a3cc10497501f6f7f49b759a61c27cc585e1
parent adc2a9b6011eb06345abd318a206bb9b878f4f41
author darwinos <darwinos@example.com> 1529068305 +0200
committer darwinos <darwinos@example.com> 1529068305 +0200

Modif longueur.sh : retour à la v1.1
$ git cat-file -p e442a3cc10497501f6f7f49b759a61c27cc585e1
00644 blob 90ab30c8b35f2951feefae21992b7696d4e378e9	README.md
100644 blob ed1604c621f8d4d369e1db4b78dcf40991cc8a27	file1.txt
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391	file4.txt
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391	file6.txt
100644 blob 20415af9af697db1a651ef950433b71211988c28	longueur.sh
$ git cat-file -p 20415af9af697db1a651ef950433b71211988c28
#!/usr/bin/env python3

import sys

def taille(s) :
    if not s : return 0
    return 1 + taille(s[1:])

for x in sys.argv[1:] :
    print(taille(x))

 

 

Afficher l’auteur des modifications d’un fichier, ligne par ligne, et les commits correspondants :

git blame filename

ex:

$ git blame longueur.sh
159f7562 (darwinos 2018-06-14 22:13:50 +0200 1) #!/usr/bin/env python3
159f7562 (darwinos 2018-06-14 22:13:50 +0200 2) 
159f7562 (darwinos 2018-06-14 22:13:50 +0200 3) import sys
159f7562 (darwinos 2018-06-14 22:13:50 +0200 4) 
adc2a9b6 (darwinos 2018-06-14 22:16:20 +0200 5) def taille(s) : return 1 + taille(s[1:]) if s else 0
159f7562 (darwinos 2018-06-14 22:13:50 +0200 6) 
159f7562 (darwinos 2018-06-14 22:13:50 +0200 7) for x in sys.argv[1:] :
159f7562 (darwinos 2018-06-14 22:13:50 +0200 8)     print(taille(x))

 

Spécifier les lignes précises d’un fichier à contrôler :

git blame filename -L n,m

Les lignes n à m seront affichées pour contrôle.
ex:

$ git blame longueur.sh -L 5,8
adc2a9b6 (darwinos 2018-06-14 22:16:20 +0200 5) def taille(s) : return 1 + taille(s[1:]) if s else 0
159f7562 (darwinos 2018-06-14 22:13:50 +0200 6) 
159f7562 (darwinos 2018-06-14 22:13:50 +0200 7) for x in sys.argv[1:] :
159f7562 (darwinos 2018-06-14 22:13:50 +0200 8)     print(taille(x))

 

N’afficher que les commits correspondant aux modifications :

git blame -s filename

Les auteurs et les dates de modifications ne sont pas affichés ici.
ex:

$ git blame -s longueur.sh
159f7562 1) #!/usr/bin/env python3
159f7562 2) 
159f7562 3) import sys
159f7562 4) 
adc2a9b6 5) def taille(s) : return 1 + taille(s[1:]) if s else 0
159f7562 6) 
159f7562 7) for x in sys.argv[1:] :
159f7562 8)     print(taille(x))

 

 

Afficher le statut de la copie de travail :

• Différences entre le dernier commit et l’index actuel : fichiers indexés mais non commités au dépôt local
• Différences entre l’index actuel et l’espace de travail courant : modifications non indexées
• Fichiers ajoutés à l’espace de travail courant mais non trackés : fichiers non indexés

$ git status

ex :

$ git status
Sur la branche master
Modifications qui seront validées :
  (utilisez "git reset HEAD 
           
         
         
          
           
          
          
            ..." pour désindexer)

	
            
          
          
           supprimé : tempfile4.txt

Modifications qui ne seront pas validées :
  (utilisez "git add 
            
          
          
           
             ..." pour mettre à jour ce qui sera validé) (utilisez "git checkout -- 
            
              ..." pour annuler les modifications dans la copie de travail) 
             modifié : README.md Fichiers non suivis: (utilisez "git add 
             
               ..." pour inclure dans ce qui sera validé) 
              newfile.txt 
              
             
           
           
         
         
          

 

Afficher tous les fichiers non suivis:

Par défaut, Git n’affiche que les répertoires contenant des fichiers non suivis, sans préciser quels fichiers.
Avec l’option -u, on peut afficher ces fichiers.
ex :

$ git status
Fichiers non suivis:

	test/

$ git status -u
Fichiers non suivis:

	test/file1.txt
	test/file2.txt

On peut rendre définir ce comportement par défaut pour la commande git status au niveau global :

git config --global status.showUntrackedFiles all

 

 

Supprimer interactivement les fichiers non suivis de la copie de travail :

Ils sont réellement supprimés.

git clean -i

Mode simulation :

git clean -n

 

 

Vérifier l’intégrité, la connectivité et la validité des objets de la base de données :

git fsck

ex :

$ git fsck
Vérification des répertoires d'objet: 100% (256/256), fait.
dangling blob 23b8dd6f02e542a4d2cfcc3e3751dd54affa9aec
dangling blob b4d15aa6c01b3ded7e9ac44bfe299d250f303d47

 

 

Nettoyer les fichiers non nécessaires et optimiser le dépôt local :

git gc

ex :

$ git gc
Décompte des objets: 69, fait.
Compression des objets: 100% (61/61), fait.
Écriture des objets: 100% (69/69), fait.
Total 69 (delta 28), reused 0 (delta 0)

 

Nettoyer les fichiers non nécessaires et optimiser le dépôt local seulement si nécessaire :

Sinon, quitte GC.

git gc --auto

 

 

 
Créer une branche signifie inclure le contenu du commit courant et de tous ses commits parents.
Une branche est une référence, un pointeur à un commit spécifique.

Afficher les branches du dépôt local :

git branch

ex :

$ git branch
* master
  testing1
  testing2

 

Afficher les branches distantes :

git branch -r

ex :

$ git branch -r
  origin/master
  origin/testing1

 

Afficher les branches du dépôt local et les branches distantes (avec les commits associés) :

git branch -avv

ex :

$ git branch -av
* master                 14e0ac6 [origin/master] Add file4.txt
  testing                6bf13e9 [origin/testing] Add file4.txt
  remotes/gitlab/master  14e0ac6 Add file4.txt
  remotes/gitlab/testing 6bf13e9 Add file4.txt
  remotes/origin/master  14e0ac6 Add file4.txt
  remotes/origin/testing 6bf13e9 Add file4.txt

 

Afficher uniquement les branches locales fusionnées :

git branch --merged

Nous pouvons ajoutons l’option -avv pour les branches distantes et plus de détails :

git branch -avv --merged

 

Afficher uniquement les branches locales non-fusionnées :

git branch --no-merged

Nous pouvons ajoutons l’option -avv pour les branches distantes et plus de détails :

git branch -avv --no-merged

 

Supprimer une branche précédemment fusionnée :

git branch -d branchname

ex :

$ git branch -d testing1
Branche testing1 supprimée (précédemment 795f3b5).

 

Supprimer une branche non fusionnée (forcer la suppression) :

git branch -D branchname

ex :

$ git branch -d testing2
error: La branche 'testing2' n'est pas totalement fusionnée.
Si vous êtes sur que vous voulez la supprimer, lancez 'git branch -D testing2'.
$ git branch -D testing2
Branche testing2 supprimée (précédemment 90e995d).

nbsp;

Supprimer l’image locale d’une branche distante :

git branch -r -d remotename/branchname

ex :

$ git branch -a
* master
  remotes/origin/master
  remotes/origin/testing1
$ git branch -r -d origin/testing1
Branche de suivi origin/testing1 supprimée (précédemment b175110).
$ git branch -a
* master
  remotes/origin/master

 

Renommer une branche :

git branch -m oldbranchname newbranchname

 

Lier une nouvelle branche locale à une branche distante existante :

git branch --track branchname remotename/branchname

ex :

$ git branch --track greet origin/greet
La branche greet est paramétrée pour suivre la branche distante greet depuis origin.

 

Lier une branche locale existante à une branche distante existante :

git branch -u remotename/branchname branchname

 

Lier la branche locale courante à une branche distante existante :

git branch -u remotename/branchname

 

Réassigner une branche à un commit antérieur :

git branch -f branchname SHA1

ex :

$ git branch -f master 21ae8a7

 

 

Se déplacer vers un commit antérieur spécifique (mode HEAD détaché) :

HEAD est le nom symbolique pour le commit sur lequel nous nous situons actuellement. Plus simplement c’est le commit sur lequel nous travaillons. HEAD pointe toujours sur le commit le plus récent dans l’arbre des commits.
Normalement HEAD pointe sur le nom d’une branche.
Détacher HEAD signifie simplement que l’on attache HEAD à un commit au lieu d’une branche.

git checkout SHA1

ex :

$ git checkout 159f756
Note : extraction de '159f756'.

Vous êtes dans l'état « HEAD détachée ». Vous pouvez visiter, faire des modifications
expérimentales et les valider. Il vous suffit de faire une autre extraction pour
abandonner les commits que vous faites dans cet état sans impacter les autres branches

Si vous voulez créer une nouvelle branche pour conserver les commits que vous créez,
il vous suffit d'utiliser « checkout -b » (maintenant ou plus tard) comme ceci :

  git checkout -b 
           
         
         
          
           
          
          
            

HEAD est maintenant sur 159f756... Add longueur.sh

           
         
         
          

 

Se déplacer vers le dernier commit d’une branche spécifique :

git checkout branchname

git checkout tagname

ex :

$ git checkout testing1
Basculement sur la branche 'testing1'

 

Créer une nouvelle branche à partir de la branche courante et se déplacer dessus :

git checkout -b branchname

Equivaut à :

$ git branch branchname
$ git checkout branchname

 

Créer une branche locale à partir d’une autre branche locale :

git checkout -b copy-branchname src-branchname

ex :

$ git checkout -b testing-copy testing
Basculement sur la nouvelle branche 'testing-copy'

 

Créer une branche locale à partir d’une branche distante :

git checkout -b branchname remotename/branchname

Pour en plus la tracker :

git checkout -t -b branchname remotename/branchname

 

Se déplacer vers un tag spécifique :

git checkout tagname

ex :

$ git checkout v1.1
Note : extraction de 'v1.1'.

Vous êtes dans l'état « HEAD détachée ». Vous pouvez visiter, faire des modifications
expérimentales et les valider. Il vous suffit de faire une autre extraction pour
abandonner les commits que vous faites dans cet état sans impacter les autres branches

Si vous voulez créer une nouvelle branche pour conserver les commits que vous créez,
il vous suffit d'utiliser « checkout -b » (maintenant ou plus tard) comme ceci :

  git checkout -b 
           
         
         
          
           
          
          
            

HEAD est maintenant sur 159f756... Add longueur.sh

           
         
         
          

 

Spécifier un déplacement relatif :

git checkout branchname~n

Remonte de n commit en arrière d’une branche.
ex :

$ git checkout master~1

$ git checkout master~2

git checkout tagname~n

Remonte de n commit en arrière d’un tag.
ex :

$ git checkout v1.1~1

$ git checkout v1.1~2

git checkout HEAD@{n}

Ci-dessous on se déplace à une position de HEAD spécifique obtenue à partir de git reflog :

$ git checkout HEAD@{24}
Note : extraction de 'HEAD@{24}'.

Vous êtes dans l'état « HEAD détachée ». Vous pouvez visiter, faire des modifications
expérimentales et les valider. Il vous suffit de faire une autre extraction pour
abandonner les commits que vous faites dans cet état sans impacter les autres branches

Si vous voulez créer une nouvelle branche pour conserver les commits que vous créez,
il vous suffit d'utiliser « checkout -b » (maintenant ou plus tard) comme ceci :

  git checkout -b 
           
         
         
          
           
          
          
            

HEAD est maintenant sur 5cb7f07... Add file4.txt

           
         
         
          

 

Annuler les modifications faites à un fichier et qui n’ont pas encore été indexées :

git checkout -- filename

ex :

$ git checkout -- longueur.sh

$ git checkout -- .

 

Détacher HEAD de la branche courante :

git checkout --detach

Equivaut à faire un git checkout sur le dernier commit.
 

 

 
Git enregistre une image (snapshot) de tous les fichiers de la copie de travail dans le dépôt local. Git fait en sorte que les commits soient aussi légers que possible donc il ne recopie pas tout le répertoire à chaque commit. En fait, Git n’enregistre que l’ensemble des changements (« delta ») depuis la version précédente du dépôt, son commit parent.
 

Enregistrer les modifications indexées (en cache, staging area) dans le dépôt local :

Les modifications sont ainsi validées, mais restent locales.

$ git commit -m "Message relatif au commit"

Ou, si l’on souhaite ouvrir l’éditeur de texte par défaut pour saisir le message du commit :

$ git commit

La première ligne, le sujet du commit, fera moins de 50 caractères. Ce sera la sortie de la commande git log --oneline.
Ensuite une ligne vide.
Et enfin un ou plusieurs paragraphes d’explications détaillées sur le commit. Mais chaque ligne devra être limitée à 72 caractères.
ex :

$ git commit

Première ligne de sujet du commit

Développement du commit avec explications détaillées.
Modifications apportées par rapport au précédent commit :
 * Ajout de telle ligne
 * Suppression de celle-ci

Mais aussi :
 - Ajout de la fonctionnalité A
 - Ajout de la fonctionnalité B

Ajout d'une ligne de plus de 72 caractères pour voir ce que cela fait lors de l'affichage des logs complets.

# Veuillez saisir le message de validation pour vos modifications. Les lignes
# commençant par '#' seront ignorées, et un message vide abandonne la validation.
#
# Date :       Fri Jun 29 12:00:04 2018 +0200
#
# Sur la branche master
# Votre branche est en avance sur 'origin/master' de 1 commit.
#   (utilisez "git push" pour publier vos commits locaux)
#
# Modifications qui seront validées :
#       modifié :         test.txt
#

Affichage oneline :

$ git log --oneline -1
46a0f4a Première ligne de sujet du commit
96b893f First commit

Affichage sur un terminal de 80 caractères (valeur par défaut) :

$ git log -1
commit 46a0f4aed978d238ea06567e8cee83e0579e9216
Author: darwinos 
           
         
         
          
           
          
          
            
Date:   Fri Jun 29 12:00:04 2018 +0200

    Première ligne de sujet du commit
    
    Développement du commit avec explications détaillées.
    Modifications apportées par rapport au précédent commit :
     * Ajout de telle ligne
     * Suppression de celle-ci
    
    Mais aussi :
     - Ajout de la fonctionnalité A
     - Ajout de la fonctionnalité B
    
    Ajout d'une ligne de plus de 72 caractères pour voir ce que cela fait lors d
e l'affichage des logs complets.

           
         
         
          

L’éditeur sera déterminé en fonction de :

1. GIT_EDITOR (variable d’environnement)
2. core.editor (paramètre de configuration : local, puis global, puis system)
3. VISUAL (variable d’environnement)
4. EDITOR (variable d’environnement)

Pour ajouter les modifications (des fichiers déjà connus et trackés) à l’index tout en les commitant :

$ git commit -am "Message relatif au commit"

ex :

$ git commit -am "Modif README.md, Del tempfile4.txt"
[master 5616d53] Modif README.md, Del tempfile4.txt
 2 files changed, 2 insertions(+)
 delete mode 100644 tempfile4.txt

 

Apporter de modifications au précédent commit

Il s’agit ici de modifier des fichiers et d’inclure a posteriori ces modifications à un commit déjà validé.
Généralement il s’agit de modifications mineures que l’on a oublié d’ajouter au précédent commit.

$ nano filename
$ git add filename
$ git commit --amend -m "Message remplaçant le message du précédent commit"

ou, alternativement, on peut rétablir le commit antérieur et apporter les modifications désirées :

$ git reset HEAD~1
$ nano filename
$ git add filename
$ git commit -m "Message remplaçant le message du précédent commit"

La commande git reset ci-dessus se déplace à l’état staging juste avant le commit à redéfinir. Les modifications de fichiers sont présentes dans l’index.
 

 

 

Appliquer les changements introduits par certains commits :

git cherry-pick SHA1-list

ex :

$ git cherry-pick aa85407 6bf13e9
[master 2aaa198] Add file2.txt
 Date: Tue Jun 19 03:12:40 2018 +0200
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 file2.txt
[master 14e0ac6] Add file4.txt
 Date: Tue Jun 19 03:14:21 2018 +0200
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 file4.txt

 

 

Sauvegarder l’état de la copie de travail pour une utilisation ultérieure :

git stash save

git stash save -u "Message relatif au stash"

L’option -u permet de conserver les fichiers non suivis. Parallèlement on peut également ajouter un message définissant le stash en question.
ex :

$ git stash save
Copie de travail et état de l'index sauvegardés dans WIP on master: 4c6ba8c Updated Rakefile
HEAD est maintenant à 4c6ba8c Updated Rakefile

 

Afficher la liste des sauvegardes stash :

git stash list

stash@{0} est la dernière sauvegarde de la copie de travail.
ex :

$ git stash list
stash@{0}: WIP on master: 4c6ba8c Updated Rakefile
stash@{1}: WIP on master: 4c6ba8c Updated Rakefile

 

Afficher une sauvegarde stash particulière :

git stash show shashID

ex :

$ git stash stash@{0}
 lib/greeter.rb | 8 --------
 lib/hello.rb   | 7 -------
 2 files changed, 15 deletions(-)

 

Afficher une version détaillée du stash avec le patch :

git stash show -p shashID

 

Restaurer le dernier stash sans le supprimer de la liste :

git stash apply

 

Restaurer le dernier stash et le supprimer de la liste :

git stash pop

 

Supprimer le stash le plus récent sans le restaurer :

git stash drop

 

Supprimer tous les stashes en stock, sans restauration :

git stash clear

 

 

Afficher les différences entre la copie de travail courante et le dernier commit :

Les différences retournées n’ont pas encore été ajoutées à l’index. Ce sont les modifications de l’espace de travail qui seront ajoutées à l’index avec la commande git add.

git diff [filename]

ex :

$ git diff longueur.sh
diff --git a/longueur.sh b/longueur.sh
index 20194fe..20415af 100644
--- a/longueur.sh
+++ b/longueur.sh
@@ -2,7 +2,9 @@
 
 import sys
 
-def taille(s) : return 1 + taille(s[1:]) if s else 0
+def taille(s) :
+    if not s : return 0
+    return 1 + taille(s[1:])
 
 for x in sys.argv[1:] :
     print(taille(x))

Pour appliquer un patch généré avec git format-patch, voir la commande git am filename.patch.
Pour appliquer un patch généré avec git diff, voir la commande git apply filename.patch (option --check pour simulation).
 

Afficher les modifications depuis le dernier commit :

git diff HEAD

 

Affiches les différences entre le staging area (modifications indexées en cache) et le dernier commit :

Ici les modifications ont été validées avec git add mais n’ont pas encore été commitées.

git diff --cached [filename]

 

Afficher les modifications entre deux commits :

git diff commit1(-) commit2(+) [filename]

ex :

$ git diff 159f756 089e7b1 longueur.sh
diff --git a/longueur.sh b/longueur.sh
index 20415af..9f87067 100644
--- a/longueur.sh
+++ b/longueur.sh
@@ -2,9 +2,7 @@
 
 import sys
 
-def taille(s) :
-    if not s : return 0
-    return 1 + taille(s[1:])
+def taille(s) : return s and 1 + taille(s[1:]) or 0
 
 for x in sys.argv[1:] :
     print(taille(x))

 

Afficher les erreurs d’espaces sur les fichiers modifiés (modifications non indexées) :

git diff --check [filename]

ex :

$ git diff --check
test.txt:1: trailing whitespace.
+ajout  d'une ligne     de texte 
test.txt:2: trailing whitespace.
+ et d'une  nouvelle  
test.txt:3: new blank line at EOF.

 

Retourner seulement des stats différentielles (insertions, délétions) :

git diff --stat

git diff --numstat

Afficher uniquement le nom des fichiers modifiés et le statut de la modification apportée :

git diff --name-status

Pour n’afficher que le nom des fichiers modifiés, utiliser l’option --name-only)
Les différents statuts possibles sont :

A: addition of a file
C: copy of a file into a new one
D: deletion of a file
M: modification of the contents or mode of a file
R: renaming of a file
T: change in the type of the file
U: file is unmerged (you must complete the merge before it can be committed)
X: « unknown » change type (most probably a bug, please report it)

On peut également afficher des différences avec positions relatives :

$ git diff HEAD HEAD~2

Ou entre deux branches :

$ git diff testing master

Ou entre une branche locale et une branche distante :

$ git fetch
$ git diff master origin/master

 

 

Afficher avec un outil graphique les différences entre la copie de travail et le dernier commit :

Les différences retournées n’ont pas encore été ajoutées à l’index. Ce sont les modifications de l’espace de travail qui seront ajoutées à l’index avec la commande git add.

git difftool [filename]

ex :

$ git difftool longueur.sh

 

Afficher les modifications entre deux commits :

git diff commit1 commit2 [filename]

ex :

$ git difftool 159f756 089e7b1 longueur.sh

 

 

 

Fusionner une branche avec une autre :

Ceci crée un nouveau commit de fusion.

$ git checkout branchname1
$ git merge branchname2

ex :

$ git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short --all
* c570971 - (master) 2018-06-18 | Added README (master) [darwinos]
| * 28917a4 - (HEAD -> greet) 2013-04-13 | Updated Rakefile (HEAD -> greet) [darwinos]
| * 4dac415 - 2013-04-13 | Hello uses Greeter [darwinos]
| * 39347b3 - 2013-04-13 | Added greeter class [darwinos]
|/  
* 96ee164 - 2013-04-13 | Added a Rakefile. [darwinos]
$ git checkout master
Basculement sur la branche 'master'
$ git merge greet
Merge made by the 'recursive' strategy.
 Rakefile       | 2 +-
 lib/greeter.rb | 8 ++++++++
 lib/hello.rb   | 6 ++++--
 3 files changed, 13 insertions(+), 3 deletions(-)
 create mode 100644 lib/greeter.rb
$ git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short --all
*   6a31e2c - (HEAD -> master) 2018-06-18 | Merge branch 'greet' (HEAD -> master) [darwinos]
|\  
| * 28917a4 - (greet) 2013-04-13 | Updated Rakefile (greet) [darwinos]
| * 4dac415 - 2013-04-13 | Hello uses Greeter [darwinos]
| * 39347b3 - 2013-04-13 | Added greeter class [darwinos]
* | c570971 - 2018-06-18 | Added README [darwinos]
|/  
* 96ee164 - 2013-04-13 | Added a Rakefile. [darwinos]

 

 

Utiliser l’outil graphique de résolution de conflits :

git mergetool

ex :

$ git pull origin master
Depuis github.com:darwinos/repotest
 * branch            master     -> FETCH_HEAD
Fusion automatique de file1.txt
CONFLIT (contenu) : Conflit de fusion dans file1.txt
La fusion automatique a échoué ; réglez les conflits et validez le résultat.
$ git mergetool 
Merging:
file1.txt

Normal merge conflict for 'file1.txt':
  {local}: modified file
  {remote}: modified file

L’outil Meld se lance car c’est celui qui a été défini par défaut avec la commande suivante :

git config --global difftool.meld.path "/usr/bin/meld"

Trois versions du fichiers en conflit s’affichent :

• à gauche, la version locale après modification
• au centre, l’ancêtre commun, avant modification
• à droit, la version distante, après modification

 

 

 

Fusionner une branche avec une autre avec rebasage :

Les commits de la branche branchname intégrée sont réécrits et translatés sur newbase. La fusion se fait en fast-forward.

$ git rebase newbase branchname

branchname aura comme nouvelle base newbase
ou, implicitement la branche rebasée et déplacée est la branche courante sur newbase :

$ git checkout branchname
$ git rebase newbase

ex :

$ git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short --all
* c570971 - (master) 2018-06-18 | Added README (master) [darwinos]
| * 28917a4 - (HEAD -> greet) 2013-04-13 | Updated Rakefile (HEAD -> greet) [darwinos]
| * 4dac415 - 2013-04-13 | Hello uses Greeter [darwinos]
| * 39347b3 - 2013-04-13 | Added greeter class [darwinos]
|/  
* 96ee164 - 2013-04-13 | Added a Rakefile. [darwinos]
$ git checkout greet
Déjà sur 'greet'
$ git rebase master
Premièrement, rembobinons head pour rejouer votre travail par-dessus...
Application de  Added greeter class
Application de  Hello uses Greeter
Application de  Updated Rakefile
$ git log --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %ad | %s%d [%C(bold blue)%an%Creset]' --graph --date=short --all
* 4c6ba8c - (HEAD -> greet) 2013-04-13 | Updated Rakefile (HEAD -> greet) [darwinos]
* 7793b69 - 2013-04-13 | Hello uses Greeter [darwinos]
* 497a2b8 - 2013-04-13 | Added greeter class [darwinos]
* c570971 - (master) 2018-06-18 | Added README (master) [darwinos]
* 96ee164 - 2013-04-13 | Added a Rakefile. [darwinos]

 

Effectuer un rebasage interactif :

git rebase -i newbase

Attantion les commits sont inversés : de haut en bas, du plus ancien au plus récent.
Options interactives disponibles lors du rebasage :

p, pick = picorer le commit
r, reword = picorer le commit, mais reformuler son message
e, edit = picorer le commit, mais s’arrêter pour le modifier
s, squash = prendre le commit, mais le fusionner avec le précédent
f, fixup = comme « squash », mais en éliminant son message
x, exec = lancer la commande (reste de la ligne) dans un shell
d, drop = supprimer le commit

 

Effectuer un rebasage interactif pour réorganiser les n derniers commits :

git rebase -i HEAD~n

 

 

 

Créer un tag léger (non annoté), une référence pointant sur un commit (ou release, étiquette, version) :

git tag tagname [SHA1]

Si le SHA1 n’est pas spécifié, le tag se fera sur HEAD.
ex :

$ git tag v1.1 159f756
$ git tag v1.2 089e7b1
$ git tag v1.3 adc2a9b

 

Créer un tag annoté, une référence pointant sur un commit (ou release, étiquette, version) :

git tag tagname [SHA1] -a -m "Message relatif au tag"

Si le SHA1 n’est pas spécifié, le tag se fera sur HEAD.
ex :

$ git tag v2.0-local -a -m "Etiquette pour version 2.0"
$ git tag v1.6-local 025ff98 -a -m "Etiquette pour version 1.6"

 

Supprimer un tag :

git tag -d tagname

ex :

$ git tag -d v1.3
Étiquette 'v1.3' supprimée (elle était sur adc2a9b)

 

Lister les tags définis :

git tag

ex :

$ git tag
v1.1
v1.2
v1.3

Faire une recherche parmi les tags définis :

git tag -l "regex"

ex :

$ git tag -l "*local"
v1.6-local
v2.0-local

 

 

Afficher toutes les références et les empreintes SHA1 associées :

git show ref

ex :

$ git show-ref
6f2b7412aee4684dbb2e636f369c67ad9b24365f refs/heads/master
6bf13e93866e419819ae1706e45aec780d41b9c7 refs/heads/testing
14e0ac6f8c139935c3ba837575516b82f53e97df refs/remotes/gitlab/master
6bf13e93866e419819ae1706e45aec780d41b9c7 refs/remotes/gitlab/testing
1fd3c16b1d2e9acad43a32c0758106f6d9d12898 refs/remotes/origin/master
6bf13e93866e419819ae1706e45aec780d41b9c7 refs/remotes/origin/testing
159f75622601942793b74e6a2a8ff9ba07a5019b refs/tags/v1.1
089e7b1961451999cf5120ab7d62dd80af072e4c refs/tags/v1.2
adc2a9b6011eb06345abd318a206bb9b878f4f41 refs/tags/v1.3

 

Afficher seulement les tags et les empreintes SHA1 associées :

git show ref --tags

ex :

$ git show-ref --tags
159f75622601942793b74e6a2a8ff9ba07a5019b refs/tags/v1.1
089e7b1961451999cf5120ab7d62dd80af072e4c refs/tags/v1.2
adc2a9b6011eb06345abd318a206bb9b878f4f41 refs/tags/v1.3

 

 

Afficher le nombre de commits entre le dernier tag et un commit donné :

git describe --tags branchname SHA1

 

Afficher le nombre de commits entre le dernier tag et le dernier commit de la branche spécifiée :

git describe --tags branchname

ex :

$ git describe --tags master
v1.3-19-g14e0ac6

Ci-dessus, 19 commits séparent le tag v1.3 et le commit g14e0c6 (dernier commit de la branche master).

 

 

 

Télécharger en local les objets et références distantes, ainsi que leurs commits :

Aucune fusion n’est opérée avec les branches locales. En d’autres termes, on récupère l’état d’avancée d’une branche distante, les commits, mais on ne les fusionne pas avec la branche locale paramétrée pour suivre la branche distante.

git fetch remotename branchname

ex :

$ git fetch origin master
remote: Counting objects: 6, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 6 (delta 3), reused 0 (delta 0), pack-reused 0
Dépaquetage des objets: 100% (6/6), fait.
Depuis github.com:darwinos/repotest
 * branch            master     -> FETCH_HEAD
   3332f20..e8482d9  master     -> origin/master

 

Télécharger les commits de toutes les branches

git fetch

 

Mode simulation (dry-run) :

git fetch --dry-run

 

 

 

Télécharger les mises à jour distantes et les intégrer en local en les fusionnant avec la branche courante :

git pull remotename branchname

Ci-dessus, la fusion se fait de la branche distante vers la branche courante.
Equivaut à :

$ git fetch remotename remote-branchname
$ git merge remotename/remote-branchname

ou

git pull remotename remote-branchname:local-branchname

Ci-dessus, la fusion se fait de la branche distante vers la branche locale spécifiée.
Equivaut à :

$ git fetch remotename remote-branchname:local-branchname
$ git merge remotename/remote-branchname

ex :

$ git pull origin master

Equivaut à :

$ git fetch origin master
$ git merge origin/master


$ git pull origin bar~1:bugFix

Equivaut à :

$ git fetch origin bar~1:bugFix
$ git merge bugFix

 

Avec rebasage sur la branche distante :

Par défaut, git pull effectue un merge, mais nous pouvons préciser que nous souhaitons plutôt rebaser.

git pull --rebase remotename branchname

ex :

$ git pull origin master
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 4 (delta 2), reused 0 (delta 0), pack-reused 0
Dépaquetage des objets: 100% (4/4), fait.
Depuis github.com:darwinos/repotest
 * branch            master     -> FETCH_HEAD
   e8482d9..7999e0b  master     -> origin/master
Mise à jour e8482d9..7999e0b
Fast-forward
 file2.txt | 0
 file3.txt | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 file2.txt
 delete mode 100644 file3.txt

 

 

 

Publier (pusher) des modifications locales vers un dépôt distant :

git push remotename remote-branchname

Pour lier la branche distante et la branche locale courante :

git push -u remotename remote-branchname

Ci-dessus implicitement la source est la branche courante.
ou

git push remotename local-branchname:remote-branchname

ex :

$ git push origin master
Décompte des objets: 8, fait.
Compression des objets: 100% (8/8), fait.
Écriture des objets: 100% (8/8), 1.00 KiB | 0 bytes/s, fait.
Total 8 (delta 4), reused 0 (delta 0)
remote: Resolving deltas: 100% (4/4), completed with 1 local object.
To github.com:darwinos/repotest.git
   c74c5ee..3332f20  master -> master
$ git push gitlab master
Décompte des objets: 38, fait.
Compression des objets: 100% (33/33), fait.
Écriture des objets: 100% (38/38), 3.81 KiB | 0 bytes/s, fait.
Total 38 (delta 16), reused 0 (delta 0)
To gitlab.com:darwinos/repotest.git
 * [new branch]      master -> master

$ git push origin HEAD:testing HEAD:master

$ git push origin foo^:master

 

Pusher un tag local vers un remote :

git push remotename tagname

 

Pusher tous les tags locaux vers un remote :

git push remotename branchname --tags

ex :

$ git push origin master --tags
Total 0 (delta 0), reused 0 (delta 0)
To github.com:darwinos/repotest.git
 * [new tag]         v1.1 -> v1.1
 * [new tag]         v1.2 -> v1.2
 * [new tag]         v1.3 -> v1.3

 

Supprimer un tag distant sur le serveur distant :

git push -d remotename tagname

 

Supprimer une branche distante sur le serveur distant :

git push -d remotename branchname

ou

git push remotename :branchname

ex :

$ git push -d origin testing1
To github.com:darwinos/repotest.git
 - [deleted]         testing1

 

Créer une branche distante à partir d’une branche locale :

git push remotename branchname

 

Pusher HEAD vers plusieurs branches distantes :

git push remotename HEAD:branchname1 HEAD:branchname2 HEAD:branchname3

 

Reseter une branche distante à un commit antérieur

git push --force remotename SHA1:branchname

ex :

$ git push --force origin 4d75f9a:master
Total 0 (delta 0), reused 0 (delta 0)
To github.com:darwinos/repotest.git
 + adc2a9b...4d75f9a 4d75f9a -> master (forced update)

 

 

Ajouter un dépôt distant :

git remote add remotename URL-repository

Converse :

git remote remove remotename

ex :

$ git remote add gitlab git@gitlab.com:darwinos/repotest.git

 

Modifier l’URL d’un dépôt distant :

git remote set-url remotename URL-repository

Afficher les branches distantes :

git remote -v

ex :

$ git remote -v
gitlab	git@gitlab.com:darwinos/repotest.git (fetch)
gitlab	git@gitlab.com:darwinos/repotest.git (push)
origin	git@github.com:darwinos/repotest.git (fetch)
origin	git@github.com:darwinos/repotest.git (push)

 

Afficher les informations détaillées relatives à un dépôt distant :

git remote show remotename

ex :

$ git remote show origin
* distante origin
  URL de rapatriement : git@github.com:darwinos/repotest.git
  URL push : git@github.com:darwinos/repotest.git
  Branche HEAD : master
  Branches distantes :
    master  suivi
    testing suivi
  Branche locale configurée pour 'git pull' :
    master fusionne avec la distante master
  Références locales configurées pour 'git push' :
    master  pousse vers master  (à jour)
    testing pousse vers testing (à jour)

 

 

Afficher toutes les références (branches, tags, etc.) des dépôts distants référencés :

git ls-remote

ex :

$ git ls-remote
From git@github.com:darwinos/repotest.git
adc2a9b6011eb06345abd318a206bb9b878f4f41	HEAD
adc2a9b6011eb06345abd318a206bb9b878f4f41	refs/heads/master
159f75622601942793b74e6a2a8ff9ba07a5019b	refs/tags/v1.1
089e7b1961451999cf5120ab7d62dd80af072e4c	refs/tags/v1.2
adc2a9b6011eb06345abd318a206bb9b878f4f41	refs/tags/v1.3
$ git push origin testing1
Décompte des objets: 7, fait.
Compression des objets: 100% (6/6), fait.
Écriture des objets: 100% (7/7), 671 bytes | 0 bytes/s, fait.
Total 7 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), done.
To github.com:darwinos/repotest.git
 * [new branch]      testing1 -> testing1
$ git ls-remote
From git@github.com:darwinos/repotest.git
adc2a9b6011eb06345abd318a206bb9b878f4f41	HEAD
adc2a9b6011eb06345abd318a206bb9b878f4f41	refs/heads/master
b175110e6973eb5c6bee201aa2168e9a0786e843	refs/heads/testing1
159f75622601942793b74e6a2a8ff9ba07a5019b	refs/tags/v1.1
089e7b1961451999cf5120ab7d62dd80af072e4c	refs/tags/v1.2
adc2a9b6011eb06345abd318a206bb9b878f4f41	refs/tags/v1.3

 

 

Afficher l’interface graphique git pour la gestion des commits et des modifications :

$ git gui

Cette commande est à saisir si le répertoire courant est un projet git.
 

 

---

 
Les GIFs et les scénarios présents dans cet article ont été générés à partir de l’excellent site de tutoriels relatifs à Git intitulé Learn Git Branching.