Comment combiner vos derniers commits N Git

Maîtriser le Commit Squashing dans Git :

Lorsque vous travaillez sur un projet, votre historique de validation peut être encombré de nombreux petits commits. Ces engagements mineurs peuvent rendre difficile l’examen des modifications et la compréhension de l’historique du projet.

Dans Git, vous pouvez regrouper vos N derniers commits en un seul commit, créant ainsi un historique plus propre et plus gérable. Ce guide vous guidera à travers les étapes pour y parvenir, rendant votre contrôle de version plus efficace.

Commande	Description
git rebase -i HEAD~N	Lance un rebase interactif des N derniers commits.
pick	Conserve un commit tel quel lors d'un rebase interactif.
squash	Combine un commit avec le précédent lors d'un rebase interactif.
sed -i '1!s/pick/squash/' .git/rebase-merge/git-rebase-todo	Remplace automatiquement « pick » par « squash » pour tous les commits sauf le premier dans la liste de tâches de rebase.
git rebase --continue	Continue le processus de rebase après avoir résolu les conflits.
git rebase --abort	Abandonne le processus de rebase et revient à l'état avant le démarrage du rebase.
HEAD~N	Fait référence au commit N places avant le HEAD actuel.

Comprendre l'écrasement des commits de Git

Le premier script utilise pour lancer un rebase interactif des N derniers commits. Dans l'écran interactif, vous remplacez « pick » par « squash » pour les commits que vous souhaitez combiner. Ce processus permet de consolider plusieurs commits plus petits en un seul, rendant votre historique de commit plus propre et plus facile à gérer. Après l'édition, enregistrez et fermez l'éditeur. S'il y a des conflits, vous les résolvez et continuez .

Le deuxième script est un script Bash qui automatise le processus d'écrasement. Cela commence par vérifier si un nombre de commits (N) est fourni. Ensuite, ça tourne et utilise pour remplacer « pick » par « squash » pour tous les commits sauf le premier dans la liste de tâches de rebase. Cela facilite l'écrasement de plusieurs validations sans modifier manuellement le fichier. Enfin, il continue le processus de rebase avec , gérant automatiquement toutes les résolutions de conflits nécessaires.

git rebase -i HEAD~N
# Replace N with the number of commits you want to squash
# In the interactive rebase screen that appears, change 'pick' to 'squash' (or 's') for the commits you want to squash
# Save and close the editor
# Edit the commit message if needed, then save and close the editor again
# If there are conflicts, resolve them and then run
git rebase --continue
# Your last N commits are now squashed into one commit

#!/bin/bash
if [ -z "$1" ]
then
  echo "Usage: ./squash_commits.sh <N>"
  exit 1
fi
git rebase -i HEAD~$1
# Automatically replace 'pick' with 'squash' for all but the first commit
sed -i '1!s/pick/squash/' .git/rebase-merge/git-rebase-todo
git rebase --continue

Techniques avancées de compression de Git

Un autre aspect important de l’écrasement des commits dans Git est la gestion des conflits de fusion qui peuvent survenir au cours du processus. Lors de la combinaison de plusieurs validations, les modifications de différentes validations peuvent entrer en conflit les unes avec les autres. Pour résoudre ces conflits, Git fournit des commandes telles que pour voir quels fichiers sont en conflit et pour les marquer comme résolus. Après avoir résolu les conflits, vous continuez le rebase avec .

Il est également utile de savoir comment abandonner un rebase si les choses tournent mal. La commande arrête le processus de rebase et ramène votre référentiel à son état précédent avant le démarrage du rebase. Cela garantit que vous pouvez annuler en toute sécurité toutes les modifications apportées au cours du processus de rebase. Comprendre ces commandes peut améliorer considérablement votre capacité à gérer efficacement des historiques Git complexes.

1. Que signifie écraser les commits ?
2. Écraser les commits signifie combiner plusieurs commits en un seul commit pour simplifier l’historique des commits.
3. Pourquoi devrais-je écraser les commits ?
4. L'écrasement des commits peut rendre l'historique de votre projet plus propre et plus facile à lire, en particulier lorsque de nombreux petits commits sont utilisés.
5. Comment démarrer un rebase interactif ?
6. Utilisez la commande , en remplaçant N par le nombre de commits que vous souhaitez écraser.
7. Que signifient « choisir » et « écraser » dans le rebase interactif ?
8. « Pick » conserve un commit tel quel, tandis que « squash » le combine avec le commit précédent.
9. Comment résoudre les conflits lors d’un rebase ?
10. Utiliser pour identifier les conflits, résolvez-les manuellement, puis utilisez et .
11. Puis-je abandonner un rebase si quelque chose ne va pas ?
12. Oui, vous pouvez utiliser pour arrêter le rebase et revenir à l'état précédent.
13. Quel est l’avantage d’utiliser un script Bash pour écraser les commits ?
14. Un script Bash automatise le processus, permettant ainsi de gagner du temps et de réduire le risque d'erreurs manuelles.
15. Existe-t-il un moyen d'écraser automatiquement les commits lors d'un rebase ?
16. Oui, en utilisant un script pour modifier la liste de tâches de rebase avec , vous pouvez automatiquement remplacer « choisir » par « écraser ».

Conclusion de l'écrasement du commit Git

L'écrasement des commits dans Git est une technique puissante pour maintenir un historique de projet propre et lisible. Qu'il s'agisse d'utiliser un rebase interactif ou d'automatiser avec un script Bash, vous pouvez combiner plusieurs commits en un seul, ce qui facilite la gestion du journal. Comprendre comment résoudre les conflits et abandonner un rebase ajoute à votre maîtrise de Git, vous garantissant ainsi de pouvoir gérer tous les problèmes qui surviennent. La maîtrise de ces commandes et méthodes améliorera considérablement vos pratiques de contrôle de version.