mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-05 06:04:35 +03:00
584 lines
17 KiB
Markdown
584 lines
17 KiB
Markdown
---
|
|
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)
|