Vous êtes sur la page 1sur 31

10/1/2015

GrezvoscodessourceavecGit

Accueil

Cours

Grez vos codes source avec Git

Grez vos codes source avec Git

4 heures Difficile

Licence

Si vous avez dj travaill sur un projet informatique, que ce soit un petit projet personnel ou un plus gros projet
professionnel, vous avez certainement dj rencontr un de ces problmes :
Qui a modifi le fichier X, il marchait bien avant et maintenant il provoque des bugs ! ;
Robert, tu peux maider en travaillant sur le fichier X pendant que je travaille sur le fichier Y ? Attention ne pas
toucher au fichier Y car si on travaille dessus en mme temps je risque dcraser tes modifications ! ;
Qui a ajout cette ligne de code dans ce fichier ? Elle ne sert rien ! ;
quoi servent ces nouveaux fichiers et qui les a ajouts au code du projet ? ;
Quelles modifications avions-nous faites pour rsoudre le bug de la page qui se ferme toute seule ?
Si ces problmes-l vous parlent, vous auriez d utiliser un logiciel de gestion de versions. Ce type de logiciel est devenu
indispensable lorsquon travaille plusieurs sur un mme projet et donc sur le mme code source. Mme si vous travaillez
seuls, vous aurez intrt commencer en utiliser un rapidement car il vous offrira de nombreux avantages, comme la
conservation dun historique de chaque modification des fichiers par exemple.
Il existe de nombreux logiciels de gestion de versions, comme SVN (Subversion), Mercurial et Git. Dans ce tutoriel, je vous
prsenterai Git (prononcez guite ) qui est un des plus puissants logiciels de ce genre. Nous lutilisons notamment pour
grer le code source du Site du Zro !

Qu'est-ce quun logiciel de gestion de versions ?


Les logiciels de gestion de versions sont utiliss principalement par les dveloppeurs ; ce sont donc bel et bien des outils
pour geeks. En effet, ils sont quasi exclusivement utiliss pour grer des codes sources, car ils sont capables de suivre
lvolution dun fichier texte ligne de code par ligne de code.
Ces logiciels sont fortement conseills pour grer un projet informatique.

Un projet informatique correspond aux tapes de cration dun programme, dun site web ou de tout autre outil
informatique. Que vous travailliez seuls sur le dveloppement de ce projet ou plusieurs, vous avez un objectif (par
exemple, crer un site web ) et vous allez devoir crire du code source pour parvenir cet objectif. On dit que
vous travaillez sur un projet.
Ces outils suivent lvolution de vos fichiers source et gardent les anciennes versions de chacun deux.
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

1/31

10/1/2015

GrezvoscodessourceavecGit

Bymoviemode

Sils sarrtaient cela, ce ne seraient que de vulgaires outils de backup (sauvegarde). Cependant, ils proposent de
nombreuses fonctionnalits qui vont vraiment vous tre utiles tout au long de lvolution de votre projet informatique :
Livraisongratuite
9,80

229,78
10,90
ils retiennent qui a effectu chaque modification de chaque fichier et pourquoi
. Ils sont par consquent
capables de
dire qui a crit chaque ligne de code de chaque fichier et dans quel but ;

Plus
si deux personnes travaillent simultanment sur un mme fichier,
ils sont capables dassembler (de fusionner) leurs
modifications et dviter que le travail dune de ces personnes ne soit cras.
24,60

Ces logiciels ont donc par consquent deux utilits principales :


suivre lvolution dun code source, pour retenir les modifications effectues sur chaque fichier et tre ainsi capable
de revenir en arrire en cas de problme ;
travailler plusieurs, sans risquer de se marcher sur les pieds. Si deux personnes modifient un mme fichier en
mme temps, leurs modifications doivent pouvoir tre fusionnes sans perte dinformation.

Logiciels centraliss et distribus


Il existe deux types principaux de logiciels de gestion de versions.
Les logiciels centraliss : un serveur conserve les anciennes versions des fichiers et les dveloppeurs sy connectent
pour prendre connaissance des fichiers qui ont t modifis par dautres personnes et pour y envoyer leurs
modifications.
Les logiciels distribus : il ny a pas de serveur, chacun possde lhistorique de lvolution de chacun des fichiers. Les
dveloppeurs se transmettent directement entre eux les modifications, la faon du peer-to-peer.
Voici, schmatiquement, comment fonctionne un logiciel de gestion de versions centralis :

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

2/31

10/1/2015

GrezvoscodessourceavecGit

Un logiciel de gestion de versions centralis.


Le serveur retient les anciennes versions des fichiers et communique les changements aux dveloppeurs.
De mme, voici le fonctionnement dun logiciel de gestion de versions distribu :

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

3/31

10/1/2015

GrezvoscodessourceavecGit

Un logiciel de gestion de versions distribu.


Il ny a pas de serveur. Les dveloppeurs conservent lhistorique des modifications et se transmettent les nouveauts.
Dans la pratique, les logiciels distribus sont rarement utiliss comme sur le schma prcdent. Mme lorsque les logiciels
sont capables de fonctionner en mode distribu, on utilise trs souvent un serveur qui sert de point de rencontre entre les
dveloppeurs. Le serveur connat lhistorique des modifications et permet lchange dinformations entre les dveloppeurs,
qui eux possdent galement lhistorique des modifications.

Un logiciel de gestion de versions distribu avec un serveur.


Le serveur sert de point de rencontre entre les dveloppeurs et possde lui aussi lhistorique des versions.
Cest dans ce dernier mode que nous allons fonctionner avec Git.
Il a lavantage dtre la fois flexible et pratique. Pas besoin de faire de sauvegarde du serveur tant donn que tout le
monde possde lhistorique des fichiers, et le serveur simplifie la transmission des modifications.

Git et les autres logiciels de gestion de versions


Les diffrents logiciels de gestion de versions

Dans ce tutoriel, je vais vous prsenter Git, le logiciel de gestion de versions que nous utilisons pour grer le code source du
Site du Zro.
Nanmoins, il existe dautres logiciels du mme type que je tiens aussi vous prsenter rapidement afin que vous les
connaissiez au moins de nom.
Projets qui
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

4/31

10/1/2015

GrezvoscodessourceavecGit

Outil

Type

Description

lutilisent

Cest un des plus anciens logiciels de gestion de versions. Bien quil


fonctionne et soit encore utilis pour certains projets, il est prfrable
CVS

Centralis

dutiliser SVN (souvent prsent comme son successeur) qui corrige


un certain nombre de ses dfauts, comme son incapacit suivre les

OpenBSD

fichiers renomms par exemple.

SVN
(Subversion)

Centralis

Probablement loutil le plus utilis lheure actuelle. Il est assez


simple dutilisation, bien quil ncessite comme tous les outils du
mme type un certain temps dadaptation. Il a lavantage dtre bien

Apache,

intgr Windows avec le programme Tortoise SVN, l o beaucoup


dautres logiciels sutilisent surtout en ligne de commande dans la

Redmine,
Struts

console.
Il y a un tutoriel SVN sur le Site du Zro.
Plus rcent, il est complet et puissant. Il est apparu quelques jours
Mercurial

Distribu

aprs le dbut du dveloppement de Git et est dailleurs comparable


ce dernier sur bien des aspects.

Mozilla, Python,
OpenOffice.org

Vous trouverez un tutoriel sur Mercurial sur le Site du Zro.

Bazaar

Distribu

Un autre outil, complet et rcent, comme Mercurial. Il est sponsoris


par Canonical, lentreprise qui dite Ubuntu. Il se focalise sur la facilit
dutilisation et la flexibilit.

Git

Distribu

Ubuntu, MySQL,
Inkscape

Trs puissant et rcent, il a t cr par Linus Torvalds, qui est entre


autres lhomme lorigine de Linux. Il se distingue par sa rapidit et sa

Kernel de Linux,
Debian, VLC,

gestion des branches qui permettent de dvelopper en parallle de


nouvelles fonctionnalits.

Android, Gnome,
Qt

Notez quil existe dautres outils de gestion de versions ; je ne vous ai prsent ici que les principaux.
Tous ceux de cette liste sont des logiciels libres, mais il existe aussi des logiciels propritaires : Perforce, BitKeeper, Visual
SourceSafe de Microsoft, etc.

Quelles sont les particularits de Git ?


Je nentrerai pas dans les dtails de la comparaison de Git avec les autres outils concurrents comme SVN et Mercurial.
Retenez simplement que :
CVS est le plus ancien et il est recommand de ne plus lutiliser car il est le moins puissant et nest plus trs bien mis
jour ;
SVN est le plus connu et le plus utilis lheure actuelle, mais de nombreux projets commencent passer des outils
plus rcents ;
Mercurial, Bazaar et Git se valent globalement, ils sont rcents et puissants, chacun a des avantages et des dfauts.
Ils sont tous distribus, donc chaque dveloppeur possde lhistorique des modifications et ils permettent en thorie
de se passer de serveur (bien quon utilise toujours un serveur pour des raisons pratiques).
Concernant les avantages de Git sur les autres, certains ont fait des listes comparatives intressantes (bien que toujours
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

5/31

10/1/2015

GrezvoscodessourceavecGit

criticables).

On retiendra surtout que Git :


est trs rapide ;
sait travailler par branches (versions parallles dun mme projet) de faon trs flexible ;
est assez complexe, il faut un certain temps dadaptation pour bien le comprendre et le manipuler, mais cest
galement valable pour les autres outils ;
est lorigine prvu pour Linux. Il existe des versions pour Windows mais pas vraiment dinterface graphique
simplifie. Il est donc rserver aux dveloppeurs ayant un minimum dexprience et travaillant de prfrence
sous Linux.
Une des particularits de Git, cest lexistence de sites web collaboratifs bass sur Git comme GitHub et Gitorious. GitHub,
par exemple, est trs connu et utilis par de nombreux projets : jQuery, Symfony, Ruby on Rails
Cest une sorte de rseau social pour dveloppeurs : vous pouvez regarder tous les projets voluer et dcider de participer
lun dentre eux si cela vous intresse. Vous pouvez aussi y crer votre propre projet : cest gratuit pour les projets open

source et il existe une version payante pour ceux qui lutilisent pour des projets propritaires.
GitHub fournit le serveur o les dveloppeurs qui utilisent Git se rencontrent. Cest un excellent moyen de participer des
projets open source et de publier votre projet !

Installer et configurer Git


Installation
Nous allons voir ici comment installer Git sous Linux, Windows et Mac OS X. Comme je vous le disais plus tt, Git est plus
agrable utiliser sous Linux et sensiblement plus rapide, mais il reste nanmoins utilisable sous Windows.

Installer Git sous Linux


Avec un gestionnaire de paquets, cest trs simple :
console

sudoaptgetinstallgitcoregitk

Cela installe 2 paquets :


git-core : cest git, tout simplement. Cest le seul paquet vraiment indispensable ;
gitk : une interface graphique qui aide mieux visualiser les logs. Facultatif.
Il est recommand de se crer une paire de cls pour se connecter au serveur de rencontre lorsque laccs Git se fait via
SSH. Un tutoriel du SdZ explique comment crer des cls : http://www.siteduzero.com/tutoriel-3-7 [...] tml#ss_part_5.

Installer Git sous Windows


http://openclassrooms.com/courses/gerezvoscodessourceavecgit

6/31

10/1/2015

GrezvoscodessourceavecGit

Pour utiliser Git sous Windows, il faut installer msysgit : http://msysgit.github.io.


Cela installe msys (un systme dmulation des commandes Unix sous Windows) et Git simultanment.

Comme vous le voyez, ce nest pas une vraie version pour Windows mais plutt une forme dmulation. Je lai
test, cela fonctionne, mais cest loin dtre aussi agrable et rapide que sous Linux. Si la majorit des dveloppeurs
de votre projet utilisent Windows, je vous recommanderai donc plutt dessayer Mercurial ou Bazaar qui, sous
Windows, ont des interfaces graphiques plus adaptes.
Lors de linstallation, laissez toutes les options par dfaut, elles conviennent bien.
Une fois que cest install, vous pouvez lancer une console qui permet dutiliser Git en ouvrant le programme Git Bash. Les
commandes de base dUnix fonctionnent sans problme : cd, pwd, mkdir, etc.
De la mme faon que sous Linux, pour se connecter rgulirement un serveur, il est recommand de se crer une paire de
cls avec Puttygen et de charger la cl en mmoire avec Pageant (normalement install avec Putty). Toutes les explications
sont dans le tutoriel du SdZ : http://www.siteduzero.com/tutoriel-3-7 [...] tml#ss_part_5.

Installer Git sous Mac OS X


Il y a plusieurs faons dinstaller Git sous Mac OS X. Le plus simple est de se baser sur cet installeur pour Mac OS X.
Vous allez tlcharger une archive .dmg. Il suffit de louvrir pour la monter, ce qui vous donnera accs plusieurs fichiers :

Ouvrez tout simplement larchive .pkg qui se trouve lintrieur, ce qui aura pour effet dexcuter le programme
dinstallation :

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

7/31

10/1/2015

GrezvoscodessourceavecGit

Suivez les tapes en laissant les valeurs par dfaut (cest suffisant), et vous aurez install Git !
Il vous suffit ensuite douvrir un terminal et vous aurez alors accs aux commandes de Git comme sous Linux.

Configurer Git
Maintenant que Git est install, vous devriez avoir une console ouverte dans laquelle vous allez pouvoir taper des
commandes de Git.
Dans la console, commencez par envoyer ces trois lignes :
console

gitconfigglobalcolor.diffauto
gitconfigglobalcolor.statusauto
gitconfigglobalcolor.branchauto

Elles activeront la couleur dans Git. Il ne faut le faire quune fois, et a aide la lisibilit des messages dans la console.
De mme, il faut configurer votre nom (ou pseudo) :
console

gitconfigglobaluser.name"votre_pseudo"

Puis votre e-mail :


console

gitconfigglobaluser.emailmoi@email.com

Vous pouvez aussi diter votre fichier de configuration .gitconfig situ dans votre rpertoire personnel pour y ajouter
une section alias la fin :
console

vim~/.gitconfig

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

8/31

10/1/2015

GrezvoscodessourceavecGit

[color]
diff=auto
status=auto
branch=auto
[user]
name=votre_pseudo
email=moi@email.com
[alias]
ci=commit
co=checkout
st=status
br=branch

Ces alias permettent de raccourcir certaines commandes de Git. Ainsi, au lieu dcrire
gitcheckout
, vous pourrez crire si vous le dsirez
gitco
, ce qui est plus court.

Crer un nouveau dpt ou cloner un dpt existant


Pour commencer travailler avec Git, il y a deux solutions :
soit vous crez un nouveau dpt vide, si vous souhaitez commencer un nouveau projet ;
soit vous clonez un dpt existant, cest--dire que vous rcuprez tout lhistorique des changements dun projet
pour pouvoir travailler dessus.

Dans un logiciel de gestion de versions comme Git, un dpt reprsente une copie du projet. Chaque ordinateur
dun dveloppeur qui travaille sur le projet possde donc une copie du dpt.
Dans chaque dpt, on trouve les fichiers du projet ainsi que leur historique (voir les schmas du dbut du
chapitre).
Je vais vous montrer les deux mthodes : la cration dun nouveau dpt vide et le clonage dun dpt existant. vous de
choisir celle que vous prfrez, sachant quil peut tre pratique de commencer par cloner un dpt existant pour se faire la
main sur un projet qui utilise dj Git.

Crer un nouveau dpt


Commencez par crer un dossier du nom de votre projet sur votre disque. Par exemple, je vais crer
/home/mateo21/plusoumoins pour hberger mon jeu Plus ou Moins dvelopp en C.
console

cd/home/mateo21
mkdirplusoumoins
cdplusoumoins

Si votre projet existe dj, inutile de crer un nouveau dossier. Rendez-vous simplement dans le dossier o se
trouve votre projet.
Vous pouvez donc ignorer les tapes prcdentes.
Ensuite, initialisez un dpt Git tout neuf dans ce dossier avec la commande :
console

gitinit
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

9/31

10/1/2015

GrezvoscodessourceavecGit

Cest tout ! Vous venez de crer un nouveau projet Git dans le dossier o vous vous trouvez.
Un dossier cach .git vient tout simplement dtre cr.
Il faudra ensuite crer les fichiers source de votre projet et les faire connatre Git en faisant des commits, ce que je vous
expliquerai un peu plus loin.

Cloner un dpt existant


Cloner un dpt existant consiste rcuprer tout lhistorique et tous les codes source dun projet avec Git.
Pour trouver un dpt Git, rien de plus facile ! Comme je vous le disais, GitHub est une formidable fourmilire de dpts Git.
Vous y trouverez de nombreux projets connus (certains nutilisent pas GitHub directement mais on y trouve quand mme
une copie jour du projet).
Prenons par exemple Symfony, la nouvelle version du framework PHP qui permet de crer des sites robustes facilement (il
sagit ici de la version Symfony 2 en cours de dveloppement), que le Site du Zro utilise, par ailleurs.
Rendez-vous sur la page GitHub du projet. Vous y voyez la liste des fichiers et des derniers changements ainsi quun champ
contenant ladresse du dpt. En loccurrence, ladresse du dpt de Symfony est :
http://github.com/symfony/symfony.git

Comme vous le voyez, on se connecte au dpt en HTTP, mais il existe dautres mthodes : les protocoles git:// et
ssh:// . Le plus souvent, on utilise SSH car il permet de chiffrer les donnes pendant lenvoi et gre lauthentification des
utilisateurs.
Pour cloner le dpt de Symfony, il suffit de lancer la commande suivante :
console

gitclonehttp://github.com/symfony/symfony.git

Cela va crer un dossier symfony et y tlcharger tous les fichiers source du projet ainsi que lhistorique de chacune de
leurs modifications !
Git compresse automatiquement les donnes pour le transfert et le stockage afin de ne pas prendre trop de place.
Nanmoins, le clonage dun dpt comme ceci peut prendre beaucoup de temps (ce nest pas vraiment le cas avec
Symfony, mais essayez de cloner le dpt du Kernel Linux pour voir !

).

Les messages suivants devraient apparatre dans la console :


console

$gitclonehttp://github.com/symfony/symfony.git
InitializedemptyGitrepositoryin/home/mateo21/symfony/.git/
remote:Countingobjects:7820,done.
remote:Compressingobjects:100%(2490/2490),done.
remote:Total7820(delta4610),reused7711(delta4528)
Receivingobjects:100%(7820/7820),1.40MiB|479KiB/s,done.
Resolvingdeltas:100%(4610/4610),done.
Checkingoutfiles:100%(565/565),done.

Inutile dessayer den comprendre le dtail. Vous noterez toutefois que les objets sont compresss avant lenvoi, ce qui
acclre le tlchargement. Une fois les fichiers reus, Git les organise sur votre disque et vous voil dsormais en
possession de tous les changements des fichiers du projet ainsi que de leur dernire version !
Vous pouvez ouvrir le dossier symfony et regarder son contenu, il y a tout le code source du projet.
Le seul dossier un peu particulier cr par Git est un dossier .git (cest un dossier cach situ la racine du projet). Il
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

10/31

10/1/2015

GrezvoscodessourceavecGit

contient lhistorique des modifications des fichiers et la configuration de Git pour ce projet.
Lorsque Git cre ou clone un dpt sur votre ordinateur, il organise les dossiers comme ceci :

En fait, Git cre tout simplement un dossier .git cach la racine du dossier de votre projet. Vous naurez pas vous rendre
dans ce dossier cach en temps normal, sauf ventuellement pour modifier le fichier de configuration .git/config qui se
trouve lintrieur.
Mis part ce dossier un peu spcial , vous retrouverez tous les fichiers dans leur dernire version dans le dossier du
projet. Ce sont eux que vous modifierez.

Sur GitHub, la plupart des dpts sont en mode lecture seule (read only). Vous pouvez tlcharger les fichiers,
effectuer des modifications sur votre ordinateur (en local) mais pas les envoyer sur le serveur. Ceci permet dviter
que nimporte qui fasse nimporte quoi sur les gros projets publics.
Si vous faites une modification utile sur le projet (vous rsolvez un bug par exemple) il faudra demander lun des
principaux dveloppeurs du projet de faire un pull , cest--dire de tlcharger vos modifications lui-mme afin
quil puisse vrifier si elles sont correctes.

Crer un dpt qui servira de serveur


Si vous souhaitez mettre en place un serveur de rencontre pour votre projet, il suffit dy faire un
gitclone
ou un
gitinit
avec loption --bare. Cela aura pour effet de crer un dpt qui contiendra uniquement le dossier .git reprsentant
lhistorique des changements (ce qui est suffisant, car personne ne modifie les fichiers source directement sur le serveur).
console

gitinitbare//excutersurleserveur.

Pour se connecter au serveur, la meilleure mthode consiste utiliser SSH. Ainsi, si vous voulez cloner le dpt du serveur
sur votre ordinateur, vous pouvez crire quelque chose comme :
console

gitclonessh://utilisateur@monserveur.domaine.com/chemin/vers/le/depot/git//excutersurvotremachine.

Il faudra bien entendu vous identifier en entrant votre mot de passe (sauf si vous avez autoris votre cl publique).

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

Modifier le code et effectuer des commits

11/31

10/1/2015

GrezvoscodessourceavecGit

ce stade, vous devriez avoir cr ou clon un dpt Git. Je vous recommande davoir fait un clone afin davoir une base de
travail, ce sera plus simple que de commencer zro pour le moment.
Supposons que vous ayez clon comme moi le dpt Git de Symfony. Vous avez sur votre disque dur tous les fichiers source
du projet et vous pouvez vous amuser les modifier avec un diteur de texte (pas de panique, les changements restent sur
votre ordinateur, vous ne risquez pas denvoyer des btises et pouvez donc faire toutes les expriences que vous voulez).
Placez-vous dans le rpertoire de base du code, par exemple :
console

cd/home/mateo21/symfony

La commande
gitstatus
vous indique les fichiers que vous avez modifis rcemment :
console

$gitstatus
#Onbranchmaster
nothingtocommit(workingdirectoryclean)

Ce message nous informe que rien na t modifi (nothing to commit).

Si vous avez dfini des alias prcdemment, il est plus rapide de taper
gitst
que
gitstatus
. Cest une commande que lon peut tre amen taper plusieurs fois par jour.

Mthode de travail
Lorsquon travaille avec Git, on suit en gnral toujours les tapes suivantes :
1. modifier le code source ;
2. tester votre programme pour vrifier si cela fonctionne ;
3. faire un commit pour enregistrer les changements et les faire connatre Git ;
4. recommencer partir de ltape 1 pour une autre modification.

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

12/31

10/1/2015

GrezvoscodessourceavecGit

Quest-ce quon appelle une modification du code source ?


Cest un ensemble de changements qui permet soit de rgler un bug, soit dajouter une fonctionnalit.
Cela peut aussi bien correspondre une ligne change dans un fichier que 50 lignes changes dans un fichier A et 25 lignes
dans un fichier B. Un commit reprsente donc un ensemble de changements. vous de dterminer, ds que vos
changements sont stables, quand vous devez faire un commit.

titre indicatif, si vous travaillez toute une journe sur un code et que vous ne faites quun commit la fin de la
journe, cest quil y a un problme (sauf si vous avez pass toute la journe sur le mme bug). Les commits sont l
pour valider lavancement de votre projet : nen faites pas un pour chaque ligne de code modifie, mais
nattendez pas davoir fait 50 modifications diffrentes non plus !
Supposons que vous ayez effectu des modifications dans un des fichiers (par exemple
src/Symfony/Components/Yaml/Yaml.php). Si vous avez modifi ce fichier et que vous lavez enregistr, faites un
gitstatus
dans la console pour voir :
console

$gitstatus
#Onbranchmaster
#Changedbutnotupdated:
#(use"gitadd<file>"toupdatewhatwillbecommitted)
#(use"gitcheckout<file>"todiscardchangesinworkingdirectory)
#
#modified:src/Symfony/Components/Yaml/Yaml.php
#
nochangesaddedtocommit(use"gitadd"and/or"gitcommita")

Git vous liste tous les fichiers qui ont chang sur le disque. Il peut aussi bien dtecter les modifications que les ajouts, les
suppressions et les renommages.
Vous pouvez voir concrtement ce que vous avez chang en tapant
gitdiff
:
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

13/31

10/1/2015

GrezvoscodessourceavecGit
console

$gitdiff
diffgita/src/Symfony/Components/Yaml/Yaml.phpb/src/Symfony/Components/Yaml/
indexfa0b806..77f9902100644
a/src/Symfony/Components/Yaml/Yaml.php
+++b/src/Symfony/Components/Yaml/Yaml.php
@@19,7+19,7@@namespaceSymfony\Components\Yaml;
*/
classYaml
{
staticprotected$spec=1.2;
+staticprotected$spec=1.3;
/**
*SetstheYAMLspecificationversiontouse.
@@33,6+33,8@@classYaml
if(!in_array($version,array(1.1,1.2))){
thrownew\InvalidArgumentException(sprintf(Version%softheYAML
}
+
+$mtsource=$version;
self::$spec=$version;
}

Les lignes ajoutes sont prcdes dun + tandis que les lignes supprimes sont prcdes dun - . Normalement les
lignes sont colores et donc faciles reprer.
Jai fait des modifications alatoires ici mais cela aurait trs bien pu correspondre la correction dun bug ou lajout dune
fonctionnalit.
Par dfaut, Git affiche les modifications de tous les fichiers qui ont chang. Dans notre cas, il ny en avait quun, mais sil y en
avait eu plusieurs nous les aurions tous vus.
Vous pouvez demander Git dafficher seulement les changements dun fichier prcis, comme ceci :
console

gitdiffsrc/Symfony/Components/Yaml/Yaml.php

Si les modifications vous paraissent bonnes et que vous les avez testes, il est temps de faire un commit.

Effectuer un commit des changements


En faisant
gitstatus
, vous devriez voir les fichiers que vous avez modifis en rouge. Cela signifie quils ne seront pas pris en compte lorsque vous
allez faire un commit.
Il faut explicitement prciser les fichiers que vous voulez commiter . Pour cela, trois possibilits :
faire
gitaddnomfichier1nomfichier2
pour ajouter les fichiers la liste de ceux devant faire lobjet dun commit, puis faire un
gitcommit
. Si vous faites un
gitstatus
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

14/31

10/1/2015

GrezvoscodessourceavecGit

aprs un
gitadd
, vous les verrez alors en vert ;
faire
gitcommita
pour commiter tous les fichiers qui taient lists dans
gitstatus
dans les colonnes Changes to be committed et Changed but not updated (quils soient en vert ou en rouge) ;
faire
gitcommitnomfichier1nomfichier2
pour indiquer lors du commit quels fichiers prcis doivent tre commits .
Jutilise personnellement la seconde solution lorsque je veux commiter tous les fichiers que jai modifis, et la troisime
solution lorsque je veux commiter seulement certains des fichiers modifis.
Faire appel
gitadd
est indispensable lorsque vous venez de crer de nouveaux fichiers que Git ne connat pas encore. Cela lui permet de les
prendre en compte pour le prochain commit.
Lorsque la commande commit est lance, lditeur par dfaut (gnralement nano ou Vim) souvre. Vous devez sur la
premire ligne taper un message qui dcrit quoi correspondent vos changements.

Il est possible de faire un message de commit sur plusieurs lignes. Nanmoins, rservez la premire ligne pour une
courte description synthtique de vos changements. Si vous ne mettez pas de message de commit, celui-ci sera
annul.

En rgle gnrale, si vous ne pouvez pas rsumer vos changements en une courte ligne cest que vous avez pass
trop de temps faire des changements sans commiter .
Exemple de messages de commit dune ligne corrects :
Amliore la visibilit des post-it sur le forum. ;
Simplifie linterface de changement davatar. ;
Rsout #324 : bug qui empchait de valider un tutoriel plusieurs .
Comme vous pouvez le constater, on a tendance crire les messages de commit au prsent. Dautre part, vous
remarquerez que la plupart des projets open source sont crits en anglais, donc il est frquent de voir des messages de
commit en anglais.
Une fois le message de commit enregistr, Git va officiellement sauvegarder vos changements dans un commit. Il ajoute
donc cela la liste des changements quil connat du projet.

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

15/31

10/1/2015

GrezvoscodessourceavecGit

git commit ajoute vos dernires modifications votre historique des modifications.

Un commit avec git est local : moins denvoyer ce commit sur le serveur comme on apprendra le faire plus loin,
personne ne sait que vous avez fait ce commit pour le moment. Cela a un avantage : si vous vous rendez compte
que vous avez fait une erreur dans votre dernier commit, vous avez la possibilit de lannuler (ce qui nest pas le cas
avec SVN !).

Annuler un commit effectu par erreur


Il est frquent de chercher comprendre ce qui sest pass rcemment, pourquoi une erreur a t introduite et comment
annuler ce changement qui pose problme. Cest mme l tout lintrt dun logiciel de gestion de versions comme Git.
Nous allons dabord apprendre lire les logs, puis nous verrons comment corriger une erreur.

Que sest-il pass ? Vrifions les logs


Il est possible tout moment de consulter lhistorique des commits : ce sont les logs. Vous pouvez ainsi retrouver tout ce qui
a t chang depuis les dbuts du projet.
Lorsque vous avez effectu un commit, vous devriez donc le voir dans
gitlog
:
console

commit227653fd243498495e4414218e0d4282eef3876e
Author:FabienPotencier<fabien.potencier@gmail.com>
Date:ThuJun308:47:462010+0200
[TwigBundle]addedthejavascripttokenparsersinthehelperextension
commit6261cc26693fa1697bcbbd671f18f4902bef07bc
Author:JeremyMikola<jmikola@gmail.com>
Date:WedJun217:32:0820100400
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

16/31

10/1/2015

GrezvoscodessourceavecGit

Fixedbadexamplesindoctrine:generate:entitieshelpoutput.
commit12328a1bcbf231da8eaf942f8d68c7dc0c7c4f38
Author:FabienPotencier<fabien.potencier@gmail.com>
Date:ThuJun308:42:222010+0200
[TwigBundle]updatedthebundletoworkwiththelatestTwigversion

Chaque commit est numrot grce un long numro hexadcimal comme


12328a1bcbf231da8eaf942f8d68c7dc0c7c4f38. Cela permet de les identifier.
Vous pouvez parcourir les logs avec les touches Page up , Page down et les flches directionnelles, et quitter en
appuyant sur la touche Q . Git utilise en fait le programme less pour paginer les rsultats.
Utilisez loption -p pour avoir le dtail des lignes qui ont t ajoutes et retires dans chaque commit, en tapant
gitlogp
:
console

commit227653fd243498495e4414218e0d4282eef3876e
Author:FabienPotencier<fabien.potencier@gmail.com>
Date:ThuJun308:47:462010+0200
[TwigBundle]addedthejavascripttokenparsersinthehelperextension
diffgita/src/Symfony/Framework/TwigBundle/Extension/Helpers.phpb/src/Symfon
indexe4c9cce..57a3d2f100644
a/src/Symfony/Framework/TwigBundle/Extension/Helpers.php
+++b/src/Symfony/Framework/TwigBundle/Extension/Helpers.php
@@33,6+33,8@@classHelpersextends\Twig_Extension
publicfunctiongetTokenParsers()
{
returnarray(
+newJavascriptTokenParser(),
+newJavascriptsTokenParser(),
newStylesheetTokenParser(),
newStylesheetsTokenParser(),
newRouteTokenParser(),
commit6261cc26693fa1697bcbbd671f18f4902bef07bc
Author:JeremyMikola<jmikola@gmail.com>
Date:WedJun217:32:0820100400

Vous pouvez avoir un rsum plus court des commits avec


gitlogstat
:
console

commit227653fd243498495e4414218e0d4282eef3876e
Author:FabienPotencier<fabien.potencier@gmail.com>
Date:ThuJun308:47:462010+0200
[TwigBundle]addedthejavascripttokenparsersinthehelperextension
/Framework/TwigBundle/Extension/Helpers.php|2++
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

17/31

10/1/2015

GrezvoscodessourceavecGit

1fileschanged,2insertions(+),0deletions()
commit6261cc26693fa1697bcbbd671f18f4902bef07bc
Author:JeremyMikola<jmikola@gmail.com>
Date:WedJun217:32:0820100400
Fixedbadexamplesindoctrine:generate:entitieshelpoutput.
/Command/GenerateEntitiesDoctrineCommand.php|4++
1fileschanged,2insertions(+),2deletions()

Corriger une erreur


Voici diffrentes mthodes permettant de corriger les erreurs, selon leur anciennet ou leur importance.

Modifier le dernier message de commit


Si vous avez fait une faute dorthographe dans votre dernier message de commit ou que vous voulez tout simplement le
modifier, vous pouvez le faire facilement grce la commande suivante :
console

gitcommitamend

Lditeur de texte souvrira nouveau pour changer le message.


Cette commande est gnralement utilise juste aprs avoir effectu un commit lorsquon se rend compte dune erreur
dans le message. Il est en effet impossible de modifier le message dun commit lorsque celui-ci a t transmis dautres
personnes.

Annuler le dernier commit (soft)


Si vous voulez annuler votre dernier commit :
console

gitresetHEAD^

Cela annule le dernier commit et revient lavant-dernier.


Pour indiquer quel commit on souhaite revenir, il existe plusieurs notations :
HEAD : dernier commit ;
HEAD^ : avant-dernier commit ;
HEAD

: avant-avant-dernier commit ;

HEAD~2 : avant-avant-dernier commit (notation quivalente) ;


d6d98923868578a7f38dea79833b56d0326fcba1 : indique un numro de commit prcis ;
d6d9892 : indique un numro de commit prcis (notation quivalente la prcdente, bien souvent crire les
premiers chiffres est suffisant tant quaucun autre commit ne commence par les mmes chiffres).
Seul le commit est retir de Git ; vos fichiers, eux, restent modifis.
Vous pouvez alors nouveau changer vos fichiers si besoin est et refaire un commit.

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

18/31

10/1/2015

GrezvoscodessourceavecGit

Annuler tous les changements du dernier commit (hard)


Si vous voulez annuler votre dernier commit et les changements effectus dans les fichiers, il faut faire un reset hard.

Cela annulera sans confirmation tout votre travail ! Faites donc attention et vrifiez que cest bien ce que vous
voulez faire !
console

gitresethardHEAD^/!\Annulelescommitsetperdtousleschangements

Normalement, Git devrait vous dire quel est maintenant le dernier commit quil connat (le nouveau HEAD) :
console

$gitresethardHEAD^
HEADisnowat6261cc2Fixedbadexamplesindoctrine:generate:entitieshelpoutput.

Annuler les modifications dun fichier avant un commit


Si vous avez modifi plusieurs fichiers mais que vous navez pas encore envoy le commit et que vous voulez restaurer un
fichier tel quil tait au dernier commit, utilisez
gitcheckout
:
console

gitcheckoutnomfichier

Le fichier redeviendra comme il tait lors du dernier commit.

Annuler/Supprimer un fichier avant un commit


Supposons que vous veniez dajouter un fichier Git avec
gitadd
et que vous vous apprtiez le commiter . Cependant, vous vous rendez compte que ce fichier est une mauvaise ide et
vous voudriez annuler votre
gitadd
.
Il est possible de retirer un fichier qui avait t ajout pour tre commit en procdant comme suit :
console

gitresetHEADfichier_a_supprimer

Tlcharger les nouveauts et partager votre travail


Pour le moment, vous avez tout effectu en local. Comment partager votre travail avec d'autres personnes ?

Tlcharger les nouveauts


La commande
gitpull
tlcharge les nouveauts depuis le serveur :
console

gitpull

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

19/31

10/1/2015

GrezvoscodessourceavecGit

git pull tlcharge les nouvelles modifications effectues par dautres personnes.
Deux cas sont possibles :
soit vous navez effectu aucune modification depuis le dernier pull, dans ce cas la mise jour est simple (on parle de
mise jour fast-forward) ;
soit vous avez fait des commits en mme temps que dautres personnes. Les changements quils ont effectus sont
alors fusionns aux vtres automatiquement.
Si deux personnes modifient en mme temps deux endroits distincts dun mme fichier, les changements sont
intelligemment fusionns par Git.
Parfois, mais cela arrive normalement rarement, deux personnes modifient la mme zone de code en mme temps. Dans ce
cas, Git dit quil y a un conflit car il ne peut dcider quelle modification doit tre conserve ; il vous indique alors le nom des
fichiers en conflit. Ouvrez-les avec un diteur et recherchez une ligne contenant <<<<<<<<< . Ces symboles dlimitent vos
changements et ceux des autres personnes. Supprimez ces symboles et gardez uniquement les changements ncessaires,
puis faites un nouveau commit pour enregistrer tout cela.

Envoyer vos commits


Vous pouvez envoyer vos commits sur le serveur qui sert de point de rencontre entre les dveloppeurs.

Si vous avez clon un dpt Git depuis GitHub comme je lai fait prcdemment, il y a de fortes chances pour que
lenvoi des commits dcrit ci-aprs ne fonctionne pas. Les dpts publics sont en effet en lecture seule et il faut
demander un dveloppeur officiel du projet de venir rcuprer les modifications chez vous (en faisant un pull sur
votre ordinateur), afin quil puisse vrifier votre travail avant de lintgrer au projet officiel.
Nous supposons ici que vous avez mis en place un serveur pour votre projet.
Avant denvoyer vos commits, je vous recommande fortement de consulter votre log local afin de savoir ce que vous vous
apprtez envoyer :
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

20/31

10/1/2015

GrezvoscodessourceavecGit
console

gitlogp

Vrifiez que tout est conforme et quil ny a pas derreur qui vous saute aux yeux. Il est encore temps de corriger ces
commits, mais une fois envoys, il sera trop tard !
Une fois que vous tes srs, passez lenvoi. Vous pouvez envoyer vos commits avec la commande
gitpush
:
console

gitpush

git push envoie vos nouvelles modifications (commits) sur le serveur.


Le changement vers le serveur doit tre de type fast-forward car le serveur ne peut rgler les conflits votre place sil y en a.
Personne ne doit avoir fait un push avant vous depuis votre dernier pull.
Le mieux est de sassurer que vous tes jour en faisant un pull avant de faire un push. Si le push choue, vous serez de
toute faon invits faire un pull.

Il est recommand de faire rgulirement des commits, mais pas des push. Vous ne devriez faire un push quune
fois de temps en temps (pas plus dune fois par jour en gnral). Evitez de faire systmatiquement un push aprs
chaque commit. Pourquoi ? Parce que vous perdriez la facilit avec laquelle il est possible dannuler ou modifier un
commit.

Un push est irrversible. Une fois que vos commits sont publis, il deviendra impossible de les supprimer ou de
modifier le message de commit ! Rflchissez donc deux fois avant de faire un push. Cest pour cela que je
recommande de ne faire un push quune fois par jour, afin de ne pas prendre lhabitude denvoyer dfinitivement
chacun de vos commits trop vite.

Annuler un commit publi


http://openclassrooms.com/courses/gerezvoscodessourceavecgit

21/31

10/1/2015

GrezvoscodessourceavecGit

Dans le cas malheureux o vous auriez quand mme envoy un commit erron sur le serveur, il reste possible de lannuler
en crant un nouveau commit qui effectue linverse des modifications (souvenez-vous quil nest pas possible de supprimer
un vieux commit envoy, on ne peut quen crer de nouveaux.). Les lignes que vous aviez ajoutes seront supprimes dans
ce commit, et inversement.
Jetez tout dabord un il votre
gitlog
:
console

commit227653fd243498495e4414218e0d4282eef3876e
Author:FabienPotencier<fabien.potencier@gmail.com>
Date:ThuJun308:47:462010+0200
[TwigBundle]addedthejavascripttokenparsersinthehelperextension
commit6261cc26693fa1697bcbbd671f18f4902bef07bc
Author:JeremyMikola<jmikola@gmail.com>
Date:WedJun217:32:0820100400
Fixedbadexamplesindoctrine:generate:entitieshelpoutput.

Supposons que vous vouliez annuler le commit 6261cc2 dans cet exemple. Il faut utiliser
gitrevert
qui va crer un commit inverse :
console

gitrevert6261cc2

Il faut prciser lID du commit revert . Je vous rappelle quil nest pas obligatoire dindiquer lID en entier (qui est un peu
long), il suffit de mettre les premiers chiffres tant quils sont uniques (les 4-5 premiers chiffres devraient suffire).
On vous invite entrer un message de commit. Un message par dfaut est indiqu dans lditeur.
Une fois que cest enregistr, le commit dannulation est cr. Il ne vous reste plus qu vrifier que tout est bon et le
publier (avec un
gitpush
).

Travailler avec des branches


Les branches font partie du cur mme de Git et constituent un de ses principaux atouts. Cest un moyen de travailler en

parallle sur dautres fonctionnalits. Cest comme si vous aviez quelque part une copie du code source du site qui vous
permet de tester vos ides les plus folles et de vrifier si elles fonctionnent avant de les intgrer au vritable code source de
votre projet.
Bien que les branches soient la base de Git, je nen ai pas parl avant pour rester simple. Pourtant, il faut absolument les
connatre et sen servir. La gestion pousse des branches de Git est la principale raison qui incite les projets passer Git,
donc il vaut mieux comprendre comment a fonctionne et en faire usage, sinon on passe vraiment ct de quelque chose.

Dans Git, toutes les modifications que vous faites au fil du temps sont par dfaut considres comme appartenant la
branche principale appele master :
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

22/31

10/1/2015

GrezvoscodessourceavecGit

On voit sur ce schma les commits qui sont effectus au fil du temps.
Supposons que vous ayez une ide pour amliorer la gestion des erreurs dans votre programme mais que vous ne soyez pas
srs quelle va fonctionner : vous voulez faire des tests, a va vous prendre du temps, donc vous ne voulez pas que votre
projet incorpore ces changements dans limmdiat.
Il suffit de crer une branche, que vous nommerez par exemple idee_gestion_erreurs , dans laquelle vous allez pouvoir
travailler en parallle :

un moment donn, nous avons dcid de crer une nouvelle branche. Nous avons pu y faire des commits, mais cela ne
nous a pas empch de continuer travailler sur la branche principale et dy faire des commits aussi.
la fin, mon ide sest rvle concluante, jai largement amlior la gestion des erreurs et jai donc intgr les
changements dans la branche principale master . Mon projet dispose maintenant de mon ide que javais dveloppe en
parallle. Tous les commits de ma branche se retrouvent fusionns dans la branche principale.
Git nest pas le seul outil capable de grer des branches, mais il est le seul le faire aussi bien. En effet, en temps normal
vous pourriez tout simplement copier le rpertoire de votre projet dans un autre dossier, tester les modifications et les
incorporer ensuite dans le vritable dossier de votre projet. Mais cela aura ncessit de copier tous les fichiers et de se
souvenir de tout ce que vous avez modifi. Et je ne vous parle mme pas du cas o quelquun aurait modifi le mme fichier
que vous en mme temps dans la branche principale !
Git gre tous ces problmes pour vous. Au lieu de crer une copie des fichiers, il cre juste une branche virtuelle dans
laquelle il retient vos changements en parallle. Lorsque vous dcidez de fusionner une branche (et donc de ramener vos
changements dans master pour les valider), Git vrifie si vos modifications nentrent pas en conflit avec des commits
effectus en parallle. Sil y a des conflits, il essaie de les rsoudre tout seul ou vous avertit sil a besoin de votre avis (cest le
cas si deux personnes ont modifi la mme ligne dun mme fichier par exemple).
Ce concept de branches trs lgres qui ne ncessitent pas de copier les fichiers est dune grande puissance. Cela vous
encourage crer des branches tout le temps, pour toutes les modifications qui pourraient prendre du temps avant dtre
termines.
Vous pouvez mme crer une sous-branche partir dune branche !

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

23/31

10/1/2015

GrezvoscodessourceavecGit

Dans le cas ci-dessus, ma sous-branche ne sest pas rvle concluante ; jai donc d la supprimer et aucun des commits
intermdiaires ne sera finalement incorpor la branche principale du projet.

Les branches locales


Tout le monde commence avec une seule branche master : cest la branche principale. Jusquici, vous avez donc travaill
dans la branche master , sur le vrai code source de votre projet.
Pour voir toutes vos branches, tapez ceci :
console

gitbranch

Vous verrez normalement uniquement master :


console

$gitbranch
*master

Il y a une toile devant pour indiquer que cest la branche sur laquelle vous tes actuellement.

Pourquoi crer une branche et quand dois-je en crer une ?


Lorsque vous vous apprtez faire des modifications sur le code source, posez-vous les questions suivantes :
Ma modification sera-t-elle rapide ? ;
Ma modification est-elle simple ? ;
Ma modification ncessite-t-elle un seul commit ? ;
Est-ce que je vois prcisment comment faire ma modification dun seul coup ? .
Si la rponse lune de ces questions est non , vous devriez probablement crer une branche. Crer une branche est trs
simple, trs rapide et trs efficace. Il ne faut donc pas sen priver.
Crez une branche pour toute modification que vous vous apprtez faire et qui risque dtre un peu longue.
Au pire, si votre modification est plus courte que prvu, vous aurez cr une branche pour pas grand-chose , mais cest
toujours mieux que de se rendre compte de linverse.

Crer une branche et changer de branche


Supposons que vous vouliez amliorer la page des options membres du code de votre site. Vous ntes pas srs du temps
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

24/31

10/1/2015

GrezvoscodessourceavecGit

que cela va prendre, ce nest pas un changement simple qui consiste modifier deux-trois liens et vous risquez de faire
plusieurs commits. Bref, il faut crer une branche pour cela.
console

gitbranchoptions_membres

Cela cre une branche appele options_membres . Il est important de noter que cette branche est locale : vous seuls y
avez accs (il est nanmoins possible de publier une branche pour que dautres personnes puissent vous aider, mais ce nest
pas le sujet pour le moment).
Une fois la branche cre, vous devriez la voir quand vous tapez simplement
gitbranch
:
console

$gitbranch
*master
options_membres

Comme vous pouvez le voir, vous tes toujours sur la branche master . Pour aller sur la branche options_membres ,
tapez ceci :
console

gitcheckoutoptions_membres

gitcheckout
est utilis pour changer de branche mais aussi pour restaurer un fichier tel quil tait lors du dernier commit. La
commande a donc un double usage.

Quest-ce qui se passe lorsque lon change de branche ? En fait, vous ne changez pas de dossier sur votre disque dur, mais
Git change vos fichiers pour quils refltent ltat de la branche dans laquelle vous vous rendez. Imaginez que les branches
dans Git sont comme des dossiers virtuels : vous sautez de lun lautre avec la commande
gitcheckout
. Vous restez dans le mme dossier, mais Git modifie les fichiers qui ont chang entre la branche o vous tiez et celle o
vous allez.
Faites maintenant des modifications sur les fichiers, puis un commit, puis dautres modifications, puis un commit, etc. Si
vous faites
gitlog
, vous verrez tous vos rcents commits.
Maintenant, supposons quun bug important ait t dtect sur votre site et que vous deviez le rgler immdiatement.
Revenez sur la branche master , branche principale du site :
console

gitcheckoutmaster

Faites vos modifications, un commit, ventuellement un push sil faut publier les changements de suite, etc.
Ensuite, revenez votre branche :
console

gitcheckoutoptions_membres

Si vous faites un
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

25/31

10/1/2015

GrezvoscodessourceavecGit

gitlog
, vous verrez que le commit que vous avez effectu sur la branche master napparat pas. Cest en cela que les branches
sont distinctes.

Fusionner les changements


Lorsque vous avez fini de travailler sur une branche et que celle-ci est concluante, il faut fusionner cette branche vers
master avec la commande
gitmerge
.

Avec Git, on peut fusionner nimporte quelle branche dans une autre branche, bien que le plus courant soit de
fusionner une branche de test dans master une fois que celle-ci est concluante.
Supposons que vous ayez fini votre travail dans la branche options_membres et que vous vouliez maintenant le publier.
Pour cela, il faut fusionner le contenu de la branche options_membres dans la branche principale master .
Rendez-vous dabord dans la branche master :
console

gitcheckoutmaster

Demandez ensuite y intgrer le travail que vous avez fait dans options_membres :
console

gitmergeoptions_membres

Tous vos commits de la branche options_membres se retrouvent maintenant dans master ! Vous avez pu travailler en
parallle sans gner la branche principale, et maintenant que votre travail est termin vous lavez appliqu sur master !

Lorsque vous rcuprez les nouveaux commits depuis le serveur avec


gitpull
, cela revient en fait appeler deux commandes diffrentes :
gitfetch
, qui soccupe du tlchargement des nouveaux commits, et
gitmerge
, qui fusionne les commits tlchargs issus de la branche du serveur dans la branche de votre ordinateur !
Votre branche options_membres ne servant plus rien, vous pouvez la supprimer :
console

gitbranchdoptions_membres

Git vrifie que votre travail dans la branche options_membres a bien t fusionn dans master . Sinon, il vous en
avertit et vous interdit de supprimer la branche (vous risqueriez sinon de perdre tout votre travail dans cette branche !).
Si vraiment vous voulez supprimer une branche mme si elle contient des changements que vous navez pas fusionns (par
exemple parce que votre ide la base tait une erreur), utilisez loption -D (lettre capitale) :
console

gitbranchDoptions_membres/!\Supprimelabrancheetperdtousleschangements.

Mettre de ct le travail en cours avant de changer de branche


http://openclassrooms.com/courses/gerezvoscodessourceavecgit

26/31

10/1/2015

GrezvoscodessourceavecGit

Cette section est un peu complexe. Je vous recommande de rserver sa lecture pour plus tard.
Avant de changer de branche, vous devez avoir effectu un commit de tous vos changements. En clair, un
gitstatus
ne devrait afficher aucun fichier en cours de modification.
Si vous avez des changements non commits et que vous changez de branche, les fichiers modifis resteront comme ils
taient dans la nouvelle branche (et ce nest en gnral pas ce que vous voulez !).
Pour viter davoir faire un commit au milieu dun travail en cours, tapez :
console

gitstash

Vos fichiers modifis seront sauvegards et mis de ct. Maintenant,


gitstatus
ne devrait plus afficher aucun fichier (on dit que votre working directory est propre).
Vous pouvez alors changer de branche, faire vos modifications, committer , puis revenir sur la branche o vous tiez.
console

gitcheckoutmaster
(modifierdesfichiers)
gitcommita
gitcheckoutmabranche

Pour rcuprer les changements que vous aviez mis de ct dans mabranche , tapez :
console

gitstashapply

Vos fichiers seront alors restaurs et se retrouveront donc ltat dans lequel ils taient avant le
gitstash
!

Les branches partages


Il est possible de travailler plusieurs sur une mme branche. En fait, cest dj ce que vous faisiez en travaillant sur la
branche master .
Utilisez
gitbranchr
pour lister toutes les branches que le serveur connat :
console

$gitbranchr
origin/HEAD
origin/master

origin, cest le nom du serveur depuis lequel vous avez clon le dpt (par exemple celui de GitHub). Vous pouvez en thorie
suivre directement les branches de plusieurs personnes (souvenez-vous, Git fonctionne un peu comme le peer-to-peer),
mais on travaille plutt avec un serveur pour suivre les changements.
Si on met de ct HEAD qui est un peu particulier, on voit quil y a une seule branche sur le serveur : master . Le serveur
ne connat donc que lhistorique de la branche principale.

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

27/31

10/1/2015

GrezvoscodessourceavecGit

Si le serveur possde une autre branche, par exemple origin/options_membres , et que vous souhaitez travailler dessus, il
faut crer une copie de cette branche sur votre ordinateur qui va suivre (on dit tracker) les changements sur le serveur.
console

gitbranchtrackbranchelocaleorigin/brancheserveur

Par exemple, vous pouvez crer une branche options_membres locale qui sera connecte la branche
options_membres du serveur :
console

gitbranchtrackoptions_membresorigin/options_membres

Lorsque vous ferez un pull depuis la branche options_membres , les changements seront fusionns dans votre
options_membres local. Il est donc important de savoir dans quelle branche vous vous trouvez avant de faire un pull. Un
pull depuis la branche master met jour votre branche master locale en fonction de ce qui a chang sur le serveur, et
il en va de mme pour nimporte quelle autre branche.

Ajouter ou supprimer une branche sur le serveur


Il est possible dajouter des branches sur le serveur pour y travailler plusieurs, mais il faut reconnatre que la syntaxe
propose par Git est tout sauf claire ce niveau.
Voici comment on ajoute une branche sur le serveur :
console

gitpushoriginorigin:refs/heads/nom_nouvelle_branche

Vous pouvez ensuite crer une branche locale qui suit la branche du serveur avec
gitbranchtrack
, comme nous lavons vu prcdemment.

Linverse est possible : crer une branche locale puis la copier sur le serveur. Pour ce faire, vous devez crer la
branche sur le serveur comme expliqu juste au-dessus, mais plutt que de tracker les modifications, modifiez le
fichier .git/config comme ceci :
copiez le bloc [branch "master"] ;
remplacez les occurrences de master par le nom de votre branche ;
enregistrez les modifications.
Faites ensuite un
gitpull
et un
gitpush
; normalement vos modifications devraient tre mises jour sur le serveur.
Pour supprimer une branche sur le serveur :
console

gitpushorigin:heads/nom_branche_a_supprimer

noter que les remote tracking branches (celles qui apparaissent lorsquon fait
gitbranchr
) ne seront pas automatiquement supprimes chez les autres clients. Il faut quils les suppriment manuellement laide de
la commande suivante :
console

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

28/31

10/1/2015

GrezvoscodessourceavecGit

gitbranchrdorigin/nom_branche_a_supprimer

Quelques autres fonctionnalits de Git, en vrac


Je vous ai prsent les principales fonctionnalits de Git, mais il est possible de faire bien d'autres choses avec cet outil.
Voici, en vrac, quelques-unes de ses autres possibilits utiles connatre.

Tagger une version


Il est possible de donner un alias un commit prcis pour le rfrencer sous ce nom. Cest utile par exemple pour dire tel
commit correspond la version 1.3 de mon projet . Cela permettra dautres personnes de reprer la version 1.3 plus
facilement. Cest justement le rle des tags.
Pour ajouter un tag sur un commit :
console

gittagNOMTAGIDCOMMIT

Donc dans le cas prsent, on crirait :


console

gittagv1.32f7c8b3428aca535fdc970feeb4c09efa33d809e

Un tag nest pas envoy lors dun push, il faut prciser loption --tags pour que ce soit le cas :
console

gitpushtags

Maintenant, tout le monde peut rfrencer ce commit par ce nom plutt que par son numro de rvision.
Pour supprimer un tag cr :
console

gittagdNOMTAG

Rechercher dans les fichiers source


Comme Git connat tous les fichiers source de votre projet, il est facile de faire une recherche lintrieur de tout votre
projet.
Par exemple, si vous voulez connatre les noms des fichiers qui contiennent le mot TODO dans le code source, il suffit
dcrire :
console

gitgrep"TODO"

Git accepte les expressions rgulires pour les recherches. Si vous connaissez les expressions rgulires, sachez
donc quil est possible de les utiliser.
Si vous voulez connatre les numros des lignes qui contiennent le mot que vous recherchez, utilisez le paramtre -n :
console

gitgrepn"TODO"

Demander Git dignorer des fichiers (.gitignore)


Pour ignorer un fichier dans git, crez un fichier .gitignore ( la racine) et indiquez-y le nom du fichier. Entrez un nom de
fichier par ligne, comme ceci :
http://openclassrooms.com/courses/gerezvoscodessourceavecgit

29/31

10/1/2015

GrezvoscodessourceavecGit

project.xml
dossier/temp.txt
*.tmp
cache/*

Aucun de ces fichiers napparatra dans


gitstatus
, mme sil est modifi. Il ne paratra donc pas dans les commits.
Utilisez cela sur les fichiers temporaires par exemple, qui nont aucune raison dapparatre dans Git.
Il est possible dutiliser une toile (*) comme joker. Dans lexemple prcdent, tous les fichiers ayant lextension .tmp
seront ignors, de mme que tous les fichiers du dossier cache.
Git est un outil trs complet qui peut parfois se rvler complexe. Comme tout bon outil UNIX, il fait ce quon lui demande
sans confirmation, ce qui peut tre dangereux entre les mains dun dbutant. Commencez donc lutiliser doucement et
apprenez petit petit dcouvrir ses autres fonctionnalits : vous allez tre surpris !
Cest un outil rellement puissant que je recommande aux dveloppeurs, particulirement ceux qui travaillent sous Linux.
Ce nest pas le seul qui existe (je pense Mercurial et Bazaar que vous pouvez galement essayer et qui sont trs bien) mais
il a son lot davantages, tels que sa rapidit et sa gestion puissante des branches.
Je vous recommande dessayer de prfrence un logiciel de gestion de versions rcent (comme Git, Mercurial ou Bazaar) et
dviter si vous le pouvez SVN, qui commence se faire vieux. Si vous utilisez dj SVN pour votre projet, sachez quil est
possible de migrer facilement Git avec loutil gitsvn. Il sert aussi faire le pont entre un serveur SVN et Git, ce qui vous
permet dutiliser Git de votre ct mme si votre projet utilise officiellement SVN !

Si vous voulez en savoir plus, vous pouvez consulter les vidos de ce cours sur Git et GitHub sur OpenClassrooms.
Je vous recommande galement le cours Pro Git (en anglais), qui couvre plus en dtail le fonctionnement de Git.
Bonne lecture !

Thmatiques du cours : IDE Programmation

L'auteur
Mathieu Nebra
Entrepreneur plein temps, auteur plein temps et co-fondateur
d'OpenClassrooms :o)

Dcouvrez aussi ce cours en...

PDF

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

30/31

10/1/2015

GrezvoscodessourceavecGit

En ce moment sur OpenClassrooms

1 815 visiteurs en ligne 3 visiteurs sur cette page 8 039 752 messages sur le forum

Restez connect OpenClassrooms


OK

E-mail

Facebook

Twitter

Conditions Gnrales d'Utilisation

Youtube

Roadmap

Google

Nous recrutons

http://openclassrooms.com/courses/gerezvoscodessourceavecgit

Instagram

Qui sommes-nous ?

Publicit

Blog

Nous contacter

31/31