git documentation - en to fr translation catalogue (389 entries)

note: type: Plain text
en: Verifies the connectivity and validity of the objects in the database.
fr: Vérifie la connectivité et la validité des objets en base de données.

note: type: Plain text
en: Manage set of tracked repositories.
fr: Gerer un ensemble de dépôts suivis.

note: type: Plain text
en: Import from and submit to Perforce repositories.
fr: Importer depuis et soumettre vers des dépôts Perforce.

note: type: Plain text
en: Add file contents to the index.
fr: Ajouter le contenu de fichiers à l'index.

note: type: Plain text
en: Remove untracked files from the working tree.
fr: Supprimer des fichiers non-suivis depuis un arbre de travail.

note: type: Plain text
en: Record changes to the repository.
fr: Enregistrer les modifications dans le dépôt.

note: type: Plain text
en: Download objects and refs from another repository.
fr: Télécharger les objets et références depuis un autre dépôt.

note: type: Plain text
en: Remove files from the working tree and from the index.
fr: Supprimer des fichiers d'un arbre de travail ou de l'index.

note: type: Plain text
en: Compares files in the working tree and the index.
fr: Comparer des fichiers dans l'arbre de travail et l'index.

note: type: Plain text
en: Compare a tree to the working tree or index.
fr: Comparer un arbre à l'arbre de travail ou l'index.

note: type: Plain text
en: Apply a patch to files and/or to the index.
fr: Appliquer une rustine à des fichiers et/ou à l'index.

note: type: Plain text
en: Copy files from the index to the working tree.
fr: Copier des fichiers depuis l'index dans l'arbre de travail.

note: type: Plain text
en: Reads tree information into the index.
fr: Lire l'information d'arbre dans l'index.

note: type: Plain text
en: Register file contents in the working tree to the index.
fr: Enregistrer le contenu de fichiers de l'arbre de travail dans l'index.

note: type: Plain text
en: Download from a remote Git repository via HTTP.
fr: Télécharger depuis une dépôt Git distant via HTTP.

note: type: Plain text
en: Push objects over HTTP/DAV to another repository.
fr: Pousser des objets par HTTP/DAV vers un autre dépôt.

note: type: Plain text
en: Receive what is pushed into the repository.
fr: Recevoir ce qui est poussé dans un dépôt.

note: type: Plain text
en: Receive missing objects from another repository.
fr: Recevoir des objets manquants depuis un autre dépôt.

note: type: Plain text
en: Push objects over Git protocol to another repository.
fr: Pousser des objets sur le protocole Git sur un autre dépôt.

note: type: Title -
en: CONFIGURATION FILE
fr: FICHIER DE CONFIGURATION

note: type: Plain text
en: Tells Git if the executable bit of files in the working tree is to be honored.
fr: Indique à Git si le bit exécutable de fichiers dans l'arbre de travail doit être honoré.

note: type: Plain text
en: non-matching text in context lines (when using `-A`, `-B`, or `-C`)
fr: texte sans correspondance dans les lignes de contexte (avec l'utilisation de `-A`, `-B` ou `-C`)

note: type: Plain text
en: matching text in context lines
fr: texte correspondant dans les lignes de contexte

note: type: Plain text
en: matching text in selected lines
fr: texte correspondant dans les lignes sélectionnnées

note: type: Plain text
en: non-matching text in selected lines
fr: texte sans correspondance dans les lignes sélectionnées

note: type: Labeled list
en: color.interactive.<slot>
fr: color.interactive.<créneau>

note: type: Labeled list
en: color.status.<slot>
fr: color.status.<créneau>

note: type: Plain text
en: A boolean to enable/disable inclusion of status information in the commit message template when using an editor to prepare the commit message.  Defaults to true.
fr: Un booléen pour activer/désactiver l'inclusion de l'information de statut dans le modèle de message de validation lors de l'utilisation d'un éditeur pour préparer le message de validation. true par défaut.

note: type: Labeled list
en: difftool.<tool>.path
fr: difftool.<outil>.path

note: type: Labeled list
en: difftool.<tool>.cmd
fr: difftool.<outil>.cmd

note: type: Plain text
en: The default pretty format for log/show/whatchanged command, See linkgit:git-log[1], linkgit:git-show[1], linkgit:git-whatchanged[1].
fr: Le format automatique par défaut de la commande log/show/whatchanged, voir linkgit:git-log[1], linkgit:git-show[1], linkgit:git-whatchanged[1].

note: type: Plain text
en: If true, makes linkgit:git-log[1], linkgit:git-show[1], and linkgit:git-whatchanged[1] assume `--abbrev-commit`. You may override this option with `--no-abbrev-commit`.
fr: Si true, oblige linkgit:git-log[1], linkgit:git-show[1] et linkgit:git-whatchanged[1] à supposer `--abbrev-commit`. Vous pouvez surcharger cette option avec `--no-abbrev-commit`.

note: type: Plain text
en: If true, makes linkgit:git-log[1], linkgit:git-show[1], and linkgit:git-whatchanged[1] assume `--use-mailmap`.
fr: Si true, oblige linkgit:git-log[1], linkgit:git-show[1] et linkgit:git-whatchanged[1] à supposer `--use-mailmap`.

note: type: Labeled list
en: mergetool.<tool>.path
fr: mergetool.<outil>.path

note: type: Labeled list
en: mergetool.<tool>.cmd
fr: mergetool.<outil>.cmd

note: type: Plain text
en: The default set of "refspec" for linkgit:git-fetch[1]. See linkgit:git-fetch[1].
fr: L'ensemble par défaut de "refspec" pour linkgit:git-fetch[1]. Voir linkgit:git-fetch[1].

note: type: Labeled list
en: remote.<name>.push
fr: remote.<nom>.push

note: type: Plain text
en: The default set of "refspec" for linkgit:git-push[1]. See linkgit:git-push[1].
fr: L'ensemble par défaut de "refspec" pour linkgit:git-push[1]. Voir linkgit:git-push[1].

note: type: Labeled list
en: sendemail.<identity>.*
fr: sendemail.<identité>.*

note: type: Plain text
en: See linkgit:git-send-email[1] for description.
fr: Voir linkgit:git-send-email[1] pour une description.

note: type: Plain text
en: The default set of branches for linkgit:git-show-branch[1].  See linkgit:git-show-branch[1].
fr: L'ensemble par défaut de branches pour linkgit:git-show-branch[1].  Voir linkgit:git-show-branch[1].

note: type: Plain text
en: `no` - Show no untracked files.
fr: 'no' - Ne montrer aucun fichier non-suivi.

note: type: Plain text
en: `normal` - Show untracked files and directories.
fr: 'normal' - Montrer les fichiers et les dossiers non-suivis.

note: type: Labeled list
en: submodule.<name>.url
fr: submodule.<nom>.url

note: type: Labeled list
en: submodule.<name>.update
fr: submodule.<nom>.update

note: type: Labeled list
en: submodule.<name>.branch
fr: submodule.<nom>.branch

note: type: Labeled list
en: submodule.<name>.ignore
fr: submodule.<nom>.ignore

note: type: Title -
en: DATE FORMATS
fr: FORMATS DE DATE

note: type: Plain text
en: The `GIT_AUTHOR_DATE`, `GIT_COMMITTER_DATE` environment variables
fr: Les variables d'environnement `GIT_AUTHOR_DATE`, `GIT_COMMITTER_DATE`

note: type: Plain text
en: and the `--date` option
fr: et l'option `--date`

note: type: Plain text
en: support the following date formats:
fr: prend en charge les formats de date suivants :

note: type: Labeled list
en: Git internal format
fr: Format interne de Git

note: type: Plain text
en: It is `<unix timestamp> <time zone offset>`, where `<unix timestamp>` is the number of seconds since the UNIX epoch.  `<time zone offset>` is a positive or negative offset from UTC.  For example CET (which is 1 hour ahead of UTC) is `+0100`.
fr: Il est de la forme `<horodatage unix> <décalage de fuseau horaire>`, où `<horodatage unix>` est un nombre de secondes depuis l'époque UNIX. `<décalage de fuseau horaire>` est un décalage positif ou négative par rapport à UTC. Par exemple, CET (qui est en avance d'une heure sur UTC) est `+0100`.

note: type: Plain text
en: The standard email format as described by RFC 2822, for example `Thu, 07 Apr 2005 22:13:13 +0200`.
fr: Le standard de format des courriel tel que décrit par la RFC 2822, par exemple `Thu, 07 Apr 2005 22:13:13 +0200`.

note: type: Plain text
en: Time and date specified by the ISO 8601 standard, for example `2005-04-07T22:13:13`. The parser accepts a space instead of the `T` character as well.
fr: Les heures et les dates sont spécifiées par le standard ISO 8601, par exemple `2005-04-07T22:13:13`. L'analyseur accepte aussi un espace au lieu du caractère `T`.

note: type: Plain text
en: In addition, the date part is accepted in the following formats: `YYYY.MM.DD`, `MM/DD/YYYY` and `DD.MM.YYYY`.
fr: De plus, la partie date est acceptée dans les formats suivants : `AAAA.MM.JJ`, `MM/JJ/AAAA` et `JJ.MM.AAAA`.

note: type: Labeled list
en: git-diff-index <tree-ish>
fr: git-diff-index <arbre-esque>

note: type: Plain text
en: compares the <tree-ish> and the files on the filesystem.
fr: compare l'<arbre-esque> et les fichiers du système de fichiers.

note: type: Labeled list
en: git-diff-index --cached <tree-ish>
fr: git-diff-index --cached <arbre-esque>

note: type: Plain text
en: compares the <tree-ish> and the index.
fr: compare l'<arbre-esque> et l'index.

note: type: Plain text
en: That is, from the left to the right:
fr: C'est-à-dire, de gauche à droite :

note: type: Plain text
en: M: modification of the contents or mode of a file
fr: M : modification de contenu ou du mode d'un fichier

note: type: Title -
en: other diff formats
fr: autres formats de diff

note: type: Plain text
en: Pathnames with "unusual" characters are quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).
fr: Les noms de chemin avec des caractères « inhabituels » sont cités comme expliqué pour la variable de configuration `core.quotePath` (voir linkgit:git-config[1]).

note: type: Title -
en: combined diff format
fr: format de diff combiné

note: type: Plain text
en: Be verbose.
fr: Mode bavard.

note: type: Plain text
en: git-add - Add file contents to the index
fr: git-add - Ajoute le contenu de fichiers à l'index

note: type: Plain text
en: 'git add' [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p]
    	  [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]]
    	  [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing]
    	  [--chmod=(+|-)x] [--] [<pathspec>...]
fr: 'git add' [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p]
    	  [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]]
    	  [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing]
    	  [--chmod=(+|-)x] [--] [<spécificateur de chemin>...]

note: type: Plain text
en: This command updates the index using the current content found in the working tree, to prepare the content staged for the next commit.  It typically adds the current content of existing paths as a whole, but with some options it can also be used to add content with only part of the changes made to the working tree files applied, or remove paths that do not exist in the working tree anymore.
fr: Cette commande met à jour l'index en utilisant le contenu actuel trouvé dans l'arbre de travail, pour préparer le contenu de la prochaine validation. Typiquement, elle ajoute intégralement le contenu actuel des chemins existant, mais peut aussi n'ajouter que certaines parties des modifications au moyen d'options ou soustraire certains chemins qui n'existent plus dans l'arbre de travail.

note: type: Plain text
en: The "index" holds a snapshot of the content of the working tree, and it is this snapshot that is taken as the contents of the next commit.  Thus after making any changes to the working tree, and before running the commit command, you must use the `add` command to add any new or modified files to the index.
fr: L'« index » contient un instantané du contenu de la copie de travail et c'est cet instantané qui sera utilisé comme contenu du prochain commit.  Ainsi, après avoir réalisé des modifications dans la copie de travail, et avant de lancer la commande commit, vous devez utiliser la commande `add` pour ajouter tout fichier nouveau ou modifié à l'index.

note: type: Plain text
en: This command can be performed multiple times before a commit.  It only adds the content of the specified file(s) at the time the add command is run; if you want subsequent changes included in the next commit, then you must run `git add` again to add the new content to the index.
fr: Cette commande peut être effectuée plusieurs fois avant la validation.  Elle n'ajoute que le contenu des fichiers spécifiés au moment où la commande `add` est lancée ; si vous souhaitez inclure des modifications postérieures à un `add` dans la prochaine validation, vous devez alors lancer `git add` à nouveau pour ajouter le nouveau contenu à l'index.

note: type: Plain text
en: The `git status` command can be used to obtain a summary of which files have changes that are staged for the next commit.
fr: La commande `git status` permet d'obtenir un résumé des fichiers modifiés qui sont préparés pour la prochaine validation.

note: type: Plain text
en: The `git add` command will not add ignored files by default.  If any ignored files were explicitly specified on the command line, `git add` will fail with a list of ignored files.  Ignored files reached by directory recursion or filename globbing performed by Git (quote your globs before the shell) will be silently ignored.  The 'git add' command can be used to add ignored files with the `-f` (force) option.
fr: Par défaut, la commande `git add` n'ajoute pas les fichiers ignorés.  Si des fichiers ignorés sont spécifiés explicitement en ligne de commande, `git add` échouera avec la liste des fichiers ignorés. Les fichiers ignorés atteint via la récursion de répertoires ou les patrons de fichiers gérés par Git (les patrons doivent alors être échappés du shell par des quotes)  seront ignorés silencieusement. La commande `git add` peut tout de même ajouter des fichiers ignorés avec l'option `-f` (force).

note: type: Plain text
en: Please see linkgit:git-commit[1] for alternative ways to add content to a commit.
fr: Référez-vous linkgit:git-commit[1] pour des méthodes alternatives d'ajout de contenu à une validation.

note: type: Labeled list
en: <pathspec>...
fr: <spécificateur de chemin>...

note: type: Plain text
en: Files to add content from.  Fileglobs (e.g. `*.c`) can be given to add all matching files.  Also a leading directory name (e.g. `dir` to add `dir/file1` and `dir/file2`) can be given to update the index to match the current state of the directory as a whole (e.g.  specifying `dir` will record not just a file `dir/file1` modified in the working tree, a file `dir/file2` added to the working tree, but also a file `dir/file3` removed from the working tree). Note that older versions of Git used to ignore removed files; use `--no-all` option if you want to add modified or new files but ignore removed ones.
fr: Fichiers dont le contenu doit être ajouté. Les patrons (ex : `*.c`) permettent de restreindre à tous les fichiers correspondant. Un nom de répertoire (ex : `rep` pour ajouter `rep/fichier1` et `rep/fichier2`) permet d'ajouter récursivement tous les fichiers d'un répertoire (par exemple spécifier `rep` n'enregistrera pas seulement le fichier modifié dans l'arbre de travail `rep/fichier1` ou un fichier ajouté `rep/fichier2`, mais aussi un fichier `rep/fichier3` supprimé de l'arbre de travail). Veuillez noter que des version anciennes de Git ignoraient les fichiers supprimés ; utilisez l'option `--no-all` si vous souhaitez ajouter les fichiers nouveaux ou modifiés mais ignorer les fichiers supprimés.

note: type: Plain text
en: Don't actually add the file(s), just show if they exist and/or will be ignored.
fr: Ne pas ajouter réellement les fichiers. Montrer juste ceux qui existent ou seront ignorés.

note: type: Plain text
en: Allow adding otherwise ignored files.
fr: Permettre l'ajout de fichiers qui sont normalement ignorés.

note: type: Plain text
en: Add modified contents in the working tree interactively to the index. Optional path arguments may be supplied to limit operation to a subset of the working tree. See ``Interactive mode'' for details.
fr: Ajouter le contenu modifié dans l'arbre de travail à l'index. Les arguments optionnels de chemin permettent de limiter les opérations à un sous-ensemble de l'arbre de travail. Référez-vous à « Mode interactif » pour plus de détails.

note: type: Plain text
en: Interactively choose hunks of patch between the index and the work tree and add them to the index. This gives the user a chance to review the difference before adding modified contents to the index.
fr: Choisir de manière interactive les sections de patch entre l'index et la copie de travail et les ajouter à l'index. Cela permet à l'utilisateur de réviser les différences avec d'ajouter le contenu modifié à l'index.

note: type: Plain text
en: This effectively runs `add --interactive`, but bypasses the initial command menu and directly jumps to the `patch` subcommand.  See ``Interactive mode'' for details.
fr: Cela lance effectivement `add --interactive` mais court-circuite le menu initial et saute directement à la sous-commande `patch`. Référez-vous à « Mode interactif » pour plus de détails.

note: type: Plain text
en: Open the diff vs. the index in an editor and let the user edit it.  After the editor was closed, adjust the hunk headers and apply the patch to the index.
fr: Ouvrir les différences avec l'index dans un éditeur et laisser l'utilisateur les éditer. Après la fermeture de l'éditeur, ajuster les entêtes de sections et appliquer le patch à l'index.

note: type: Plain text
en: The intent of this option is to pick and choose lines of the patch to apply, or even to modify the contents of lines to be staged. This can be quicker and more flexible than using the interactive hunk selector.  However, it is easy to confuse oneself and create a patch that does not apply to the index. See EDITING PATCHES below.
fr: L'objectif de cette option est de permettre de choisir et retenir les lignes de la rustine à appliquer, ou même de modifier le contenu des lignes à indexer. Cela peut être plus rapide et plus flexible que l'utilisation du sélecteur interactif. Cependant, il est plus facile de se tromper et de créer un patch qui ne s'applique pas. Référez-vous à ÉDITER LES RUSTINES ci-dessous.

note: type: Plain text
en: Update the index just where it already has an entry matching <pathspec>.  This removes as well as modifies index entries to match the working tree, but adds no new files.
fr: Mettre à jour l'index sur les seuls fichiers déjà présents et correspondant à <chemin>. Cela retire ou modifie les entrées d'index pour correspondre à la copie de travail, mais n'ajoute pas de fichier.

note: type: Plain text
en: If no <pathspec> is given when `-u` option is used, all tracked files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).
fr: Si aucun <chemin> n'est spécifié, quand l'option `-u` est utilisée, tous les fichiers suivis dans la totalité de l'arbre de travail sont mis à jour (les versions anciennes de Git limitaient la mise à jour au répertoire courant et ses sous-répertoires).

note: type: Plain text
en: Update the index not only where the working tree has a file matching <pathspec> but also where the index already has an entry. This adds, modifies, and removes index entries to match the working tree.
fr: Mettre à jour l'index non seulement pour tous les fichiers de l'arbre de travail correspondant à <chemin> mais aussi pour toutes les entrées existant déjà dans l'index. Ceci ajoute, modifie et retire des entrées d'index pour correspondre à la copie de travail.

note: type: Plain text
en: If no <pathspec> is given when `-A` option is used, all files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).
fr: Si aucun <chemin> n'est spécifié quand l'option `-A` est utilisée, tous les fichiers de l'arbre de travail sont mis à jour (les versions anciennes de Git utilisaient le répertoire courant et ses sous-répertoires).

note: type: Plain text
en: Update the index by adding new files that are unknown to the index and files modified in the working tree, but ignore files that have been removed from the working tree.  This option is a no-op when no <pathspec> is used.
fr: Mettre à jour l'index en y ajoutant les nouveaux fichiers qui sont inconnus et les fichiers modifiés dans la copie de travail, mais ignore les fichiers qui ont été effacés de la copie de travail. Cette option ne fait rien quand aucun <chemin> n'est utilisé.

note: type: Plain text
en: This option is primarily to help users who are used to older versions of Git, whose "git add <pathspec>..." was a synonym for "git add --no-all <pathspec>...", i.e. ignored removed files.
fr: Cette option sert principalement à aider les utilisateurs de versions anciennes de Git pour lesquels « git add <chemin>... » était synonyme de « git add --no-all <chemin>... », c'est-à-dire qui ignorait les fichiers effacés.

note: type: Plain text
en: Record only the fact that the path will be added later. An entry for the path is placed in the index with no content. This is useful for, among other things, showing the unstaged content of such files with `git diff` and committing them with `git commit -a`.
fr: N'enregistrer que le fait que le chemin sera ajouté plus tard. Une entrée pour le chemin est placée en index sans contenu. C'est particulièrement utile pour, entre autres choses, montrer le contenu non indexé de ces fichiers avec `git diff` et les valider avec `git commit -a`.

note: type: Plain text
en: Don't add the file(s), but only refresh their stat()  information in the index.
fr: Ne pas ajouter le ou les fichiers mais rafraîchir seulement leur information de stat() dans l'index.

note: type: Plain text
en: If some files could not be added because of errors indexing them, do not abort the operation, but continue adding the others. The command shall still exit with non-zero status.  The configuration variable `add.ignoreErrors` can be set to true to make this the default behaviour.
fr: Si des fichiers n'ont pas pu être ajoutés à cause d'erreurs lors de leur indexation, ne pas annuler l'opération mais continuer l'ajout des autres fichiers. La commande se terminera tout de même avec un code d'erreur non nul. Le paramètre de configuration `add.ignoreErrors` peut être positionné à true pour que ce comportement soit celui par défaut.

note: type: Plain text
en: This option can only be used together with --dry-run. By using this option the user can check if any of the given files would be ignored, no matter if they are already present in the work tree or not.
fr: Cette option ne peut être utilisée que couplée avec --dry-run. L'utilisation de cette option permet à l'utilisateur de vérifier si un des fichiers indiqués serait ignoré, qu'il soit présent ou non dans la copie de travail.

note: type: Plain text
en: Override the executable bit of the added files.  The executable bit is only changed in the index, the files on disk are left unchanged.
fr: Forcer le bit exécutable des fichiers ajoutés. Le bit exécutable n'est modifié que dans l'index, les fichiers de la copie de travail ne sont pas modifiés.

note: type: Plain text
en: This option can be used to separate command-line options from the list of files, (useful when filenames might be mistaken for command-line options).
fr: Cette option permet de séparer les options de la ligne de commande de la liste des fichiers (utile si certains noms de fichiers peuvent être confondus avec des options).

note: type: Plain text
en: The optional configuration variable `core.excludesFile` indicates a path to a file containing patterns of file names to exclude from git-add, similar to $GIT_DIR/info/exclude.  Patterns in the exclude file are used in addition to those in info/exclude.  See linkgit:gitignore[5].
fr: Le paramètre de configuration optionnel `core.excludesFile` indique un chemin vers un fichier contenant les patrons des noms de fichier à exclure de git-add, similaire à $GIT_DIR/info/exclude. Les patrons dans le fichier d'exclusion sont additionnés à ceux de info/exclude. Référez-vous à linkgit:gitignore[5].

note: type: Title -
en: EXAMPLES
fr: EXEMPLES

note: type: Plain text
en: Adds content from all `*.txt` files under `Documentation` directory and its subdirectories:
fr: Ajouter le contenu de tous les fichiers `*.txt` sous le répertoire `Documentation` et ses sous répertoires :

note: type: Plain text
en: Note that the asterisk `*` is quoted from the shell in this example; this lets the command include the files from subdirectories of `Documentation/` directory.
fr: Remarquez que l'astérisque `*` est échappé du shell dans cet exemple ; cela permet d'inclure les fichiers dans les sous-répertoires du Répertoire `Documentation/`.

note: type: Plain text
en: Considers adding content from all git-*.sh scripts:
fr: Ajouter le contenu de tous les scripts git-*.sh :

note: type: Plain text
en: Because this example lets the shell expand the asterisk (i.e. you are listing the files explicitly), it does not consider `subdir/git-foo.sh`.
fr: Comme cet exemple laisse le shell réaliser l'expansion de l'astérisque (c'est-à-dire que vous listez explicitement les fichiers du répertoire), il ne traite pas `subdir/git-foo.sh`.

note: type: Title -
en: Interactive mode
fr: Mode interactif

note: type: Plain text
en: When the command enters the interactive mode, it shows the output of the 'status' subcommand, and then goes into its interactive command loop.
fr: Quand la commande entre en mode interactif, elle affiche le résultat de la sous-commande 'status', puis entre en boucle de commande interactive.

note: type: Plain text
en: The command loop shows the list of subcommands available, and gives a prompt "What now> ".  In general, when the prompt ends with a single '>', you can pick only one of the choices given and type return, like this:
fr: La boucle de commande affiche la liste des sous-commandes disponibles et affiche le prompt « What now> » (Que faire maintenant). En général, lorsque le prompt se termine par un '>' unique, vous ne pouvez choisir qu'une seule des propositions et appuyer Entrée, comme cela :

note: type: Plain text
en: You also could say `s` or `sta` or `status` above as long as the choice is unique.
fr: Vous pouvez indiquer `s` ou `sta` ou `status` dans le cas ci-dessus, à condition que le choix soit univoque.

note: type: Plain text
en: The main command loop has 6 subcommands (plus help and quit).
fr: La boucle de commande principale propose 6 sous-commandes (plus help (aide)  et quit (quitter)).

note: type: Plain text
en: This shows the change between HEAD and index (i.e. what will be committed if you say `git commit`), and between index and working tree files (i.e. what you could stage further before `git commit` using `git add`) for each path.  A sample output looks like this:
fr: Affiche les modifications entre HEAD et l'index (c-à-d ce qui serait validé si vous lanciez `git commit`), et entre l'index et les fichiers de la copie de travail (c-à-d ce que vous pourriez indexer au moyen de `git add` avant de lancer `git commit`) pour chaque chemin. Un exemple d'affichage ressemble à ceci :

note: type: Plain text
en: It shows that foo.png has differences from HEAD (but that is binary so line count cannot be shown) and there is no difference between indexed copy and the working tree version (if the working tree version were also different, 'binary' would have been shown in place of 'nothing').  The other file, git-add{litdd}interactive.perl, has 403 lines added and 35 lines deleted if you commit what is in the index, but working tree file has further modifications (one addition and one deletion).
fr: foo.png contient des différences avec HEAD (mais c'est un format binaire donc le nombre de lignes ne peut pas être affiché) et il n'y a pas différence entre la copie indexée et la copie de travail (si la copie de travail avait été aussi différente, 'binary' aurait été affiché à la place de 'nothing'). L'autre fichier, git-add{litdd}interactive.perl, a 430 lignes ajoutées et 35 effacées si vous validez ce qui est dans l'index, mais la copie de travail contient d'autres modifications (un ajout et un retrait).

note: type: Plain text
en: This shows the status information and issues an "Update>>" prompt.  When the prompt ends with double '>>', you can make more than one selection, concatenated with whitespace or comma.  Also you can say ranges.  E.g. "2-5 7,9" to choose 2,3,4,5,7,9 from the list.  If the second number in a range is omitted, all remaining patches are taken.  E.g. "7-" to choose 7,8,9 from the list.  You can say '*' to choose everything.
fr: Affiche l'information d'état et un prompt "Update>>". Quand le prompt se termine par un double '>', vous pouvez sélectionner plus d'une option, concaténées avec des espaces ou des virgules. Vous pouvez aussi indiquer des intervalles.  Par exemple "2-5 7,9" pour choisir 2, 3, 4, 5, 7 et 9 dans la liste. Si le second nombre d'un intervalle est absent, tous les patchs restants sont sélectionnés. Par ex. "7-" choisit 7, 8 et 9 dans la liste. '*' permet de tout sélectionner.

note: type: Plain text
en: What you chose are then highlighted with '*', like this:
fr: Tout ce qui a été sélectionné est indiqué par une '*', comme ceci :

note: type: Plain text
en: To remove selection, prefix the input with `-` like this:
fr: Pour retirer une sélection, préfixez-la avec `-` comme ceci :

note: type: Plain text
en: After making the selection, answer with an empty line to stage the contents of working tree files for selected paths in the index.
fr: Après sélection, répondez avec une ligne vide pour indexer le contenu des fichiers sélectionnés de l'arbre de travail.

note: type: Plain text
en: This has a very similar UI to 'update', and the staged information for selected paths are reverted to that of the HEAD version.  Reverting new paths makes them untracked.
fr: Ceci présente une interface d'utilisation similaire à 'update', et le contenu indexé des chemins sélectionnés sont ramenés à la version HEAD. Inverser des chemins nouveaux les rend non-suivis.

note: type: Plain text
en: This has a very similar UI to 'update' and 'revert', and lets you add untracked paths to the index.
fr: Ceci présente une interface d'utilisation très similaire à 'update' et 'revert' et permet d'ajouter des chemins non-suivis à l'index.

note: type: Plain text
en: This lets you choose one path out of a 'status' like selection.  After choosing the path, it presents the diff between the index and the working tree file and asks you if you want to stage the change of each hunk.  You can select one of the following options and type return:
fr: Ceci permet de choisir un chemin depuis une sélection similaire à 'status'. Après le choix du chemin, la différence entre l'index et le fichier dans l'arbre de travail est présenté et vous demande si vous souhaitez indexer chaque section de modification. Vous pouvez sélectionner une des options suivantes et taper entrée :

note: type: Plain text
en: After deciding the fate for all hunks, if there is any hunk that was chosen, the index is updated with the selected hunks.
fr: Après avoir décidé du devenir de chaque section, l'index est mis à jour avec les sections sélectionnées.

note: type: Plain text
en: You can omit having to type return here, by setting the configuration variable `interactive.singleKey` to `true`.
fr: Vous pouvez vous éviter de taper entrée ici, en mettant la variable de configuration `interactive.singlekey` à `true`.

note: type: Plain text
en: This lets you review what will be committed (i.e. between HEAD and index).
fr: Ceci permet de faire une revue de ce qui sera validé (c'est une différence entre HEAD et index).

note: type: Title -
en: EDITING PATCHES
fr: ÉDITER LES RUSTINES

note: type: Plain text
en: Invoking `git add -e` or selecting `e` from the interactive hunk selector will open a patch in your editor; after the editor exits, the result is applied to the index. You are free to make arbitrary changes to the patch, but note that some changes may have confusing results, or even result in a patch that cannot be applied.  If you want to abort the operation entirely (i.e., stage nothing new in the index), simply delete all lines of the patch. The list below describes some common things you may see in a patch, and which editing operations make sense on them.
fr: Invoquer `git add -e` ou sélectionner `e` depuis le sélecteur interactif de sections ouvre un patch dans votre éditeur ; après avoir quitté l'éditeur, le résultat est appliqué à l'index. Vous êtes libre de modifier en tout point le patch, mais notez cependant que certaines modifications provoquent des résultats inattendus ou même créent des patchs inapplicables. Si vous souhaitez abandonner complètement l'opération (c'est-à-dire ne rien ajouter à l'index), effacez toutes les lignes du patch. La liste ci-dessous décrit des formes habituelles dans les patchs et quelles opérations d'édition peuvent être réalisées.

note: type: Labeled list
en: added content
fr: contenu ajouté

note: type: Plain text
en: Added content is represented by lines beginning with "{plus}". You can prevent staging any addition lines by deleting them.
fr: Le contenu ajouté est représenté par des lignes commençant par un "{plus}". Vous pouvez empêcher l'indexation de lignes ajoutées en les supprimant.

note: type: Labeled list
en: removed content
fr: contenu supprimé

note: type: Plain text
en: Removed content is represented by lines beginning with "-". You can prevent staging their removal by converting the "-" to a " " (space).
fr: Le contenu supprimé est représenté par des lignes commençant par "-". Vous pouvez empêcher l'indexation de ces suppression en convertissant le "-" en " " (espace).

note: type: Labeled list
en: modified content
fr: contenu modifié

note: type: Plain text
en: Modified content is represented by "-" lines (removing the old content)  followed by "{plus}" lines (adding the replacement content). You can prevent staging the modification by converting "-" lines to " ", and removing "{plus}" lines. Beware that modifying only half of the pair is likely to introduce confusing changes to the index.
fr: Le contenu modifié est représenté par des lignes "-" (supprimant l'ancien contenu) suivies de lignes "{plus}" (ajoutant le nouveau contenu). Vous pouvez empêcher l'indexation de ces modifications en convertissant les lignes "-" en ligne " " et en supprimant les lignes "{plus}". Méfiez-vous : ne modifier que la moitié de la paire de lignes a de fortes chances de créer des modifications inattendues dans l'index.

note: type: Plain text
en: There are also more complex operations that can be performed. But beware that because the patch is applied only to the index and not the working tree, the working tree will appear to "undo" the change in the index.  For example, introducing a new line into the index that is in neither the HEAD nor the working tree will stage the new line for commit, but the line will appear to be reverted in the working tree.
fr: Il existe aussi des opérations plus complexes. Méfiez-vous : quand le patch n'est appliqué que dans l'index et pas dans l'arbre de travail, l'arbre de travail semblera « défaire » les modifications de l'index. Par exemple, l'introduction dans l'index d'une nouvelle ligne qui n'apparait ni dans HEAD ni dans l'arbre de travail indexera la nouvelle ligne pour validation, mais cette ligne semblera être supprimée dans l'arbre de travail.

note: type: Plain text
en: Avoid using these constructs, or do so with extreme caution.
fr: Évitez d'utiliser ces constructions, ou faites-le avec une extrême précaution.

note: type: Labeled list
en: removing untouched content
fr: suppression de contenu intact

note: type: Plain text
en: Content which does not differ between the index and working tree may be shown on context lines, beginning with a " " (space).  You can stage context lines for removal by converting the space to a "-". The resulting working tree file will appear to re-add the content.
fr: Le contenu qui ne diffère pas entre l'index et l'arbre de travail peut être visible dans des lignes de contexte commençant par un " " (espace). Vous pouvez indexer l'élimination de lignes de contexte en convertissant l'espace en "-". Le fichier dans l'arbre de travail semblera ré-ajouter le contenu.

note: type: Labeled list
en: modifying existing content
fr: modification de contenu existant

note: type: Plain text
en: One can also modify context lines by staging them for removal (by converting " " to "-") and adding a "{plus}" line with the new content.  Similarly, one can modify "{plus}" lines for existing additions or modifications. In all cases, the new modification will appear reverted in the working tree.
fr: On peut aussi modifier le contenu de lignes de contexte en indexant leur suppression (en convertissant " " en "-") et en ajoutant dessous une ligne "{plus}" avec le nouveau contenu. On peut modifier des lignes "{plus}" dans des ajouts ou des modifications de contenu. Dans tous les cas, la nouvelle modification indexée semblera être annulée dans l'arbre de travail.

note: type: Labeled list
en: new content
fr: contenu nouveau

note: type: Plain text
en: You may also add new content that does not exist in the patch; simply add new lines, each starting with "{plus}". The addition will appear reverted in the working tree.
fr: Vous pouvez aussi ajouter du contenu nouveau qui n'existe pas dans le patch ; ajoutez simplement des nouvelles lignes, chacune commençant par "{plus}". L'ajout semblera annulé dans l'arbre de travail.

note: type: Plain text
en: There are also several operations which should be avoided entirely, as they will make the patch impossible to apply:
fr: Il existe aussi quelques opérations à éviter complètement car celles-ci rendent le patch inapplicable :

note: type: Plain text
en: adding context (" ") or removal ("-") lines
fr: ajout de context (" ") ou lignes de suppression ("-")

note: type: Plain text
en: deleting context or removal lines
fr: suppression de contexte ou de lignes supprimées

note: type: Plain text
en: modifying the contents of context or removal lines
fr: modification de contenu de contexte ou de lignes supprimées

note: type: Title -
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: Part of the linkgit:git[1] suite
fr: Fait partie de la suite linkgit:git[1]

note: type: Plain text
en: git-am - Apply a series of patches from a mailbox
fr: git-am - Appliquer une série de rustines depuis des fichiers mailbox

note: type: Plain text
en: 'git am' [--signoff] [--keep] [--[no-]keep-cr] [--[no-]utf8]
    	 [--[no-]3way] [--interactive] [--committer-date-is-author-date]
    	 [--ignore-date] [--ignore-space-change | --ignore-whitespace]
    	 [--whitespace=<option>] [-C<n>] [-p<n>] [--directory=<dir>]
    	 [--exclude=<path>] [--include=<path>] [--reject] [-q | --quiet]
    	 [--[no-]scissors] [-S[<keyid>]] [--patch-format=<format>]
    	 [(<mbox> | <Maildir>)...]
    'git am' (--continue | --skip | --abort)
fr: 'git am' [--signoff] [--keep] [--[no-]keep-cr] [--[no-]utf8]
    	 [--[no-]3way] [--interactive] [--committer-date-is-author-date]
    	 [--ignore-date] [--ignore-space-change | --ignore-whitespace]
    	 [--whitespace=<option>] [-C<n>] [-p<n>] [--directory=<répertoire>]
    	 [--exclude=<path>] [--include=<path>] [--reject] [-q | --quiet]
    	 [--[no-]scissors] [-S[<idclé>]] [--patch-format=<format>]
    	 [(<mbox> | <Maildir>)...]
    'git am' (--continue | --skip | --abort)

note: type: Plain text
en: Splits mail messages in a mailbox into commit log message, authorship information and patches, and applies them to the current branch.
fr: Découpe des messages courriel dans un boîte aux lettre en message, auteur, information et rustine de commit, et les applique sur la branche en cours.

note: type: Plain text
en: The list of mailbox files to read patches from. If you do not supply this argument, the command reads from the standard input.  If you supply directories, they will be treated as Maildirs.
fr: La liste de fichiers de boîte aux lettres desquelles on lit les rustines. Si vous ne fournissez pas cet argument, la commande lit depuis l'entrée standard. Si vous fournissez des répertoires, ils sont lus comme des Maildirs.

note: type: Plain text
en: Add a `Signed-off-by:` line to the commit message, using the committer identity of yourself.  See the signoff option in linkgit:git-commit[1] for more information.
fr: Ajouter une ligne `Signed-off-by:` au message de commit, en utilisant votre identité pour validateur. Référez-vous à l'option signoff dans linkgit:git-commit[1] pour plus d'information.

note: type: Plain text
en: Pass `-k` flag to 'git mailinfo' (see linkgit:git-mailinfo[1]).
fr: Passer l'option `-k` à 'git mailinfo' (voir linkgit:git-mailinfo[1]).

note: type: Plain text
en: Pass `-b` flag to 'git mailinfo' (see linkgit:git-mailinfo[1]).
fr: Passer l'option `-b` à 'git mailinfo' (voir linkgit:git-mailinfo[1]).

note: type: Plain text
en: With `--keep-cr`, call 'git mailsplit' (see linkgit:git-mailsplit[1])  with the same option, to prevent it from stripping CR at the end of lines. `am.keepcr` configuration variable can be used to specify the default behaviour.  `--no-keep-cr` is useful to override `am.keepcr`.
fr: Avec `--keep-cr`, appeler 'git mailsplit' (voir linkgit:git-mailsplit[1]) avec la même option, pour l'empêcher de supprimer les CR en fin de ligne. La variable de configuration `am.keepcr` peut être utilisée pour spécifier le comportement par défaut. `--no-keep-cr` permet de surcharger `am.keepcr`.

note: type: Plain text
en: Remove everything in body before a scissors line (see linkgit:git-mailinfo[1]). Can be activated by default using the `mailinfo.scissors` configuration variable.
fr: Retirer tout du corps du message avant la ligne de ciseaux (voir linkgit:git-mailinfo[1]). Peut être activé par défaut en utilisant la variable de configuration `mailinfo.scissors`.

note: type: Plain text
en: Ignore scissors lines (see linkgit:git-mailinfo[1]).
fr: Ignorer les lignes ciseaux (voir linkgit:git-mailinfo[1]).

note: type: Plain text
en: Do not add the Message-ID header to the commit message.  `no-message-id` is useful to override `am.messageid`.
fr: Ne pas ajouter l'entête Message-ID au message de validation. `no-message-id` est utile pour surcharger `am.messageid`.

note: type: Plain text
en: Be quiet. Only print error messages.
fr: N'afficher que les messages d'erreur.

note: type: Plain text
en: Pass `-u` flag to 'git mailinfo' (see linkgit:git-mailinfo[1]).  The proposed commit log message taken from the e-mail is re-coded into UTF-8 encoding (configuration variable `i18n.commitencoding` can be used to specify project's preferred encoding if it is not UTF-8).
fr: Passer l'option `-u` à 'git mailinfo' (voir linkgit:git-mailinfo[1]). Le message de validation proposé extrait depuis le courriel est re-codé en UTF-8 (la variable de configuration `i18n.commitencoding` peut spécifier un codage préféré s'il est différent d'UTF-8).

note: type: Plain text
en: This was optional in prior versions of git, but now it is the
    default.   You can use `--no-utf8` to override this.
fr: C'était optionnel dans les versions précédentes de git, mais c'est
    à présent par défaut. Vous pouvez utiliser `--no-utf8` pour surcharger.

note: type: Plain text
en: Pass `-n` flag to 'git mailinfo' (see linkgit:git-mailinfo[1]).
fr: Passer l'option `-n` à 'git mailinfo' (voir linkgit:git-mailinfo[1]).

note: type: Plain text
en: When the patch does not apply cleanly, fall back on 3-way merge if the patch records the identity of blobs it is supposed to apply to and we have those blobs available locally. `--no-3way` can be used to override am.threeWay configuration variable. For more information, see am.threeWay in linkgit:git-config[1].
fr: Quand la rustine ne s'applique pas correctement, revenir à une fusion à 3 points si la rustine contient l'identité des blobs auxquels elle est supposée s'appliquer et que ces blobs sont disponibles localement. `--no-3way` permet de surcharger la variable de configuration am.threeWay. Pour plus d'information, référez-vous à am.threeWay dans linkgit:git-config[1].

note: type: Labeled list
en: --directory=<dir>
fr: --directory=<rép.>

note: type: Labeled list
en: --exclude=<path>
fr: --exclude=<chemin>

note: type: Labeled list
en: --include=<path>
fr: --include=<chemin>

note: type: Plain text
en: Run interactively.
fr: Lancer de manière interactive.

note: type: Labeled list
en: -S[<keyid>]
fr: -S[<idclé>]

note: type: Labeled list
en: --gpg-sign[=<keyid>]
fr: --gpg-sign[=<idclé>]

note: type: Plain text
en: GPG-sign commits. The `keyid` argument is optional and defaults to the committer identity; if specified, it must be stuck to the option without a space.
fr: Signer les commits avec GPG. L'argument `idclé` est optionnel avec par défaut l'identité du validateur ; si spécifiée, elle doit être collée à l'option sans aucun espace.

note: type: Title -
en: HOOKS
fr: CROCHETS

note: type: Plain text
en: This command can run `applypatch-msg`, `pre-applypatch`, and `post-applypatch` hooks.  See linkgit:githooks[5] for more information.
fr: Cette commande peut lancer les crochets `applypatch-msg`, `pre-applypatch` et `post-applypatch`.  Voir linkgit:githooks[5] pour de plus amples informations.

note: type: Plain text
en: git-apply - Apply a patch to files and/or to the index
fr: git-apply - Applique une rustine à des fichiers et/ou à l'index

note: type: Labeled list
en: <patch>...
fr: <rustine>...

note: type: Plain text
en: The files to read the patch from.  '-' can be used to read from the standard input.
fr: Prendre le message de validation depuis le fichier indiqué. Utilisez '-' pour lire le message depuis l'entrée standard.

note: type: Plain text
en: Apply the patch in reverse.
fr: Appliquer la rustine à rebours.

note: type: Title -
en: Submodules
fr: Sous-modules

note: type: Plain text
en: git-archive - Create an archive of files from a named tree
fr: git-archive - Crée une archive de fichiers depuis un arbre nommé

note: type: Plain text
en: Report progress to stderr.
fr: Mode bavard.

note: type: Labeled list
en: <tree-ish>
fr: <arbre-esque>

note: type: delimited block -
en: git bisect old [<rev>]
fr: git bisect old [<rév>]

note: type: delimited block -
en: git bisect new [<rev>...]
fr: git bisect new [<rév>...]

note: type: Title ~
en: Avoiding testing a commit
fr: Éviter le test d'un commit

note: type: delimited block -
en: $ git bisect run my_script arguments
fr: $ git bisect run mon_script arguments

note: type: Plain text
en: Do not set up "upstream" configuration, even if the branch.autoSetupMerge configuration variable is true.
fr: Ne pas renseigner la configuration « amont », même si la configuration branch.autoSetupMerge est true.

note: type: Labeled list
en: <oldbranch>
fr: <anciennebranche>

note: type: Labeled list
en: [<refname>...]
fr: [<nom-de-réf>...]

note: type: Plain text
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: You can use the number of commits:
fr: Vous pouvez utiliser le nombre de commits :

note: type: Labeled list
en: --path=<path>
fr: --path=<chemin>

note: type: Title -
en: BATCH OUTPUT
fr: SORTIE DE LOT

note: type: Plain text
en: Do not interpret any more arguments as options.
fr: Ne pas interpréter les arguments qui suivent comme options.

note: type: Plain text
en: git-checkout - Switch branches or restore working tree files
fr: git-checkout - Bascule de branches ou restaure des fichiers de l'arbre de travail

note: type: Plain text
en: 'git checkout' [-q] [-f] [-m] [<branch>]
    'git checkout' [-q] [-f] [-m] --detach [<branch>]
    'git checkout' [-q] [-f] [-m] [--detach] <commit>
    'git checkout' [-q] [-f] [-m] [[-b|-B|--orphan] <new_branch>] [<start_point>]
    'git checkout' [-f|--ours|--theirs|-m|--conflict=<style>] [<tree-ish>] [--] <paths>...
    'git checkout' [-p|--patch] [<tree-ish>] [--] [<paths>...]
fr: 'git checkout' [-q] [-f] [-m] [<branche>]
    'git checkout' [-q] [-f] [-m] --detach [<branche>]
    'git checkout' [-q] [-f] [-m] [--detach] <commit>
    'git checkout' [-q] [-f] [-m] [[-b|-B|--orphan] <nouvelle_branche>] [<point_de_départ>]
    'git checkout' [-f|--ours|--theirs|-m|--conflict=<style>] [<arbre-esque>] [--] <chemins>...
    'git checkout' [-p|--patch] [<arbre-esque>] [--] [<chemins>...]

note: type: Plain text
en: Updates files in the working tree to match the version in the index or the specified tree.  If no paths are given, 'git checkout' will also update `HEAD` to set the specified branch as the current branch.
fr: Met à jour les fichiers dans l'arbre de travail pour correspondre à la version dans l'index ou dans l'arbre spécifié. Si aucun chemin n'est fourni, 'git checkout' met aussi à jour `HEAD`pour positionner la branche specifiée comme la branche actuelle.

note: type: Labeled list
en: 'git checkout' <branch>
fr: 'git checkout' <branche>

note: type: Plain text
en: To prepare for working on <branch>, switch to it by updating the index and the files in the working tree, and by pointing HEAD at the branch. Local modifications to the files in the working tree are kept, so that they can be committed to the <branch>.
fr: Pour se préparer à travailler sur <branche>, basculer dessus en mettant l'index et les fichiers de l'arbre de travail à jour, et en pointant HEAD sur cette branche. Les modifications locales aux fichiers de l'arbre de travail sont conservées, de sorte qu'elles peuvent être validées sur la <branche>.

note: type: Plain text
en: If <branch> is not found but there does exist a tracking branch in exactly one remote (call it <remote>) with a matching name, treat as equivalent to
fr: Si la <branche> a été trouvée mais qu'il n'existe pas de branche de suivi pour un dépôt distant unique (appelé <distant>) avec un nom identique, le traiter comme équivalent à

note: type: delimited block -
en: $ git checkout -b <branch> --track <remote>/<branch>
fr: $ git checkout -b <branche> --track <distant>/<branche>

note: type: Plain text
en: You could omit <branch>, in which case the command degenerates to "check out the current branch", which is a glorified no-op with a rather expensive side-effects to show only the tracking information, if exists, for the current branch.
fr: Vous pourriez omettre <branche>, auquel cas le commande a une forme dégénérée « extraire la branche actuelle », qui est une opération nulle de luxe avec un effet de bord plutôt cher de ne montrer que l'information de suivi, si elle existe, pour la branche actuelle.

note: type: Labeled list
en: 'git checkout' -b|-B <new_branch> [<start point>]
fr: 'git checkout' -b|-B <nouvelle_branche> [<point_de_départ>]

note: type: Plain text
en: Specifying `-b` causes a new branch to be created as if linkgit:git-branch[1] were called and then checked out.  In this case you can use the `--track` or `--no-track` options, which will be passed to 'git branch'.  As a convenience, `--track` without `-b` implies branch creation; see the description of `--track` below.
fr: Spécifier `-b` provoque la création d'une nouvelle branche comme si linkgit:git-branch[1] était lancé puis la branche extraite. Dans ce cas, vous pouvez utiliser les options `--track` ou `--no-track`, qui seront passées à 'git branch'. Pour plus de confort, `--track` sans `-b` implique la création d'une branche ; voir la description de `--track` ci-dessous.

note: type: Plain text
en: If `-B` is given, <new_branch> is created if it doesn't exist; otherwise, it is reset. This is the transactional equivalent of
fr: Si `-B` est fourni, <nouvelle_branche> est créée si elle n'existe pas ; sinon, elle est réinitialisée. C'est l'équivalent transactionnel de

note: type: delimited block -
en: $ git branch -f <branch> [<start point>]
    $ git checkout <branch>
fr: $ git branch -f <branche> [<point_de_départ>]
    $ git checkout <branche>

note: type: Plain text
en: that is to say, the branch is not reset/created unless "git checkout" is successful.
fr: Ce qui veut dire que la branche n'est pas créée ou réinitialisée à moins que « git checkout » soit réussie.

note: type: Labeled list
en: 'git checkout' --detach [<branch>]
fr: 'git checkout' --detach [<branche>]

note: type: Plain text
en: Prepare to work on top of <commit>, by detaching HEAD at it (see "DETACHED HEAD" section), and updating the index and the files in the working tree.  Local modifications to the files in the working tree are kept, so that the resulting working tree will be the state recorded in the commit plus the local modifications.
fr: Prépare à travailler par-dessus <commit>, en détachant HEAD dessus (voir la section « HEAD DÉTACHÉE »), et en mettant l'index et les fichiers de l'arbre de travail à jour. Les modifications locales des fichiers dans l'arbre de travail sont conservées, de sorte que l'arbre de travail sera le résultat du commit plus les modifications locales.

note: type: Plain text
en: When the <commit> argument is a branch name, the `--detach` option can be used to detach HEAD at the tip of the branch (`git checkout <branch>` would check out that branch without detaching HEAD).
fr: Quand l'argument <commit> est un nom de branche, l'option `--detach` peut être utilisée pour détacher HEAD au sommet de la branche (`git checkout <branche>` extrairait cette branche sans détacher HEAD).

note: type: Plain text
en: Omitting <branch> detaches HEAD at the tip of the current branch.
fr: Omettre <branche> détache HEAD au sommet de la branche actuelle.

note: type: Labeled list
en: 'git checkout' [-p|--patch] [<tree-ish>] [--] <pathspec>...
fr: 'git checkout' [-p|--patch] [<arbre-esque>] [--] <spéc. de chemin>...

note: type: Plain text
en: When <paths> or `--patch` are given, 'git checkout' does *not* switch branches.  It updates the named paths in the working tree from the index file or from a named <tree-ish> (most often a commit).  In this case, the `-b` and `--track` options are meaningless and giving either of them results in an error.  The <tree-ish> argument can be used to specify a specific tree-ish (i.e.  commit, tag or tree) to update the index for the given paths before updating the working tree.
fr: Quand <spéc. de chemin> ou `--patch` sont fournis 'git checkout' ne bascule *pas* de branche. Elle met à jour à jour les chemins nommés dans l'arbre de travail depuis le fichier d'index ou depuis l'<arbre-esque> nommé (le plus souvent un <commit>. Dans ce cas, les options `-b` et `--track` ne signifient rien et les fournir provoque une erreur. L'argument <arbre-esque> peut servir à spécifier un arbre-esque particulier (c'est-à-dire un commit, une étiquette ou un arbre) pour mettre à jour l'index pour les chemins fournis avant de mettre à jour l'arbre de travail.

note: type: Plain text
en: 'git checkout' with <paths> or `--patch` is used to restore modified or deleted paths to their original contents from the index or replace paths with the contents from a named <tree-ish> (most often a commit-ish).
fr: 'git checkout' avec <chemins> ou `--patch` est utilisé pour restaurer des chemins modifiés ou supprimés à leur contenu d'origine depuis l'index ou pour remplacer les chemins avec le contenu issu d'un <arbre-esque> nommé (le plus souvent un <commit-esque>).

note: type: Plain text
en: The index may contain unmerged entries because of a previous failed merge.  By default, if you try to check out such an entry from the index, the checkout operation will fail and nothing will be checked out.  Using `-f` will ignore these unmerged entries.  The contents from a specific side of the merge can be checked out of the index by using `--ours` or `--theirs`.  With `-m`, changes made to the working tree file can be discarded to re-create the original conflicted merge result.
fr: L'index peut contenir des entrées non fusionnées à cause d'un échec précédent de fusion. Par défaut, si vous essayez d'extraire une telle entrée depuis l'index, l'opération d'extraction échouera et rien ne sera extrait. L'utilisation de `-f` forcera à ignorer des entrées non fusionnées. Le contenu depuis un côté donné de la fusion peut être extrait de l'index en utilisant `--ours` (notre côté) ou `--theirs` (l'autre côté). Avec `-m`, les modifications opérées sur le fichier de l'arbre de travail peuvent être jetées pour récréer le résultat originel de conflit de fusion.

note: type: Plain text
en: Quiet, suppress feedback messages.
fr: Silencieux, supprimer les messages d'état.

note: type: Plain text
en: Progress status is reported on the standard error stream by default when it is attached to a terminal, unless `--quiet` is specified. This flag enables progress reporting even if not attached to a terminal, regardless of `--quiet`.
fr: L'état d'avancement est affiché sur la sortie standard d'erreur par défaut quand elle est attachée à un terminal, à moins que `--quiet` ne soit spécifié. Cette bascule active l'état d'avancement même sans être attaché à un terminal, indépendamment de `--quiet`.

note: type: Plain text
en: When switching branches, proceed even if the index or the working tree differs from HEAD.  This is used to throw away local changes.
fr: Lors du basculement de branche, continuer même si l'index ou l'arbre de travail sont différents de HEAD. Ceci peut servir à éliminer des modifications locales.

note: type: Plain text
en: When checking out paths from the index, do not fail upon unmerged entries; instead, unmerged entries are ignored.
fr: Lors de l'extraction de chemins depuis l'index, ne pas échouer sur des entrées non fusionnées ; à la place, les entrées non fusionnées sont ignorées.

note: type: Plain text
en: When checking out paths from the index, check out stage #2 ('ours') or #3 ('theirs') for unmerged paths.
fr: Lors de l'extraction de chemins depuis l'index, extraire l'état #2 ('ours', le nôtre) ou #3 ('theirs', le leur) pour les chemins non fusionnés.

note: type: Plain text
en: Note that during `git rebase` and `git pull --rebase`, 'ours' and 'theirs' may appear swapped; `--ours` gives the version from the branch the changes are rebased onto, while `--theirs` gives the version from the branch that holds your work that is being rebased.
fr: Veuillez noter que pendant `git rebase` et `git pull --rebase`, `ours` et `theirs` peuvent sembler échangés ; `--ours` fournit la version depuis la branche sur laquelle les modifications sont rebasées, tandis que `--theirs` fournit la version de la branche qui contient le travail rebasé.

note: type: Plain text
en: This is because `rebase` is used in a workflow that treats the history at the remote as the shared canonical one, and treats the work done on the branch you are rebasing as the third-party work to be integrated, and you are temporarily assuming the role of the keeper of the canonical history during the rebase.  As the keeper of the canonical history, you need to view the history from the remote as `ours` (i.e. "our shared canonical history"), while what you did on your side branch as `theirs` (i.e. "one contributor's work on top of it").
fr: C'est parce que `rebase` est utilisé dans une approche qui traite l'historique distant comme la référence canonique partagée, et traite le travail sur la branche que vous rebasez comme un travail tiers à intégrer, et vous assumez temporairement le rôle du gardien de l'historique canonique quand vous rebasez. En tant que gardien de l'historique canonique, vous devez voir l'historique distant comme le vôtre ('ours', c'est-à-dire « notre historique partagé canonique »), tandis que votre travail sur l'autre branche devient le tiers ('theirs', c'est-à-dire « le travail d'un contributeur sur le canonique »).

note: type: Labeled list
en: -b <new_branch>
fr: -b <nouvelle_branche>

note: type: Plain text
en: Create a new branch named <new_branch> and start it at <start_point>; see linkgit:git-branch[1] for details.
fr: Créer une nouvelle branche nommée <nouvelle_branche> et la commencer à <point_de_départ> ; voir linkgit:git-branch[1] pour plus de détails.

note: type: Labeled list
en: -B <new_branch>
fr: -B <nouvelle_branche>

note: type: Plain text
en: Creates the branch <new_branch> and start it at <start_point>; if it already exists, then reset it to <start_point>. This is equivalent to running "git branch" with "-f"; see linkgit:git-branch[1] for details.
fr: Créer la branche <nouvelle_branche> et la commencer à <point_de_départ> ; si elle existe déjà, alors la réinitialise à <point_de_départ>. C'est équivalent à lancer 'git branch' avec `-f` ; voir linkgit:git-branch[1] pour plus de détails.

note: type: Plain text
en: When creating a new branch, set up "upstream" configuration. See "--track" in linkgit:git-branch[1] for details.
fr: À la création d'une nouvelle branche, positionner la configuration 'upstream' (branche amont). Voir `--track` dans linkgit:git-branch[1] pour plus de détails.

note: type: Plain text
en: If no `-b` option is given, the name of the new branch will be derived from the remote-tracking branch, by looking at the local part of the refspec configured for the corresponding remote, and then stripping the initial part up to the "*".  This would tell us to use "hack" as the local branch when branching off of "origin/hack" (or "remotes/origin/hack", or even "refs/remotes/origin/hack").  If the given name has no slash, or the above guessing results in an empty name, the guessing is aborted.  You can explicitly give a name with `-b` in such a case.
fr: Si aucune option `-b` n'est fournie, le nom de la nouvelle branche sera dérivé depuis la branche de suivi à distance, en regardant la partie locale de la spécification de référence configurée pour le distant correspondant et en élidant la partie initiale jusqu'au "*". Cela indiquerait d'utiliser le nom « hack » comme branche locale créée à partir « origin/hack » (ou « remotes/origin/hack », ou même « refs/remotes/origin/hack »). Si le nom fournit ne contient pas de barre oblique, ou si le résultat de la dérivation est un nom vide, la dérivation échoue. Vous pouvez spécifier explicitement un nom avec `-b` dans ce cas.

note: type: Plain text
en: Create the new branch's reflog; see linkgit:git-branch[1] for details.
fr: Créer le reflog de la nouvelle branche ; voir linkgit:git-branch[1] pour plus de détails.

note: type: Plain text
en: Rather than checking out a branch to work on it, check out a commit for inspection and discardable experiments.  This is the default behavior of "git checkout <commit>" when <commit> is not a branch name.  See the "DETACHED HEAD" section below for details.
fr: Plutôt que d'extraire une branche pour travailler dessus, extraire un commit pour l'inspecter et faire des expériences jetables. C'est le comportement par défaut de « git checkout <commit> » quand <commit> n'est pas un nom de branche. Voir la section « HEAD DÉTACHÉE » plus bas pour plus de détails.

note: type: Labeled list
en: --orphan <new_branch>
fr: --orphan <nouvelle_branche>

note: type: Plain text
en: Create a new 'orphan' branch, named <new_branch>, started from <start_point> and switch to it.  The first commit made on this new branch will have no parents and it will be the root of a new history totally disconnected from all the other branches and commits.
fr: Créer une nouvelle branche « orpheline », nommée <nouvelle_branche>, commençant depuis <point_de_départ> et basculer dessus. Le premier commit réalisé sur cette branche n'aura pas de parent et il sera la racine du nouvel historique totalement déconnecté de toutes les autres branches et des autres commits.

note: type: Plain text
en: The index and the working tree are adjusted as if you had previously run "git checkout <start_point>".  This allows you to start a new history that records a set of paths similar to <start_point> by easily running "git commit -a" to make the root commit.
fr: L'index et l'arbre de travail sont ajustés comme si vous aviez déjà lancé « git checkout <point_de_départ> ». Cela vous permet de démarrer un nouvel historique qui enregistre un ensemble de chemins similaires à <point_de_départ> en lançant simplement « git commit -a » pour créer une commit racine.

note: type: Plain text
en: This can be useful when you want to publish the tree from a commit without exposing its full history. You might want to do this to publish an open source branch of a project whose current tree is "clean", but whose full history contains proprietary or otherwise encumbered bits of code.
fr: Ceci peut être utile quand vous souhaitez publier un arbre depuis un commit sans exposer tout son historique. Vous pourriez souhaiter le faire pour publier un branche open source d'un projet dont l'arbre présent est « propre », mais dont l'historique complet contient des morceaux de code propriétaires ou autrement non publiables.

note: type: Plain text
en: If you want to start a disconnected history that records a set of paths that is totally different from the one of <start_point>, then you should clear the index and the working tree right after creating the orphan branch by running "git rm -rf ." from the top level of the working tree.  Afterwards you will be ready to prepare your new files, repopulating the working tree, by copying them from elsewhere, extracting a tarball, etc.
fr: Si vous voulez démarrer un historique déconnecté qui enregistre un ensemble de chemins qui sont totalement différents de celui de <point_de_départ>, vous devriez effacer l'index et l'arbre de travail juste après avoir créé la branche orpheline en lançant « git rm -rf . » depuis la racine de l'arbre de travail. Après, vous pourrez préparer vos nouveaux fichiers, pour repeupler l'arbre de travail, en les copiant depuis un autre endroit, en les extrayant depuis une archive, etc.

note: type: Plain text
en: In sparse checkout mode, `git checkout -- <paths>` would update only entries matched by <paths> and sparse patterns in $GIT_DIR/info/sparse-checkout. This option ignores the sparse patterns and adds back any files in <paths>.
fr: En mode d'extraction clairsemé, `git checkout -- <chemins>` mettrait seulement à jour les entrées correspondant à <chemins> et aux motifs clairsemés dans $GIT_DIR/info/sparse-checkout. Cette option ignore les motifs clairsemés et ré-ajoute tous les fichiers de <chemins>.

note: type: Plain text
en: When switching branches, if you have local modifications to one or more files that are different between the current branch and the branch to which you are switching, the command refuses to switch branches in order to preserve your modifications in context.  However, with this option, a three-way merge between the current branch, your working tree contents, and the new branch is done, and you will be on the new branch.
fr: Lors d'un basculement de branche, si vous avez des modifications locales sur un fichier ou plus qui sont différentes entre la branche actuelle et celle sur laquelle vous basculez, la commande refuse le basculement pour préserver vos modifications dans leur contexte. Cependant, avec cette option, une fusion à trois points entre la branche actuelle, le contenu de votre arbre de travail et la nouvelle branche est opérée et vous serez sur la nouvelle branche.

note: type: Plain text
en: When a merge conflict happens, the index entries for conflicting paths are left unmerged, and you need to resolve the conflicts and mark the resolved paths with `git add` (or `git rm` if the merge should result in deletion of the path).
fr: Quand un conflit de fusion apparaît, les entrées d'index pour les chemins en conflit sont laissées non-fusionnées et vous devez résoudre les conflits et les marquer résolus pour les chemins concernés avec `git add` (ou `git rm` si la suppression résulte de la fusion du chemin).

note: type: Plain text
en: When checking out paths from the index, this option lets you recreate the conflicted merge in the specified paths.
fr: Lors de l'extraction de chemins depuis l'index, cette option vous permet de récréer la fusion en conflit dans les chemins spécifiés.

note: type: Plain text
en: The same as --merge option above, but changes the way the conflicting hunks are presented, overriding the merge.conflictStyle configuration variable.  Possible values are "merge" (default) and "diff3" (in addition to what is shown by "merge" style, shows the original contents).
fr: Identique à l'option `--merge` ci-dessus, mais la manière dont les sections en conflits sont présentées est modifiée, en surchargeant la variable de configuration merge.conflictStyle. Les valeurs possibles sont `merge` (fusion, par défaut) et `diff3` (en plus de ce qui est affiché avec le style `merge`, affiche aussi le contenu d'origine).

note: type: Plain text
en: Interactively select hunks in the difference between the <tree-ish> (or the index, if unspecified) and the working tree.  The chosen hunks are then applied in reverse to the working tree (and if a <tree-ish> was specified, the index).
fr: Sélectionner interactivement les sections dans la différence entre l'<arbre-esque> (ou l'index, si non spécifié) et l'arbre de travail. Les sections choisies sont ensuite appliquées en ordre inversé à l'arbre de travail (et si un <arbre-esque> a été spécifié, à l'index).

note: type: Plain text
en: This means that you can use `git checkout -p` to selectively discard edits from your current working tree. See the ``Interactive Mode'' section of linkgit:git-add[1] to learn how to operate the `--patch` mode.
fr: Ceci signifie que vous pouvez utiliser `git checkout -p` pour supprimer sélectivement les éditions depuis votre arbre de travail actuel. Voir la section « Mode Interactif » de linkgit:git-add[1] pour apprendre à utiliser le mode `--patch`.

note: type: Plain text
en: `git checkout` refuses when the wanted ref is already checked out by another worktree. This option makes it check the ref out anyway. In other words, the ref can be held by more than one worktree.
fr: `git checkout` échoue quand la référence voulue est déjà extraite dans un autre arbre de travail. Cette option force l'extraction. En d'autres termes, la réf peut être tenue par plus d'un arbre de travail.

note: type: Labeled list
en: <branch>
fr: <branche>

note: type: Plain text
en: Branch to checkout; if it refers to a branch (i.e., a name that, when prepended with "refs/heads/", is a valid ref), then that branch is checked out. Otherwise, if it refers to a valid commit, your HEAD becomes "detached" and you are no longer on any branch (see below for details).
fr: Branche à extraire ; si c'est une référence à une branche (c'est-à-dire un nom qui, préfixé par « refs/heads/ » est une référence valide), alors cette branche est extraite. Sinon, si c'est une référence à un commit valide, votre HEAD devient « détacheé » et vous n'êtes plus sur aucune branche (voir plus bas pour plus de détails).

note: type: Plain text
en: As a special case, the `"@{-N}"` syntax for the N-th last branch/commit checks out branches (instead of detaching).  You may also specify `-` which is synonymous with `"@{-1}"`.
fr: Cas spécial, la syntaxe `"@{-N}"` pour la N-ième dernière branche ou commit extrait les branches (au lieu de les détacher). Vous pouvez aussi spécifier `-` qui est synonyme de `"@{-1}"`.

note: type: Plain text
en: As a further special case, you may use `"A...B"` as a shortcut for the merge base of `A` and `B` if there is exactly one merge base. You can leave out at most one of `A` and `B`, in which case it defaults to `HEAD`.
fr: Autre cas spécial, vous pouvez utiliser « A...B » comme raccourci pour la base de fusion de `A` et `B` s'il y a exactement une seule base de fusion. Vous pouvez ne pas spécifier `A` ou `B`, auquel cas ce sera `HEAD` par défaut.

note: type: Labeled list
en: <new_branch>
fr: <nouvelle_branche>

note: type: Plain text
en: Name for the new branch.
fr: Nom pour une nouvelle branche.

note: type: Labeled list
en: <start_point>
fr: <point_de_départ>

note: type: Plain text
en: The name of a commit at which to start the new branch; see linkgit:git-branch[1] for details. Defaults to HEAD.
fr: Le nom du commit auquel démarrer la nouvelle branche ; voir linkgit:git-branch[1] pour plus de détails. HEAD par défaut.

note: type: Plain text
en: Tree to checkout from (when paths are given). If not specified, the index will be used.
fr: Arbre depuis lequel extraire (quand des chemins sont indiqués). Si non spécifié, l'index est utilisé.

note: type: Title -
en: DETACHED HEAD
fr: HEAD DÉTACHÉE

note: type: Plain text
en: HEAD normally refers to a named branch (e.g. 'master'). Meanwhile, each branch refers to a specific commit. Let's look at a repo with three commits, one of them tagged, and with branch 'master' checked out:
fr: HEAD fait normalement référence à une branche nommée (par exemple, 'master'). Dans le même temps, chaque branche pointe sur un commit spécifique. Regardons un dépôt avec trois commits, tous étiquetés et avec une branche extraite :

note: type: delimited block -
en: 	   HEAD (refers to branch 'master')
    	    |
    	    v
    a---b---c  branch 'master' (refers to commit 'c')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr: 	   HEAD (se réfère à la branche 'master')
    	    |
    	    v
    a---b---c  branche 'master' (se réfère au commit 'c')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: When a commit is created in this state, the branch is updated to refer to the new commit. Specifically, 'git commit' creates a new commit 'd', whose parent is commit 'c', and then updates branch 'master' to refer to new commit 'd'. HEAD still refers to branch 'master' and so indirectly now refers to commit 'd':
fr: Quand un commit est créé dans cet état, la branche est mise à jour pour faire référence à un nouveau commit. Spécifiquement, 'git commit' crée un nouveau commit 'd', dont le parent est le commit 'c', et ainsi elle met à jour la branche 'master' pour faire référence au nouveau commit 'd'. HEAD fait toujours référence à la branche 'master' et donc indirectement maintenant fait référence au commit 'd' :

note: type: delimited block -
en: 	       HEAD (refers to branch 'master')
    		|
    		v
    a---b---c---d  branch 'master' (refers to commit 'd')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr: 	       HEAD (se réfère à la branche 'master')
    		|
    		v
    a---b---c---d  branch 'master' (se réfère au commit 'd')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: It is sometimes useful to be able to checkout a commit that is not at the tip of any named branch, or even to create a new commit that is not referenced by a named branch. Let's look at what happens when we checkout commit 'b' (here we show two ways this may be done):
fr: Il est utile quelquefois de permettre d'extraire un commit qui n'est sommet d'aucune branche ou même de créer un nouveau commit qui n'est pas référencé par une branche nommée. Regardons ce qui arrive quand on extrait le commit 'b' (ici, deux manières sont montrées) :

note: type: delimited block -
en: $ git checkout v2.0  # or
    $ git checkout master^^
fr: $ git checkout v2.0  # ou
    $ git checkout master^^

note: type: delimited block -
en:    HEAD (refers to commit 'b')
        |
        v
    a---b---c---d  branch 'master' (refers to commit 'd')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr:    HEAD (se réfère au commit 'b')
        |
        v
    a---b---c---d  branch 'master' (se réfère au commit 'd')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: Notice that regardless of which checkout command we use, HEAD now refers directly to commit 'b'. This is known as being in detached HEAD state.  It means simply that HEAD refers to a specific commit, as opposed to referring to a named branch. Let's see what happens when we create a commit:
fr: Veuillez noter que quelle que soit la commande d'extraction utilisée, HEAD pointe maintenant directement sur le commit 'b'. C'est connu comme un état de HEAD détachée. Ceci signifie simplement que HEAD fait référence à un commit spécifique, par opposition à une référence à une branche nommée. Voyons ce qui arrive quand un commit est créé :

note: type: delimited block -
en:      HEAD (refers to commit 'e')
          |
          v
          e
         /
    a---b---c---d  branch 'master' (refers to commit 'd')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr:      HEAD (se réfère au commit 'e')
          |
          v
          e
         /
    a---b---c---d  branche 'master' (se réfère au commit 'd')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: There is now a new commit 'e', but it is referenced only by HEAD. We can of course add yet another commit in this state:
fr: Il y a maintenant un nouveau commit 'e' mais il est référencé seulement par HEAD. Un autre commit peut bien sur être ajouté dans cet état :

note: type: delimited block -
en: 	 HEAD (refers to commit 'f')
    	  |
    	  v
          e---f
         /
    a---b---c---d  branch 'master' (refers to commit 'd')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr: 	 HEAD (se réfère au commit 'f')
    	  |
    	  v
          e---f
         /
    a---b---c---d  branche 'master' (se réfère au commit 'd')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: In fact, we can perform all the normal Git operations. But, let's look at what happens when we then checkout master:
fr: En fait, toutes les opérations normales de Git peuvent être exécutées. Mais, regardons ce qui arrive quand master est extraite :

note: type: delimited block -
en: 	       HEAD (refers to branch 'master')
          e---f     |
         /          v
    a---b---c---d  branch 'master' (refers to commit 'd')
        ^
        |
      tag 'v2.0' (refers to commit 'b')
fr: 	       HEAD (se réfère au branch 'master')
          e---f     |
         /          v
    a---b---c---d  branche 'master' (se réfère au commit 'd')
        ^
        |
      tag 'v2.0' (se réfère au commit 'b')

note: type: Plain text
en: It is important to realize that at this point nothing refers to commit 'f'. Eventually commit 'f' (and by extension commit 'e') will be deleted by the routine Git garbage collection process, unless we create a reference before that happens. If we have not yet moved away from commit 'f', any of these will create a reference to it:
fr: Il est important de réaliser qu'à ce moment, rien ne fait référence au commit 'f'. À un moment ultérieur, le commit 'f' (et par extension le commit 'e') sera supprimé par le processus de ramasse-miette régulier de Git, à moins de créer une référence avant que cela n'arrive. Si vous n'avez pas encore quitté le commit 'f', une des commandes suivantes permet de créer une référence sur lui :

note: type: Plain text
en: creates a new branch 'foo', which refers to commit 'f', and then updates HEAD to refer to branch 'foo'. In other words, we'll no longer be in detached HEAD state after this command.
fr: crée une nouvelle branche 'foo' qui fait référence au commit 'f', puis met à jour HEAD pour faire référence à la branche 'foo'. En d'autres termes, l'état ne sera plus en HEAD détachée après cette commande.

note: type: Plain text
en: similarly creates a new branch 'foo', which refers to commit 'f', but leaves HEAD detached.
fr: crée aussi une nouvelle branche 'foo' qui fait référence au commit 'f' mais laisse la tête détachée.

note: type: Plain text
en: creates a new tag 'foo', which refers to commit 'f', leaving HEAD detached.
fr: Crée une nouvelle étiquette 'foo' qui fait référence au commit 'f', en laissant HEAD détachée.

note: type: Plain text
en: If we have moved away from commit 'f', then we must first recover its object name (typically by using git reflog), and then we can create a reference to it. For example, to see the last two commits to which HEAD referred, we can use either of these commands:
fr: Si nous ne sommes plus sur 'f', alors nous devons déjà retrouver son nom d'objet (typiquement en utilisant git reflog), puis nous pouvons créer une référence dessus. Par exemple, pour voir les deux derniers commits sur lesquels HEAD pointait, nous pouvons utiliser une des deux commandes suivantes :

note: type: delimited block -
en: $ git reflog -2 HEAD # or
    $ git log -g -2 HEAD
fr: $ git reflog -2 HEAD # ou
    $ git log -g -2 HEAD

note: type: Title -
en: ARGUMENT DISAMBIGUATION
fr: DÉSAMBIGUÏSATION D'ARGUMENT

note: type: Plain text
en: When there is only one argument given and it is not `--` (e.g. "git checkout abc"), and when the argument is both a valid `<tree-ish>` (e.g. a branch "abc" exists) and a valid `<pathspec>` (e.g. a file or a directory whose name is "abc" exists), Git would usually ask you to disambiguate.  Because checking out a branch is so common an operation, however, "git checkout abc" takes "abc" as a `<tree-ish>` in such a situation.  Use `git checkout -- <pathspec>` if you want to checkout these paths out of the index.
fr: Quand il n'y a qu'un argument et qu'il n'est pas `--` (par exemple « git checkout abc ») et quand l'argument fourni est à la fois un `<arbre-esque>` valide (par exemple une branche « abc » existe) et un <spécificateur_de_chemin> valide (par exemple un fichier ou un répertoire du nom de « abc » existe), Git vous demandera généralement de lever l'ambigüité. Du fait qu'extraire une branche est une opération très commune, cependant, « git checkout abc » considère « abc » comme un <arbre-esque> dans une telle situation. Utilisez `git checkout -- <spécificateur_de_chemin>` si vous voulez extraire ces chemins depuis l'index.

note: type: Plain text
en: The following sequence checks out the `master` branch, reverts the `Makefile` to two revisions back, deletes hello.c by mistake, and gets it back from the index.
fr: La séquence suivante extrait la branche `master`, ramène le fichier `Makefile` à deux révisions en arrière, supprime hello.c par erreur et le récupère de l'index.

note: type: Plain text
en: switch branch
fr: bascule de branche

note: type: Plain text
en: take a file out of another commit
fr: prend un fichier depuis un autre commit

note: type: Plain text
en: restore hello.c from the index
fr: restaure hello.c depuis l'index

note: type: Plain text
en: If you want to check out _all_ C source files out of the index, you can say
fr: Si vous souhaitez extraire _tous_ les fichiers source C de l'index, vous pouvez lancer

note: type: Plain text
en: Note the quotes around `*.c`.  The file `hello.c` will also be checked out, even though it is no longer in the working tree, because the file globbing is used to match entries in the index (not in the working tree by the shell).
fr: Notez les guillemets autour de `*.c`. Le fichier `hello.c` sera aussi extrait, même s'il n'est plus dans l'arbre de travail, parce que le patron de fichier est utilisé pour trouver les entrées dans l'index (et non dans l'arbre de travail par le shell).

note: type: Plain text
en: If you have an unfortunate branch that is named `hello.c`, this step would be confused as an instruction to switch to that branch.  You should instead write:
fr: Si vous avez une branche qui s'appelle malheureusement `hello.c`, cette étape pourrait être confondue avec une instruction de basculer sur cette branche. Vous devriez alors plutôt écrire :

note: type: Plain text
en: After working in the wrong branch, switching to the correct branch would be done using:
fr: Après avoir travaillé dans la mauvaise branche, basculer sur la branche correcte serait réalisé par :

note: type: delimited block -
en: $ git checkout mytopic
fr: $ git checkout monsujet

note: type: Plain text
en: However, your "wrong" branch and correct "mytopic" branch may differ in files that you have modified locally, in which case the above checkout would fail like this:
fr: Cependant, votre branche « fausse » et votre branche correcte « monsujet » peuvent être différentes par les fichiers que vous avez modifiés localement, auquel cas l'extraction ci-dessus échouerait comme ceci :

note: type: delimited block -
en: $ git checkout mytopic
    error: You have local changes to 'frotz'; not switching branches.
fr: $ git checkout monsujet
    error: Vos modifications locales aux fichiers suivants seraient écrasées par l'extraction :

note: type: Plain text
en: You can give the `-m` flag to the command, which would try a three-way merge:
fr: Vous pouvez fournir l'option `-m` à la commande, ce qui essaierait une fusion à trois points :

note: type: delimited block -
en: $ git checkout -m mytopic
    Auto-merging frotz
fr: $ git checkout -m monsujet
    Fusion automatique de frotz

note: type: Plain text
en: After this three-way merge, the local modifications are _not_ registered in your index file, so `git diff` would show you what changes you made since the tip of the new branch.
fr: Après cette fusion à trois points, les modifications locales ne sont _pas_ enregistrées dans votre index, donc `git diff` vous montrerait ce qui a changé depuis le sommet de la nouvelle branche.

note: type: Plain text
en: When a merge conflict happens during switching branches with the `-m` option, you would see something like this:
fr: Quand un conflit de fusion arrive pendant une basculement de branche avec l'option `-m`, vous devriez voir quelque chose comme :

note: type: delimited block -
en: $ git checkout -m mytopic
    Auto-merging frotz
    ERROR: Merge conflict in frotz
    fatal: merge program failed
fr: $ git checkout -m mytopic
    Fusion automatique de frotz
    CONFLIT (contenu): Conflit de fusion dans frotz
    fatal: merge program failed

note: type: Plain text
en: At this point, `git diff` shows the changes cleanly merged as in the previous example, as well as the changes in the conflicted files.  Edit and resolve the conflict and mark it resolved with `git add` as usual:
fr: À ce niveau, `git diff` affiche les modifications proprement fusionnées comme dans l'exemple précédent, ainsi que les modifications en conflit. Éditez et résolvez le conflit et marquez-le résolu avec `git add` comme d'habitude :

note: type: Labeled list
en: -F <file>
fr: -F <fichier>

note: type: Title -
en: FILES
fr: FICHIERS

note: type: Plain text
en: git-commit - Record changes to the repository
fr: git-commit - Enregistrer les modifications dans le dépôt

note: type: Plain text
en: 'git commit' [-a | --interactive | --patch] [-s] [-v] [-u<mode>] [--amend]
    	   [--dry-run] [(-c | -C | --fixup | --squash) <commit>]
    	   [-F <file> | -m <msg>] [--reset-author] [--allow-empty]
    	   [--allow-empty-message] [--no-verify] [-e] [--author=<author>]
    	   [--date=<date>] [--cleanup=<mode>] [--[no-]status]
    	   [-i | -o] [-S[<keyid>]] [--] [<file>...]
fr: 'git commit' [-a | --interactive | --patch] [-s] [-v] [-u<mode>] [--amend]
    	   [--dry-run] [(-c | -C | --fixup | --squash) <commit>]
    	   [-F <fichier> | -m <msg>] [--reset-author] [--allow-empty]
    	   [--allow-empty-message] [--no-verify] [-e] [--author=<auteur>]
    	   [--date=<date>] [--cleanup=<mode>] [--[no-]status]
    	   [-i | -o] [-S[<idclé>]] [--] [<fichier>...]

note: type: Plain text
en: Stores the current contents of the index in a new commit along with a log message from the user describing the changes.
fr: Enregistre les contenus actuels de l'index dans un nouveau commit avec un message de journal de l'utilisateur décrivant les modifications.

note: type: Plain text
en: The content to be added can be specified in several ways:
fr: Le contenu à ajouter peut être spécifié de différentes manières :

note: type: Plain text
en: by using 'git add' to incrementally "add" changes to the index before using the 'commit' command (Note: even modified files must be "added");
fr: en utilisant 'git add' pour « ajouter » de manière incrémentale des modifications à l'index avant d'utiliser la commande 'commit' (Note : les fichiers doivent être « ajoutés » pour faire partie du commit, même s'ils ont été modifiés);

note: type: Plain text
en: by using 'git rm' to remove files from the working tree and the index, again before using the 'commit' command;
fr: en utilisant 'git rm' pour supprimer des fichiers de l'arbre de travail et de l'index, encore une fois, avant d'utiliser la commande 'commit';

note: type: Plain text
en: by listing files as arguments to the 'commit' command (without --interactive or --patch switch), in which case the commit will ignore changes staged in the index, and instead record the current content of the listed files (which must already be known to Git);
fr: en listant les fichiers comme arguments de la commande 'commit' (sans les options --interactive ou --patch), auquel cas la validation ignorera les modifications indexées et enregistrera plutôt le contenu actuel des fichiers listés (qui doivent déjà être connus de Git);

note: type: Plain text
en: by using the -a switch with the 'commit' command to automatically "add" changes from all known files (i.e. all files that are already listed in the index) and to automatically "rm" files in the index that have been removed from the working tree, and then perform the actual commit;
fr: en utilisant l'option -a avec la commande 'commit' pour « ajouter » automatiquement les modifications de tous les fichiers connus (c'est-à-dire les fichiers listés dans l'index) et supprimer ('rm') automatiquement les fichiers de l'index qui ont été supprimés dans l'arbre de travail, puis d'effectuer la validation;

note: type: Plain text
en: by using the --interactive or --patch switches with the 'commit' command to decide one by one which files or hunks should be part of the commit in addition to contents in the index, before finalizing the operation. See the ``Interactive Mode'' section of linkgit:git-add[1] to learn how to operate these modes.
fr: en utilisant les options --interactive ou --patch avec la commande 'commit' pour choisir quels fichiers ou sections de fichier doivent être inclus dans le commit en plus de l'index, avant finalisation de l'opération. Référez-vous à la section « Mode interactif » de linkgit:git-add[1] pour la description de ces modes.

note: type: Plain text
en: If you make a commit and then find a mistake immediately after that, you can recover from it with 'git reset'.
fr: Si vous validez et trouvez une erreur immédiatement après, vous pouvez annuler la validation avec 'git reset'.

note: type: Plain text
en: Tell the command to automatically stage files that have been modified and deleted, but new files you have not told Git about are not affected.
fr: Indiquer à la commande d'indexer automatiquement les fichiers qui ont été modifiés ou supprimés, mais les nouveaux fichiers dont vous n'avez pas signalé la présence à Git ne sont pas affectés.

note: type: Plain text
en: Use the interactive patch selection interface to chose which changes to commit. See linkgit:git-add[1] for details.
fr: Utiliser la sélection interactive de rustine pour choisir quelles modifications valider. Référez-vous à linkgit:git-add[1] pour plus de détails.

note: type: Plain text
en: Take an existing commit object, and reuse the log message and the authorship information (including the timestamp)  when creating the commit.
fr: Prendre un objet commit existant et réutiliser son message de validation et son information d'auteur (y compris l'horodatage) pour la création du commit.

note: type: Plain text
en: Like '-C', but with `-c` the editor is invoked, so that the user can further edit the commit message.
fr: Comme '-C', mais avec '-c', l'éditeur est appelé pour permettre à l'utilisateur de modifier le message de validation.

note: type: Plain text
en: Construct a commit message for use with `rebase --autosquash`.  The commit message subject line is taken from the specified commit with a prefix of "squash! ".  Can be used with additional commit message options (`-m`/`-c`/`-C`/`-F`). See linkgit:git-rebase[1] for details.
fr: Construire un message de validation pour une utilisation avec `rebase --autosquash`. La ligne de titre du message de validation est tirée du commit spécifié préfixé par « squash! ». Peut être utilisé avec d'autres options de 'commit' (`-m`/`-c`/`-C`/`-F`). Référez-vous à linkgit:git-rebase[1] pour plus de détails.

note: type: Plain text
en: When used with -C/-c/--amend options, or when committing after a a conflicting cherry-pick, declare that the authorship of the resulting commit now belongs to the committer. This also renews the author timestamp.
fr: Utilisé avec les options -C/-c/--amend ou lors de validation après un picorage conflictuel, déclarer que la paternité du commit résultant appartient à présent au validateur avec un horodatage mis à jour.

note: type: Plain text
en: When doing a dry-run, give the output in the short-format. See linkgit:git-status[1] for details. Implies `--dry-run`.
fr: Seulement avec '--dry-run', fournir la sortie en format court. Voir linkgit:git-status[1] pour plus de détails.

note: type: Plain text
en: Show the branch and tracking info even in short-format.
fr: Montrer la branche et l'information de suivi, y compris en format court.

note: type: Plain text
en: When doing a dry-run, give the output in a porcelain-ready format. See linkgit:git-status[1] for details. Implies `--dry-run`.
fr: Seulement avec '--dry-run', donner la sortie en format compatible porcelaine. Voir linkgit:git-status[1] pour plus de détails.

note: type: Plain text
en: When doing a dry-run, give the output in a the long-format.  Implies `--dry-run`.
fr: Seulement avec '--dry-run', donner la sortie en format long.

note: type: Plain text
en: When showing `short` or `porcelain` status output, print the filename verbatim and terminate the entries with NUL, instead of LF.  If no format is given, implies the `--porcelain` output format.  Without the `-z` option, filenames with "unusual" characters are quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).
fr: Avec les sorties de status `short` ou `porcelain`, afficher le nom du fichier verbatim et terminer par NUL, au lieu de LF. Si aucun format n'est spécifié, implique `--porcelain`. Sans l'option `-z`, les noms de fichier contenant des caractères « inusuels » sont cités selon la variable de configuration `core.quotePath` (voir linkgit:git-config[1]).

note: type: Labeled list
en: --file=<file>
fr: --file=<fichier>

note: type: Plain text
en: Take the commit message from the given file.  Use '-' to read the message from the standard input.
fr: Prendre le message de validation depuis le fichier indiqué. Utilisez '-' pour lire le message depuis l'entrée standard.

note: type: Labeled list
en: --author=<author>
fr: --author=<auteur>

note: type: Plain text
en: Override the commit author. Specify an explicit author using the standard `A U Thor <author@example.com>` format. Otherwise <author> is assumed to be a pattern and is used to search for an existing commit by that author (i.e. rev-list --all -i --author=<author>); the commit author is then copied from the first such commit found.
fr: Surcharger l'auteur du commit. Spécifier un auteur explicite avec le format standard `A U Teur <auteur@exemple.com>`. Sinon <auteur> est considéré comme un patron utilisé pour chercher un commit existant par cet auteur (c-à-d rev-list --all -i --author=<auteur>) ; l'auteur du commit est alors copié depuis le premier commit trouvé.

note: type: Plain text
en: Override the author date used in the commit.
fr: Surcharger la date d'auteur utilisée dans le commit.

note: type: Plain text
en: Use the given <msg> as the commit message.  If multiple `-m` options are given, their values are concatenated as separate paragraphs.
fr: Utiliser le <msg> fourni comme message de validation. Si plusieurs options `-m` sont fournies, leurs valeurs sont concaténées comme paragraphes séparés.

note: type: Labeled list
en: -t <file>
fr: -t <fichier>

note: type: Labeled list
en: --template=<file>
fr: --template=<fichier>

note: type: Plain text
en: When editing the commit message, start the editor with the contents in the given file.  The `commit.template` configuration variable is often used to give this option implicitly to the command.  This mechanism can be used by projects that want to guide participants with some hints on what to write in the message in what order.  If the user exits the editor without editing the message, the commit is aborted.  This has no effect when a message is given by other means, e.g. with the `-m` or `-F` options.
fr: À l'édition du message de validation, démarrer l'éditeur avec le contenu du fichier indiqué. La variable de configuration `commit.template` est souvent utilisée pour fournir implicitement cette option à la commande. Ce mécanisme peut être utilisé par les projets qui souhaitent guider les collaborateurs avec une aide sur ce qu'il faut écrire dans le message et dans quel ordre. Si l'utilisateur sort de l'éditeur sans changer le message, la validation est annulée. Ceci n'a aucun effet quand un message est fourni par un autre moyen, par exemple par les options `-m` ou `-F`.

note: type: Plain text
en: Add Signed-off-by line by the committer at the end of the commit log message.  The meaning of a signoff depends on the project, but it typically certifies that committer has the rights to submit this work under the same license and agrees to a Developer Certificate of Origin (see http://developercertificate.org/ for more information).
fr: Ajouter une ligne Signed-off-by du validateur à la fin du message de validation. La signification de signoff dépend du projet, mais ceci certifie typiquement que le validateur a les droits de soumettre son travail sous la même licence et accepte un Certificat d'Origine de Développeur (voir http://developercertificate.org/ pour plus d'information).

note: type: Plain text
en: This option bypasses the pre-commit and commit-msg hooks.  See also linkgit:githooks[5].
fr: Cette option court-circuite les crochets pre-commit et commit-msg. Voir aussi linkgit:githooks[5].

note: type: Plain text
en: Usually recording a commit that has the exact same tree as its sole parent commit is a mistake, and the command prevents you from making such a commit.  This option bypasses the safety, and is primarily for use by foreign SCM interface scripts.
fr: Généralement enregistrer un commit qui pointe sur la même version que son unique parent est une erreur et la commande vous empêche de créer un tel commit. Cette option court-circuite cette sécurité et sert principalement dans les scripts d'interface avec d'autres SCM.

note: type: Plain text
en: Like --allow-empty this command is primarily for use by foreign SCM interface scripts. It allows you to create a commit with an empty commit message without using plumbing commands like linkgit:git-commit-tree[1].
fr: Comme --allow-empty cette commande est principalement utilisée par les scripts d'interface d'autres SCM. Elle vous permet de créer un commit avec un message vide sans utiliser de commande de plomberie telle que linkgit:git-commit-tree[1].

note: type: Plain text
en: This option determines how the supplied commit message should be cleaned up before committing.  The '<mode>' can be `strip`, `whitespace`, `verbatim`, `scissors` or `default`.
fr: Cette option détermine comment le message fourni doit être nettoyé avant la validation. Le '<mode>' peut être `strip`, `whitespace`, `verbatim`, `scissors` ou `default`.

note: type: Plain text
en: Strip leading and trailing empty lines, trailing whitespace, commentary and collapse consecutive empty lines.
fr: Retirer les lignes vides en début et fin du message, les espaces de fin de ligne, les commentaires et dédupliquer les lignes vides consécutives.

note: type: Plain text
en: Same as `strip` except #commentary is not removed.
fr: Identique à `strip` sauf que les #commentaires ne sont pas supprimés.

note: type: Plain text
en: Do not change the message at all.
fr: Laisser le message inchangé.

note: type: Plain text
en: Same as `strip` if the message is to be edited.  Otherwise `whitespace`.
fr: Identique à `strip` si le messages est édité. Sinon identique à `whitespace`.

note: type: Plain text
en: The default can be changed by the `commit.cleanup` configuration variable (see linkgit:git-config[1]).
fr: La valeur par défaut peut être modifiée par la variable de configuration `commit.cleanup` (voir linkgit:git-config[1]).

note: type: Plain text
en: The message taken from file with `-F`, command line with `-m`, and from commit object with `-C` are usually used as the commit log message unmodified. This option lets you further edit the message taken from these sources.
fr: Le message tiré d'un fichier avec `-F`, ou de la ligne de commande avec `-m`, ou depuis un objet commit avec `-C` est généralement utilisé sans modification. Cette option permet d'éditer au passage le message tiré de ces sources.

note: type: Plain text
en: Use the selected commit message without launching an editor.  For example, `git commit --amend --no-edit` amends a commit without changing its commit message.
fr: Utiliser le message de validation sélectionné sans lancer d'éditeur. Par exemple, `git commit --amend --no-edit` corrige un commit sans changer son message de validation.

note: type: Plain text
en: It is a rough equivalent for:
fr: C'est un équivalent grossier de :

note: type: delimited block -
en: 	$ git reset --soft HEAD^
    	$ ... do something else to come up with the right tree ...
    	$ git commit -c ORIG_HEAD
fr: 	$ git reset --soft HEAD^
    	$ ... faire autre chose pour obtenir l'arbre correct ...
    	$ git commit -c ORIG_HEAD

note: type: Plain text
en: but can be used to amend a merge commit.
fr: mais peut être utilisé pour corriger un commit de fusion.

note: type: Plain text
en: You should understand the implications of rewriting history if you amend a commit that has already been published.  (See the "RECOVERING FROM UPSTREAM REBASE" section in linkgit:git-rebase[1].)
fr: Vous devriez comprendre les implications d'une réécriture de l'historique si vous modifiez un commit qui a déjà été publié. (Voir la section « RATTRAPPER UN REBASAGE AMONT » dans linkgit:git-rebase[1].)

note: type: Plain text
en: Bypass the post-rewrite hook.
fr: Court-circuiter le crochet post-rewrite.

note: type: Plain text
en: Before making a commit out of staged contents so far, stage the contents of paths given on the command line as well.  This is usually not what you want unless you are concluding a conflicted merge.
fr: Avant de créer un commit à partir du contenu indexé jusqu'à présent, indexer aussi les contenus des chemins fournis sur la ligne de commande. Cela n'est habituellement pas ce que vous souhaitez, à part si vous terminez une fusion conflictuelle.

note: type: Plain text
en: Make a commit by taking the updated working tree contents of the paths specified on the command line, disregarding any contents that have been staged for other paths. This is the default mode of operation of 'git commit' if any paths are given on the command line, in which case this option can be omitted.  If this option is specified together with `--amend`, then no paths need to be specified, which can be used to amend the last commit without committing changes that have already been staged. If used together with `--allow-empty` paths are also not required, and an empty commit will be created.
fr: Réaliser une validation en prenant le contenu de l'arbre de travail des chemins spécifiés sur la ligne de commande, en ignorant tout contenu d'autres chemins déjà indexé. C'est le mode d'opération par défaut de 'git commit' si des chemins sont fournis sur la ligne de commande, auquel cas l'option peut être omise. Si cette option est spécifiée en même temps que `--amend`, alors il n'est pas nécessaire de spécifier des chemins, ce qui peut être utile pour corriger le dernier commit sans valider les modifications qui ont déjà été indexées. Si utilisé avec `--allow-empty`, les chemins ne sont pas nécessaires non plus et un commit vide sera créé.

note: type: Plain text
en: Show untracked files.
fr: Montrer les fichiers non-suivis.

note: type: Plain text
en: The mode parameter is optional (defaults to 'all'), and is used to specify the handling of untracked files; when -u is not used, the default is 'normal', i.e. show untracked files and directories.
fr: Le paramètre de mode est optionnel (par défaut, 'all') et sert à spécifier la gestion des fichiers non suivis ; quand -u n'est pas utilisé, le mode par défaut est 'normal', c'est-à-dire montrer les fichiers et les dossiers non-suivis.

note: type: Plain text
en: The possible options are:
fr: Les options possibles sont :

note: type: Plain text
en: 'no'     - Show no untracked files
fr: 'no'     - Ne montrer aucun fichier non-suivi

note: type: Plain text
en: 'normal' - Shows untracked files and directories
fr: 'normal' - Montrer les fichiers et les dossiers non-suivis

note: type: Plain text
en: 'all'    - Also shows individual files in untracked directories.
fr: 'all'    - Montrer aussi les fichiers individuels dans les dossiers non-suivis.

note: type: Plain text
en: The default can be changed using the status.showUntrackedFiles configuration variable documented in linkgit:git-config[1].
fr: La valeur par défaut est contenue dans la variable de configuration status.showUntrackedFiles documentée dans linkgit:git-config[1].

note: type: Plain text
en: Show unified diff between the HEAD commit and what would be committed at the bottom of the commit message template to help the user describe the commit by reminding what changes the commit has.  Note that this diff output doesn't have its lines prefixed with '#'. This diff will not be a part of the commit message. See the `commit.verbose` configuration variable in linkgit:git-config[1].
fr: Afficher en bas du modèle de message de validation un diff unifié entre le commit HEAD et ce qui serait validé pour aider l'utilisateur à décrire le commit en lui rappelant les modifications qui seront validées. Veuillez noter que cette sortie de diff n'est pas préfixée par des '#'. Elle ne fera pas pour autant partie du message de validation. Référez-vous à la variable de configuration `commit.verbose` dans linkgit:git-config[1].

note: type: Plain text
en: If specified twice, show in addition the unified diff between what would be committed and the worktree files, i.e. the unstaged changes to tracked files.
fr: Si spécifié deux fois, afficher en plus le diff unifié entre ce qui serait valié et les fichiers de l'arbre de travail, c'est-à-dire les modifications non-indexées des fichiers suivis.

note: type: Plain text
en: Suppress commit summary message.
fr: Supprimer le message de résumé de commit.

note: type: Plain text
en: Do not create a commit, but show a list of paths that are to be committed, paths with local changes that will be left uncommitted and paths that are untracked.
fr: Ne pas créer de commit, mais montrer une liste des chemins qui seront validés, une de ceux contenant des modifications locales et qui ne seront pas validés, et une de ceux non-suivis.

note: type: Plain text
en: Include the output of linkgit:git-status[1] in the commit message template when using an editor to prepare the commit message.  Defaults to on, but can be used to override configuration variable commit.status.
fr: Inclure la sortie de linkgit:git-status[1] dans le modèle de message de validation lors de l'utilisation d'un éditeur pour préparer le message de validation. Activé par défaut, mais peut surcharger la variable de configuration commit.status.

note: type: Plain text
en: Do not include the output of linkgit:git-status[1] in the commit message template when using an editor to prepare the default commit message.
fr: Ne pas inclure la sortie de linkgit:git-status[1] dans le modèle de message de validation lors de l'utilisation d'un éditeur pour préparer le message de validation par défaut.

note: type: Plain text
en: Countermand `commit.gpgSign` configuration variable that is set to force each and every commit to be signed.
fr: Annuler la variable de configuration `commit.gpgSign` qui force tous les commits à être signés.

note: type: Labeled list
en: <file>...
fr: <fichier>...

note: type: Plain text
en: When files are given on the command line, the command commits the contents of the named files, without recording the changes already staged.  The contents of these files are also staged for the next commit on top of what have been staged before.
fr: Quand des chemins sont fournis sur la ligne de commande, la commande valide le contenu des fichiers spécifiés, sans enregistrer les modifications déjà indexées. Le contenu de ces fichiers est aussi indexé pour le commit suivant par-dessus ce qui a été indexé auparavant.

note: type: Plain text
en: When recording your own work, the contents of modified files in your working tree are temporarily stored to a staging area called the "index" with 'git add'.  A file can be reverted back, only in the index but not in the working tree, to that of the last commit with `git reset HEAD -- <file>`, which effectively reverts 'git add' and prevents the changes to this file from participating in the next commit.  After building the state to be committed incrementally with these commands, `git commit` (without any pathname parameter) is used to record what has been staged so far.  This is the most basic form of the command.  An example:
fr: Lors de l'enregistrement de votre propre travail, le contenu des fichiers modifiés dans votre arbre de travail est temporairement stocké au moyen de `git add` dans une zone de stockage intermédiaire appelée « l'index ». Un fichier peut n'être ramené à son contenu correspondant au dernier commit seulement dans l'index mais pas dans l'arbre de travail grâce à `git reset HEAD -- <fichier>`, ce qui inverse effectivement le 'git add' et empêche les modifications de ce fichier de participer à la prochaine validation. Après avoir construit l'état à valider de manière incrémentale avec ces commandes, `git commit` (sans aucun nom de chemin en paramètre) sert à enregistrer ce qui a été préparé jusqu'ici. C'est la forme la plus simple de la commande. Par exemple :

note: type: Plain text
en: Instead of staging files after each individual change, you can tell `git commit` to notice the changes to the files whose contents are tracked in your working tree and do corresponding `git add` and `git rm` for you.  That is, this example does the same as the earlier example if there is no other change in your working tree:
fr: Au lieu d'indexer les fichiers après chaque modification individuelle, vous pouvez ordonner à `git commit` d'observer les modifications aux fichiers dans le contenu est déjà suivi dans votre arbre de travail et de réaliser les `git add` et `git rm` correspondant pour vous. De fait, l'exemple suivant fait la même chose que l'exemple précédent si aucune autre modification n'a eu lieu dans votre arbre de travail :

note: type: Plain text
en: The command `git commit -a` first looks at your working tree, notices that you have modified hello.c and removed goodbye.c, and performs necessary `git add` and `git rm` for you.
fr: La commande `git commit -a` observe votre arbre de travail, remarque que vous avez modifié hello.c et supprimé goodbye.c, puis réalise les `git add` et `git rm` nécessaires pour vous.

note: type: Plain text
en: After staging changes to many files, you can alter the order the changes are recorded in, by giving pathnames to `git commit`.  When pathnames are given, the command makes a commit that only records the changes made to the named paths:
fr: Après l'indexation des modifications de nombreux fichiers, vous pouvez modifier l'ordre dans lequel les modifications sont enregistrées, en fournissant des chemins à `git commit`. Quand ces chemins sont fournis, la commande crée un commit qui n'enregistre que les modifications aux chemins indiqués :

note: type: Plain text
en: This makes a commit that records the modification to `Makefile`.  The changes staged for `hello.c` and `hello.h` are not included in the resulting commit.  However, their changes are not lost -- they are still staged and merely held back.  After the above sequence, if you do:
fr: Ceci crée un commit qui enregistre les modifications de `Makefile`. Les modifications indexées pour `hello.c` et `hello.h` ne sont pas incluses dans le commit résultant. Cependant, leurs modifications ne sont pas perdues -- elles sont toujours indexées et simplement suspendues. Après la séquence ci-dessus, si vous faites :

note: type: Plain text
en: this second commit would record the changes to `hello.c` and `hello.h` as expected.
fr: cette seconde validation enregistrerait les modifications de `hello.c` et `hello.h` comme attendu.

note: type: Plain text
en: After a merge (initiated by 'git merge' or 'git pull') stops because of conflicts, cleanly merged paths are already staged to be committed for you, and paths that conflicted are left in unmerged state.  You would have to first check which paths are conflicting with 'git status' and after fixing them manually in your working tree, you would stage the result as usual with 'git add':
fr: Après l'arrêt d'une fusion (commencée avec `git merge` ou `git pull`) pour cause de conflit, les chemins fusionnés proprement sont déjà indexés pour vous, et les chemins en conflit sont laissé dans un état non-fusionné. Vous auriez à chercher d'abord les chemins en conflit avec `git status` et après les avoir corrigés manuellement dans votre copie de travail, vous les indexeriez comme d'habitude avec `git add` :

note: type: delimited block -
en: $ git status | grep unmerged
    unmerged: hello.c
    $ edit hello.c
    $ git add hello.c
fr: $ git status | grep non-fusionné
    non-fusionné : hello.c
    $ edit hello.c
    $ git add hello.c

note: type: Plain text
en: After resolving conflicts and staging the result, `git ls-files -u` would stop mentioning the conflicted path.  When you are done, run `git commit` to finally record the merge:
fr: Après avoir résolu les conflits et indexé le résultat, `git ls-files -u` arrêterait de mentionner les chemins en conflit. Quand vous avez terminé, lancez `git commit` pour finaliser la validation de la fusion :

note: type: Plain text
en: As with the case to record your own changes, you can use `-a` option to save typing.  One difference is that during a merge resolution, you cannot use `git commit` with pathnames to alter the order the changes are committed, because the merge should be recorded as a single commit.  In fact, the command refuses to run when given pathnames (but see `-i` option).
fr: Comme dans le cas de la validation de vos propres modifications, vous pouvez utiliser l'option `-a` pour vous épargner de la frappe. Une différence est que pendant la résolution de fusion, vous ne pouvez pas utiliser `git commit` avec des noms de chemin pour changer l'ordre des modifications à valider, parce que la fusion doit être enregistrée comme un commit unique. En fait, la commande refuse d'être lancée avec des noms de chemin (voir par contre l'option `-i`).

note: type: Plain text
en: Though not required, it's a good idea to begin the commit message with a single short (less than 50 character) line summarizing the change, followed by a blank line and then a more thorough description.  The text up to the first blank line in a commit message is treated as the commit title, and that title is used throughout Git.  For example, linkgit:git-format-patch[1] turns a commit into email, and it uses the title on the Subject line and the rest of the commit in the body.
fr: Bien que ça ne soit pas requis, c'est une bonne pratique de commencer les messages de validation avec une courte ligne seule (moins de 50 caractères) pour résumer la modification, suivie d'une ligne blanche, suivie d'un description plus précise. Le texte jusqu'à la ligne vide du message de validation est traité comme le titre du commit, et ce titre est utilisé extensivement dans Git. Par exemple, linkgit:git-format-patch[1] transforme un commit en courriel et utilise le titre comme sujet et le reste du texte comme corps.

note: type: Title -
en: ENVIRONMENT AND CONFIGURATION VARIABLES
fr: ENVIRONNEMENT ET VARIABLES DE CONFIGURATION

note: type: Plain text
en: The editor used to edit the commit log message will be chosen from the `GIT_EDITOR` environment variable, the core.editor configuration variable, the `VISUAL` environment variable, or the `EDITOR` environment variable (in that order).  See linkgit:git-var[1] for details.
fr: L'éditeur utilisé pour éditer le message de validation sera choisi dans l'ordre de recherche depuis la variable d'environnement `GIT_EDITOR`, puis depuis la variable de configuration `core.editor`, puis depuis la variable d'environnement `VISUAL` ou la variable d'environnement `EDITOR`. Voir linkgit:git-var[1] pour plus de détails.

note: type: Plain text
en: This command can run `commit-msg`, `prepare-commit-msg`, `pre-commit`, `post-commit` and `post-rewrite` hooks.  See linkgit:githooks[5] for more information.
fr: Cette commande peut lancer les crochets `commit-msg`, `prepare-commit-msg`, `pre-commit`, `post-commit` et `post-rewrite`.  Voir linkgit:githooks[5] pour de plus amples informations.

note: type: Plain text
en: This file contains the commit message of a commit in progress.  If `git commit` exits due to an error before creating a commit, any commit message that has been provided by the user (e.g., in an editor session) will be available in this file, but will be overwritten by the next invocation of `git commit`.
fr: Ce fichier contient le message de validation en cours. Si `git commit` sort à cause d'une erreur avant de créer un commit, tout message de validation fourni par l'utilisateur (par exemple dans une session d'éditeur) sera disponible dans ce fichier, mais sera écrasé par l'invocation suivante de `git commit`.

note: type: Plain text
en: Show changes between commits, commit and working tree, etc
fr: Afficher les changements entre les validations, entre validation et copie de travail, etc

note: type: Plain text
en: force
fr: forcer

note: type: Labeled list
en: done
fr: fait

note: type: Labeled list
en: reason
fr: raison

note: type: Labeled list
en: upstream
fr: amont

note: type: Plain text
en: 'git fsck' [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]
    	 [--[no-]full] [--strict] [--verbose] [--lost-found]
    	 [--[no-]dangling] [--[no-]progress] [--connectivity-only]
    	 [--[no-]name-objects] [<object>*]
fr: 'git fsck' [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]
    	 [--[no-]full] [--strict] [--verbose] [--lost-found]
    	 [--[no-]dangling] [--[no-]progress] [--connectivity-only]
    	 [--[no-]name-objects] [<objet>*]

note: type: Title -
en: Other
fr: Autre

note: type: Title ~
en: General options
fr: Options générales

note: type: Plain text
en: Provide more progress information.
fr: Fournir plus d'information de progression.

note: type: Title ~
en: Options related to merging
fr: Options relatives à la fusion

note: type: Title ~
en: Options related to fetching
fr: Options relatives au rapatriement

note: type: Title -
en: Merging
fr: Fusion

note: type: Labeled list
en: create
fr: créer

note: type: Labeled list
en: delete
fr: supprimer

note: type: Plain text
en: Git is to some extent character encoding agnostic.
fr: Git est dans une certaine mesure agnostique concernant l'encodage des caractères.

note: type: Plain text
en: The contents of the blob objects are uninterpreted sequences of bytes.  There is no encoding translation at the core level.
fr: Le contenu des objets blob est une séquence d'octets non interprétés. Il n'y a pas de conversion d'encodage au niveau de base.

note: type: Plain text
en: Path names are encoded in UTF-8 normalization form C. This applies to tree objects, the index file, ref names, as well as path names in command line arguments, environment variables and config files (`.git/config` (see linkgit:git-config[1]), linkgit:gitignore[5], linkgit:gitattributes[5] and linkgit:gitmodules[5]).
fr: Les noms de chemins sont encodés en forme C de normalisation UTF-8. Ceci s'applique aux objets arbre, au fichier d'index, au noms de références ainsi qu'aux noms de chemin en argument de ligne de commande, aux variables d'environnement et aux fichiers de configuration (`.git/config` (voir linkgit:git-config[1]), linkgit:gitignore[5], linkgit:gitattributes[5] and linkgit:gitmodules[5]).

note: type: Plain text
en: Note that Git at the core level treats path names simply as sequences of non-NUL bytes, there are no path name encoding conversions (except on Mac and Windows). Therefore, using non-ASCII path names will mostly work even on platforms and file systems that use legacy extended ASCII encodings. However, repositories created on such systems will not work properly on UTF-8-based systems (e.g. Linux, Mac, Windows) and vice versa.  Additionally, many Git-based tools simply assume path names to be UTF-8 and will fail to display other encodings correctly.
fr: Remarquez que Git traite les noms de chemins comme des séquences d'octets non-nuls au niveau de base, il n'y a pas de conversion d'encodage des noms de fichiers (sauf sur Mac et Windows). De ce fait, l'utilisation de noms de chemins non-ASCII fonctionnera pratiquement, même sur les plateformes et systèmes de fichier utilisant d'anciens encodages d'ASCII étendu.

note: type: Plain text
en: Commit log messages are typically encoded in UTF-8, but other extended ASCII encodings are also supported. This includes ISO-8859-x, CP125x and many others, but _not_ UTF-16/32, EBCDIC and CJK multi-byte encodings (GBK, Shift-JIS, Big5, EUC-x, CP9xx etc.).
fr: Les messages du journal des validations sont typiquement encodés en UTF-8, mais les autres encodages d'ASCII étendu sont aussi pris en charge. Ceci inclut  ISO-8859-x, CP125x et de nombreux autres, mais _pas_ UTF-16/32, EBCDIC ni les encodages multi-octets CJK (GBK, Shift-JIS, Big5, EUC-x, CP9xx etc.).

note: type: Plain text
en: Although we encourage that the commit log messages are encoded in UTF-8, both the core and Git Porcelain are designed not to force UTF-8 on projects.  If all participants of a particular project find it more convenient to use legacy encodings, Git does not forbid it.  However, there are a few things to keep in mind.
fr: Bien que l'usage de UTF-8 dans les messages de validation soit encouragé, le cœur de Git et la porcelaine sont conçus pour ne pas forcer l'usage d'UTF-8 dans les projets. Si tous les participants d'un projet donné trouvent plus simple d'utiliser des encodages anciens, Git ne l'interdit pas. Cependant, il y a quelques détails à garder en tête.

note: type: Plain text
en: 'git commit' and 'git commit-tree' issues a warning if the commit log message given to it does not look like a valid UTF-8 string, unless you explicitly say your project uses a legacy encoding.  The way to say this is to have i18n.commitencoding in `.git/config` file, like this:
fr: `git commit` et `git commit-tree` affichent un avertissement si le message de validation fourni ne semble pas être une chaîne de caractères UTF-8 valide, à moins que vous n'indiquiez explicitement que votre projet utilise un encodage ancien. La manière de l'indiquer est d'avoir i18n.commitencoding dans `.git/config`, comme ceci :

note: type: Plain text
en: Commit objects created with the above setting record the value of `i18n.commitencoding` in its `encoding` header.  This is to help other people who look at them later.  Lack of this header implies that the commit log message is encoded in UTF-8.
fr: Les objets commit créés avec le réglage ci-dessus enregistrent la valeur de `i18n.commitencoding` dans leur entête d'encodage `encoding`. Ceci permet d'aider les personnes qui les liront plus tard. L'absence de cet entête implique que les message de validation est encodé en UTF-8.

note: type: Plain text
en: 'git log', 'git show', 'git blame' and friends look at the `encoding` header of a commit object, and try to re-code the log message into UTF-8 unless otherwise specified.  You can specify the desired output encoding with `i18n.logoutputencoding` in `.git/config` file, like this:
fr: Sauf indication contraire, 'git log', 'git show', 'git blame' et consort lisent l'entête `encoding` d'un objet commit et essaient de ré-encoder le message de validation en UTF-8. Vous pouvez spécifier l'encodage de sortie que vous souhaitez avec `i18n.logoutputencoding` dans le fichier `.git/config`, comme ceci :

note: type: Plain text
en: If you do not have this configuration variable, the value of `i18n.commitencoding` is used instead.
fr: Si vous n'avez pas changé cette variable de configuration, c'est la valeur de `i18n.commitencoding` qui est utilisée.

note: type: Plain text
en: Note that we deliberately chose not to re-code the commit log message when a commit is made to force UTF-8 at the commit object level, because re-coding to UTF-8 is not necessarily a reversible operation.
fr: Remarquez qu'il a été délibérément choisi de ne pas ré-encoder le message de validation quand le commit est créé pour forcer l'UTF-8 au niveau de l'objet commit parce que ré-encoder en UTF-8 n'est pas nécessairement une opération réversible.
