Memento Git

 0
 0
Estimated reading time:4 minutes 54 seconds

Voici une liste des principales notions et commandes utilisées par Git.
Ce fichier est un canevas qui s'étoffera au fur et à mesure de mes expérimentations sur cet outil et son éco système .

Références/Sources:

Bases

Notions

  • zones locales majeures :
    • le répertoire de travail (working directory/WD)
      git add
    • l’index (stage)
      git commit
      • le dépôt local (Git directory/repository)
        git pull/push
      • le dépôt distant
  • Le HEAD est une référence sur notre position actuelle dans notre répertoire de travail Git. Par défaut il pointe sur la branche courante.
  • les commit sont identifiés par un SHA dont seuls les 8 premiers charactères sont nécessaires pour l'identifier

Config initiale

  • taper les commandes suivantes pour une config initiale ou bien récupérer un ~/.gitconfig

    git config --global user.name "Laurent Ongaro";
    git config --global user.email "[email protected]";
    git config --global color.diff auto;
    git config --global color.status auto;
    git config --global color.branch auto
    git config --global cola.spellcheck true;
    git config --global core.editor code;

Commandes de base

dépots

  • créer un dépôt local: git init
  • cloner un dépôt distant : git clone [MY_remote_URL]
  • ajouter un dépôt distant : git add remote [MY_remote] [MY_remote_URL]

log

  • voir le status du dépot en cours (modifs, branches...): git status
  • voir le log: git log
  • voir le log global: git reflog
  • examiner le contenu d’un fichier ligne par ligne, déterminer la date à laquelle chaque ligne a été modifiée, et le nom de l’auteur des modifications: git blame [file]

commits

  • ajouter à l'index: git add . OU git add [fichier_ou_dossier]
  • valider les dernieres modifs en ajoutant à l'index (-a): git commit -a -m "Mon message” .
  • RECTIFIER le dernier commit (en créant un nouveau commit): git revert HEAD
  • changer le message du dernier commit: git commit --amend -m "Votre nouveau message de commit"
  • intégrer les modifs en cours dans le dernier commit: git commit --amend --no-edit"
  • sélectionner un ou plusieurs commits et les migrer sur la branche master: git cherry-pick [SHA1] [SHA2]...

git reset

  • en SUPPRIMANT les modifs en cours
    • annuler les modifications non commitées: git reset --hard HEAD^
    • revenir à un commit donné (quelque soit la branche !): git reset --hard [SHA] (RAPPEL seuls les 8 premiers charactères du sha sont nécessaires)
  • en CONSERVANT les modifs en cours, en désindexant les fichiers (sans les supprimer) et en créant un HEAD détaché
    • revenir juste après le dernier commit: git reset --mixed HEAD~
    • revenir à un commit donné (quelque soit la branche !): git reset --mixed [SHA]
  • en CONSERVANT tout et sans créer un HEAD détaché
    • revenir juste après le dernier commit: git reset --soft HEAD~
    • revenir à un commit donné (quelque soit la branche !): git reset --soft [SHA]

remises (stash)

  • créer: git stash
  • lister: git stash list
  • appliquer: git stash apply (la dernière) ou git stash apply [SHA_dans_liste]

branches

  • créer: git branch [branche]
  • supprimer: git branch -d [branche]
  • supprimmer en effaçant les modifs en cours: git branch -D [branche]
  • merger une nouvelle branche dans master: se placer dans master et faire git merge [nouvelle_branche]
  • supprimer une branche distante: git push origin --delete [branche]
    • propager la suppression sur chaque dépot local: git fetch --all --prune

Commandes avancées

branches distantes (remote)

  • envoyer des modifications locles sur le dépôt distant: git push [remote] [branche] OU git push (si un remote/branch est défini par défaut)
  • récupérer les modifications distantes SANS LES FUSIONNER: git fetch [remote] [branche] OU git fetch (si un remote/branch est défini par défaut)
  • intégrer les données distantes: git pull [remote] [branche] OU git pull (si un remote/branch est défini par défaut)
    • NOTE: git pull exécute git fetch suivi d'un git merge

rebase

  • rebase consiste à changer la base de votre branche d'un commit vers un autre, donnant l'illusion que vous avez créé votre branche à partir d'un commit différent
  • rebase permet de garder un historique plus clair et plus compréhensible
  • Il est important de toujours nettoyer son historique avant d'envoyer sur le dépôt à distance !
  • NE JAMAIS REBASER DES COMMITS PUSHÉS SUR LE DÉPÔT DISTANT

  • exemple:modifier les 3 dernier commits de manière interactive: git rebase -i HEAD~3
    • il sera demandé que faire sur chacun des commits concernés
    • commande possibles
    • p (pick): utiliser le commit
    • r (reword): utiliser le commit, mais éditez le message de commit
    • e (edit): utiliser le commit, mais arrêtez-vous pour apporter des changements
    • s (squash): utiliser le commit, mais intégrez-le au commit précédent
    • f (fixup): commande similaire à "squash", mais qui permet d'annuler le message de log de ce commit
    • x (exec): exécuter la commande (le reste de la ligne) à l'aide de Shell
    • d (drop): supprimer le commit

bisect

  • se déplacer (à l'envers) de commit en commit pour identifier l'apparition d'un bug: git bisect start [SHA_bad] [SHA_good]
    • SHA_bad: commit où le bug est présent.
    • SHA_good: commit où le bug n'était pas présent
    • Git va alors naviguer dans chacun des commits entre les deux et demander si le commit est "good" or "bad"

sous-modules

  • intégrer un nouveau dépot dans un dépot existant: git submodule add [url] [dossier_destination]
  • créer un nouvel arbre de commits (nouveau module) pour un sous-dossier dans un dépot existant: git subtree push -P [dossier] [[email protected]:group/projet.git master]

divers

  • supprimer tous les fichiers et dossiers non indexés en ignorant le .gitignore:git clean -d -f -x
    • utile pour supprimer les résultats de compilation et fichiers intermédiares

Previous Post Next Post