Tuto :

• https://git-scm.com/book/fr/v2
• https://www.grafikart.fr/formations/git
• https://education.github.com/git-cheat-sheet-education.pdf
• http://cdiese.fr/git-en-5-min/
• https://delicious-insights.com/fr/articles/bien-utiliser-git-merge-et-rebase/

Créer un fichier .gitignore pour ignorer certains fichiers, répertoires, extensions :

.gitignore

*
!*/
*.swp
*.swo
!.gitignore
!README.md
!/dir2/
/dir2/dir1/passwd
!/dir1/dir2/file2

• Officiel
• Tuto

• Officiel
• Tuto

• Affiche la liste, taille et attributs des fichiers :

$ git ls-tree --full-tree -rl HEAD

• Affiche la racine du projet géré par git :

$ git rev-parse --show-toplevel
/home/gigix/test-github/gigix

• Affiche tous les changements sur un fichier :
  • pour touts les commit :

$ git rev-list --all --abbrev-commit | xargs git grep -n mon_fichier

• pour les 10 derniers commit :

$ git rev-list --abbrev-commit --all --max-count=10 | xargs git grep -n mon-fichier

• pour tous les fichiers xml du répertoire dir1 :

$ git rev-list --all --abbrev-commit | xargs -I{} git grep dir1 {} -- ".xml"

• Vérifie si un fichier match avec le fichier .gitignore :

$ git check-ignore -v dir11/file
.gitignore:1:* dir11/file

• Affiche la branche courante :

$ git rev-parse --abbrev-ref HEAD
master

• Remplace tous les nom et email d'un auteur par un autre pour l'ensemble des commit :

$ git filter-branch --commit-filter '                                                                                      
         if [ "$GIT_AUTHOR_NAME" = "root" ];
         then
                 GIT_AUTHOR_NAME="Ghislain LE MEUR";
                 GIT_COMMITTER_NAME="Ghislain LE MEUR";
                 GIT_AUTHOR_EMAIL="gigi206@users.noreply.github.com";
                 GIT_COMMITTER_EMAIL="gigi206@users.noreply.github.com"; 
                 git commit-tree "$@";
         else
                 git commit-tree "$@";
         fi' -f HEADt commit-tree "$@";
         fi' HEAD

• Efface mydir/myfile pour l'ensemble des commit :

$ git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch mydir/myfile' --prune-empty --tag-name-filter cat -- --all
$ git push origin --force --all
$ git push origin --force --tags
$ git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
$ git reflog expire --expire=now --all
$ git gc --prune=now

• Désactiver le pager :

$ git config --global --replace-all core.pager "less -F -X"

Affiche l'aide :

$ git help <module>
$ git help config

Gère la configuration locale ou globale des projets git. Options :

• –global : pour tous les repo git (fichier /home/gigix/.gitconfig)
• –local : pour le repo courant (par défaut dans le répertoire .git/config du projet)

• Pousser une configuration :

$ git config --global user.name "GigiX"
$ git config --global user.email gigixdvelannes.com

• Voir la configuration :

$ git config -l --global 
$ git config -l --local

• Editer la configuration :

$ git config -e --global 
$ git config -e --local

$ git remote set-url origin https://github.com/gigi206/test.git

• Afficher la configuration d'une variable :

$ git config --get remote.origin.url

Initialise un nouveau projet git :

• Créer un repo local git pour gérer notre projet :

$ git init

• Créer un repo local pour accueillir les push :

$ git init --bare

Gère les remotes.

• Lister les remote :

$ git remote -v
origin	https://github.com/gigi206/test.git (fetch)
origin	https://github.com/gigi206/test.git (push)

• Ajoute un remote :

$ git remote add origin /home/gigix/test-repo
$ git remote add upstream https://github.com/gigi206/vim-gigix.git

• Supprimer un remote :

$ git remote remove origin /home/gigix/test-repo

• Renommer un remote :

$ git remote rename origin test

Clone un projet.

• Copie un repo distant :

$ git clone https://github.com/gigi206/vim-gigix.git myclonerepo

• Copie le dépôt avec les 10 derniers commit (utile pour récupérer les gros dépôts) :

$ git clone --depth 10 https://github.com/gigi206/vim-gigix.git

Afficher l'état de notre copie de travail :

$ git status
$ git status -s

• Ajoute un fichier à l'index :

$ git add mon_fichier

• Ajoute tous les fichiers à l'index :

$ git add --all
$ git add -A

• Ajouter le répertoire courant :

$ git add .

• Supprimer un fichier à l'index :

$ git rm mon_fichier

• Supprimer les fichier de l'index :

$ git rm --cached monfichier

• Supprimer tous les fichiers d'un répertoire :

$ git rm -r mon_repertorie

Renomme un fichier, dossier ou lien de l'espace de travail :

$ git mv file1 file2

Gère les révisions localement uniquement.

• Envoie de tous les fichiers trackés :

$ git commit -a -m 'mon message'

• Envoie d'un fichier :

$ git commit -m 'mon message' mon-fichier

• Changer l'auteur :

$ git commit --author "GigiX" -m "message"

• Modifie le dernier commit en ajoutant nos modifications actuelles au derniers commit et en modifiant son message (ne crée pas une nouvelle entrée dans l'historique :

$ git add -A
$ git commit --amend –m "message"

Envoie les commit, branches, tags au remote

• Envoyer ses modifications de la branche master au remote origin:

$ git push -u origin master

• Envoyer toutes ses branches et tags :

$ git push --all --tags

Met à jour le répertoire local depuis un remote :

$ git fetch origin master
$ git fetch --all

• Récupérer les modifications du remote :

$ git pull

• Pull avec un rebase à la place d'un merge :

$ git pull --rebase

$ git config --global branch.autosetuprebase always

• Pull avec un rebase sur le dernier commit uniquement pour préserver le graph d'historique :

$ git pull --rebase=preserve

$ git config --global pull.rebase = preserve

• Sans fast-forward (l'équivalent d'un merge dans l'historique) :

$ git pull --no-ff

• En forçant le fast-forward (l'équivalent d'un rebase dans l'historique) :

$ git pull --ff-only

Récupère seulement un seul commit effectué sur une autre branche complètement séparée de la branche courante. Elle permet d’appliquer les modifications correspondant à un seul commit sans effectuer de merge ou rebase.

• Se placer dans la branche sur laquelle on veut appliquer le commit, par exemple master :

$ git checkout master
$ git cherry-pick <SHA-1>

Imaginons, vous avez des modifications en cours de création et vous avez envie de les mettre de côté temporairement, plutôt que de commit les différentes modifications vous pouvez les stocker grâce à stash.

• Backup les modifications courantes :

$ git stash -u
$ git stash save -u mon message

• Ramène les modifications dans une nouvelle branche :

$ git stash branch gigix

• Restaure les dernières modifications sauvegardées en stash :

$ git stash apply
$ git stash apply stash@{1}

• Supprime le backup :

$ git stash drop
$ git stash drop stash@{1}

• Restaure et supprime le backup :

$ git stash drop
$ git stash drop stash@{1}

• Affiche ce qui a été sauvegardé :

$ git stash pop
$ git stash pop stash@{1}

• Voir l'ensemble des modifications sauvegardées :

$ git stash list

Affiche les révisions, auteurs, date, diff des commit.

• Affiche les logs des commit :

$ git log --oneline                                                                                                       
$ git log --raw --oneline -10
$ git log --stat
$ git log -p
$ git log --graph --decorate --oneline
$ git log --author="GigiX" -p hello.py
$ git log master..origin/master # Permet de voir les commits entre ma branche master et celle du remote
$ git log 852e094^..852e094 -p
$ git log 852e094..HEAD --oneline
$ git log 852e094..HEAD -L 2,6:mon_fichier
$ git log --grep=gigix
$ git log --since="1 month" --until="1 day" --oneline
$ git log --graph --abbrev-commit --decorate --date=relative --all
$ git log --graph --topo-order --decorate --oneline --all
$ git log --graph --topo-order --decorate --oneline --boundary test..master
$ git log --graph --full-history --all --color --pretty=format:"%x1b[31m%h%x09%x1b[32m%d%x1b[0m%x20%s"

• Rechercher un fichier et ses révisions (même supprimé) :

$ git log --all --full-history -- test

• Ajouter un alias pour les logs (celui que j'utilise) :

$ git config --global alias.lg 'log --graph --full-history --color --oneline --format="%x1B[33m%h%x1B[32m%d %x1B[0m%s %x1B[36m(%an %cr)%x1B[0m"'
$ git config --global alias.lga 'log --graph --full-history --color --oneline --all --format="%x1B[33m%h%x1B[32m%d %x1B[0m%s %x1B[36m(%an %cr)%x1B[0m"'
$ git lg --all
$ git lga
$ git lg --first-parent mybranch
$ git lg --parents mybranch

Affiche les logs des rebase, merge, etc…

$ git reflog

• Affiche les différences sur les fichier pour un commit ou affiche un fichier pour un commit donné :

$ git show 651bb22                                                                                                        
$ git show 651bb22:README.md
$ git show --topo-order --decorate --oneline
$ git show --topo-order --decorate --oneline --all

• Affiche un fichier ligne par ligne avec son commit et son auteur.

$ git blame myfile 
$ git blame -n myfile
$ git blame -L 3,6 -C myfile

• Affiche la différence entre 2 commit :

$ git diff HEAD^^
$ diff 8084b3f..edeaa87                                                                     
$ git diff 26e5423:.gitignore  3c99fa1:.gitignore
$ git diff 3c99fa1..26e5423 dir1/dir2/file2

• Comparer avec l'index :

$ git diff --cached

• Créer et appliquer un patch :

$ git diff 2d8de18..17dc028 > path
$ git apply patch
$ git diff

$ git diff 2d8de18..17dc028 | patch
$ git status

Utilise un outil tiers comme vim pour afficher les diff (comme vimdiff par exemple).

$ git difftool  HEAD^..HEAD -t vimdiff

$ git config --global alias.vimdiff difftool

Gère les branches.

• Crée la branche gigix :

$ git branch gigix 

• Détruit la branche gigix localement :

$ git branch -d gigix

• Détruit la branche distante gigix sur le remote origin :

$ git push -u origin -d gigix

• Renommer une branche :

$ git branch -m gigix new

• Liste les branches :

$ git branch -vv --all

Change de branche ou restaure un fichier d'un autre commit.

• Se positionner sur une révision ou branche pour l'explorer :

$ git checkout HEAD^^
$ git checkout 8084b3f
$ git checkout master
$ git checkout mabranche

• Restaurer un fichier d'un ancien commit :

$ git checkout 8084b3f 1

• Créer la branche gigix et se positionner dessus :

$ git checkout -b gigix

• Annule seulement les commit sélectionnés (n'altère pas l'historique) :

$ git revert 416515b
$ git revert 7db7d1c..852e094
$ git revert 17dc028 --no-commit

Retourne à un ancien commit et supprime le log.

• Déplace le HEAD sur un commit sans rien faire d'autre (ne touche pas à l'index, ni au répertoire de travail) :

$ git reset --soft 181d77f
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff --cached
$ git commit -m "message"

• L'option –mixed est l'option par défaut (il n'est donc pas nécessaire de la spécifier). Il déplace le HEAD et l'index :

• Sur une révision complète :

$ git reset --mixed 181d77f
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff
$ git commit -a -m "message"

• Seulement sur un fichier :

$ git reset 181d77f myfile
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff
$ git commit -a -m "message"

• Enlève le travail de l'index (donné avec git add) :

$ git reset

• L'option –hard déplace le HEAD, l'index et l'espace de travail (vous perdrez donc votre travail en cours) :

$ git reset --hard 181d77f

• Remet l'espace de travail à l'état du dernier commit :

$ git reset --hard

Supprime les fichiers non trackés.

• Mode intéractif :

$ git clean -i

• Simule :

$ git clean -n

• supprime les fichiers :

$ git clean -f

Rapatrie les commit d'une autre branche dans celle courante.

• Si la branche test est en avance et qu'on souhaite mettre branche courante au même niveau que test :

$ git rebase -i test

• Si l'on souhaite éditer, ou fusionner les 3 commit précédents :

$ git rebase -i HEAD~3

• Rejoue les modifications de dev sur le sommet de la branche master :

$ git rebase master dev
#ou
$ git rebase -i master dev
#On peut ensuite avancer master au niveau de dev et supprimer dev
$ git checkout master
$ git merge dev --ff-only
$ git branch -d dev

• Récupérer une sous branche d'une branche dans master :

Prenons le cas ci-dessous :

Pour fusionner la sous-branche client de server dans master, on fera :

$ git rebase --onto master server client

Ce qui donnera :

Fusionne 2 branche et garde une trace dans l'historique.

• Merge la branche test sur celle courante :

$ git merge test

• Merge avec fast forward (équivaut à un rebase) :

$ git merge test --ff-only

• Merge sans fast forward :

$ git merge test --no-ff

• Merge une branche dans une autre sans modifier l'historique (exemple : merge la branche gigix dans la branche master) :

$ git checkout master
$ git merge --squash gigix
$ git diff --staged
$ git commit -a -m "New feature gigix"
#Si on souhaite supprimer gigix
$ git push origin -d gigix

Affiche les statistiques.

• Affiche le commit par utilisateur :

$ git shortlog -sn

Créer une archive du dépôt git.

• Affiche les formats de compressions :

$ git archive -l

• Compresser le dépôt courant :

$ git archive --format=tar.gz -o gigix.tar.gz master
$ git archive --format=tar.gz -o gigix.tar.gz HEAD^1

Gère les tags.

• Affiche les tags :

$ git tag
$ git tag -n
$ git tag -l -n

• Crée le tag test :

$ git tag test 6452b46

• Crée un tag annoté :

$ git tag -a test 6452b46 -m "gigix"

• Supprime le tag test :

$ git tag -d test

Recherche dans les fichiers :

$ git grep --all-match -e "^gigix$" -e "modif"
$ git grep -i 'gigix' $(git rev-list --all --abbrev-commit)

Trouver par recherche dichotomique la modification qui a introduit un bug :

• Tuto git bisect