Cmd git

Commande git

git log

Option:

• --oneline: Chaque commit est représenté sur une ligne.
• --graph: Re* présente la sortie sous la forme d'un graphe (utile lorsqu'il y a plusieurs branches).
• --name-status: Rajoute comme information le type d'action réalisée (A pour un ajout, M pour une modification)

git diff

Différence entre deux commit

exemple: git diff numero_de_commit1 numero_de_commit2

git log --oneline
57e62b7 (HEAD -> main, origin/main, origin/HEAD) update index
8fdf0bc Update invalidateCache.yml
953ce04 Update invalidateCache.yml

git diff 8fdf0bc 953ce04

Git Blame

Une fonctionnalité intéressante de git est de pouvoir afficher les informations d'un document ligne par ligne, ainsi que l'auteur, la date du commit lié à au changement d'état du document. On peut pour cela utiliser git blame nom_du_fichier.

git revert

Retour en arrière Après avoir observé les différences entre les commits, on peut en cas d'incident vouloir revenir à une version précédente du code. Pour cela il existe plusieurs possibilités, les plus utilisées étant git revert et git reset.

La commande git revert permet de créer un nouveau commit qui annule un commit précédent, en appliquant la transformation inverse.

Par exemple, si le commit qui porte le numéro 123 crée un nouveau fichier fichier_1.txt, la commit git revert 123 créera un nouveau commit qui supprime le fichier fichier_1.txt.

Pour revenir en arrière d'un commit il faut donc utiliser la commande :

git revert numero_du_dernier_commit

On peut aussi revenir en arrière de plusieurs commit en utilisant git revert pour annuler une plage de commit :

git revert HEAD~2..HEAD # revenir 2 commit en arrière

Cette commande créera deux nouveaux commits, qui annulent respectivement le dernier et l'avant dernier commit.

git reset

A la différence de git revert, qui crée des nouveaux commits pour annuler des commits passés, git reset supprime purement et simplement des commits de l'historique.

Ainsi, si l'historique des commits est le suivant : commit1 -- commit2 -- commit3 -- commit4, pour revenir à l'état du deuxième commit, on pourra utiliser la commande suivante:

git reset commit2 # revenir à l'état du commit commit2

Si l'on souhaite annuler le précédent commit sans effacer les modifications faites en local lors de celui-ci, on utilisera l'argument --soft:

git reset --soft HEAD~1
# L'argument HEAD~1 précise que l'on souhaite revenir au commit précédent
# l'actuel étant (designé par HEAD)

Si l'on souhaite annuler le commit ainsi que les modifications faites durant celui-ci, on utilisera l'argument --hard:

git reset --hard HEAD~1

Utiliser git revert est considéré comme plus "propre", car on garde une trace de tous les commits, et de leurs suppressions.

Branche

Depuis le début du cours, on parle de branche, c'est le moment de comprendre cette fonctionnalité indispensable lors du développement d'un projet. Lorsque vous créez une application, il est toujours souhaitable d'avoir une version stable de celle-ci, mais que se passe-t-il si vous souhaitez développer une nouvelle fonctionnalité ? Car vous ne voulez pas écraser la version stable, ou vous ne voulez pas avoir a faire des git revert sans arrêt en cas d'erreur. C'est là que l'intérêt des branches entre en jeu.

Théorie

Par défaut une seule branche existe lors de l'initialisation du dépôt, la branche master (celle-ci a été renommée en branche main sur GitHub). La bonne pratique est de laisser la version de votre projet la plus stable sur celle-ci.

Lors du développement d'une nouvelle fonctionnalité vous serez amenés à créer une nouvelle branche. Le fait de créer une nouvelle branche va nous permettre de travailler avec les fichiers du répertoire courant dans la nouvelle branche. Ainsi vous pourrez développer votre nouvelle fonctionnalité sur la nouvelle branche, sans oublier les bonnes pratiques apprises jusqu'à présent (git add, status, commit...). Quand vous êtes satisfaits du travail réalisé sur la branche, il est possible de fusionner la nouvelle branche avec la branche master.

Création de branche

Pour créer une nouvelle branche, on exécute la commande suivante depuis la nouvelle courante:

git branch nom-branche

Pour observer les branches qui sont à notre disposition on peut simplement faire un git branch.

Changement de branche Pour se déplacer de branche en branche on exécute la commande suivante:

git checkout nom-branche

Fusion de branche (merge)

Enfin pour fusionner deux branches, par exemple si on veut apporter les changements de la branche branche-source à la branche master, il faudra d'abord se situer dans la branche master avec un git checkout puis utiliser la commande git merge :

git checkout master
git merge branche-source

Tag

Une dernière notion importante à connaître lorsque l'on utilise git est le concept de tag. Les tags sont des références vers un point particulier de l'historique des modifications.

Un tag représente donc un commit en particulier, alors qu'une branche représente une succession de commits. Les tags sont notamment utilisés pour indiquer un point important dans l'historique des modifications, par exemple des commits correspondants à des versions déployées de l'application (c'est à dire version x.y.z, par exemple 1.0.1).

Pour créer un tag, il suffit d'exécuter la commande git tag suivi du nom du tag :

git tag 1.0.1

git log -- oneline
c9e5d18 (HEAD -> master, tag: 1.0.1) Merge branch 'update-merge-file'