Aide-Mémoire Sur Les Commandes Git

Par Nicolas Malet / Publié le 05.02.2020

Voici une liste de commandes git qui t’aidera à gérer et versionner tes projets pas à pas.

Initialisation

git init : initialise un nouveau dépôt Git. Jusqu’à ce que tu exécutes cette commande dans un dépôt ou répertoire, c’est juste un dossier ordinaire.

Seulement après avoir entré cette commande, tu peux entrer les commandes Git qui suivent.

Configuration

git config -l : lire le contenu de la configuration.

git config : configure Git, ceci est tout particulièrement utile quand tu paramètres Git pour la première fois.

git config --global user.name "<user-name>"
git config --global user.email "<contact@gmail.com>"

Info :

--global définie la configuration de manière globale. Tu ne seras pas obligé de configurer chaque dépôt séparément.

git remote add origin <url> : indique le répertoire Git a utiliser sur le serveur github (utiliser la méthode ssh -> public key).

git push --set-upstream origin master : permet de téléverser le répertoire local vers le répertoire Git sur le serveur.

git submodule add <host> : ajoute un projet externe dans le projet principal.

.gitignore : liste les fichiers ou dossiers à ignorer (important pour les mots de passe).

Tester la connexion

git ls-remote

Indexation

git status : vérifie le statut du repository. Voir quels fichiers sont à l’intérieur, quelles sont les modifications à “commiter”, et sur quelle branche du repository tu es en train de travailler.

git add <nomDeFichier> : ajoute les fichiers et modifications à l’index.

git add . : ajoute tous les fichiers.

git rm --cached <fichier> ou git reset <fichier> : supprime les modifications de l’index.

git commmit -m "<message>" : crée un commit.

git diff HEAD^ HEAD : affiche la différence entre les 2 derniers commits.

git commit -am "<message>" : combine les deux opérations précédentes.

Un sujet

Une ligne blanche

Une description

Ne pas hésite à créer un commit même pour une modification mineure

git diff <fichier> : affiche la différence entre le dernier commit et les nouvelles modifications (à faire avant git add)

sinon git diff ---cached <fichier>

graph LR modif( Modification fa:fa-floppy-o ) -.-> diff(git diff) diff -.-> add(Git add .) add -.-> diffC(git diff --cached)

Info :

HEAD est un tag indiquant le commit sur lequel on se situe.

Indexer de manière provisoire

git stash save "message" : mettre de côté les modifications.

graph LR v1(Modification Version 3) -.-> |ERREUR|check(git checkout version 2) v1 --> stash("git stash save message") stash --> |OK|check

git stash list : afficher les “stashs”.

git stash show <stash-ID> : affiche plus d’informations sur le stash.

git stash pop <stash-ID> : réintégre les modifications (avant commit).

git stash apply : rec avant commit.

Historique des commits

git log : affiche la liste de tous les commits réalisés de la branche courante.

git log --online : affiche seulement l’entête des commits.
git log -n 2 : affiche les 2 derniers commits.
git log <nomDeLabranche> : affiche les commits de la branche indiquée.
git log -a : affiche tous les commits après avoir fait git fetch.

git show <SHADuCommit> | <tag> : affiche un commit précis (même affichage que git diff).

git checkout <sha-1> | <tag> : se place sur un commit, git checkout master pour revenir.

Branches et Tags

git branch : voir les branches.

git branch <nomDeLaBranche> : crée une nouvelle branche.

git branch -d <nomDeLabranche> : supprime la branche locale.
git push origin --delete <nomDeLabranche> : supprime la branche sur le dépôt distant.
git branch -a : affiche toutes les branches locales et distantes.

git switch | git checkout <nomDeLaBranche> : permet de se placer sur une autre branche.

git switch -c <nomDeLaBranche> | git checkout -b <nomDeLaBranche> : crée une branche et se place dessus.

git tag : affiche la liste de tous les tags.
git tag <tag-name> : attribue un tag au commit.
git tag --delete <tag-name> : supprime le nom du tag.
git push --tags : mettre à jour les tags sur le dépôt distant.

git blame <fichier> : affiche toutes les modifications d’un fichier.

Gérer les dépôts distants

git commit --amend -m "<nouveau message>" : modifie le message du derniers commit.

git remote -v : affiche la liste des distants.

git remote add : clone le dossier sur le serveur (utiliser la méthode ssh -> public key).

git clone <host>... : importe le dossier repository.

Publier les commits sur un dépôt distant

git push [origin master] : mettre en ligne les commits.

git push --tag : publie les commits de tous les tags (Release).
git push --all : publie les commits de toutes les branches.
git push -f : force la publication des commits.

git pull : met a jour la version locale (Réalise un merge si il y a conflit).

git merge --abort : annule git pull si il y a conflit.
git pull --rebase : mettre a jour la version locale. Résoudre le conflit, faire un commit puis git rebase --skip

git fetch : cette commande s’adresse au dépôt distant et récupère toutes les données de ce projet que vous ne possédez pas encore.

git diff HEAD...origin/master : cette commande produit une différence entre le sommet de 2 banches. Si tu préfère trouver la différence de leur ancêtre commun, tu peux utiliser 3 points au lieu de 2.

git diff master...test

Récupérer un commit

git cherry-pick <SHADuCommit> : replace un commit d’une branche à une autre.

Merge et Rebase

git checkout <branche A> puis git merge <branche B> : fusionne la branche B dans la branche A.

Pour avoir un travail mieux organisé (plus propre)

Annuler / modifier un commit

git commit --amend : ajoute des changements au derniers commit

git restore <fichier> | git checkout <fichier> : Supprime les modifications en-cours (avant commit)

git restore --staged | git reset : annule l’indexation

git reset --soft <fichier>|<commit-(c-1)> : annule un commit mais garde les changements (sélectionne d’abord un commit antérieur)

git reset --hard <fichier>|<commit-(c-1)> : annule un commit mais sans garde les changements (sélectionne d’abord un commit antérieur)

git revert <SHADuCommit> : annule ou crée un commit inverse

A noter :

L’annulation fait qu’on se repositionne sur un commit antérieur

réf¹ réf²

Aide

git help : affiche les 21 commandes les plus courantes de Git. Tu peux aussi être plus spécifique et saisir “git help init” ou tout autre terme pour voir comment utiliser et configurer une commande spécifique git

Avant de réaliser un “git pull”

git fetch
git log HEAD..origin/master
git log -p HEAD..origin/master
git diff HEAD...origin/master

Submodule git

Ajouter un sous dépot git avec “submodule”

git submodule add <host> <path/to/dir>

Réaliser un “git pull” pour un “submodule”

La première fois, on peut extraire tous les sous-modules en utilisant

git submodule update --init --recursive

Pour mettre à jour les sous-modules, on peut faire

git submodule update --recursive --remote

Supprimer un sous-module

Supprime la section appropriée du fichier .gitmodules.
Exécute la commande git add .gitmodules pour mettre à jour les changements.
Supprime la section appropriée dans .git/config.
Exécute la commande git rm --cached path_to_submodule (aucune barre oblique finale).
Exécute la commande rm -rf .git/modules/path_to_submodule (pas de barre oblique finale).
Exécute la commande git commit -m "Sous-module supprimé".
Supprime les fichiers de sous-module maintenant non suivis rm -rf path_to_submodule.

réf : https://gist.github.com/myusuf3/7f645819ded92bda6677