Git : aide mémoire de base

Anne git gestion_de_version

Mes tous premiers pas avec git.

Configuration

Après avoir installé git sur la machine, il faut configurer un utilisateur :

$ git config --global user.name "nom ou pseudo"
$ git config --global user.email "identifiant@email.com"

Seules les deux propriétés ci-dessus sont obligatoires, mais on peut aussi configurer plein d’autres choses.

Si on veut avoir une configuration différente pour un dépôt, par exemple pour un projet sur GitHub, on peut faire :

$ cd mon_projet
$ git config user.email "username@users.noreply.github.com"
$ git config user.name "username"

Pour vérifier qu’on a bien l’identité que l’on souhaite avant de lancer des commandes, on peut faire par exemple :

$ git config user.email

On peut aussi voir toute la configuration avec :

$ git config --list

Créer un nouveau projet

On crée ici un projet local. On verra plus loin comment utiliser un dépôt central.

$ mkdir MonProjet
$ cd MonProjet
$ git init

Le répertoire est maintenant prêt à recevoir les fichiers du projet.

Commandes de base

On crée maintenant quelques fichiers dans le projet, et on lance :

$ git status

On voit qu’on a une liste de Fichiers non suivis car ils sont encore inconnus de git. Pour qu’ils soient connus de git, on fait :

$ git add f1 f2

On voit avec git status que les fichiers sont maintenant dans l’index. Pour les enregistrer dans l’historique, on fait :

$ git commit -m "mon message"

Il faut prendre soin d’avoir des messages clairs pour s’y retrouver.

Par la suite, on peut directement faire un commit sur les fichiers connus de git avec l’option -a.

$ git commit -a -m "mon message"

ou plus simplement :

$ git commit -am "mon message"

On peut aussi ajouter les fichiers connus dans l’index avec :

$ git add -u .

Cela permet entre-autre de n’ajouter qu’une partie des fichiers contrairement à l’option -a de commit.

Si certains fichiers ne doivent pas être enregistrés dans git, il faut les ajouter dans le fichier .gitignore.

Se déplacer dans l’historique

Pour se déplacer sur un commit, il faut récupérer sa clé dans le log, et faire :

$ git checkout xxxxxxxxxxxxxxxx

Avec git log on voit bien qu’on est remonté, et on peut observer que les fichiers sont revenu dans leur état antérieur.

Pour revenir au dernier commit, on fait :

$ git checkout master

Cela permet de se balader facilement dans l’historique.

Partage

Quand on travaille à plusieurs, il est utile d’avoir un dépôt central partagé, autrement appelé remote.

Pour récupérer un projet existant :

$ git clone <url>

L’URL est fourni sur l’interface web du dépôt.

Pour créer un projet partagé (sur GitHub par exemple), le plus simple est de le créer sur le dépôt central (sur GitHub : New Repository en indiquant que l’on veut créer le fichier README). On peut ensuite le récupérer (avec git clone).

Après avoir bien travaillé et fait des commit locaux comme on l’a vu plus haut, il faut transférer tout ça sur le dépôt avec :

$ git push origin master
  • origin est le nom générique pour le dépôt central. On pourrait très bien avec plusieurs dépôts avec des noms différents.
  • master est le nom de la branche principale sur laquelle on a travaillé jusqu’ici.

Si quelqu’un d’autre a fait des modifications dans le dépôt, on les récupère avec :

$ git pull origin master

Explorer qui a fait quoi

Pour savoir qui a écrit une certaine ligne, on utilise :

$ git blame un_fichier

On voit alors pour chaque ligne, les informations du dernier commit qui y a été effectué.

On peut aussi faire :

$ git show xxxxxx

Ici, xxxxxx est le début de clé indiqué par blame, et le résultat de la commande montre ce qu’il s’est passé dans ce commit.

Mettre de côté

Si on a besoin de faire rapidement une modification, mais qu’on n’a pas fini ce qu’on était en train de faire, on n’a pas envie de faire un commit qui n’aurait pas grand sens. La commande suivante permet de mettre temporairement de côté ce qu’on était en train de faire :

$ git stash

On peut maintenant faire la modification urgente, faire le commit, puis reprendre le travail en cours en faisant:

$ git stash pop

On peut aussi avoir besoin de stash si on a besoin de changer de branche :

$ git stash
$ git checkout master
...
$ git commit -am ...
$ git checkout ma_branche
$ git stash pop

Attention :

Proposer une modification

L’action s’appelle pull-request.

Pour commencer, s’il s’agit d’un projet externe, il faut commencer par faire un fork : c’est-à-dire faire une copie du projet dans son propre compte.

Ensuite, il faut créer une branche, y faire les modifications, et la transférer sur le dépôt. Depuis l’interface web, on peut ensuite faire une pull-request. Il faut alors écrire un message à la personne qui doit faire la validation pour expliquer la modification proposée.

Documentation

Voir aussi :

Table des matières
Tags
Dernières notes