RĂšgles de vol pour Git

July 21, 2023 · View on GitHub

🌍 English ∙ Español ∙ РуссĐșĐžĐč ∙ çčé«”äž­æ–‡ ∙ çź€äœ“äž­æ–‡ ∙ 한ꔭ얎 ∙ Tiáșżng Việt ∙ Français ∙ æ—„æœŹèȘž

C'est quoi des "rĂšgles de vol" ?

Un guide pour les astronautes (pour les développeur·euse·s utilisant Git, dans le cas présent) sur quoi faire quand les choses se passent mal.

Les rĂšgles de vol reprĂ©sentent l'ensemble des connaissances durement acquises consignĂ©es dans des manuels rĂ©pertoriant, Ă©tape par Ă©tape, la procĂ©dure Ă  suivre si telle chose se produit et pourquoi. Il s'agit essentiellement de procĂ©dures d'exploitation standard extrĂȘmement dĂ©taillĂ©es et spĂ©cifiques Ă  chaque scĂ©nario. [...]

La NASA a recueilli nos faux pas, nos désastres et nos solutions depuis le début des années 60, lorsque les équipes terrestres de l'Úre Mercury ont commencé à rassembler les "leçons tirées" dans un recueil qui répertorie désormais des milliers de situations problématiques, des pannes de moteur aux poignées de trappes cassées en passant par les bugs informatiques, et leurs solutions.

— Chris Hadfield, Guide d'un astronaute pour la vie sur Terre.

Conventions pour ce document

Pour des raisons de clarté tous les exemples dans ce document utilisent une invite de commande bash personnalisée dans le but d'indiquer la branche actuelle et s'il y a des modifications indexées ou non. La branche se trouve entre parenthÚses, et un * aprÚs le nom de la branche indique des modifications indexées.

Toutes les commandes devraient fonctionner pour les versions de Git au moins supérieures à la 2.13.0. Visitez le site de Git pour mettre à jour votre version de git locale.

Join the chat at https://gitter.im/k88hudson/git-flight-rules

Table of Contents generated with DocToc

DĂ©pĂŽts

Je veux initialiser un dépÎt local

Pour initialiser un répertoire existant comme dépÎt Git :

(mon-dossier) $ git init

Je veux cloner un dépÎt distant

Pour cloner (copier) un dépÎt distant, copiez l'url de ce dernier, et lancez :

$ git clone [url]

Ceci le sauvegardera dans un dossier nommĂ© d'aprĂšs le nom du dĂ©pĂŽt. Assurez-vous d'avoir une connexion avec le serveur distant que vous essayez de cloner (dans la plupart des cas ceci revient Ă  s'assurer d'ĂȘtre connecté·e Ă  Internet).

Pour le cloner vers un dossier ayant un nom différent de celui du dépÎt distant :

$ git clone [url] nom-du-nouveau-dossier

Éditer des Commits

Qu'est-ce que je viens de commiter ?

Imaginons que vous venez tout juste d'enregistrer des changements Ă  l'aveugle avec {code0}git commit -a{/code0} et que vous n'ĂȘtes pas sĂ»r·e du contenu rĂ©el du commit que vous venez d'effectuer. Vous pouvez visualiser le dernier commit sur votre HEAD actuel avec :

(main)$ git show

Ou :

$ git log -n1 -p

Si vous voulez voir un fichier Ă  un commit spĂ©cifique, vous pouvez aussi faire (oĂč <commitid> est le commit qui vous intĂ©resse).

$ git show <commitid>:nomdufichier

J'ai commis une erreur dans un message de commit

Si vous vous ĂȘtes trompé·e et que le commit n'a pas encore Ă©tĂ© poussĂ©, vous pouvez appliquer la commande suivante afin de changer le message du commit sans affecter les changements de ce mĂȘme commit :

$ git commit --amend --only

Cela ouvrira votre Ă©diteur de texte par dĂ©faut, oĂč vous pourrez Ă©diter le message. Vous pouvez Ă©galement effectuer la mĂȘme chose en une seule commande :

$ git commit --amend --only -m 'xxxxxxx'

Si vous avez déjà poussé le message, vous pouvez modifier le commit et pousser de force, mais cela n'est pas recommandé.

J'ai commit avec le mauvais nom et email dans les configurations

Si c'est un commit unique, modifiez-le :

$ git commit --amend --no-edit --author "Nouvel Auteur·trice <emaildelauteurice@mondomaine.com>"

Une alternative est de configurer correctement vos paramÚtres d'auteur·trice avec git config --global author.(name|email) puis de lancer :

$ git commit --amend --reset-author --no-edit

Si vous avez besoin de changer tout l'historique, veuillez vous référer à la page man pour git filter-branch.

Je veux retirer un fichier du commit précédent

Pour retirer les changements effectués sur un fichier lors du précédent commit, faites la chose suivante :

$ git checkout HEAD^ monfichier
$ git add monfichier
$ git commit --amend --no-edit

Dans le cas oĂč le fichier fut introduit dans le commit et que vous voulez le retirer (de Git seul), faites :

$ git rm --cached monfichier
$ git commit --amend --no-edit

Cela est particuliÚrement utile quand vous avez un patch d'ouvert et que vous avez commité un fichier non nécessaire, et que vous avez besoin de pousser de force pour mettre à jour le patch sur le dépÎt distant. L'option --no-edit est utilisée pour garder le message de commit existant.

Je veux supprimer ou retirer mon dernier commit

Si vous avez besoin de supprimer des commits poussĂ©s, vous pouvez utiliser la commande suivante. Cependant, cela modifiera votre historique de maniĂšre irreversible, et mettra la pagaille dans l'historique de quiconque ayant dĂ©jĂ  rĂ©cupĂ©rĂ© des changements depuis le dĂ©pĂŽt distant. Pour faire court, si vous n'ĂȘtes pas sĂ»r·e, vous ne devriez pas faire ça, jamais.

$ git reset HEAD^ --hard
$ git push --force-with-lease [remote] [branche]

Si vous n'avez pas poussé, pour réinitialiser Git vers l'état dans lequel il était avant que vous ne fassiez votre dernier commit (tout en gardant vos changements) :

(ma-branche)$ git reset --soft HEAD^

Cela ne marchera que si vous n'avez pas poussĂ©. Si vous avez poussĂ©, la seule vraie chose sĂ©curisĂ©e Ă  faire est git revert SHAduMauvaisCommit. Cela crĂ©era un nouveau commit qui annule tous les changements du commit en question. Ou, si la branche vers laquelle vous avez poussĂ© est "rebase-safe" (en d'autres termes, les autres dĂ©veloppeur·euse·s ne la rĂ©cupĂ©reront pas), vous pouvez juste lancer git push --force-with-lease. Pour plus d'informations, jetez un Ɠil Ă  la section ci-dessus.

Supprimer/retirer un commit arbitraire

Le mĂȘme avertissement que ci-dessus s'applique. Ne faites jamais cela si possible.

$ git rebase --onto SHA1_DU_MAUVAIS_COMMIT^ SHA1_DU_MAUVAIS_COMMIT
$ git push --force-with-lease [remote] [branche]

Ou faites un rebase interactif et retirez les lignes correspondantes au(x) commit(s) que vous souhaitez supprimer.

J'ai essayé de pousser un commit modifié vers le dépÎt distant, mais j'ai eu un message d'erreur

To https://github.com/votrenomdutilisateur/repo.git
! [rejected]        ma-branche -> ma-branche (non-fast-forward)
error: failed to push some refs to 'https://github.com/tanay1337/webmaker.org.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Notez que, tout comme avec un rebase (voir ci-dessous), le fait de modifier remplace l'ancien commit avec un nouveau, donc vous devez pousser de force (--force-with-lease) vos changements si vous avez déjà poussé le commit vers votre dépÎt distant avant sa modification. Soyez prudent·e quand vous faites cela : Assurez vous de toujours spécifier une branche !

(ma-branche)$ git push origin ma-branche --force-with-lease

En rĂšgle gĂ©nĂ©rale, Ă©vitez de pousser de force. Il est prĂ©fĂ©rable de crĂ©er et pousser un nouveau commit plutĂŽt que de pousser de force un commit modifiĂ© car cela causera des conflits dans l'historique pour n'importe quel dĂ©veloppeur·euse ayant dĂ©jĂ  intĂ©ragit avec la branche en question ou quelque branche fille. --force-with-lease Ă©chouera toujours, si quelqu'un d'autre Ă©tait dĂ©jĂ  en train de travailler sur la mĂȘme branche que vous et que votre push rĂ©Ă©crirait par-dessus ces modifications.

Si vous ĂȘtes absolument sĂ»r·e que personne n'est en train de travailler sur la mĂȘme branche que vous ou que vous souhaitez mettre Ă  jour la branche de maniĂšre inconditionnelle, vous pouvez utiliser --force (-f), mais cela devrait ĂȘtre Ă©vitĂ© en gĂ©nĂ©ral.

J'ai fait un hard reset par accident, et je veux retrouver mes changements

Si vous avez accidentellement fait un git reset --hard, vous pouvez normalement retrouver votre commit, car Git garde un log de tout ce que vous faites pendant quelques jours.

À noter : Cela n'est valide que si votre travail est sauvegardĂ©, c'est Ă  dire dans un commit ou un remisage. git reset --hard supprimera les modifications non commitĂ©es, donc utilisez cela avec prĂ©caution (une option plus sĂ»re est git reset --keep).

(main)$ git reflog

Vous verrez une liste de vos précédents commits, et un commit pour la réinitialisation. Choisissez le SHA du commit vers lequel vous souhaitez retourner, et réinitialisez à nouveau :

(main)$ git reset --hard SHA1234

Et cela devrait faire l'affaire.

J'ai commité et poussé une fusion par accident

Si vous avez accidentellement fusionnĂ© une branche d'une fonctionnalitĂ© avec la branche de dĂ©veloppement principale avant qu'elle ne soit prĂȘte Ă  ĂȘtre fusionnĂ©e, vous pouvez toujours annuler cette fusion. Mais il y a un piĂšge : un commit de fusion a plus d'un parent (en gĂ©nĂ©ral deux).

Utilisez cette commande :

(feature-branch)$ git revert -m 1 <commit>

oĂč l'option -m 1 demande de sĂ©lectionner le parent numĂ©ro 1 (la branche vers laquelle la fusion a Ă©tĂ© faite) comme parent vers lequel annuler la fusion.

À noter : le numĂ©ro du parent n'est pas un identifiant de commit. Un commit de fusion ressemble plus Ă  Merge: 8e2ce2d 86ac2e7. Le numĂ©ro du parent est l'index basĂ© sur 1 du parent souhaitĂ© sur cette ligne, le premier identifiant est le numĂ©ro 1, le second le numĂ©ro 2, et ainsi de suite.

J'ai commité et poussé des fichiers contenant des données sensibles par accident

Si vous avez accidentellement poussé des fichiers contenant des données sensibles (mots de passe, clés, etc.), vous pouvez modifier le commit précédent. Gardez toutefois à l'esprit qu'une fois que vous avez poussé un commit, vous devez considérer n'importe quelle donnée qu'il contient comme étant compromise. Ces étapes peuvent supprimer les données sensibles de votre dépÎt public ou de votre copie locale, mais vous ne pouvez pas supprimer les données sensibles des copies clonées par d'autres personnes. Si vous avez commité un mot de passe, changez-le immédiatement. Si vous avez commité une clé, révoquez-la et régénérez-la immédiatement. Modifier le commit poussé n'est pas suffisant, étant donné que n'importe qui aurait pu extraire le commit original contenant vos données sensibles pendant ce temps.

Si vous souhaitez modifier le fichier et supprimer les données sensibles, lancez :

(feature-branch)$ git add fichier_modifié
(feature-branch)$ git commit --amend --no-edit
(feature-branch)$ git push --force-with-lease origin [branche]

Si vous souhaitez supprimer tout un fichier (mais le garder en local), lancez :

(feature-branch)$ git rm --cached fichier_sensible
echo fichier_sensible >> .gitignore
  (feature-branch)$ git add .gitignore
(feature-branch)$ git commit --amend --no-edit
(feature-branch)$ git push --force-with-lease origin [branche]

Alternativement, stockez vos données sensibles dans des variables d'environnement locales.

Si vous souhaitez supprimer tout un fichier (et ne pas le garder en local), lancez :

(feature-branch)$ git rm fichier_sensible
(feature-branch)$ git commit --amend --no-edit
(feature-branch)$ git push --force-with-lease origin [branche]

Si vous avez créé d'autres commits pendant ce temps (c'est à dire que les données sensibles sont dans un commit avant le commit précédent), vous devrez utiliser la fonction rebase.

Indexation

J'ai besoin d'ajouter des modifications indexées sur le commit précédent

(ma-branche*)$ git commit --amend

Si vous savez déjà que vous ne souhaitez pas modifier le message du commit, vous pouvez dire à Git de réutiliser ce dernier :

(ma-branche*)$ git commit --amend -C HEAD

Je veux indexer une partie d'un fichier, mais pas tout le fichier

Normalement, quand vous souhaitez modifier une partie d'un fichier, il faut lancer ceci :

$ git add --patch nomdufichier.x

-p fonctionnera comme raccourci. Cela ouvrira le mode interactif. Vous serez en mesure d'utiliser l'option s pour séparer le commit. Cependant, si le fichier est nouveau, vous n'aurez pas cette option. Pour ajouter un nouveau fichier, faites comme ceci :

$ git add -N nomdufichier.x

Ensuite, vous devrez utiliser l'option e afin de choisir manuellement quelles lignes ajouter. Lancer git diff --cached ou git diff --staged vous montrera quelles lignes vous avez indexées comparées à celles qui sont toujours sauvegardées en local.

Je veux ajouter les changements d'un fichier dans deux commits différents

git add ajoutera le fichier entier à un commit. git add -p vous permettra de sélectionner interactivement quels changements vous souhaitez ajouter.

Je veux indexer mes modifications indexées, et désindexer mes modifications indexées

Cela est délicat. La meilleure chose que nous pouvons vous conseiller est que vous devriez remiser vos modifications non indexées, puis utiliser git reset. AprÚs cela, utilisez pop pour déremiser vos modifications, puis ajoutez-les :

$ git stash -k
$ git reset --hard
$ git stash pop
$ git add -A

Modifications non indexées

Je veux déplacer mes modifications non indexées vers une nouvelle branche

$ git checkout -b ma-branche

Je veux déplacer mes modifications non indexées vers une branche différente existante

$ git stash
$ git checkout ma-branche
$ git stash pop

Je veux me débarrasser de mes modifications locales non commitées (indexées et non-indexées)

Si vous voulez vous débarrasser de toutes vos modifications locales indexées et non-indexées, vous pouvez faire ceci :

(ma-branche)$ git reset --hard
# ou
(main)$ git checkout -f

Cette commande désindexera tous les fichiers que vous avez pu indexer avec git add :

$ git reset

Cette commande annulera toutes les modifications locales non commitĂ©es (elle devrait ĂȘtre exĂ©cutĂ©e Ă  la racine du dĂ©pĂŽt) :

$ git checkout .

Vous pouvez également annuler les changements non commités d'un fichier ou d'un dossier en particulier :

$ git checkout [un_dossier|fichier.txt]

Il existe également une autre façon d'annuler toutes vos modifications non commitées (plus longue à taper, mais fonctionne depuis n'importe quel sous-dossier) :

$ git reset --hard HEAD

Cette commande supprimera tous les fichiers locaux non indexés, afin que seuls les fichiers suivis par Git ne restent :

$ git clean -fd

-x supprimera également tous les fichiers ignorés.

Je veux me débarrasser de modifications non-indexées spécifiques

Quand vous souhaitez vous débarrasser de quelques modifications dans votre copie de travail, mais pas toutes, faites un checkout sur les modifications non désirées, et gardez les bonnes :

$ git checkout -p
# RĂ©pondez y Ă  tous les bouts de code que vous souhaitez jeter

Une autre stratégie implique d'utiliser stash. Remisez toutes les bonnes modifications, réinitialisez votre copie locale, et réappliquez les bonnes modifications :

$ git stash -p
# SĂ©lectionnez tous les bouts de code que vous souhaitez garder
$ git reset --hard
$ git stash pop

Alternativement, remisez vos changements non désirés, puis jetez le stash :

$ git stash -p
# SĂ©lectionnez tous les bouts de code que vous ne souhaitez pas sauvegarder
$ git stash drop

Je veux me débarrasser de fichiers non-indexés spécifiques

Quand vous souhaitez vous débarrasser d'un fichier en particulier de votre copie de travail :

$ git checkout monFichier

Alternativement, pour vous débarrasser de plusieurs fichiers dans votre copie locale, listez chacun d'entre eux :

$ git checkout monPremierFichier monDeuxiemeFichier

Je veux me débarrasser de mes modifications locales non-indexées uniquement

Quand vous souhaitez vous débarrasser de toutes vos modifications locales non commitées :

$ git checkout .

Je veux me débarrasser de tous mes fichiers non suivis

Quand vous souhaitez vous débarrasser de tous vos fichiers non suivis :

$ git clean -f

Je veux désindexer un fichier indexé spécifique

Il arrive parfois que nous ayons un ou plusieurs fichiers qui ont été indexés par accident. Et ces fichiers n'ont pas été commités auparavant. Pour les désindexer :

$ git reset -- <nomdufichier>

Cela entraßnera la désindexation du fichier et le remettra à son état non suivi.

Branches

Je veux lister toutes les branches

Pour lister les branches locales :

$ git branch

Pour lister les branches distantes :

$ git branch -r

Pour lister toutes les branches (Ă  la fois locales et distantes) :

$ git branch -a

Créer une branche à partir d'un commit

$ git checkout -b <branche> <SHA1_DU_COMMIT>

J'ai pull depuis/vers la mauvaise branche

C'est une autre occasion d'utiliser git reflog afin de voir oĂč votre HEAD pointait avant le mauvais pull :

(main)$ git reflog
ab7555f HEAD@{0}: pull origin wrong-branch: Fast-forward
c5bc55a HEAD@{1}: checkout: checkout message goes here

Réinitialisez simplement votre branche vers le commit désiré :

$ git reset --hard c5bc55a

Et voilĂ .

Je veux supprimer mes commits locaux afin que ma branche soit pareille Ă  celle sur le serveur

Assurez-vous que vous n'avez pas poussé vos modifications sur le serveur.

git status devrait vous indiquer combien de commits en avance vous ĂȘtes par rapport Ă  origin :

(ma-branche)$ git status
# On branch ma-branche
# Your branch is ahead of 'origin/my-branch' by 2 commits.
#   (use "git push" to publish your local commits)
#

Une des façons de faire pour rĂ©initialiser votre branche afin qu'elle corresponde Ă  origin (afin d'avoir la mĂȘme chose que le dĂ©pĂŽt distant) est de lancer ceci :

(ma-branche)$ git reset --hard origin/ma-branche

J'ai commité sur main au lieu d'une nouvelle branche

Créez la nouvelle branche tout en restant sur main :

(main)$ git branch ma-branche

Réinitialisez la branche main vers le commit précédent :

(main)$ git reset --hard HEAD^

HEAD^ est un raccourci pour HEAD^1. Cela indique le premier parent de HEAD, de la mĂȘme façon que HEAD^2 indique le second parent du commit (des fusions peuvent avoir deux parents).

Notez que HEAD^2 ne signifie pas la mĂȘme chose que HEAD~2 (visitez ce lien pour plus d'informations).

Alternativement, si vous ne souhaitez pas utiliser HEAD^, retrouvez le hash du commit vers lequel vous souhaitez remettre votre branche main (git log devrait faire l'affaire). Puis réinitialisez vers ce hash. git push s'assurera que la modification est reflétée sur le serveur distant.

Par exemple, si le hash du commit sur lequel votre branche main est supposĂ©e ĂȘtre est a13b85e :

(main)$ git reset --hard a13b85e
HEAD is now at a13b85e

DĂ©placez-vous vers la nouvelle branche pour continuer de travailler :

(main)$ git checkout ma-branche

Je veux séparer tout un fichier d'un autre ref-ish

Admettons que vous avez un pic de travail (voir la note), avec des centaines de changements. Tout fonctionne bien. Maintenant, vous commitez vers une autre branche pour sauvegarder ce travail :

(solution)$ git add -A && git commit -m "Ajout de tous les changements de ce pic vers un gros commit."

Quand vous souhaitez mettre tout cela vers une branche (d'une fonctionnalité ou develop), ce qui vous intéresse est de garder les fichiers dans leur entiÚreté. Vous voudriez également séparer votre gros commit en plusieurs petits commits.

Admettons que vous ayez :

  • La branche solution, avec la solution Ă  votre pic. En avance d'un commit par rapport Ă  develop.
  • La branche develop, oĂč vous souhaitez ajouter vos modifications.

Vous pouvez résoudre cela en ramenant les contenus vers votre branche :

(develop)$ git checkout solution -- fichier1.txt

Cela ramĂšnera le contenu de ce fichier dans la branche solution vers votre branche develop :

# On branch develop
# Your branch is up-to-date with 'origin/develop'.
# Changes to be committed:
#  (use "git reset HEAD <file>..." to unstage)
#
#        modified:   fichier1.txt

Puis, commitez comme d'habitude.

Note: Les pics de solutions servent à analyser ou résoudre un problÚme. Ces solutions sont ensuite utilisées afin d'avoir une estimation puis jetées une fois que tout le monde a une vision claire du problÚme. ~ Wikipedia.

J'ai fait plusieurs commits sur une mĂȘme branche qui auraient dĂ» ĂȘtre sur plusieurs branches

Admettons que vous ĂȘtes sur votre branche main. En lançant git log, vous remarquez que vous avez fait deux commits :

(main)$ git log

commit e3851e817c451cc36f2e6f3049db528415e3c114
Author: Alex Lee <alexlee@example.com>
Date:   Tue Jul 22 15:39:27 2014 -0400

    Bug #21 - Ajout de la protection CSRF

commit 5ea51731d150f7ddc4a365437931cd8be3bf3131
Author: Alex Lee <alexlee@example.com>
Date:   Tue Jul 22 15:39:12 2014 -0400

    Bug #14 - Correction de l'espacement du titre

commit a13b85e984171c6e2a1729bb061994525f626d14
Author: Aki Rose <akirose@example.com>
Date:   Tue Jul 21 01:12:48 2014 -0400

    Premier commit

Notons dans un coin les hashes des commits pour chaque bug (e3851e8 pour le #21, 5ea5173 pour le #14).

Pour commencer, réinitialisons notre branche main sur le bon commit (a13b85e) :

(main)$ git reset --hard a13b85e
HEAD is now at a13b85e

Maintenant, nous pouvons créer une nouvelle branche pour le bug #21 :

(main)$ git checkout -b 21
(21)$

Maintenant, faisons un cherry-pick du commit pour le bug #21 par-dessus notre branche. Cela signifie que nous appliquerons ce commit, et seulement ce commit, directement au-dessus de ce qui se trouve sur notre HEAD :

(21)$ git cherry-pick e3851e8

Lors de cette étape, il est possible qu'il y ait des conflits. Regardez la section Il y a eu des conflits dans la section faire un rebase interactif ci-dessus pour savoir comment résoudre ces conflits.

Maintenant, créons une nouvelle branche pour le bug #14, aussi basée sur main :

(21)$ git checkout main
(main)$ git checkout -b 14
(14)$

Et pour finir, faisons un cherry-pick du commit pour le bug #14 :

(14)$ git cherry-pick 5ea5173

Je veux supprimer mes branches locales qui ont été supprimée sur le dépÎt distant

Une fois que vous avez accepté une Pull Request sur GitHub, vous avez l'option de supprimer la branche fusionnée dans votre fork. Si vous ne prévoyez pas de continuer à travailler sur la branche, cela est plus propre de supprimer les copies locales de la branche afin de ne pas encombrer votre copie de travail avec un tas de branches obsolÚtes.

$ git fetch -p upstream

oĂč upstream est le dĂ©pĂŽt distant depuis lequel vous voulez mettre Ă  jour.

J'ai supprimé ma branche par accident

Si vous poussez réguliÚrement sur la branche distante, vous devriez ne pas avoir de problÚme la plupart du temps. Mais il arrive parfois que vous finissez par supprimer vos branches. Admettons que nous créons une nouvelle branche avec un nouveau fichier :

(main)$ git checkout -b ma-branche
(ma-branceh)$ git branch
(ma-branche)$ touch foo.txt
(ma-branche)$ ls
README.md foo.txt

Ajoutons cela et commitons :

(ma-branche)$ git add .
(ma-branche)$ git commit -m 'ajout de foo.txt'
(ma-branche)$ ajout de foo.txt
 1 files changed, 1 insertions(+)
 create mode 100644 foo.txt
(ma-branche)$ git log

commit 4e3cd85a670ced7cc17a2b5d8d3d809ac88d5012
Author: siemiatj <siemiatj@example.com>
Date:   Wed Jul 30 00:34:10 2014 +0200

    ajout de foo.txt

commit 69204cdf0acbab201619d95ad8295928e7f411d5
Author: Kate Hudson <katehudson@example.com>
Date:   Tue Jul 29 13:14:46 2014 -0400

    Correction #6: Push de force aprÚs avoir édité les commits

Maintenant, revenons sur main et supprimons notre branche "par accident" :

(ma-branche)$ git checkout main
Switched to branch 'main'
Your branch is up-to-date with 'origin/main'.
(main)$ git branch -D my-branch
Deleted branch ma-branche (was 4e3cd85).
(main)$ echo oh non, j'ai supprimé ma branche !
oh non, j'ai supprimé ma branche !

À cette Ă©tape, vous devriez devenir familier avec reflog, un logueur amĂ©liorĂ©. Il stocke l'historique de toutes les actions dans le dĂ©pĂŽt :

(main)$ git reflog
69204cd HEAD@{0}: checkout: moving from ma-branche to main
4e3cd85 HEAD@{1}: commit: ajout de foo.txt
69204cd HEAD@{2}: checkout: moving from main to ma-branche

Comme vous pouvez le remarquer, nous avons le hash du commit de notre branche supprimée. Voyons voir si nous pouvons restaurer notre branche supprimée.

(main)$ git checkout -b ma-branche-help
Switched to a new branch 'ma-branche-help'
(ma-branche-help)$ git reset --hard 4e3cd85
HEAD is now at 4e3cd85 ajout de foo.txt
(ma-branche-help)$ ls
README.md foo.txt

Voilà ! Nous avons récupéré notre fichier supprimé. git reflog est aussi utile quand un rebase se passe terriblement mal.

Je veux supprimer une branche

Pour supprimer une branche distante :

(main)$ git push origin --delete ma-branche

Vous pouvez aussi faire :

(main)$ git push origin :ma-branche

Pour supprimer une branche locale :

(main)$ git branch -d ma-branche

Pour supprimer une branche locale qui n'a pas été fusionnée vers la branche actuelle ou une branche distante :

(main)$ git branch -D ma-branche

Je veux supprimer plusieurs branches

Admettons que vous voulez supprimer toutes les branches qui commencent par fix/ :

(main)$ git branch | grep 'fix/' | xargs git branch -d

Je veux renommer une branche

Je veux renommer la branche actuelle (locale) :

(main)$ git branch -m nouveau-nom

Pour renommer une autre branche (locale) :

(main)$ git branch -m ancien-nom nouveau-nom

Je veux me déplacer sur une branche distante sur laquelle quelqu'un est en train de travailler

Pour commencer, récupérez toutes les branches depuis le dépÎt distant :

(main)$ git fetch --all

Admettons que vous souhaitez vous déplacer sur daves depuis le dépÎt distant :

(main)$ git checkout --track origin/daves
Branch daves set up to track remote branch daves from origin.
Switched to a new branch 'daves'

(--track est un raccourci pour git checkout -b [branch] [remotename]/[branch])

Cela vous donnera une copie locale de la branche daves, et n'importe quelle mise à jour qui y sera poussée sera aussi visible sur le dépÎt distant.

Je veux créer une nouvelle branche distante à partir de celle en locale

$ git push <remote> HEAD

Si vous voulez configurer cette branche distante en tant qu'upstream pour la branche actuelle, lancez la commande suivante Ă  la place :

$ git push -u <remote> HEAD

Avec le mode upstream et le mode simple (défaut dans Git 2.0) de la configuration de push.default, la commande suivante poussera la branche actuelle par rapport à la branche distante qui a été précédemment enregistrée avec -u :

$ git push

Le comportement des autres modes de git push est détaillé dans la documentation de push.default.

Je veux configurer une branche distante en tant qu'upstream pour une branche locale

Vous pouvez configurer une branche distante en tant qu'upstream pour la branche locale actuelle en utilisant :

$ git branch --set-upstream-to [nomduremote]/[branche]
# ou, en utilisant le raccourci :
$ git branch -u [nomduremote]/[branche]

Pour configurer la branche distante en tant qu'upstream pour une autre branche locale :

$ git branch -u [nomduremote]/[branche] [branche-locale]

Je veux configurer mon HEAD pour suivre la branche distante par défaut

En vérifiant vos branches distantes, vous pouvez voir lesquelles d'entre-elles sont suivies par HEAD. Dans certains cas, ce n'est pas la branche désirée.

$ git branch -r
  origin/HEAD -> origin/gh-pages
  origin/main

Pour changer cela afin que origin/HEAD suive origin/main, vous pouvez lancer cette commande :

$ git remote set-head origin --auto
origin/HEAD set to main

J'ai fait des modifications sur la mauvaise branche

Si vous avez fait des modifications non commitĂ©es et rĂ©alisez par la suite que vous ĂȘtes sur la mauvaise branche, remisez les modifications et appliquez-les sur la branche que vous voulez :

(mauvaise_branche)$ git stash
(mauvaise_branche)$ git checkout <bonne_branche>
(bonne_branche)$ git stash apply

Rebaser et fusionner

Je veux annuler un rebase/merge

Il se peut que vous avez fait une fusion ou un rebase sur votre branche actuelle avec une mauvaise branche, ou que vous vous ĂȘtes perdus ou n'arrivez pas Ă  finir le processus de rebase ou de fusion. Git sauvegarde le pointeur de HEAD original dans une variable appelĂ©e ORIG_HEAD avant de faire des opĂ©rations dangereuses, afin qu'il soit plus facile de rĂ©initialiser votre branche dans l'Ă©tat avant le rebase ou la fusion :

(ma-branche)$ git reset --hard ORIG_HEAD

J'ai rebase, mais je ne veux pas pousser de force

Malheureusement, vous devez pousser de force si vous souhaitez que ces modifications soient répercutées sur la branche distante. C'est parce que vous avez changé l'historique. La branche distante n'acceptera pas les modifications, sauf si vous poussez de force. C'est l'une des principales raisons pour lesquelles de nombreuses personnes utilisent un flux de travail à base de fusions plutÎt qu'un flux de travail à base de rebase : les grandes équipes peuvent avoir des problÚmes avec les développeurs qui poussent de force. Utilisez ceci avec prudence. Une façon plus sûre d'utiliser rebase est de ne pas du tout refléter vos modifications sur la branche distante, mais plutÎt de procéder de la maniÚre suivante :

(main)$ git checkout ma-branche
(ma-branche)$ git rebase -i main
(ma-branche)$ git checkout main
(main)$ git merge --ff-only ma-branche

Pour plus d'informations, visitez ce thread de SO.

J'ai besoin de combiner des commits

Admettons que vous ĂȘtes en train de travailler sur une branche qui sera ou est dans une demande de fusion vers main. Dans le cas le plus simple, il suffit de combiner tous vos commits en un seul et vous vous fichez des timestamps des commits, vous pouvez faire un reset et recommiter. Assurez-vous que la branche main est Ă  jour et que toutes vos modifications sont commitĂ©es, puis faites :

(ma-branche)$ git reset --soft main
(ma-branche)$ git commit -am "Nouvelle fonctionnalité géniale"

Si vous voulez plus de contrĂŽle, et Ă©galement conserver les timestamps, vous devez faire ce qu'on appelle un rebase interactif :

(ma-branche)$ git rebase -i main

Si vous ne travaillez pas par rapport Ă  une autre branche, vous allez devoir rebase relativement Ă  votre HEAD. Si vous voulez combiner les 2 derniers commits par exemple, vous allez devoir rebase par rapport Ă  HEAD~2. Pour les 3 derniers, HEAD~3, etc.

(main)$ git rebase -i HEAD~2

AprÚs avoir lancé votre commande rebase, vous verrez quelque chose dans le genre dans votre éditeur de texte :

pick a9c8a1d Un peu de refactor
pick 01b2fd8 Nouvelle feature génial
pick b729ad5 fixup
pick e3851e8 autre fix

# Rebase 8074d12..b729ad5 onto 8074d12
#
# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#  x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

Toutes les lignes commençant par un # sont des commentaires, elles n'affecteront pas votre rebase.

Vous devez ensuite remplacer les commandes pick avec n'importe laquelle parmi celles présentes dans la liste ci-dessus, et vous pouvez également supprimer des commits en supprimant les lignes correspondantes.

Par exemple, si vous voulez laisser le commit le plus vieux (le premier) tel quel et combiner tous les commits suivants avec le deuxiÚme plus vieux, vous devez remplacer les lettres à cÎté de chaque commit sauf le premier et le deuxiÚme par un f :

pick a9c8a1d Un peu de refactor
pick 01b2fd8 Nouvelle feature géniale
f b729ad5 fixup
f e3851e8 autre fix

Si vous voulez combiner ces commits et renommer le commit, il vous faudra ajouter un r à cÎté du deuxiÚme commit ou utiliser simplement s au lieu de f :

pick a9c8a1d Un peu de refactor
pick 01b2fd8 Nouvelle feature géniale
s b729ad5 fixup
s e3851e8 autre fix

Vous pouvez ensuite renommer le commit dans le prochain Ă©diteur de texte qui s'affiche :

Nouvelles fonctionnalités encore plus géniales

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# rebase in progress; onto 8074d12
# You are currently editing a commit while rebasing branch 'main' on '8074d12'.
#
# Changes to be committed:
#   modified:   README.md
#

Si tout se passe bien, vous devriez voir quelque chose comme ceci :

(main)$ Successfully rebased and updated refs/heads/main.

Stratégie de fusion sûre

--no-commit fait une fusion mais prétend que la fusion a échoué et ne commit pas automatiquement, laissant la chance à l'utilisateur d'inspecter plus et de bidouiller plus les résultats de la fusion avant de commiter. no-ff garde une preuve qu'une branche de fonctionnalité a auparavant existé, gardant ainsi l'historique du projet consistant :

(main)$ git merge --no-ff --no-commit ma-branche

J'ai besoin de fusionner deux branches en un seul commit

(main)$ git merge --squash ma-branche

Je veux combiner les commits non poussés uniquement

Parfois, vous avez plusieurs commits en cours que vous souhaitez combiner avant de les pousser sur l'upstream. Vous ne voulez pas combiner des commits qui ont dĂ©jĂ  Ă©tĂ© poussĂ©s sur l'upstream par accident, car quelqu'un d'autre a peut-ĂȘtre dĂ©jĂ  effectuĂ© des commits qui y font rĂ©fĂ©rence :

(main)$ git rebase -i @{u}

Cela fera un rebase interactif que liste seulement les commits que vous n'avez pas poussé, afin que cela soit plus sûr de réordonner/corriger/combiner n'importe lesquels de la liste.

J'ai besoin d'annuler la fusion

Parfois, une fusion peux produire des problÚmes pour certains fichiers. Dans ces cas là, nous pouvons utiliser l'option abort afin d'abonner le processus de résolution de conflits en cours, afin d'essayer de reconstruire l'état qu'on avait avant la fusion :

(ma-branche)$ git merge --abort

Cette commande est disponible dans Git depuis les versions >= 1.7.4

J'ai besoin de mettre Ă  jour le commit parent de ma branche

Admettons que vous avez une branche main, une branche feature-1 crĂ©Ă©e Ă  partir de main, et une branche feature-2 crĂ©Ă©e Ă  partir de feature-1, puis que le commit parent de feature-2 n'est plus le bon (il devrait ĂȘtre celui correspondant au HEAD de feature-1, Ă©tant donnĂ© que notre branche a Ă©tĂ© crĂ©Ă©e Ă  partir de celui-ci). Vous pouvez rĂ©parer ça avec git rebase --onto :

(feature-2)$ git rebase --onto feature-1 <le premier commit dans votre branche feature-2 que vous ne voulez pas ramene> feature-2

Cela peut vous venir en aide dans les situations dĂ©licates oĂč vous avez une fonctionnalitĂ© crĂ©Ă©e sur la base d'une autre fonctionnalitĂ© qui n'a pas encore Ă©tĂ© fusionnĂ©e, et qu'une correction de bug sur la branche feature-1 a besoin d'ĂȘtre reflĂ©tĂ©e sur votre branche feature-2.

Vérifier si tous les commits d'une branche sont fusionnés

Pour vérifier si tous les commits d'une branche sont fusionnés sur une autre branche, vous devriez comparer les HEAD (ou n'importe quel autre commit) de ces branches :

(main)$ git log --graph --left-right --cherry-pick --oneline HEAD...feature/120-on-scroll

Cela vous dira si des commits sont dans l'une mais pas dans l'autre, et vous donnera une liste de tout ce qui n'est pas commun aux deux branches. Une alternative est de faire ceci :

(main)$ git log main ^feature/120-on-scroll --no-merges

ProblĂšmes possibles avec les rebase interactifs

L'Ă©cran d'Ă©dition du rebase affiche 'noop'

Si vous voyez cela :

noop

Cela signifie que vous ĂȘtes en train de rebaser par rapport Ă  une branche qui a un commit identique, ou qui est en avance par rapport Ă  votre branche actuelle. Vous pouvez essayer :

  • de vous assurez que votre branche main est lĂ  oĂč elle devrait ĂȘtre
  • de rebaser par rapport Ă  HEAD~2 ou plus tĂŽt Ă  la place

Il y a eu des conflits

Si vous n'ĂȘtes pas en mesure de terminer le rebase avec succĂšs, vous allez peut-ĂȘtre devoir rĂ©soudre des conflits.

Pour commencer, lancez git status afin de voir quels fichiers ont des conflits :

(ma-branche)$ git status
On branch ma-branche
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

  both modified:   README.md

Dans cet exemple, README.md a des conflits. Ouvrez le fichier et cherchez la chose suivante :

   <<<<<<< HEAD
   some code
   =========
   some code
   >>>>>>> nouveau-commit

Vous aurez besoin de résoudre les différences entre le code qui fut ajouté dans votre nouveau commit (dans cet exemple, tout ce qu'il y a entre la ligne du milieu et nouveau-commit) et votre HEAD.

Si vous voulez garder la version du code d'une des branches, vous pouvez utiliser --ours ou --theirs :

(main*)$ git checkout --ours README.md
  • Quand vous fusionnez, utilisez --ours pour garder les modifications de la branche locale, ou --theirs pour garder les modifications de l'autre branche.
  • Quand vous rebasez, utilisez --theirs pour garder les modifications de la branche locale, ou --ours pour garder les modifications de l'autre branche. Pour des explications concernant cet Ă©change, consultez cette note dans la documentation de Git.

Si les fusions sont plus complexes, vous pouvez utiliser un Ă©diteur de diff visuel :

(main*)$ git mergetool -t opendiff

AprÚs avoir résolu tous les conflits et testé votre code, faite un git add sur les fichiers que vous avez modifiés, puis continuez le rebase avec git rebase --continue :

(ma-branche)$ git add README.md
(ma-branche)$ git rebase --continue

Si aprÚs avoir résolu tous les conflits, vous finissez avec un arbre identique à ce qu'il était avant le commit, vous devriez faire un git rebase --skip à la place.

Si Ă  n'importe quel moment vous voulez arrĂȘter tout le rebase et revenir Ă  l'Ă©tat initial de votre branche, vous pouvez faire ceci :

(ma-branche)$ git rebase --abort

Remisage

Remiser toutes les modifications

Pour remiser toutes les modifications dans votre dossier de travail :

$ git stash

Si vous voulez Ă©galement remiser les fichiers non suivis, utilisez l'option -u :

$ git stash -u

Remiser des fichiers spécifiques

Pour remiser les modifications dans votre dossier de travail uniquement :

$ git stash push chemin-du-dossier-de-travail/nomdufichier.ext

Pour remiser plusieurs fichiers de votre dossier de travail :

$ git stash push chemin-du-dossier-de-travail/nomdufichier1.ext chemin-du-dossier-de-travail/nomdufichier2.ext

Remiser avec un message

$ git stash save <message>

Appliquer un remisage spécifique de la liste

Commencez par vérifier la liste de vos remisages avec un message en utilisant :

$ git stash list

Puis appliquez la commande suivante en choisissant un remisage de la liste :

$ git stash apply "stash@{n}"

Ici, n indique la position du remisage dans la pile. Celui le plus haut sera en position 0.

Rechercher

Je veux rechercher une chaĂźne de caractĂšres dans un commit

Pour rechercher une certaine chaĂźne de caractĂšres dans un commit, vous pouvez utiliser la commande suivante :

$ git log -S "chaĂźne de caractĂšres Ă  rechercher"

ParamĂštres communs :

  • --source sert Ă  montrer le nom du ref en se basant sur la ligne de commande avec laquelle chaque commit a Ă©tĂ© atteint.

  • --all sert Ă  commencer depuis chaque branche.

  • --reverse retourne les rĂ©sultats dans l'ordre inverse, c'est Ă  dire que la commande affichera le premier commit qui a fait la modification.

Je veux rechercher par auteur·trice/validateur·trice

Pour rechercher des commits par auteur·trice/validateur·trice, vous pouvez utiliser :

$ git log --author=<nom ou email>
$ git log --committer=<nom ou email>

Gardez en tĂȘte que l'auteur·trice et la personne qui a crĂ©Ă© le commit ne sont pas les mĂȘmes personnes. L'option --author correspond Ă  la personne qui a Ă©crit le code, et, d'un autre cĂŽtĂ©, l'option --committer, correspond Ă  la personne qui a commitĂ© le code au nom de l'autreur·trice.

Je veux lister les commits ayant des fichiers spécifiques

Pour trouver tous les commits contenant un fichier spécifique, vous pouvez utiliser :

$ git log -- <chemin du fichier>

En général, vous préciseriez un chemin exact, mais vous pouvez aussi utiliser des wildcards dans le chemin et le nom du fichier :

$ git log -- **/*.js

En utilisant des wildcards, il est utile de préciser --name-status pour voir la liste des fichiers commités :

$ git log --name-status -- **/*.js

Trouver un tag oĂč un commit est rĂ©fĂ©rencĂ©

Pour trouver tous les tags contenant un commit en particulier :

$ git tag --contains <idducommit>

Sous-modules

Cloner tous les sous-modules

$ git clone --recursive git://github.com/foo/bar.git

Si ces derniers ont déjà été clonés :

$ git submodule update --init --recursive

Retirer un sous-module

Créer un sous-module est assez trivial, mais le supprimer l'est moins. Les commandes dont vous avez besoin sont :

$ git submodule deinit nomdusubmodule
$ git rm nomdusubmodule
$ git rm --cached nomdusubmodule
$ rm -rf .git/modules/nomdusubmodule

Objets divers

Récupérer un fichier supprimé

Trouvez le commit le plus rĂ©cent oĂč le fichier existait encore :

$ git rev-list -n 1 HEAD -- nomdufichier

Puis faites un checkout sur ce fichier :

git checkout idducommitquiasupprimé^ -- nomdufichier

Supprimer un tag

$ git tag -d <nom_du_tag>
$ git push <remote> :refs/tags/<nom_du_tag>

Récupérer un tag supprimé

Si vous voulez récupérer un tag qui a déjà été supprimé, vous pouvez le faire en suivant ces étapes : Tout d'abord, vous devez retrouver le tag inaccessible en question :

$ git fsck --unreachable | grep tag

Notez le hash du tag dans un coin. Puis, restaurez le tag supprimé avec la commande suivante, qui utilise git update-ref :

$ git update-ref refs/tags/<nom_du_tag> <hash>

Votre tag devrait maintenant ĂȘtre restaurĂ©.

Patch supprimé

Si quelqu'un vous a envoyĂ© une Pull Request sur GitHub, mais a par la suite supprimĂ© son fork originel, vous ne serez pas en mesure de cloner son dĂ©pĂŽt ou d'utiliser git am Ă©tant donnĂ© que les URLs de .diff, .patch sont devenues indisponibles. Mais vous pouvez vous dĂ©placer sur la PR en elle-mĂȘme en utilisant les les refs spĂ©ciaux de GitHub. Pour rĂ©cupĂ©rer le contenu de PR#1 vers une nouvelle branche intitulĂ©e pr_1 :

$ git fetch origin refs/pull/1/head:pr_1
From github.com:foo/bar
 * [new ref]         refs/pull/1/head -> pr_1

Exporter un dépÎt comme fichier Zip

$ git archive --format zip --output /full/path/to/zipfile.zip main

Pousser une branche et un tag qui ont le mĂȘme nom

Si un tag sur le dĂ©pĂŽt distant a le mĂȘme nom qu'une branche, vous aurez le message d'erreur suivant en essayant de pousser cette branche avec la commande standard $ git push <remote> <branche> :

$ git push origin <branch>
error: dst refspec same matches more than one.
error: failed to push some refs to '<git server>'

Réparez cela en spécifiant que vous voulez pousser la référence de HEAD :

$ git push origin refs/heads/<nom-de-la-branche>

Si vous voulez pousser un tag sur un dĂ©pĂŽt distant qui a le mĂȘme nom qu'une branche, vous pouvez utiliser une commande similaire :

$ git push origin refs/tags/<nom-du-tag>

Suivre des fichiers

Je veux changer la capitalisation du nom d'un fichier, sans changer son contenu

(main)$ git mv --force monFichier MonFichier

Je veux Ă©craser des fichiers locaux en faisant un git pull

(main)$ git fetch --all
(main)$ git reset --hard origin/main

Je veux retirer un fichier de Git mais garder le fichier

(main)$ git rm --cached log.txt

Je veux rétablir un fichier à une version spécifique

Supposons que le hash du commit que vous voulez est c5f567 :

(main)$ git checkout c5f567 -- file1/to/restore file2/to/restore

Si vous voulez rétablir les changements effectués un commit avant c5f567, passez le hash du commit comme étant c5f567~1 :

(main)$ git checkout c5f567~1 -- file1/to/restore file2/to/restore

Je veux lister les changements d'un fichier spécifique entre deux commits ou branches

Supposons que vous voulez comparer le dernier commit avec le fichier du commit c5f567 :

$ git diff HEAD:path_to_file/file c5f567:path_to_file/file
# ou
$ git diff HEAD c5f567 -- path_to_file/file

Il en est de mĂȘme pour les branches :

$ git diff main:path_to_file/file staging:path_to_file/file
# ou
$ git diff main staging -- path_to_file/file

Je veux que Git ignore les changements d'un fichier spécifique

Cela marche trĂšs bien pour le modĂšles de configurations ou d'autres fichier qui nĂ©cessitent d'ajouter des identifiants qui ne devraient pas ĂȘtre commitĂ©s :

$ git update-index --assume-unchanged file-to-ignore

Notez que cela n'enlÚve pas le fichier du suivi - il est seulement ignoré localement. Pour annuler cela et dire à Git de suivre les modifications à nouveau, cette commande supprime le fait d'ignorer :

$ git update-index --no-assume-unchanged fichier-Ă -ne-plus-ignorer

Paramétrage

Je veux ajouter des alias pour certaines commandes Git

Sur macOS et Linux, votre fichier de configuration Git est stocké dans ~/.gitconfig. J'ai ajouté des exemples d'alias que j'utilise comme raccourcis (et certaines de mes fautes de frappes) dans la section [alias] comme ci-dessous :

[alias]
    a = add
    amend = commit --amend
    c = commit
    ca = commit --amend
    ci = commit -a
    co = checkout
    d = diff
    dc = diff --changed
    ds = diff --staged
    extend = commit --amend -C HEAD
    f = fetch
    loll = log --graph --decorate --pretty=oneline --abbrev-commit
    m = merge
    one = log --pretty=oneline
    outstanding = rebase -i @{u}
    reword = commit --amend --only
    s = status
    unpushed = log @{u}
    wc = whatchanged
    wip = rebase -i @{u}
    zap = fetch -p

Je veux ajouter un répertoire vide à mon dépÎt

Vous ne pouvez pas ! Git ne supporte pas cela, mais il y a une astuce. Vous pouvez créer un fichier .gitignore dans le dossier avec le contenu suivant :

 # Ignorer tout dans ce dossier
 *
 # Sauf ce fichier
 !.gitignore

Une autre convention commune est de créer un fichier vide dans le dossier, intitulé .gitkeep :

$ mkdir mondossier
$ touch mondossier/.gitkeep

Vous pouvez aussi juste appeler le fichier .keep, dans ce cas la commande ci-dessus serait touch mydir/.keep.

Je veux mettre en cache un nom d'utilisateur et mot de passe pour un dépÎt

Il se peut que vous ayez un dépÎt qui nécessite une authentification. Dans ce cas, vous pouvez mettre en cache un nom d'utilisateur et un mot de passe afin que vous n'ayez pas à les rentrer à chaque push / pull. Cette commande peut faire cela pour vous :

$ git config --global credential.helper cache
# Configure Git pour utiliser le cache mémoire des identifiants

$ git config --global credential.helper 'cache --timeout=3600'
# Configurer le cache pour expirer aprĂšs une heure (le paramĂštre est en secondes)

Je veux que Git ignore les changements de permissions et de filemode

$ git config core.fileMode false

Si vous voulez configurer cela comme étant le comportement par défaut pour les utilisateurs connectés, utilisez :

$ git config --global core.fileMode false

Je veux définir un utilisateur global

Pour configurer des informations d'utilisateur à travers tous les dépÎts locaux, et pour configurer un nom qui est identifiable en relisant l'historique :

$ git config --global user.name “[prĂ©nom nom]”

Pour configurer une adresse email qui sera associée à chaque ligne de l'historique :

git config --global user.email “[adresse-email-valide]”

Je n'ai aucune idée de ce que j'ai mal fait

Donc, vous ĂȘtes fichu - vous avez reset quelque chose, ou vous avez fusionnĂ© la mauvaise branche, ou vous avez poussĂ© de force et maintenant vous ne pouvez plus trouver vos commits. Vous savez qu'Ă  un moment donnĂ©, tout allait bien, et vous voulez revenir Ă  un Ă©tat dans lequel vous Ă©tiez avant.

C'est lĂ  qu'intervient git reflog. reflog garde trace de tous les changements du bout de la branche, mĂȘme si ce dernier n'est pas rĂ©fĂ©rencĂ© par une branche ou un tag. Fondamentalement, chaque fois que le HEAD change, une nouvelle entrĂ©e est ajoutĂ©e au reflog. Cela marche seulement pour les dĂ©pĂŽts locaux, malheureusement, et ne trace que les mouvements (pas les changements d'un fichier qui n'ont Ă©tĂ© enregistrĂ©s nulle part, par exemple).

(main)$ git reflog
0a2e358 HEAD@{0}: reset: moving to HEAD~2
0254ea7 HEAD@{1}: checkout: moving from 2.2 to main
c10f740 HEAD@{2}: checkout: moving from main to 2.2

Le reflog ci-dessus indique un dĂ©placement depuis main vers la branche 2.2 et l'inverse. À partir de lĂ , il y a un hard reset vers un commit plus vieux. La derniĂšre activitĂ© est reprĂ©sentĂ©e en haut et intitulĂ©e HEAD@{0}.

Si il s'avĂšre que vous ĂȘtes accidentellement revenu en arriĂšre, le reflog contiendra le commit sur lequel pointait main (0254ea7) avant que vous ne supprimiez 2 commits par accident.

$ git reset --hard 0254ea7

En utilisant git reset, il est ensuite possible de changer main vers le commit vers lequel il pointait. Cela vous donne de la sĂ»retĂ© dans le cas oĂč l'historique a Ă©tĂ© changĂ© par accident.

(copié et édité depuis Source).

Autres Ressources

Livres

Tutoriels

Scripts et Outils

  • firstaidgit.io Un sĂ©lection recherchable des questions Git les plus souvent posĂ©es
  • git-extra-commands - Une collection de scripts Git supplĂ©mentaires trĂšs utiles
  • git-extras - utilitaires GIT -- rĂ©sumĂ© de dĂ©pĂŽts, repl, population de changelogs, pourcentage de commits par auteur·trice et plus
  • git-fire - git-fire est un plugin Git qui vient en aide en cas d'urgence en ajoutant tous les fichier actuels, les commitant, et les poussant vers une nouvelle branche (afin d'Ă©viter les conflits).
  • git-tips - Des petites astuces Git
  • git-town - Un support de flux de travail Git gĂ©nĂ©rique et de haut-niveau ! http://www.git-town.com

Clients graphiques

  • GitKraken - Le client Git de luxe pour Windows, Mac & Linux
  • git-cola - Un autre client Git pour Windows et macOS
  • GitUp - Un client graphique rĂ©cent qui a une maniĂšre dogmatique de gĂ©rer les complications de Git
  • gitx-dev - un autre client Git graphique pour macOS
  • Sourcetree - La simplicitĂ© alliĂ©e Ă  la puissance dans une belle interface gratuite. Pour Windows et Mac
  • Tower - Un client graphique pour macOS (payant)
  • tig - terminal text-mode interface for Git
  • Magit - Une interface pour Git implĂ©mentĂ©e en tant que paquet Emacs.
  • GitExtensions - Une extension du shell, un plugin Visual Studio 2010-2015 et un outil de repo Git.
  • Fork - Un client Git rapide et amical pour Mac (beta)
  • gmaster - Un client Git pour Windows qui permet les fusions Ă  3 branches, l'analyse de refactorisation, un diff et merge sĂ©mantique (beta)
  • gitk - Un client Git pour Linux qui permet d'avoir une vue simplifiĂ©e de l'Ă©tat d'un repo.
  • SublimeMerge - Un client ultra rapide et extensible qui donne la possibilitĂ© de faire des fusions Ă  3 branches, de la recherche avancĂ©e et de la colorisation syntaxique, en dĂ©veloppement actif.