Concepts de base

• main: branche par défaut
• origin: destination par défaut
• HEAD: branche courante
• HEAD^: parent de HEAD
• HEAD~4: arrière-arrière grand-parent de HEAD

Configuration

Configurer le nom et l'email qui sera rattaché à vos commits et tags

$ git config --global user.name "Jérémy"
$ git config --global user.email "my.email@gmail.com"

Commencer un projet

Créer un repo local (sans <directory>, initialise le dossier courant)

$ git init <directory>

Clôner un repo distant

$ git clone <url>

Faire des changements

Ajouter un fichier modifié

$ git add <file>

Ajouter tous les fichiers modifiés

$ git add .

Commiter tous les fichiers ajoutés

$ git commit -m "commit message"

Ajouter et commiter tous les fichiers modifiés

$ git commit -am "commit message"

Branches

Lister toutes les branches locales. Ajouter le drapeau -r pour n'afficher que les branches distantes et -a pour lister toutes les branches

$ git branch

Créer une nouvelle branche

$ git branch <new-branch>

Changer de branche

$ git checkout <branch>

Créer une nouvelle branche et passer sur celle-ci

$ git checkout -b <new-branch>

Supprimer une branche mergée

$ git branch -d <branch>

Supprimer une branche, qu'elle soit mergée ou non

$ git branch -D <branch>

Créer un tag basé sur votre commit actuel (souvent utilisé pour créer une nouvelle version d'une application)

$ git tag <tag-name>

Merger

Merger une branche A dans une branche B.

A: O---O \ B: O---O

Ajouter le drapeau --no-ff pour no-fast-forward merge

A: O---O O \ / B: O---O

$ git checkout b 
$ git merge a

Merger et squasher (fusionner) tous les commits en un seul nouveau commit

$ git merge --squash a

Rebase

Rebaser une branche feature à partir de main (ou une branche) pour incorporer les changements de main. Evite les merge non nécessaire dans feature et garde un historique de commit propre.

feature: O---O-------O \ main: O---O

feature: O---O-------O \ main: O---O

$ git checkout feature
$ git rebase main

Rebase intéractif afin de nettoyer les commit avant de rebase depuis main

$ git rebase -i main

Rebase intéractif des 3 derniers commits de votre branche courante

$ git rebase -i HEAD~3

Annuler des choses

Déplace ou renomme un fichier du stage

$ git mv <existing_path> <new_path>

Supprimer un fichier de l'espace de travail et du stage

$ git rm <file>

Supprimer un ficher du stage uniquement

$ git rm --cached <file>

Afficher le contenu d'un commit précédent (lecture uniquement)

$ git checkout <commit_ID>

Annuler un commit (revient à l'état avant ce commit)

$ git revert <commit_ID>

Revienir à un commit précédent et supprimer toutes les modifications du stage. Ajoutez le drapeau --hard pour aussi supprimer les fichiers (A UTILISER AVEC PRECAUTION)

$ git reset <commit_ID>

Vérfier votre repo

Lister tous les nouveaux fichiers et les fichiers modifiés non commités

$ git status

Afficher l'historique des commits

$ git log --oneline

Afficher la différance de tous les nouveaux fichiers et les fichiers modifiés non commités

$ git diff

Afficher la différance entre 2 commits

$ git diff <commit1_ID> <commit2_ID>

Enregistrer les modifications temporaires

Enregistrer les fichiers modifés non commités. Pour ajouter les fichiers non ajoutés, utilisez le drapeau -u

$ git stash

Comme au dessus mais avec un commentaire

$ git stash save "comment

Stasher partiellement, un fichier, un ensemble de fichiers ...

$ git stash -p

Lister tous les stash

$ git stash list

Appliquer un stash sans le supprimer

$ git stash apply

Appliquer le stash de l'index 2, puis le supprimer le la liste. Sans stash@{n} au pop, le stash le plus récent sera appliqué

$ git stash pop stash@{2}

Afficher un résumé de la différance du stash 1. Utilisez le drapeau -p pour afficher la différance complète

$ git stash show stash@{1}

Supprimer le stash de l'index 1. Sans stash@{n} au delete, le dernier stash sera supprimé

$ git stash drop stash@{1}

Supprimer tous les stash

$ git stash clear

Synchronisation

Ajouter une connextion distante au repo

$ git remote add <alias> <url>

Afficher toutes les connexions distantes. Utilisez le drapeau -v pour voir les URLs

$ git remote

Supprimer une connexion

$ git remote remove <alias>

Renommer une connexion

$ git remote rename <old> <new>

Récupérer toutes les branches à partir de la connexion distante (sans merge)

$ git fetch <alias>

Récupérer une branche spécifique

$ git fetch <alias> <branch>

Récupérer la copie distante sur votre branche courante et merge

$ git pull

Récupérer et rebaser vos changements devant les nouveaux changements du repo distant (plus propre et permet d'avoir un historique linéaire)

$ git pull --rebase <alias>

Publie tous vos commits de toutes les branches vers la connexion distante

$ git push <alias>

Publie vos commits d'une branche vers la connexion distante (pour faire une pull request)

$ git push <alias> <branch>

Source

@Shubham_pen: https://twitter.com/Shubham_pen/status/1559461208671100928