1. Commandes de récupérations
1.1 Récupérer les fichiers distants
git pull --rebase
1.2 Afficher les branches distantes
git branch -a
1.3 Rafraichir la liste des branches
git fetch -p
2. Commandes de créations
2.1 Créer une nouvelle branche
git checkout -b ma_nouvelle_branche
2.2 Partager une nouvelle branche sur le serveur distant
git push --set-upstream origin ma_nouvelle_branche
2.3 Créer un nouveau commit contenant tous les fichiers modifiés
git commit -a
2.4 Ajouter dans le futur commit un fichier précis
git add path/to/my/file.ext
2.5 Créer un nouveau commit en ajoutant un commentaire et un fichier
git commit -m 'my notes' -- path/to/my/file.ext
2.5.1 Equivalent à ceci
git add path/to/my/file.ext
git commit -m 'my notes'
3. Commandes de suppression
3.1 Supprimer une branche locale (mode force)
git branch -D ma_branche
3.2 Supprimer une branche locale (mode soft)
git branch -d ma_branche
3.3 Supprimer la branche distante
git push origin --delete ma_branche
3.4 Supprimer le dernier stash
git stash drop
4. Autres commandes
4.1 Merger une branche
git checkout tronc
git merge branche
4.2 Mettre de coté les fichiers
git stash
git pull --rebase
git stash pop
4.3 Voir la liste des fichiers modifiés
git st
4.4 Regarder le diff d'un seul fichier avec l'état de ce dernier au précédent commit
git diff -- www/fichier
4.5 Partager ses commits sur le serveur distant / Pusher à tout le monde:
git push
4.6 Annuler dernier commit en revenant à l'état exact du commit précédent
git commit -c ORIG_HEAD
4.7 Annuler dernier commit sans supprimer les fichiers
git reset HEAD^
5. Revenir à un moment précis de l'historique GIT
git reflog -20; // affiche les 20 dernières opérations d'écriture
git checkout c2f72e1; // Revient via la signature d'une opération à ce moment précis
5.1 Ignorer toutes les modifications :
git reset --hard
5.2 Modifier le dernier commit (Attention : a faire AVANT le push)
git commit --amend fichier.txt
5.3 Afficher l'historique des commits
git log
5.4 Afficher l'historique des commits de façon plus lisible
git lg -6
5.5 Afficher l'historique/tous les commits qui concerne un fichier particulier
git lg --stat fichier.txt
6. Commandes de manipulation des tags
6.1 Supprimer un tag :
git tag -d v4.4.19
git push origin :v4.4.19
6.2 Taguer un commit particulier
git tag v4.4.19 d771f3
6.3 Copier les commits connus d'un point à un autre
git checkout -b nouvelle_branche
git cherry-pick commit_merdique
git checkout fichiermerdique
git commit
git cherry-pick b984e4f..ac12869
6.3.1 Revenir au commit - 1 (HEAD-1)
git reset HEAD^
6.3.2 Fusioner plusieurs commit successif meme pushés:
git rebase -i b846106
# Revenir dans le passé en ignorant toutes les modifications et les stages
git reset --hard origin/my_branch
# Récupérer un seul fichier du stash
git checkout stash@{0} -- path/to/my/file.ext
7. Le bisect
7.1 Contexte d'utilisation du bisect
Une regression est constatée en production.
Il y au moins de façon de faire :
- soit regarder le code directement ;
- soit utiliser la commande git bisect afin de trouver quel est le commit responsable de cette regression.
7.2 L'action git bisect run
Dans un projet critique, il est prudent d'écrire des tests de non regression. Il est possible de faire tourner ces tests via le run.
📖️️Voici un article plus complet sur le sujet : https://alanhollis.com/php/solving-bugs-phpunit-git-bisect/
Exemple :
git bisect run phpunit tests/MyClassTest.php
7.3 Les limites du bisect
Le bisect pré-suppose que la regression n'est liée qu'à un seul repository Git. Dans le cas où plusieurs repository sont concernés (ex: Front + Webservices), cette solution ne parait pas pertinente.
Egalement, il est difficile de confronter le temps de résolution entre les deux chemins possibles : bisect ou analyse du code directement. Le bisect s'avère peut être plus adapté s'il est trop difficile de débogguer le problème.
Eventuellement, cela peut être interessant lorsque deux personnes cherchent une solution que chacun prenne un des deux chemins.
8. Le cherry-pick
git cherry-pick {hash}
9. Le rebase interactif
Le rebase interactif permet de retravailler les commits (contenu, commentaire).
Il est très utile pour fusionner des commits répondant à la même fonctionnalité, supprimer du code qui n'a pas lieu d'être dans l'historique (ex: code de débug, sauts à la ligne, code commenté...), modifier le commentaire lié au commit.
A noter qu'il faut faire des commits dit atomiques.
- un commit qui n'introduit pas de bug dans l'application (ex: une dépendance à un commit futur) ;
- un commit qui ne concerne qu'une seule fonctionnalité.
git rebase -i {hash}
10. Le reflog
Le reflog est très peu connu alors que son utilité est extrèmement puissante puisqu'il est possible d'aller et venir dans le temps.
Le reflog contient toutes les commandes GIT qui ont eu un impact sur l'état du projet. Il est donc possible de revenir à un moment très précis, par exemple avant un rebase/merge.
10.1 Exemple d'utilisation du git reflog
git reflog -20; // affiche les 20 dernières opérations d'écriture
git checkout c2f72e1; // Revient via la signature d'une opération à ce moment précis
10.2 Réinitialiser une branche distante à partir d'un ancien état
git checkout branche
git reflog -30
git reset --hard {hash du commit qui fonctionnait}
git push -f