Tutoriel des commandes Git : Comment corriger 18 erreurs courantes ?

Tutoriel des commandes Git : Comment corriger 18 erreurs courantes ?
Mise à jours :

Dans cet article, je vais répondre rapidement à 18 questions les plus fréquemment posées lorsqu'il s'agit d'utiliser Git en équipe.

C'est aussi applicable pour un cas d'utilisation personnel.

Répondre à certaines questions peut parfois être difficile même pour un développeur expérimenté.

Par exemple, comment faire pour modifier le message d'un commit ?

Très souvent, il est courant de vouloir revenir en arrière ou annuler une modification.

Tu peux le faire avec presque toutes les activités dans Git, telles que :

  • Les validations,
  • Les fusions,
  • Les modifications locales ou distantes
  • Et même les modifications non validées.

Tu es libre de tout modifier et supprimer.

Si tu n'a pas encore lu les bases, je t'invite à lire cet article rapidement avant de cotinuer : apprendre à gérer le code source avec git et github

1. Comment créer une branche Git ?

Avant de commencer à créer une nouvelle branche, assure-toi que ta branche master/main est mis à jour avec les dernières modifications :

 $ git pull

Après l'étape ci-dessus, tu peux créer ta nouvelle branche et y basculer directement :

 $ git checkout -b mabranche

Ou, tu peux simplement créer la nouvelle branche sans y basculer :

 $ git branch mabranche

Si tu souhaites basculer vers ta nouvelle branche après l'avoir créée, utilise simplement :

 $ git checkout mabranche

Maintenant que la branche est créée, tu peux la pousser(l'envoyer) sur GitHub :

 $ git push origin mabranche

2. Comment renommer une branche Git ?

Afin de renommer une branche Git, une option serait d'abord d'y basculer et de suivre l'étape ci-dessous :

 $ git checkout mabranche

Ensuite, tu vas voir un message qui confirme que le commutateur(changement de branche) a réussi :

Tu peux maintenant renommer la branche avec cette commande :

 $ git branch -m mabranchedev

Une autre façon de renommer une branche Git consiste à n'utiliser qu'une seule ligne, en spécifiant à la fois l'ancien et le nouveau nom :

 $ git branch -m mabranche mabranchedev

Une fois que tu as fini de renommer une branche Git, il est recommandé de vérifier son statut :

 $ git branch -a

3. Comment supprimer une branche Git locale ?

Lorsque les développeurs travaillent sur différentes fonctionnalités, ils créent souvent d'autres branches, séparées de la principale avec le code principal.

Une fois le travail sur une fonctionnalité terminé, il est souvent recommandé de supprimer la branche.

Comme Git ne te permet pas de supprimer la branche en cours d'utilisation, tu peux d'abord basculer vers une autre branche, et après cela, tu peux supprimer la branche que tu souhaites :

 $ git checkout main 
 $ git branch -d mabranchedev

Si la branche n'a pas été poussée ou fusionnée, tu peux forcer la suppression de la branche en utilisant -D au lieu de -d.

4. Comment supprimer une branche Git distante ?

Pour supprimer une branche à distance, tu dois utiliser la commande suivante :

 $ git push <remote-name> --delete <branch-name>

5. Comment Git checkout la branche distante ?

Lorsque tu travailles en équipe, tu peux utiliser des référentiels distants pouvant être hébergés ou sur la copie locale d'un collègue. 

Chacun des référentiels distants contient ses propres branches. 

Pour basculer vers une branche distante, il est nécessaire de récupérer le contenu de la branche et y basculer ensuite :

 $ git fetch --all
 $ git checkout <remote-branch-name>

6. Comment éditer (modifier) un message de commit Git ?

Pour une raison quelconque, dans certains cas, tu souhaites modifier ton message de validation. 

Tout d'abord, tu dois savoir que la modification de ton message de commit se traduit par la création d'un nouveau commit et le remplacement de l'ancien.

Si tu n'as pas encore poussé ton commit sur GitHub, et que cela n'existe que dans ton référentiel local, voici un moyen simple de changer le message de ton dernier commit. 

Accéde au référentiel qui contient ton dernier commit dans la ligne de commande et tu écris :

 $ git commit --amend

Ensuite, tu dois éditer le message de commit et enregistrer ton nouveau commit. 

La prochaine fois que tu pousses, tu dois pouvoir voir ton nouveau commit et message sur GitHub.

Comme tu êtes peut-être déjà trouvé dans la situation où tu as déjà poussé le commit vers GitHub, ne t'inquiétes pas, il existe toujours un moyen de modifier ton message de commit le plus récent. 

Pour ce faire, tu dois forcer un commit avec un message modifié. 

Attention ; ceci n'est pas recommandé car cela modifie l'historique de ton référentiel, utilise donc cette option uniquement lorsque cela est absolument nécessaire.

Tout d'abord, suis les étapes cité, puis tu écris :

 $ git push --force-with-lease <branch-name>

7. Comment annuler le dernier commit ?

Tu as accidentellement validé les mauvais fichiers dans Git, mais tu n'as pas encore poussé la validation dans ton référentiel Git. 

Comme tu n'as pas encore poussé vers un référentiel distant, tes modifications ne sont pas publiques. 

À ce stade, tu peux annuler tes modifications. 

Le moyen le plus simple d'annuler le dernier commit Git est d'exécuter la commande $ git reset avec l'option « –soft » qui conservera les modifications apportées à tes fichiers. 

tu dois juste spécifier le commit à annuler qui est "HEAD~1" dans ce cas.

 $ git reset --soft HEAD-1

Si tu souhaites supprimer le dernier commit, tu peux exécuter la $ git reset commande avec l'option "-hard".

 Les modifications seront supprimées du répertoire de travail et de l'index, tu vas perdre toutes les modifications .

 $ git reset --hard HEAD-1

Remarque : Si tu n'êtes pas familier avec cette notation, « HEAD~1 » signifie que tu souhaites réinitialiser le HEAD (le dernier commit) à un commit avant dans l'historique du journal.

 $ git log --oneline

8. Comment git revert ou revenir au commit précédent ?

Il est nécessaire de voir la liste des commits afin d'avoir l'identifiant du commit, à l'aide de la commande git log :

 $ git log --online

Si tu souhaites revenir temporairement au commit précédent puis revenir là où tu étais, il te suffit de vérifier le commit souhaité :

 $ git checkout <0c2a9da42>

Ou, si tu veux faire des commits pendant que tu y es, vas-y et crée une nouvelle branche pendant que tu y es :

 $ git checkout -b old-state <0c2a9da42>

D'un autre côté, si tu veux vraiment te débarrasser de tout ce que tu avais dejà fait depuis, mais que tu n'avais poussé aucun de ces commits, il y a une possibilité. 

Tout ce que tu as à faire est simplement de réinitialiser :

 $ git reset --hard <0c2a9da42>

Si tu as poussé les commits, il existe toujours un moyen de t'en débarrasser. 

Je t'en parle dans la prochaine question.

9. Comment annuler un commit qui a été poussé vers la télécommande ?

Si tu as déjà poussé ta chaîne de commits vers le référentiel distant, un revert ou retour est un moyen plus agréable d'annuler les modifications. 

La commande revert ajoute un nouveau commit à la fin de la chaîne.

 $ git revert <0a2b9da42...>

10. Comment Git restaurer un seul fichier ?

tu as effectué plusieurs modifications sur un fichier et les as validées. 

tu veux maintenant revenir à une version de fichier précédente. 

tu peux effectuer les opérations suivantes pour rétablir un seul fichier à son état précédent.

Si le fichier n'est pas validé, tu peux utiliser :

 $ git checkout <filename>

Si le fichier est déjà validé, tu dois trouver le hachage du commit et le chemin d'accès à ton fichier et exécuter cette commande dans le terminal :

 $ git checkout <commit-hash> -- <path/to/file>
 // e.g.
 $ git checkout <0b2a9dc42...> -- assets/main.css

Tu peux voir très facilement les commits qui ont apporté des modifications au(x) fichier(s) donné(s), et tu peux obtenir le hachage de commit correct en exécutant la commande suivante :

 $ git log path/to/file

11. Comment annuler l'ajout de Git ?

tu as déplacé plusieurs fichiers dans la zone de transit avec la commande $ git add, mais tu ne veux plus faire partie d'un commit, alors une simple réinitialisation fera l'affaire :

 // for all files
 $ git reset  // OR
 $ git reset HEAD // OR
 $ git reset

Si tu souhaites désinstaller un seul fichier, tu peux utiliser :

 // for single file
 $ git reset <filename> // OR
 $ git reset HEAD <filename> // OR
 $ git reset @ <filename>

Les modifications que tu as apportées seront toujours dans le(s) fichier(s). 

L'ensemble de commandes ci-dessus supprime simplement ce ou ces fichiers de ta zone de transit. 

La $ git resetcommande te permet de réinitialiser la Head actuelle à un état spécifique. 

Tu peux réinitialiser l'état de fichiers spécifiques ainsi que d'une branche entière.

Remarque : *HEAD est une référence au commit actuel. @ seul est un raccourci pour la tête depuis Git v1.8.5*

12. Comment supprimer un fichier de Git sans le supprimer de ton système de fichiers ?

tu as validé le mauvais fichier sur Git, ou tu as oublié d'ajouter un fichier à .gitignore et tu l'as validé. 

Maintenant, tu veux supprimer le fichier de git mais tu ne veux pas le supprimer de ton environnement de développement local.

Supprimer un seul fichier avec Git sans le supprimer :

 $ git rm --cached <filename>

Supprimer plusieurs fichiers avec Git sans les supprimer

 $ git rm --cached <filename1 filename2 filename3>

Supprimer un seul répertoire avec Git sans le supprimer :

 $ git rm --cached <directory-name>
  • -cached$ git push
    supprimera uniquement l'index mais ne tu permettra pas de supprimer le fichier sur le système local. 

Les fichiers seront supprimés du référentiel distant lors de l'exécution.

13. Git Pull contre Git Fetch

Git pull et fetch sont deux commandes couramment utilisées, il sera donc utile de connaître la différence entre elles.

Supposons que tu travailles sur un référentiel clone, qui est essentiellement un doublon d'un autre référentiel. 

Dans ce cas, il est important de le tenir à jour avec les dernières modifications qui auraient pu être appliquées à l'original. 

Pour ce faire et apporter ces modifications localement, tu as utiliser les commandes ci-dessus.

 $ git fetch

C'est la commande qui te permet de télécharger un objet à partir d'un autre référentiel mais elle n'effectuera aucun transfert de fichier, ce qui signifie qu'elle n'apportera aucune modification localement. 

Fondamentalement, il s'agit simplement de vérifier si des modifications sont disponibles.

 $ git pull

C'est la commande qui apportera ces modifications depuis le référentiel distant et qui les intégrera à ta branche locale. 

En d'autres termes, git pull fait la même chose que git fetch, sauf qu'il est suivi d'une ou plusieurs actions supplémentaires :

 $ git merge

14. Comment forcer « git pull » à écraser les fichiers locaux ?

Si tu souhaites tout écraser avec une copie de la branche distante, tu dois savoir que tu supprimes toutes vos modifications locales.

Si tu as des commits locaux que tu n'as pas encore poussés, ceux-ci seront également perdus.

Pour écraser/réinitialiser vos fichiers locaux, Voici les étapes à suivre :

 $ git fetch --all
 $ git reset --hard origin/<branch-name>

15. Comment pousser vers GitHub lors de la réception de l'erreur « besoin de fusion » ?

Si tu n'as pas exécuté $ git pull avant d'essayer de transmettre vos modifications à la branche, tu obtiens une erreur de fusion. 

Lorsque tu as cette erreur, cela signifie généralement que quelqu'un d'autre a poussé un commit vers la même branche que tu as essayé de pousser, mais tu ne l'avais pas encore localement.

Pour résoudre le problème, tu peux exécuter le code ci-dessous :

 $ git pull origin <branch-name>
 $ git push origin <branch-name>

Si tu veux faire une poussée forcée, c'est-à-dire que tu ne veux pas fusionner ta branche locale avec la branche distante, tu peux utiliser la syntaxe ci-dessous :

 $ git push -f origin <branch-name>

16. Comment créer une balise dans le référentiel GitHub ?

Git prend en charge deux types de balises : 

légères et annotées .

Une balise légère ressemble beaucoup à une branche qui ne change pas, c'est juste un pointeur vers un commit spécifique.

Les balises annotées , cependant, sont stockées en tant qu'objets complets dans la base de données Git. 

Ils font l'objet d'une somme de contrôle ; contenir le nom, l'e-mail et la date du tagueur ; avoir un message de marquage. 

Il est généralement recommandé de créer des balises annotées.

Crée une balise légère :

 $ git tag <tagname> // e.g $ git tag v1.0.0

Balise annotée créée ( recommandé ) :

 $ git tag -a <tagname> // e.g $ git tag -a v1.0.0
 // or create tag with message
 $ git tag -a <tagname> -m "tag description" // e.g $ git tag -a v1.0.0 -m "First release"

Lorsque tu transféres vers ton référentiel distant, les balises ne sont PAS incluses par défaut. 

Tu dois dire explicitement que tu souhaites transmettre tes balises à ton référentiel distant.

Pousser toutes les balises créee localement :

 $ git push origin --tags

Pousser une seule balise :

 $ git push origin <tagname>

Pour répertorier toutes les balises, Tu vas utiliser la commande suivante :

 $ git tag

17. Comment cloner toutes les branches distantes dans Git ?

Tu peux utiliser la commande git clone sur ton Git local. 

Il clonera l'ensemble du référentiel sur ton système, puis changera ton répertoire de travail actuel dans le dossier du référentiel cloné.

 $ git clone https://github.com/cristhos/mwanzo.git
 $ cd mwanzo

Si tu as plusieurs branches distantes que tu souhaites récupérer en même temps, Fais ceci :

 $ git pull --all

Ensuite, regarde les branches locales dans ton référentiel :

 $ git branch
 * main

Mais il y a d'autres branches qui se cachent dans ton référentiel ! tu peux les voir en utilisant l'indicateur -a :

 $ git branch -a
 * main
   remotes/origin/HEAD
   remotes/origin/main
   remotes/origin/another-branch

Si tu souhaites simplement jeter un coup d'œil rapide à une branche en amont, tu peux la consulter directement :

 $ git checkout origin/another-branch

Mais si tu veux travailler sur cette branche, tu dois créer une branche de suivi locale qui se fait automatiquement par :

 $ git checkout another-branch

18. Comment mettre à jour ou synchroniser un référentiel forké ?

Tu as réussi à bifurquer ton référentiel intéressé. 

Tu dois le maintenir à jour avec le référentiel d'origine. 

Le référentiel d'origine est communément appelé en amont.

Ouvre ton terminal et accéde à ton référentiel cloné sur l'ordinateur local. 

Ton référentiel local n'est pas directement lié au référentiel d'origine. 

Tu dois configurer une télécommande qui pointe vers le référentiel en amont dans Git.

 $ git remote -v // list all remote
 $ git remote add upstream https://github.com/ORIGINAL_OWNER/ORIGINAL_REPOSITORY.git
 $ git remote -v // verify the new upstream repository

Il y a deux étapes nécessaires pour synchroniser ton référentiel avec l'amont :

  • d'abord, tu dois récupérer à partir de la télécommande,
  • puis tu dois fusionner la branche souhaitée dans ta branche locale.
 $ git fetch upstream
 $ git checkout main
 $ git merge upstream/main

Après la configuration initiale en amont et la vérification principale, il te suffit d'exécuter la commande suivante pour synchroniser ton main avec l'amont :

 $ git pull upstream main

Conclusion

C'était les questions le plus fréquent des développeurs qui utilisent git.

Peut-être que tu te retrouves dans un cadre qui oblige à avoir des réponses précises à tes questions. Si tu veux faire des manipulations un peu plus poussées.

Moi aussi, j'ai parfois besoin de réponse rapides

J'espère que tu vas trouver la réponse de ton cas d'utilisation de Git. 

Si tu rencontres un problème dans Git qui ne figure pas sur notre liste, partage-le avec nous dans la section commentaires ci-dessous.