summaryrefslogtreecommitdiffhomepage
path: root/fr-fr/git-fr.html.markdown
blob: 510459fe5fdc1cf8d7deecfa26b6c4967d9875c0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
---
category: tool
tool: git
contributors:
    - ["Jake Prather", "http://github.com/JakeHP"]
    - ["Leo Rudberg" , "http://github.com/LOZORD"]
    - ["Betsy Lorton" , "http://github.com/schbetsy"]
    - ["Bruno Volcov", "http://github.com/volcov"]
translators:
    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
filename: LearnGit-fr.txt
lang: fr-fr
---

Git est un logiciel de contrôle de versions distribué et un système de gestion
du code source.

Il effectue sa tâche via des séries d'instantanés (snapshots) du projet, et
travaille avec ces instantanés afin de fournir les fonctionnalités de gestion
de version et de code source.

## Concepts du versionnage

### Qu'est ce que le contrôle de version ?

Le contrôle de version est un système qui enregistre les changements faits sur
un ou plusieurs fichiers au fil du temps.

### Versionnage centralisé VS Versionnage distribué

* Le contrôle de version centralisé se concentre sur la synchronisation, le
suivi et la sauvegarde des fichiers.
* Le contrôle de version distribué se focalise sur l'échange des changements.
Chaque changement a un identifiant unique.
* Les systèmes distribués n'ont pas de structure définie. Vous pouvez aisément
avoir un système centralisé de type SVN, avec Git.

[Informations additionnelles](http://git-scm.com/book/fr/v1/D%C3%A9marrage-rapide-%C3%80-propos-de-la-gestion-de-version)

### Pourquoi utiliser Git ?

* Fonctionne hors ligne.
* Travailler avec les autres devient facile !
* Ramifier le travail (créer des branches différentes) est facile !
* Fusionner le travail est facile !
* Git est rapide.
* Git est flexible.

## Architecture Git


### Dépôt ("repository")

Un ensemble de fichiers, dossiers, historiques de modifications, commits
(validations de changements) et de heads (état courant, "tête").
Représentez-vous ceci comme une structure de données de code source, avec la
particularité que chaque "élement" vous donne, entre autres, accès à son
historique des révisions.

Un dépôt Git comprend un répertoire .git et "l'arbre de travail" (working tree).

### Répertoire .git (composant du dépôt)

Le répertoire .git contient toutes les configurations, logs (journaux),
branches, HEAD et plus.
[Liste détaillée (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)

### Arbre de travail (composant du dépôt)

Il s'agit de l'ensemble des répertoires et fichiers de votre dépôt. Il est
souvent qualifié de répertoire de travail ("working directory").

### Index (composant du répertoire .git)

L'index est la zone de transit ("staging area") dans Git. Il s'agit d'une couche
séparant votre arbre de travail de votre dépôt Git. Ceci donne aux développeurs
plus de pouvoir sur ce qu'ils envoient au dépôt.

### Commit

Un "commit" (validation de changements) est un instantané d'un ensemble de
modifications de votre arbre de travail. Par exemple, si vous avez rajouté 5
fichiers et enlevé 2 autres, ces changements seront contenus dans un commit
(ou "snapshot", instantané). Ce commit peut ensuite être poussé ("pushed") dans
d'autres dépôts, ou non !

### Branches

Une branche consiste essentiellement en un pointeur vers le dernier commit que
vous avez fait. Au fur et à mesure de vos commits, ce pointeur se mettra
automatiquement à jour pour pointer vers le dernier commit.

### Etiquette ("tag")

Une étiquette est une marque sur un point spécifique de l'historique.
Typiquement, on utilise cette fonctionnalité pour marquer les états de
publication (v1.0, et ainsi de suite).

### HEAD and head (composant du répertoire .git)

HEAD est un pointeur pointant vers la branche courante. Un dépôt ne peut avoir
qu'un seul HEAD *actif*.
head est un pointeur pouvant pointer sur n'importe quel commit. Un dépôt peut
avoir un nombre illimité de heads.

### Les états dans Git
* Modifié - Des changements on été faits à un fichier mais ce dernier n'a pas
encore été rajouté à l'ensemble des fichiers Git
* Indexé ("staged") - Indique qu'un fichier modifié ira dans le prochain commit
* Validé ("committed") - Les fichiers ont été validés dans l'ensemble de
fichiers

### Ressources conceptuelles

* [Git pour les informaticiens (EN)](http://eagain.net/articles/git-for-computer-scientists/)
* [Git pour les designers (EN)](http://hoth.entp.com/output/git_for_designers.html)


## Commandes


### init

Créé un dépôt Git vide. Les paramètres du dépôt Git, les informations stockées
et plus sont dans un répertoire (un dossier) nommé ".git".

```bash
$ git init
```

### config

Configuration des paramètres. Que ce soit pour le dépôt, le système lui-même,
ou la configuration globale (le fichier de configuration globale
est `~/.gitconfig`).


```bash
# Lit et assigne quelques variables (globales) de configuration de base
$ git config --global user.email "monEmail@foo.com"
$ git config --global user.name "Mon nom"
```

[Apprenez-en plus à propos de git config.](https://git-scm.com/book/fr/v1/Personnalisation-de-Git-Configuration-de-Git)

### help

Vous donne un accès rapide à un guide extrêmement détaillé de chaque commande.
Ou juste vous donner un rappel rapide de la sémantique.

```bash
# Vérifie rapidement les commandes disponibles
$ git help

# Vérifie toutes les commandes disponibles
$ git help -a

# Aide pour une commande spécifique - manuel utilisateur
# git help <command_here>
$ git help add
$ git help commit
$ git help init
# ou git <command_here> --help
$ git add --help
$ git commit --help
$ git init --help
```

### ignorer des fichiers

Ne plus suivre certains fichiers et dossiers de Git.
Habituellement fait pour les fichiers privés et temporaires qui seraient,
autrement, partagés dans le dépôt.
```bash
$ echo "temp/" >> .gitignore
$ echo "cle_privee" >> .gitignore
```

### status

Montre les différences entre le fichier indexé (typiquement votre copie/dépôt
de travail) et le HEAD actuel.


```bash
# Affiche la branche, les fichiers non suivis, les changements et autres
différences
$ git status

# Pour en apprendre plus sur git status
$ git help status
```

### add

Rajoute des fichiers à la zone d'index. Si vous ne faites pas `git add` sur les
nouveaux fichiers, ils ne seront pas inclus dans les commits !

```bash
# rajoute un fichier dans votre répertoire de travail actuel
$ git add HelloWorld.java

# rajoute un fichier dans un répertoire imbriqué
$ git add /path/to/file/HelloWorld.c

# Gestion des expressions régulières !
$ git add ./*.java
```

On ne fait que rajouter des fichiers dans la zone d'index, on ne valide pas
les changements au répertoire/dépôt de travail.

### branch

Gère vos branches. Vous pouvez voir, éditer, créer et supprimer des branches en
utilisant cette commande.

```bash
# Liste les branches existantes et distantes
$ git branch -a

# Créé une nouvelle branche
$ git branch maNouvelleBranche

# Supprime une branche
$ git branch -d maBranche

# Renomme une branche
# git branch -m <anciennom> <nouveaunom>
$ git branch -m nomDeMaBranche nouveauNomDeMaBranche

# Edite la description d'une branche
$ git branch nomDeMaBranche --edit-description
```

### tag

Gère vos étiquettes

```bash
# Liste les étiquettes
$ git tag

# Créé une étiquette annotée
# L'option -m spécifie un message qui sera stockée dans l'étiquette.
# Si vous ne spécifiez pas de message pour une étiquette annotée,
# Git lance votre éditeur pour que vous puissiez le saisir.
$ git tag -a v2.0 -m 'ma version 2.0'

# Affiche des informations à propos de l'étiquette
# comprenant des informations sur l'auteur, la date du commit correspondant,
# et le message d'annotation avant d'afficher les informations du commit.
$ git show v2.0

# Pousse une seule étiquette dans le dépôt distant
$ git push origin v2.0

# Pousse beaucoup d'étiquettes dans le dépôt distant
$ git push origin --tags
```

### checkout

Met à jour tous les fichiers dans l'arbre de travail afin de correspondre à la
version de la zone d'index ou de l'arbre spécifié.

```bash
# Obtenir une copie de travail du dépôt - par défaut on prend la branche master
$ git checkout

# Bascule vers une branche spéficiée
$ git checkout nomDeLaBranche

# Créé une nouvelle branche et bascule sur celle-ci
# Revient à faire "git branch <name>; git checkout <name>"
$ git checkout -b nouvelleBranche
```

### clone

Clone (ou copie) un dépôt existant dans un nouveau répertoire. Rajoute
également les branches distantes pour chaque branche du dépôt clôné, ce qui
vous permet de pousser vers une branche distante.

```bash
# Clone learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git

# Clone superficiel ("shallow clone") - clone plus rapide qui récupère
seulement le dernier instantané ("snapshot")
$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git

# Clone seulement une branche spécifique
$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
```

### commit

Conserve le contenu actuel de la zone d'index dans un nouveau "commit." Ce
commit contient les changements faits, accompagnés d'un message écrit par son
auteur.

```bash
# Commit avec un message
$ git commit -m "Ajout de la fonction multiplierNombres() dans HelloWorld.c"

# Rajoute automatiquement dans l'index les fichiers modifiés ou supprimés,
# à l'exception des nouveaux fichiers, puis commit
$ git commit -a -m "Modification de foo.php et suppression de bar.php"

# Change le dernier commit (ceci supprime le commit précédent avec un
# nouveau commit)
$ git commit --amend -m "Message corrigé"
```

### diff

Montre les différences entre un fichier dans le répertoire de travail, la zone
d'index and les commits.

```bash
# Affiche les différences entre votre répertoire de travail et l'index
$ git diff

# Affiche les différences entre l'index et le plus récent commit.
$ git diff --cached

# Affiche les différences entre votre répertoire de travail et le plus récent
# commit
$ git diff HEAD
```

### grep

Permet de faire une recherche rapide dans le dépôt.

Configurations optionnelles :

```bash
# Merci à Travis Jeffery pour ce qui suit
# Affiche les numéros des lignes dans les résultats de la recherche grep
$ git config --global grep.lineNumber true

# Rend les résultats de recherche plus lisibles, en incluant les groupements
$ git config --global alias.g "grep --break --heading --line-number"
```

```bash
# Recherche de "nomDeVariable" dans tous les fichiers java
$ git grep 'nomDeVariable' -- '*.java'

# Recherche une ligne contenant "nomDeTableau", et "rajouter" ou "enlever"
$ git grep -e 'nomDeTableau' --and \( -e rajouter -e enlever \)
```

Google est votre ami; pour plus d'exemples :
[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)

### log

Affiche les commits d'un dépôt.

```bash
# Montre tous les commits
$ git log

# Montre seulement les messages de commits et leur référence
$ git log --oneline

# Montre seulement les commits commits des merges (fusions)
$ git log --merges
```

### merge

Fusionne les changements provenant de commits externes dans la branche
courante.

```bash
# Fusionne la branche spécifiée dans la branche courante.
$ git merge nomDeBranche

# Génère toujours un commit quand on fusionne
$ git merge --no-ff branchName
```

### mv

Renomme ou déplace un fichier

```bash
# Renomme un fichier
$ git mv HelloWorld.c HelloNewWorld.c

# Déplace un fichier
$ git mv HelloWorld.c ./new/path/HelloWorld.c

# Force le renommage ou le déplacement
# Si "fichierExistant" existe déjà dans le répertoire, il sera écrasé
$ git mv -f monFichier fichierExistant
```

### pull

Récupère la version d'un dépôt et la fusionne avec une autre branche.

```bash
# Met à jour votre dépôt local en y intégrant les changements
# depuis la branche "master" du dépôt distant "origin".
# git pull <remote> <branch>
$ git pull origin master

# Par défaut, git pull mettra à jour votre branche actuelle
# en y intégrant les nouveaux changements venant de sa branche distante suivie
$ git pull

# Intègre les changements de la branche distante et "rebase"
# les commits de la branche dans votre dépôt local, comme ceci:
#"git pull <remote> <branch>, git rebase <branch>"
$ git pull origin master --rebase
```

### push

Pousse et fusionne les changements d'une dépôt local vers une branche distante.

```bash
# Pousse et fusionne les changements d'un dépôt local vers la branche
# appelée "master" du dépôt distant "master".
# git push <remote> <branch>
$ git push origin master

# Par défaut, git push poussera et fusionnera les changements de la branche
# courante vers sa branche distante suivie.
$ git push

# Pour faire le lien entre la branche locale courante et sa branche distante,
# rajouter l'option -u :
$ git push -u origin master
# Dorénavant, à chaque fois que vous voulez pousser depuis cette même branche
# locale, utilisez ce raccourci :
$ git push
```

### stash

Sauvegarde ("stash") l'état actuel de votre espace de travail et le garde dans
pile de changements non finis que vous pouvez réappliquer n'importe quand.

Supposons que vous avez effectué du travail dans votre dépôt git, mais que vous
voulez récupérer la version de la branche distante. Depuis que vous avez des
changements "malpropres" (non commités) à quelques fichiers, vous ne pouvez pas
faire de `git pull`. A la place, vous pouvez utiliser `git stash` afin de
sauvegarder votre travail dans la pile !

```bash
$ git stash
Saved working directory and index state \
  "WIP on master: 049d078 added the index file"
  HEAD is now at 049d078 added the index file
  (To restore them type "git stash apply")
```

Vous pouvez maintenant pull !

```bash
git pull
```
`...changes apply...`

Vérifiez maintenant que tout est OK

```bash
$ git status
# On branch master
nothing to commit, working directory clean
```

Vous pouvez constater quels "morceaux" vous avez stash jusque là en
utilisant `git stash list`.
Puisque les changements sont gardés dans une pile Last-In-First-Out, notre
changement le plus récent sera en premier.

```bash
$ git stash list
stash@{0}: WIP on master: 049d078 rajout du fichier index
stash@{1}: WIP on master: c264051 annulation de "rajout de la taille_fichier"
stash@{2}: WIP on master: 21d80a5 ajout des chiffres aux logs
```

Appliquons maintenant les changements en les enlevant de notre pile.

```bash
$ git stash pop
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#
#      modified:   index.html
#      modified:   lib/simplegit.rb
#
```

`git stash apply` effectue le même travail

Vous êtes maintenant prêt à retourner sur vos tâches de travail !

[Lecture additionelle.](https://git-scm.com/book/fr/v1/Utilitaires-Git-Le-remisage)

### rebase (attention)

Prend tous les changements qui ont été commités sur une branche, et les
ré-applique sur une autre branche.
*Ne rebasez pas les commits que vous avez poussés sur un dépôt publique*.

```bash
# Expérimentation d'un rebase dans la branche "master"
# git rebase <basebranch> <topicbranch>
$ git rebase master brancheExperience
```

[Lecture additionelle.](https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Rebaser)

### reset (attention)

Réinitialise le pointeur HEAD courant à l'état spécifié. Ceci vous permet
d'annuler des fusions, des pulls, commits, ajouts et autres. C'est une commande
puissante mais également dangereuse si vous ne savez pas ce que vous faites.

```bash
# Réinitialise la zone d'index afin de correspondre au dernier commit (laisse
# le répertoire inchangé).
$ git reset

# Réinitialise la zone d'index afin de correspondre au dernier commit et
# réécrit le répertoire de travail.
$ git reset --hard

# Déplace le pointeur de la branche courante au commit spécifié (laisse
# le répertoire inchangé). Tous les changements existents toujours dans
# le répertoire.
$ git reset 31f2bb1

# Déplace le pointeur de la branche courante en arrière, au commit spécifié
# et fait correspondre le répertoire de travail (supprime les changements
# non commités et tous les commits après le commit spécifié).
$ git reset --hard 31f2bb1
```

### rm

Le contraire de git add, git rm supprime les fichiers de l'arbre de travail
courant.

```bash
# Supprime HelloWorld.c
$ git rm HelloWorld.c

# Enlève un fichier d'un répertoire imbriqué.
$ git rm /chemin/vers/le/fichier/HelloWorld.c
```

## Informations complémentaires

* [tryGit - A fun interactive way to learn Git (EN)](http://try.github.io/levels/1/challenges/1)

* [Udemy Git Tutorial: A Comprehensive Guide (EN)](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)

* [git-scm - Tutoriaux vidéos](http://git-scm.com/videos)

* [git-scm - Documentation](http://git-scm.com/docs)

* [Atlassian Git - Tutoriaux et Workflows](https://www.atlassian.com/git/)

* [SalesForce Cheat Sheet (EN)](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)

* [GitGuys (EN)](http://www.gitguys.com/)

* [Git - the simple guide (EN)](http://rogerdudler.github.io/git-guide/index.html)

* [Livre Pro Git](http://www.git-scm.com/book/fr/v1)

* [Une introduction à Git et GitHub pour les débutants (tutoriel) (EN)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)