en to it translation catalogue (81 entries)

note: type: Plain text
en: The `GIT_AUTHOR_DATE` and `GIT_COMMITTER_DATE` environment variables support the following date formats:
it: Le variabili d'ambiente `GIT_AUTHOR_DATE`,` GIT_COMMITTER_DATE`supportano i seguenti formati data:

note: type: Plain text
en: "git-diff-tree", "git-diff-files" and "git-diff --raw" can take `-c` or `--cc` option to generate diff output also for merge commits.  The output differs from the format described above in the following way:
it: "git-diff-tree", "git-diff-files" e "git-diff --raw" possono prendere l'opzione `-c` o` --cc` per generare output differenti anche per incorporare commit. L'output differisce dal formato sopra descritto nel modo seguente:

note: type: Plain text
en: Examples for `-c` and `--cc` without `--combined-all-paths`:
it: Esempi per `-c` e` --cc` senza `--combined-all-path`:

note: type: Plain text
en: 	Generate the diff in raw format.
it: 	Genera il diff in formato grezzo.

note: type: Plain text
en: 	Separate the commits with NULs instead of with new newlines.
it: 	Separare i commit con NUL invece che con nuove righe.

note: type: Plain text
en: Show colored diff.  `--color` (i.e. without '=<when>') is the same as `--color=always`.  '<when>' can be one of `always`, `never`, or `auto`.
it: Mostra diff colorato. `--color` (ovvero senza '= <when>') è uguale a` --color = always`. '<when>' può essere uno di `always`,` never` o `auto`

note: type: Plain text
en: 	Detect renames.
it: 	Rileva le rinominazioni.

note: type: Plain text
en: Ignore changes to submodules in the diff generation. <when> can be either "none", "untracked", "dirty" or "all", which is the default.  Using "none" will consider the submodule modified when it either contains untracked or modified files or its HEAD differs from the commit recorded in the superproject and can be used to override any settings of the 'ignore' option in linkgit:git-config[1] or linkgit:gitmodules[5]. When "untracked" is used submodules are not considered dirty when they only contain untracked content (but they are still scanned for modified content). Using "dirty" ignores all changes to the work tree of submodules, only changes to the commits stored in the superproject are shown (this was the behavior until 1.7.0). Using "all" hides all changes to submodules.
it: Ignora le modifiche ai sottomoduli nella generazione diff. <when> può essere "none", "untracked", "dirty" o "all", che è l'impostazione predefinita. L'uso di "none" considererà il sottomodulo modificato quando contiene file non tracciati o modificati o il suo HEAD differisce dal commit registrato nel superprogetto e può essere usato per sovrascrivere qualsiasi impostazione dell'opzione 'ignore' in linkgit:git-config[1] o linkgit:gitmodules[5]. Quando si utilizza "untracked", i sottomoduli non sono considerati sporchi quando contengono solo contenuto non tracciato (ma sono ancora sottoposti a scansione per il contenuto modificato). L'uso di "dirty" ignora tutte le modifiche all'albero di lavoro dei sottomoduli, vengono mostrate solo le modifiche ai commit archiviati nel superprogetto (questo era il comportamento fino alla 1.7.0). L'uso di "all" nasconde tutte le modifiche ai sottomoduli.

note: type: Plain text
en: Append ref names and object names of fetched refs to the existing contents of `.git/FETCH_HEAD`.  Without this option old data in `.git/FETCH_HEAD` will be overwritten.
it: Aggiungi i nomi dei riferimenti e i nomi dei riferimenti recuperati al contenuto esistente di `.git/FETCH_HEAD`. Senza questa opzione i vecchi dati presenti in `.git/FETCH_HEAD` saranno sovrascritti.

note: type: Plain text
en: Deepen or shorten the history of a shallow repository to include all reachable commits after <date>.
it: Approfondisci o limita la storia di uno shallow repository per includere tutti i commit raggiungibili dopo <date>.

note: type: Plain text
en: If the source repository is complete, convert a shallow repository to a complete one, removing all the limitations imposed by shallow repositories.
it: Se il repository di origine è completo, converti un 'repository shallow' in uno completo, rimuovendo tutte le limitazioni imposte dai repository shallow.

note: type: Plain text
en: By default when fetching from a shallow repository, `git fetch` refuses refs that require updating .git/shallow. This option updates .git/shallow and accept such refs.
it: Di default quando si recuperano i dati da uno "shallow repository", `git fetch` non accetta riferimenti che richiedono di fare l'aggiornamento di .git/shallow. Inserendo questa opzione vengono accettati questi riferimenti ed aggiornato .git/shallow.

note: type: Title -
en: NAME
it: NOME

note: type: Title -
en: SYNOPSIS
it: SINOSSI

note: type: Title -
en: DESCRIPTION
it: DESCRIZIONE

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`.
it: Ricordare solo il fatto che il percorso sarà aggiunto successivamente. Un ingresso per il percorso è posto nell'indice senza contenuto. Ciò è utile per, tra le altre cose, mostrare il contenuto non organizzato di tali file con `git diff`e impegnarli con `git commit -a`.

note: type: Plain text
en: Pathspec is passed in `<file>` instead of commandline args. If `<file>` is exactly `-` then standard input is used. Pathspec elements are separated by LF or CR/LF. Pathspec elements can be quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]). See also `--pathspec-file-nul` and global `--literal-pathspecs`.
it: Pathspec viene passato in `<file>` invece degli arg della riga di comando. Se `<file>` è esattamente `-`, viene utilizzato l'input standard. Gli elementi pathspec vengono separati da LF o CR/LF. Gli elementi pathspec possono essere citati come spiegato per la variabile di configurazione `core.quotePath` (see linkgit:git-config[1]). Vedere anche `--pathspec-file-nul` ed il `--literal-pathspecs` global.

note: type: Plain text
en: Adds content from all `*.txt` files under `Documentation` directory and its subdirectories:
it: Aggiunge contenuti da tutta la cartella `*.txt` files under `Documentation` e le sue sottocartelle:

note: type: Plain text
en: What you chose are then highlighted with '*', like this:
it: Quelli che scegli sono quindi evidenziate con '*', così:

note: type: Labeled list
en: added content
it: contenuto aggiunto

note: type: Labeled list
en: modified content
it: contenuto modificato

note: type: Title -
en: SEE ALSO
it: VEDERE ANCHE

note: type: Plain text
en: Part of the linkgit:git[1] suite
it: Parte del pacchetto linkgit:git[1]

note: type: Plain text
en: *NOTE*: this is a possibly dangerous operation; do *not* use
    it unless you understand what it does. If you clone your
    repository using this option and then delete branches (or use any
    other Git command that makes any existing commit unreferenced) in the
    source repository, some objects may become unreferenced (or dangling).
    These objects may be removed by normal Git operations (such as `git commit`)
    which automatically call `git maintenance run --auto`. (See
    linkgit:git-maintenance[1].) If these objects are removed and were referenced
    by the cloned repository, then the cloned repository will become corrupt.
it: * NOTA *: questa è un'operazione forse pericolosa; non usare
    a meno che tu non capisca cosa fa. Se cloni il tuo
    repository utilizzando questa opzione e quindi eliminare i rami (o utilizzare qualsiasi
    altro comando Git che rende qualsiasi commit esistente senza riferimento) nel
     repository di origine, alcuni oggetti potrebbero non essere più referenziati (o appesi?).
    Questi oggetti possono essere rimossi dalle normali operazioni di Git (come `git commit`)
    che chiama automaticamente `git gc --auto`. (Vedi linkgit:git-gc[1].)
    Se questi oggetti vengono rimossi e sono stati referenziati dal repository clonato,
    allora il repository clonato diverrà corrotto.

note: type: Plain text
en: The `-m` option is mutually exclusive with `-c`, `-C`, and `-F`.
it: L'opzione `-m` si esclude a vicenda con` -c`, `-C` e` -F`.

note: type: Plain text
en: Show untracked files.
it: Mostra i file non tracciati.

note: type: Plain text
en: 'git diff-index' [-m] [--cached] [--merge-base] [<common-diff-options>] <tree-ish> [<path>...]
it: 'git diff-index' [-m] [--cached] [--merge-base] [<opzioni-comuni-diff>] <tree-ish> [<path>...]

note: type: Plain text
en: Show changes between commits, commit and working tree, etc
it: Visualizza le modifiche fra commit, un commit e l'albero di lavoro, ecc.

note: type: Plain text
en: Run merge conflict resolution tools to resolve merge conflicts
it: Esegue gli strumenti di risoluzione conflitti di merge per risolvere i conflitti di merge

note: type: Plain text
en: Get and set repository or global options
it: Ottiene e imposta le opzioni a livello di repository o globali

note: type: Labeled list
en: 'git diff' [<options>] --cached [--merge-base] [<commit>] [--] [<path>...]
it: 'git diff' [<opzioni>] --cached [--merge-base] [<commit>] [--] [<percorso>...]

note: type: Labeled list
en: 'git diff' [<options>] [--merge-base] <commit> [--] [<path>...]
it: 'git diff' [<opzioni>] [--merge-base] <commit> [--] [<path>...]

note: type: Labeled list
en: 'git diff' [<options>] <commit>\...<commit> [--] [<path>...]
it: 'git diff' [<opzioni>] <commit>\...<commit> [--] [<path>...]

note: type: Plain text
en: force
it: forza l'operazione

note: type: Labeled list
en: reason
it: motivo

note: type: Plain text
en: Update the remote-tracking branches:
it: Aggiorna i rami che tracciano rami remoti:

note: type: Title -
en: Other
it: Altro

note: type: Plain text
en: 'git init-db' [-q | --quiet] [--bare] [--template=<template-directory>] [--separate-git-dir <git-dir>] [--shared[=<permissions>]]
it: 'git init' [-q | --quiet] [--bare] [--template=<template_directory>] [--separate-git-dir <git dir>] [--object-format=<format] [--shared[=<permissions>]] [directory]

note: type: Plain text
en: 'git init' [-q | --quiet] [--bare] [--template=<template-directory>]
    	  [--separate-git-dir <git-dir>] [--object-format=<format>]
    	  [-b <branch-name> | --initial-branch=<branch-name>]
    	  [--shared[=<permissions>]] [<directory>]
it: 'git init' [-q | --quiet] [--bare] [--template=<template_directory>]
    	  [--separate-git-dir <git dir>] [--object-format=<format]
    	  [-b <branch-name> | --initial-branch=<branch-name>]
    	  [--shared[=<permissions>]] [directory]

note: type: Title ~
en: General options
it: Opzioni generali

note: type: Title ~
en: Options related to merging
it: Opzioni relative al merge

note: type: Title ~
en: Options related to fetching
it: Opzioni relative al fetch

note: type: Plain text
en: Ignore changes to submodules when looking for changes. <when> can be either "none", "untracked", "dirty" or "all", which is the default.  Using "none" will consider the submodule modified when it either contains untracked or modified files or its HEAD differs from the commit recorded in the superproject and can be used to override any settings of the 'ignore' option in linkgit:git-config[1] or linkgit:gitmodules[5]. When "untracked" is used submodules are not considered dirty when they only contain untracked content (but they are still scanned for modified content). Using "dirty" ignores all changes to the work tree of submodules, only changes to the commits stored in the superproject are shown (this was the behavior before 1.7.0). Using "all" hides all changes to submodules (and suppresses the output of submodule summaries when the config option `status.submoduleSummary` is set).
it: Ignora le modifiche ai sottomoduli nella generazione diff. <when> può essere "none", "untracked", "dirty" o "all", che è l'impostazione predefinita. L'uso di "none" considererà il sottomodulo modificato quando contiene file non tracciati o modificati o il suo HEAD differisce dal commit registrato nel superprogetto e può essere usato per sovrascrivere qualsiasi impostazione dell'opzione 'ignore' in linkgit:git-config[1] o linkgit:gitmodules[5]. Quando si utilizza "untracked", i sottomoduli non sono considerati sporchi quando contengono solo contenuto non tracciato (ma sono ancora sottoposti a scansione per il contenuto modificato). L'uso di "dirty" ignora tutte le modifiche all'albero di lavoro dei sottomoduli, vengono mostrate solo le modifiche ai commit archiviati nel superprogetto (questo era il comportamento fino alla 1.7.0). L'uso di "all" nasconde tutte le modifiche ai sottomoduli.

note: type: Title ~
en: Interacting with Others
it: Interazione con altri

note: type: Plain text
en: Unless `-z` is used any "unusual" characters in the lock reason such as newlines are escaped and the entire reason is quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).  For Example:
it: A meno che non sia usata l'opzione "-z", viene fatto l'escape dei caratteri "insoliti" riportati nel motivo del lock, come i caratteri newline, e il motivo completo è citato come spiegato per la variabile di configurazione `core.quotePath` (vedi linkgit:git-config[1]). Per esempio:

note: type: Plain text
en: gitglossary - A Git Glossary
it: gitglossary - Un glossario di Git

note: type: Plain text
en: linkgit:gittutorial[7], linkgit:gittutorial-2[7], linkgit:gitcvs-migration[7], linkgit:giteveryday[7], link:user-manual.html[The Git User's Manual]
it: linkgit:gittutorial[7], linkgit:gittutorial-2[7], linkgit:gitcvs-migration[7], linkgit:giteveryday[7], link:user-manual.html[Il manuale utente di Git]

note: type: Labeled list
en: [[def_alternate_object_database]]alternate object database
it: [[def_alternate_object_database]]database degli oggetti alternativo

note: type: Plain text
en: Via the alternates mechanism, a <<def_repository,repository>> can inherit part of its <<def_object_database,object database>> from another object database, which is called an "alternate".
it: Tramite il meccanismo degli alternate, una <<def_repository,repository>> può ereditare parte del proprio <<def_object_database,database di oggetti>> da un altro database di oggetti, che è detto "alternativo".

note: type: Plain text
en: A bare repository is normally an appropriately named <<def_directory,directory>> with a `.git` suffix that does not have a locally checked-out copy of any of the files under revision control. That is, all of the Git administrative and control files that would normally be present in the hidden `.git` sub-directory are directly present in the `repository.git` directory instead, and no other files are present and checked out. Usually publishers of public repositories make bare repositories available.
it: Una bare repository è una <<def_directory,directory>> nominata appropriatamente con il suffisso `.git` che non contiene una copia locale dei file sotto controllo revisione. Significa che tutti i file Git di amministrativi e di controllo che normalmente sarebbero presenti nella sottocartella nascosta `.git`sono presenti invece nella cartella `repository.git`, e nessun altro file è presente e checked out. Solitamente chi pubblica una repository pubblica rende disponibili delle bare repository.

note: type: Labeled list
en: [[def_blob_object]]blob object
it: [[def_blob_object]]oggetto blob

note: type: Plain text
en: Untyped <<def_object,object>>, e.g. the contents of a file.
it: <<def_object,oggetto>> senza tipo, ad esempio i contenuti di un file.

note: type: Plain text
en: Obsolete for: <<def_index,index>>.
it: Termine obsoleto per: <<def_index,indice>>.

note: type: Plain text
en: A list of objects, where each <<def_object,object>> in the list contains a reference to its successor (for example, the successor of a <<def_commit,commit>> could be one of its <<def_parent,parents>>).
it: Una lista di oggetti, dove ogni <<def_object,oggetto>> della lista contiene un riferimento al suo successore (ad esempio, il successore di un <<def_commit,commit>> può essere uno dei suo <<def_parent,genitori>>).

note: type: Plain text
en: BitKeeper/cvsps speak for "<<def_commit,commit>>". Since Git does not store changes, but states, it really does not make sense to use the term "changesets" with Git.
it: Termine usato in BitKeeper/cvsps per "<<def_commit,commit>>". Siccome Git non salva cambiamenti, ma stati, non ha senso usare il termine "changeset" in Git.

note: type: Plain text
en: The action of updating all or part of the <<def_working_tree,working tree>> with a <<def_tree_object,tree object>> or <<def_blob_object,blob>> from the <<def_object_database,object database>>, and updating the <<def_index,index>> and <<def_HEAD,HEAD>> if the whole working tree has been pointed at a new <<def_branch,branch>>.
it: L'azione di aggiornare tutto o una parte del <<def_working_tree,working tree>> con un <<def_tree_object,tree object>> o un <<def_blob_object,blob>> dal <<def_object_database, database degli oggetti>>, e aggiornare l' <<def_index,indice>> e lo <<def_HEAD,HEAD>> se l'intero working tree è stato puntato verso un nuovo <<def_branch,ramo>>.

note: type: Plain text
en: In <<def_SCM,SCM>> jargon, "cherry pick" means to choose a subset of changes out of a series of changes (typically commits) and record them as a new series of changes on top of a different codebase. In Git, this is performed by the "git cherry-pick" command to extract the change introduced by an existing <<def_commit,commit>> and to record it based on the tip of the current <<def_branch,branch>> as a new commit.
it: Nel gergo di <<def_SCM,SCM>>, fare "cherry-pick" significa scegliere un sottoinsieme di cambiamenti in un insieme (tipicamente si tratta di commit) e salvarli come una nuova serie di cambiamenti sulla punta di una codebase differente. In Git si usa il comando"git cherry-pick" per estrarre un cambiamento introdotto da un <<def_commit,commit>> preesistente e salvarlo sulla punta del <<def_branch,ramo>> corrente come un nuovo commit.

note: type: Plain text
en: A <<def_working_tree,working tree>> is clean, if it corresponds to the <<def_revision,revision>> referenced by the current <<def_head,head>>. Also see "<<def_dirty,dirty>>".
it: Si dice che un <<def_working_tree,working tree>> è pulito se corrisponde alla <<def_revision,revisione>> referenziata dallo <<def_head,head>> attuale. Vedere anche "<<def_dirty,dirty>>".

note: type: Plain text
en: As a noun: A single point in the Git history; the entire history of a project is represented as a set of interrelated commits.  The word "commit" is often used by Git in the same places other revision control systems use the words "revision" or "version".  Also used as a short hand for <<def_commit_object,commit object>>.
it: Usato come nome: un singolo punto in una storia Git; l'intera storia di un progetto è rappresentata da un insieme di commit correlati. La parola "commit" è usata spesso in Git allo stessa maniera in cui altri sistemi di controllo versione usano la parola "revisione" o "versione". È usato anche come abbreviazione di <<def_commit_object,oggetto commit>>.

note: type: Plain text
en: As a verb: The action of storing a new snapshot of the project's state in the Git history, by creating a new commit representing the current state of the <<def_index,index>> and advancing <<def_HEAD,HEAD>> to point at the new commit.
it: Usato come verbo: L'azione di salvare una foto dello stato del progetto nella storia Git, creando un nuovo commit che rappresenta lo stato corrente dell'<<def_index,indice>> e spostando avanti lo <<def_HEAD,HEAD>> a puntare al nuovo commit.

note: type: Labeled list
en: [[def_commit_object]]commit object
it: [[def_commit_object]]oggetto commit

note: type: Plain text
en: An <<def_object,object>> which contains the information about a particular <<def_revision,revision>>, such as <<def_parent,parents>>, committer, author, date and the <<def_tree_object,tree object>> which corresponds to the top <<def_directory,directory>> of the stored revision.
it: Un <<def_object,oggetto>> che contiene informazioni su una particolare <<def_revision,revisione>>, come i <<def_parent,parent>>, chi ha committato, l'autore, la data e l' <<def_tree_object,albero degli oggetti>> che corrisponde alla <<def_directory,directory>> principale della revisione memorizzata.

note: type: Labeled list
en: [[def_commit-ish]]commit-ish (also committish)
it: [[def_commit-ish]]commit-ish (detto anche committish)

note: type: Plain text
en: A <<def_commit_object,commit object>> or an <<def_object,object>> that can be recursively dereferenced to a commit object.  The following are all commit-ishes: a commit object, a <<def_tag_object,tag object>> that points to a commit object, a tag object that points to a tag object that points to a commit object, etc.
it: Un <<def_commit_object,oggetto commit>> oppure un <<def_object,object>> da cui si può risalire a un oggetto commit. I seguenti sono esempi di commit-ish: un oggetto commit, un <<def_tag_object,oggetto tag>> che punta a un oggetto commit, un oggetto tag che punta a un oggetto tag che a sua volta punta a un oggetto commit, eccetera.

note: type: Plain text
en: Fundamental data structures and utilities of Git. Exposes only limited source code management tools.
it: Strutture dati e utilità fondamentali di Git. Espone solo una parte limitata degli strumenti di gestione del codice sorgente.

note: type: Plain text
en: Directed acyclic graph. The <<def_commit_object,commit objects>> form a directed acyclic graph, because they have parents (directed), and the graph of commit objects is acyclic (there is no <<def_chain,chain>> which begins and ends with the same <<def_object,object>>).
it: Grafo diretto aciclico. Gli <<def_commit_object,oggetti commit>> formano un grafo diretto aciclico, perchè hanno sempre dei genitori (diretti), e il grafo è aciclico (non c'è una <<def_chain,catena>> che inizia e finisce con lo stesso <<def_object,oggetto>>).

note: type: Plain text
en: An <<def_unreachable_object,unreachable object>> which is not <<def_reachable,reachable>> even from other unreachable objects; a dangling object has no references to it from any reference or <<def_object,object>> in the <<def_repository,repository>>.
it: Un <<def_unreachable_object,oggetto irraggiungibile>> che non è <<def_reachable,raggiungibile>> nemmeno da altri oggetti irraggiungibili; un dangling object non ha riferimenti ad esso a partire da qualsiasi altro riferimento od <<def_object,oggetto>> nella <<def_repository,repository>>.

note: type: Plain text
en: The list you get with "ls" :-)
it: La lista che ottieni con il comando "ls" :-)

note: type: Labeled list
en: [[def_dirty]]dirty
it: [[def_dirty]]sporco

note: type: Plain text
en: A <<def_working_tree,working tree>> is said to be "dirty" if it contains modifications which have not been <<def_commit,committed>> to the current <<def_branch,branch>>.
it: Un <<def_working_tree,working tree>> si dice "sporco" se contiene modifiche che non sono state <<def_commit,committate>> sul <<def_branch,branch>> corrente.

note: type: Labeled list
en: [[def_evil_merge]]evil merge
it: [[def_evil_merge]]merge cattivo

note: type: Plain text
en: An evil merge is a <<def_merge,merge>> that introduces changes that do not appear in any <<def_parent,parent>>.
it: Un merge cattivo è un <<def_merge,merge>> che introduce cambiamenti che non compaiono in alcun <<def_parent,genitore>>.

note: type: Plain text
en: A fast-forward is a special type of <<def_merge,merge>> where you have a <<def_revision,revision>> and you are "merging" another <<def_branch,branch>>'s changes that happen to be a descendant of what you have. In such a case, you do not make a new <<def_merge,merge>> <<def_commit,commit>> but instead just update your branch to point at the same revision as the branch you are merging. This will happen frequently on a <<def_remote_tracking_branch,remote-tracking branch>> of a remote <<def_repository,repository>>.
it: Il fast-forward è un tipo speciale di <<def_merge,merge>> dove hai un <<def_commit,commit>> e stai "mergiando" i cambiamenti di un <<def_branch,ramo>> che è discendente del tuo. In questo caso, non c'è bisogno di un nuovo <<def_commit,commit>> di <<def_merge,merge>>, invece basta aggiornare il tuo ramo per puntare allo stesso commit del ramo che stai mergiando. Questo capita di frequente su un <<def_remote_tracking_branch,remote-tracking branch>> di una <<def_repository,repository>> remota.

note: type: Plain text
en: Fetching a <<def_branch,branch>> means to get the branch's <<def_head_ref,head ref>> from a remote <<def_repository,repository>>, to find out which objects are missing from the local <<def_object_database,object database>>, and to get them, too.  See also linkgit:git-fetch[1].
it: Fare fetch di un <<def_branch,branch>> significa prendere il <<def_head_ref,head ref>> di un branch da una <<def_repository,repository>> remota, per scoprire quali oggetti mancano nel <<def_object_database,object database>> locale e recuperarli. Vedere anche linkgit:git-fetch[1].

note: type: Plain text
en: Synonym for <<def_repository,repository>> (for arch people).
it: Sinonimo di <<def_repository,repository>> (per quelli di arch).

note: type: Plain text
en: A plain file `.git` at the root of a working tree that points at the directory that is the real repository.
it: Un file `.git` alla base del working tree che punta alla directory che è la vera repository.

note: type: Plain text
en: In Git's context, synonym for <<def_object_name,object name>>.
it: Nel contesto di Git, sinonimo di <<def_object_name,object name>>.

note: type: Plain text
en: A <<def_ref,named reference>> to the <<def_commit,commit>> at the tip of a <<def_branch,branch>>.  Heads are stored in a file in `$GIT_DIR/refs/heads/` directory, except when using packed refs. (See linkgit:git-pack-refs[1].)
it: Un <<def_ref,riferimento>> al <<def_commit,commit>> sulla punta del <<def_branch,branch>>. Gli head sono salvati in un file nella cartella `$GIT_DIR/refs/heads/`, tranne quando si usano i packed ref. (Vedere linkgit:git-pack-refs[1].)

note: type: Plain text
en: The current <<def_branch,branch>>.  In more detail: Your <<def_working_tree, working tree>> is normally derived from the state of the tree referred to by HEAD.  HEAD is a reference to one of the <<def_head,heads>> in your repository, except when using a <<def_detached_HEAD,detached HEAD>>, in which case it directly references an arbitrary commit.
it: Il <<def_branch,ramo>> corrente. Di preciso: il tuo <<def_working_tree,working tree>> normalmente deriva dallo stato dell'albero collegato allo HEAD. HEAD è un riferimento a uno degli <<def_head,head>> nella tua repository, eccetto quando hai uno <<def_detached_HEAD,HEAD staccato>>, nel quale caso HEAD si riferisce direttamente a un qualsiasi commit.

note: type: Plain text
en: For local repositories, also supported by Git natively, the following syntaxes may be used:
it: Per i repository locali, supportati anche da Git in modo nativo, è possibile utilizzare le seguenti sintassi:

note: type: Plain text
en: where <address> may be a path, a server and path, or an arbitrary URL-like string recognized by the specific remote helper being invoked. See linkgit:gitremote-helpers[7] for details.
it: dove <indirizzo> può essere un percorso, un server e un percorso o una stringa arbitraria simile a un URL riconosciuta dall'helper remoto specifico che viene richiamato. Vedi linkgit:gitremote-helpers[7] per i dettagli.
