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"
$ git config --global user.name "Jérémy"
$ git config --global user.email "my.email@gmail.com"
Créer un repo local (sans <directory>, initialise le dossier courant)
$ git init <directory>
$ git init <directory>
Clôner un repo distant
$ git clone <url>
$ git clone <url>
Ajouter un fichier modifié
$ git add <file>
$ git add <file>
Ajouter tous les fichiers modifiés
$ git add .
$ git add .
Commiter tous les fichiers ajoutés
$ git commit -m "commit message"
$ git commit -m "commit message"
Ajouter et commiter tous les fichiers modifiés
$ git commit -am "commit message"
$ git commit -am "commit message"
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
$ git branch
Créer une nouvelle branche
$ git branch <new-branch>
$ git branch <new-branch>
Changer de branche
$ git checkout <branch>
$ git checkout <branch>
Créer une nouvelle branche et passer sur celle-ci
$ git checkout -b <new-branch>
$ git checkout -b <new-branch>
Supprimer une branche mergée
$ git branch -d <branch>
$ git branch -d <branch>
Supprimer une branche, qu'elle soit mergée ou non
$ git branch -D <branch>
$ 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>
$ git tag <tag-name>
Merger une branche A dans une branche B.
A: O---O
\
B: O---O
A: O---O
\
B: O---O
Ajouter le drapeau --no-ff pour no-fast-forward merge
A: O---O O
\ /
B: O---O
A: O---O O
\ /
B: O---O
$ git checkout b
$ git merge a
$ git checkout b
$ git merge a
Merger et squasher (fusionner) tous les commits en un seul nouveau commit
$ git merge --squash a
$ git merge --squash a
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
feature: O---O-------O
\
main: O---O
feature: O---O-------O
\
main: O---O
$ git checkout feature
$ git rebase main
$ git checkout feature
$ git rebase main
Rebase intéractif afin de nettoyer les commit avant de rebase depuis main
$ git rebase -i main
$ git rebase -i main
Rebase intéractif des 3 derniers commits de votre branche courante
$ git rebase -i HEAD~3
$ git rebase -i HEAD~3
Déplace ou renomme un fichier du stage
$ git mv <existing_path> <new_path>
$ git mv <existing_path> <new_path>
Supprimer un fichier de l'espace de travail et du stage
$ git rm <file>
$ git rm <file>
Supprimer un ficher du stage uniquement
$ git rm --cached <file>
$ git rm --cached <file>
Afficher le contenu d'un commit précédent (lecture uniquement)
$ git checkout <commit_ID>
$ git checkout <commit_ID>
Annuler un commit (revient à l'état avant ce commit)
$ git revert <commit_ID>
$ 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>
$ git reset <commit_ID>
Lister tous les nouveaux fichiers et les fichiers modifiés non commités
$ git status
$ git status
Afficher l'historique des commits
$ git log --oneline
$ git log --oneline
Afficher la différance de tous les nouveaux fichiers et les fichiers modifiés non commités
$ git diff
$ git diff
Afficher la différance entre 2 commits
$ git diff <commit1_ID> <commit2_ID>
$ git diff <commit1_ID> <commit2_ID>
Enregistrer les fichiers modifés non commités. Pour ajouter les fichiers non ajoutés, utilisez le drapeau -u
$ git stash
$ git stash
Comme au dessus mais avec un commentaire
$ git stash save "comment
$ git stash save "comment
Stasher partiellement, un fichier, un ensemble de fichiers ...
$ git stash -p
$ git stash -p
Lister tous les stash
$ git stash list
$ git stash list
Appliquer un stash sans le supprimer
$ git stash apply
$ 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}
$ 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}
$ 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}
$ git stash drop stash@{1}
Supprimer tous les stash
$ git stash clear
$ git stash clear
Ajouter une connextion distante au repo
$ git remote add <alias> <url>
$ git remote add <alias> <url>
Afficher toutes les connexions distantes. Utilisez le drapeau -v pour voir les URLs
$ git remote
$ git remote
Supprimer une connexion
$ git remote remove <alias>
$ git remote remove <alias>
Renommer une connexion
$ git remote rename <old> <new>
$ git remote rename <old> <new>
Récupérer toutes les branches à partir de la connexion distante (sans merge)
$ git fetch <alias>
$ git fetch <alias>
Récupérer une branche spécifique
$ git fetch <alias> <branch>
$ git fetch <alias> <branch>
Récupérer la copie distante sur votre branche courante et merge
$ git pull
$ 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>
$ git pull --rebase <alias>
Publie tous vos commits de toutes les branches vers la connexion distante
$ git push <alias>
$ git push <alias>
Publie vos commits d'une branche vers la connexion distante (pour faire une pull request)
$ git push <alias> <branch>
$ git push <alias> <branch>
