git-diff-tree - Online nel cloud

PROGRAMMA:

NOME

git-diff-tree - Confronta il contenuto e la modalità dei blob trovati tramite due oggetti ad albero

SINOSSI

git albero differenziale [--stdin] [-m] [-s] [-v] [--no-commit-id] [--carino]
[-t] [-r] [-c | --cc] [--root] [ ]
[ ] [ ...]

DESCRIZIONE

Confronta il contenuto e la modalità dei BLOB trovati tramite due oggetti albero.

Se ce n'è solo uno dato, il commit viene confrontato con i suoi genitori (vedi
--stdin sotto).

Si noti che git albero differenziale può utilizzare l'albero incapsulato in un oggetto commit.

VERSIONI

-p, -u, --patch
Genera patch (vedere la sezione sulla generazione di patch).

-s, --no-patch
Sopprimere l'uscita differenziale. Utile per comandi come git show che mostrano la patch di
default, o per annullare l'effetto di --patch.

-U , --unified=
Genera differenze con linee di contesto invece delle solite tre. Implica -p.

--crudo
Genera la differenza in formato raw. Questa è l'impostazione predefinita.

--patch-con-raw
Sinonimo di -p --raw.

--minimo
Dedica più tempo per assicurarti che venga prodotta la differenza più piccola possibile.

--pazienza
Genera una differenza usando l'algoritmo "pazienza diff".

--istogramma
Genera una differenza utilizzando l'algoritmo "istogramma diff".

--diff-algorithm={pazienza|minimo|istogramma|myers}
Scegli un algoritmo diff. Le varianti sono le seguenti:

predefinito, myers
L'algoritmo di base greedy diff. Attualmente, questa è l'impostazione predefinita.

minimo
Dedica più tempo per assicurarti che venga prodotta la differenza più piccola possibile.

pazienza
Utilizzare l'algoritmo "pazienza diff" durante la generazione di patch.

istogramma
Questo algoritmo estende l'algoritmo di pazienza per "supportare il comune a bassa occorrenza
elementi".

Ad esempio, se hai configurato la variabile diff.algorithm su un valore non predefinito e
vuoi usare quello predefinito, allora devi usare l'opzione --diff-algorithm=default.

--stat[= [, [, ]]]
Genera un differenziale. Per impostazione predefinita, verrà utilizzato tutto lo spazio necessario per il
la parte del nome del file e il resto per la parte del grafico. La larghezza massima è predefinita per il terminale
larghezza, o 80 colonne se non connesso a un terminale e può essere sovrascritto da .
La larghezza della parte del nome del file può essere limitata dando un'altra larghezza
dopo una virgola. La larghezza della parte del grafico può essere limitata utilizzando
--stat-graph-width= (influenza tutti i comandi che generano un grafico statico) o da
impostazione diff.statGraphWidth= (non influisce su git format-patch). Dando un
terzo parametro , puoi limitare l'output al primo linee, seguito
da ... se ce ne sono di più.

Questi parametri possono anche essere impostati individualmente con --stat-width= ,
--stat-name-width= e --stat-count= .

--numstat
Simile a --stat, ma mostra il numero di righe aggiunte ed eliminate in notazione decimale e
percorso senza abbreviazione, per renderlo più intuitivo. Per i file binari,
emette due - invece di dire 0 0.

--shortstat
Emetti solo l'ultima riga del formato --stat contenente il numero totale di modifiche
file, nonché il numero di righe aggiunte ed eliminate.

--dirstat[= ]
Emetti la distribuzione della quantità relativa di modifiche per ogni sottodirectory. Il
il comportamento di --dirstat può essere personalizzato passandogli un elenco separato da virgole di
parametri. I valori predefiniti sono controllati dalla variabile di configurazione diff.dirstat
(Vedi git-config(1)). Sono disponibili i seguenti parametri:

i cambiamenti
Calcola i numeri dirstat contando le righe che sono state rimosse dal
sorgente o aggiunto alla destinazione. Questo ignora la quantità di codice puro
movimenti all'interno di un file. In altre parole, riordinare le righe in un file non lo è
contato tanto quanto gli altri cambiamenti. Questo è il comportamento predefinito quando nessun parametro
viene data.

Linee
Calcolare i numeri dirstat eseguendo la normale analisi diff basata sulla linea e
sommando i conteggi delle righe rimosse/aggiunte. (Per i file binari, contare i blocchi da 64 byte
invece, poiché i file binari non hanno un concetto naturale di linee). Questo è un altro
costoso --dirstat comportamento rispetto al comportamento delle modifiche, ma conta
righe riordinate all'interno di un file tanto quanto altre modifiche. L'output risultante è
coerente con ciò che ottieni dalle altre opzioni --*stat.

file
Calcola i numeri dirstat contando il numero di file modificati. Ogni cambiato
il file conta allo stesso modo nell'analisi dirstat. Questo è il computazionalmente più economico
--dirstat comportamento, poiché non deve guardare affatto il contenuto del file.

cumulativo
Contare le modifiche in una directory figlio anche per la directory padre. Notare che
in caso di utilizzo cumulativo, la somma delle percentuali riportate può superare il 100%. Il
il comportamento predefinito (non cumulativo) può essere specificato con il non cumulativo
parametro.


Un parametro intero specifica una percentuale di interruzione (3% per impostazione predefinita). Directory
contribuendo meno di questa percentuale delle modifiche non viene mostrato nell'output.

Esempio: quanto segue conterà i file modificati, ignorando le directory con meno
oltre il 10% della quantità totale di file modificati e l'accumulo di conteggi di directory figlio
nelle directory principali: --dirstat=files,10,cumulative.

--riepilogo
Emetti un riepilogo condensato delle informazioni di intestazione estese come creazioni, rinomina
e cambi di modalità.

--patch-con-stat
Sinonimo di -p --stat.

-z
Quando sono stati forniti --raw, --numstat, --name-only o --name-status, non munge
nomi di percorso e utilizzare NUL come terminatori del campo di output.

Senza questa opzione, ogni output del percorso avrà TAB, LF, virgolette e
caratteri barra rovesciata sostituiti rispettivamente con \t, \n, \" e \\ e il nome del percorso
sarà racchiuso tra virgolette se si è verificata una di queste sostituzioni.

--solo-nome
Mostra solo i nomi dei file modificati.

--nome-stato
Mostra solo i nomi e lo stato dei file modificati. Vedi la descrizione del --diff-filter
opzione su cosa significano le lettere di stato.

--sottomodulo[= ]
Specificare come vengono mostrate le differenze nei sottomoduli. Quando --submodule o --submodule=log
è dato, il ceppo viene utilizzato il formato. Questo formato elenca i commit nell'intervallo come idiota-
modulo(1) riassunto fa. Omettendo l'opzione --submodule o specificando
--submodule=breve, usa il corto formato. Questo formato mostra solo i nomi dei
commit all'inizio e alla fine dell'intervallo. Può essere modificato tramite il diff.submodule
configurazione variabile.

--colore[= ]
Mostra differenze colorate --color (cioè senza =) è uguale a --color=always.
può essere uno di sempre, mai o auto.

--no-colore
Disattiva le differenze colorate. È lo stesso di --color=never.

--parola-diff[= ]
Mostra una parola diff, usando il delimitare le parole modificate. Per impostazione predefinita, le parole sono
delimitato da spazi bianchi; vedi --word-diff-regex sotto. Il il valore predefinito è pianura,
e deve essere uno tra:

colore
Evidenzia le parole modificate usando solo i colori. Implica --color.

pianura
Mostra parole come [-rimosso-] e {+aggiunto+}. Non fa alcun tentativo di sfuggire al
delimitatori se compaiono nell'input, quindi l'output potrebbe essere ambiguo.

porcellana
Utilizzare uno speciale formato basato su righe destinato al consumo di script.
Le esecuzioni aggiunte/rimosse/non modificate vengono stampate nel consueto formato diff unificato,
inizia con un carattere +/-/` ` all'inizio della riga e si estende fino a
La fine della linea. Le nuove righe nell'input sono rappresentate da una tilde ~ su una riga
di suo

nessuna
Disabilita di nuovo la differenza di parola.

Nota che nonostante il nome della prima modalità, il colore viene utilizzato per evidenziare il modificato
parti in tutte le modalità, se abilitate.

--word-diff-regex=
Utilizzo per decidere che cos'è una parola, invece di considerare sequenze di spazi non bianchi per
essere una parola. Implica anche --word-diff a meno che non sia già abilitato.

Ogni partita non sovrapposta del è considerata una parola. qualsiasi cosa tra
queste corrispondenze sono considerate spazi bianchi e ignorate(!) ai fini della ricerca
differenze. Potresti voler aggiungere |[^[:space:]] alla tua espressione regolare per creare
assicurati che corrisponda a tutti i caratteri non di spaziatura. Una corrispondenza che contiene una nuova riga è
silenziosamente troncato (!) alla nuova riga.

Ad esempio, --word-diff-regex=. tratterà ogni carattere come una parola e,
di conseguenza, mostra le differenze carattere per carattere.

La regex può anche essere impostata tramite un driver diff o un'opzione di configurazione, vedi
gitattributi(1) o git-config(1). Darlo esplicitamente sovrascrive qualsiasi driver diff o
impostazione di configurazione. I driver diff sovrascrivono le impostazioni di configurazione.

--color-words[= ]
Equivalente a --word-diff=color plus (se è stata specificata un'espressione regolare)
--word-diff-regex= .

--no-rinomina
Disattiva il rilevamento della ridenominazione, anche quando il file di configurazione fornisce l'impostazione predefinita da fare
così.

--dai un'occhiata
Avvisa se le modifiche introducono errori di spazi vuoti. Ciò che sono considerati errori di spaziatura è
controllato dalla configurazione core.whitespace. Per impostazione predefinita, spazi bianchi finali
(comprese le righe che consistono esclusivamente di spazi bianchi) e un carattere spazio che è
immediatamente seguito da un carattere di tabulazione all'interno del rientro iniziale della riga sono
considerati errori di spaziatura. Esce con stato diverso da zero se vengono rilevati problemi. Non
compatibile con --exit-code.

--ws-error-highlight=
Evidenzia gli errori di spazi vuoti sulle righe specificate da nel colore specificato da
colore.diff.spazio bianco. è un elenco separato da virgole di vecchio, nuovo, contesto. quando
questa opzione non è data, solo gli errori di spazi vuoti nelle nuove righe sono evidenziati. Per esempio
--ws-error-highlight=new,old evidenzia gli errori di spazi bianchi sia su cancellato che su aggiunto
Linee. tutto può essere usato come scorciatoia per vecchio,nuovo,contesto.

--indice completo
Invece della prima manciata di caratteri, mostra l'intero blob pre e post immagine
i nomi degli oggetti sulla riga "indice" durante la generazione dell'output in formato patch.

--binario
Oltre a --full-index, genera un differenziale binario che può essere applicato con git-apply.

--abbrev[= ]
Invece di mostrare il nome dell'oggetto esadecimale completo di 40 byte nell'output in formato diff-raw
e le righe di intestazione diff-tree, mostrano solo un prefisso parziale. Questo è indipendente dal
--full-index opzione sopra, che controlla il formato di output diff-patch. Non predefinito
il numero di cifre può essere specificato con --abbrev= .

-B[ ][/ ], --break-rewrites[=[ ][/ ]]
Rompi le modifiche di riscrittura complete in coppie di elimina e crea. Questo serve per due
fini:

Influisce sul modo in cui una modifica che equivale a una riscrittura totale di un file non come una serie
di cancellazione e inserimento mescolati insieme a pochissime righe che accadono corrispondere
testualmente come il contesto, ma come una singola eliminazione di tutto ciò che è vecchio seguito da a
singolo inserimento di tutto nuovo, e il numero m controlla questo aspetto del -B
opzione (predefinito al 60%). -B/70% specifica che meno del 30% dell'originale dovrebbe
rimangono nel risultato affinché Git lo consideri una riscrittura totale (ovvero altrimenti il
la patch risultante sarà una serie di cancellazioni e inserimenti mescolati insieme al contesto
Linee).

Se usato con -M, anche un file completamente riscritto viene considerato come la sorgente di a
rename (di solito -M considera solo un file scomparso come origine di un rinomina),
e il numero n controlla questo aspetto dell'opzione -B (il valore predefinito è 50%). -B20%
specifica che una modifica con aggiunta e cancellazione rispetto al 20% o più del
le dimensioni del file possono essere prese come possibile fonte di una ridenominazione in
un altro file.

-M[ ], --find-renames[= ]
Rileva rinomina. Se n è specificato, è una soglia sull'indice di similarità (es
quantità di aggiunte/cancellazioni rispetto alla dimensione del file). Ad esempio, -M90% significa
Git dovrebbe considerare una coppia di eliminazione/aggiunta come una ridenominazione se più del 90% del file
non è cambiato. Senza il segno %, il numero va letto come una frazione, con a
punto decimale prima di esso. Cioè, -M5 diventa 0.5, ed è quindi uguale a -M50%.
Allo stesso modo, -M05 è uguale a -M5%. Per limitare il rilevamento a rinominazioni esatte, utilizzare -M100%.
L'indice di somiglianza predefinito è 50%.

-C[ ], --trova-copie[= ]
Rileva copie e rinomina. Vedi anche --find-copies-harder. Se n è specificato, è
ha lo stesso significato di -M .

--trova-copie-difficile
Per motivi di prestazioni, per impostazione predefinita, l'opzione -C trova le copie solo se il file originale
della copia è stata modificata nello stesso changeset. Questo flag fa ispezionare il comando
file non modificati come candidati per la fonte della copia. Questo è molto costoso
operazione per grandi progetti, quindi usalo con cautela. Dare più di un'opzione -C
ha lo stesso effetto.

-D, --cancella-irreversibile
Ometti la preimmagine per le eliminazioni, cioè stampa solo l'intestazione ma non la differenza tra le
preimage e /dev/null. La patch risultante non è pensata per essere applicata con patch o
git applica; questo è solo per le persone che vogliono concentrarsi solo sulla revisione del
testo dopo la modifica. Inoltre, l'output ovviamente manca di informazioni sufficienti per
applicare tale patch al contrario, anche manualmente, da cui il nome dell'opzione.

Se usato insieme a -B, ometti anche la preimmagine nella parte di cancellazione di a
eliminare/creare coppia.

-l
Le opzioni -M e -C richiedono un tempo di elaborazione O(n^2) dove n è il numero di
potenziali target di ridenominazione/copia. Questa opzione impedisce l'esecuzione del rilevamento di rinomina/copia
se il numero di destinazioni di ridenominazione/copia supera il numero specificato.

--diff-filter=[(A|C|D|M|R|T|U|X|B)...[*]]
Seleziona solo i file che sono stati aggiunti (A), copiati (C), eliminati (D), modificati (M), rinominati
(R), hanno il loro tipo (cioè file normale, collegamento simbolico, sottomodulo, ...) cambiato (T), sono
Unmerged (U), sono Sconosciuti (X) o hanno avuto la loro coppia interrotta (B). Qualsiasi combinazione
dei caratteri del filtro (incluso nessuno). Quando viene aggiunto * (Tutto o nessuno)
alla combinazione, tutti i percorsi sono selezionati se c'è qualche file che corrisponde ad altri
criteri nel confronto; se non ci sono file che corrispondono ad altri criteri, niente
è selezionato.

-S
Cerca le differenze che modificano il numero di occorrenze della stringa specificata
(cioè aggiunta/cancellazione) in un file. Destinato all'uso dello scripter.

È utile quando stai cercando un blocco di codice esatto (come una struttura) e vuoi
per conoscere la storia di quel blocco dalla sua nascita: usa la funzione
in modo iterativo per alimentare il blocco interessante nella preimmagine in -S e continuare
fino a quando non ottieni la primissima versione del blocco.

-G
Cerca le differenze il cui testo della patch contiene righe aggiunte/rimosse che corrispondono .

Per illustrare la differenza tra -S --pickaxe-regex e -G , tener conto di
un commit con il seguente diff nello stesso file:

+ return !regexec(regexp, two->ptr, 1, ®match, 0);
...
- hit = !regexec(regexp, mf2.ptr, 1, ®match, 0);

Mentre git log -G"regexec\(regexp" mostrerà questo commit, git log -S"regexec\(regexp"
--pickaxe-regex non lo farà (perché il numero di occorrenze di quella stringa non lo farà
modificare).

Vedere la piccone entrata in gitdiffcore(7) per maggiori informazioni.

--piccone-all
Quando -S o -G trova un cambiamento, mostra tutti i cambiamenti in quel changeset, non solo il
file che contengono la modifica in .

--piccone-regex
trattare il dato a -S come espressione regolare POSIX estesa da abbinare.

-O
Emettere la patch nell'ordine specificato in , che ha un guscio glob
modello per riga. Questo sovrascrive la variabile di configurazione diff.orderFile (vedi idiota-
config(1)). Per annullare diff.orderFile, usa -O/dev/null.

-R
Scambia due ingressi; cioè, mostra le differenze dall'indice o dal file su disco all'albero
contenuto.

--relativo[= ]
Quando viene eseguito da una sottodirectory del progetto, può essere detto di escludere le modifiche all'esterno
la directory e mostra i percorsi relativi ad essa con questa opzione. Quando non ci sei
una sottodirectory (ad esempio in un repository nudo), puoi nominare quale sottodirectory creare
l'output relativo a dando a come argomento.

-un testo
Tratta tutti i file come testo.

--ignore-space-at-eol
Ignora le modifiche negli spazi bianchi a EOL.

-b, --ignore-spazio-cambiamento
Ignora i cambiamenti nella quantità di spazi bianchi. Questo ignora gli spazi bianchi alla fine della riga e
considera equivalenti tutte le altre sequenze di uno o più caratteri di spaziatura.

-w, --ignore-tutto-spazio
Ignora gli spazi bianchi quando confronti le righe. Questo ignora le differenze anche se una riga ha
spazi bianchi dove l'altra riga non ne ha.

--ignora-linee-vuote
Ignora le modifiche le cui righe sono tutte vuote.

--inter-hunk-context=
Mostra il contesto tra blocchi di differenza, fino al numero di righe specificato, quindi
fusione di pezzi che sono vicini l'uno all'altro.

-W, --contesto-funzione
Mostra tutte le funzioni circostanti dei cambiamenti.

--codice-uscita
Fai uscire il programma con codici simili a diff(1). Cioè, esce con 1 se c'è
erano differenze e 0 significa nessuna differenza.

--silenzioso
Disabilita tutti gli output del programma. Implica --exit-code.

--ext-diff
Consenti l'esecuzione di un helper diff esterno. Se imposti un driver diff esterno con
gitattributi(5), è necessario utilizzare questa opzione con git log(1) e amici.

--no-diff.est
Non consentire driver diff esterni.

--textconv, --no-textconv
Consenti (o non consentire) l'esecuzione di filtri di conversione del testo esterni durante il confronto binario
File. Vedere gitattributi(5) per i dettagli. Poiché i filtri textconv sono in genere a
conversione unidirezionale, il differenziale risultante è adatto al consumo umano, ma non può
essere applicato. Per questo motivo, i filtri textconv sono abilitati per impostazione predefinita solo per idiota-
diff(1) e git log(1), ma non per git-formato-patch(1) o comandi idraulici differenziati.

--ignore-submodules[= ]
Ignora le modifiche ai sottomoduli nella generazione diff. può essere "nessuno",
"untracked", "dirty" o "all", che è l'impostazione predefinita. L'uso di "none" prenderà in considerazione 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
impostazioni del ignorare opzione git-config(1) o gitmodules(5). Quando "non tracciato" è
i sottomoduli utilizzati non sono considerati sporchi quando contengono solo contenuto non tracciato (ma
vengono ancora scansionati per il contenuto modificato). L'uso di "sporco" ignora tutte le modifiche al
albero di lavoro dei sottomoduli, solo le modifiche ai commit memorizzati nel superprogetto sono
mostrato (questo era il comportamento fino alla 1.7.0). L'uso di "all" nasconde tutte le modifiche a
sottomoduli.

--src-prefix=
Mostra il prefisso della fonte dato invece di "a/".

--dst-prefix=
Mostra il prefisso di destinazione specificato invece di "b/".

--senza-prefisso
Non mostrare alcun prefisso di origine o destinazione.

Per una spiegazione più dettagliata su queste opzioni comuni, vedere anche gitdiffcore(7).


L'id di un oggetto albero.

...
Se forniti, i risultati sono limitati a un sottoinsieme di file che corrispondono a uno di questi prefissi
stringhe. cioè, file corrisponde a /^ | |.../ Nota che questo parametro funziona
non fornisce alcuna caratteristica jolly o regexp.

-r
ricorrono in sottoalberi

-t
mostra la voce stessa dell'albero e le sottostrutture. Implica -r.

--radice
Quando --radice è specificato che il commit iniziale verrà mostrato come un grande evento di creazione.
Questo è equivalente a una differenza rispetto all'albero NULL.

--stdin
Quando --stdin è specificato, il comando non prende argomenti da
riga di comando. Invece, legge le righe che contengono uno dei due , uno , o a
lista di dal suo ingresso standard. (Utilizzare un singolo spazio come separatore.)

Quando vengono dati due alberi, confronta il primo albero con il secondo. Quando un single
commit è dato, confronta il commit con i suoi genitori. I restanti commit, quando
dati, vengono utilizzati come se fossero i genitori del primo commit.

Quando si confrontano due alberi, l'ID di entrambi gli alberi (separato da uno spazio e terminato da
una nuova riga) viene stampata prima della differenza. Quando si confrontano i commit, l'ID del
viene stampato il primo (o unico) commit, seguito da una nuova riga.

I seguenti flag influenzano ulteriormente il comportamento quando si confrontano i commit (ma non
alberi).

-m
Per impostazione predefinita, git albero differenziale --stdin non mostra differenze per i commit di unione. Insieme a
questo flag, mostra differenze rispetto a quel commit da tutti i suoi genitori. Guarda anche -c.

-s
Per impostazione predefinita, git albero differenziale --stdin mostra le differenze, sia in formato leggibile dalla macchina
(senza -p) o in forma di patch (con -p). Questa uscita può essere soppressa. È solo
utile con -v bandiera.

-v
Questo flag causa git albero differenziale --stdin per mostrare anche il messaggio di commit prima del
differenze.

--carino[= ], --format=
Pretty-stampa il contenuto dei log di commit in un dato formato, dove può essere
uno di una linea, corto, medie, pieno, Fuller, email, crudo, formato: e a
formato:. Quando non è nessuno dei precedenti e ha %segnaposto in esso, è
si comporta come se --pretty=tformat: sono stati dati.

Vedere la sezione "FORMATI GRAZIOSI" per alcuni dettagli aggiuntivi per ogni formato. quando
= parte è omessa, il valore predefinito è medie.

Nota: puoi specificare il formato grazioso predefinito nella configurazione del repository (vedi
git-config(1)).

--abbrev-commit
Invece di mostrare il nome dell'oggetto commit esadecimale completo di 40 byte, mostra solo a
prefisso parziale. Il numero di cifre non predefinito può essere specificato con "--abbrev= "
(che modifica anche l'output differenziale, se visualizzato).

Questo dovrebbe rendere "--pretty=oneline" molto più leggibile per le persone che usano
Terminali a 80 colonne.

--no-abbreviazione-commit
Mostra il nome dell'oggetto commit esadecimale completo di 40 byte. Questo nega --abbrev-commit e
quelle opzioni che lo implicano come "--oneline". Sovrascrive anche il
log.abbrevCommit variabile.

--una linea
Questa è una scorciatoia per "--pretty=oneline --abbrev-commit" usati insieme.

--codifica=
Gli oggetti commit registrano la codifica utilizzata per il messaggio di log nella loro codifica
intestazione; questa opzione può essere utilizzata per dire al comando di ricodificare il messaggio del registro di commit
nella codifica preferita dall'utente. Per i comandi non idraulici questo valore predefinito è
UTF-8. Nota che se un oggetto afferma di essere codificato in X e stiamo emettendo in X, noi
produrrà l'oggetto alla lettera; questo significa che le sequenze non valide nell'originale
commit può essere copiato nell'output.

--note[= ]
Mostra le note (vedi git-note(1)) che annotano il commit, quando mostra il commit
messaggio di registro. Questa è l'impostazione predefinita per i comandi git log, git show e git whatchanged
quando non è presente l'opzione --pretty, --format o --oneline nella riga di comando.

Per impostazione predefinita, le note mostrate provengono dai riferimenti delle note elencati nel core.notesRif e a
note.displayRef variabili (o sostituzioni di ambiente corrispondenti). Vedere git-config(1)
per ulteriori dettagli.

Con un optional argomento, mostra questo riferimento note invece delle note predefinite
rif. Il ref specifica il refname completo quando inizia con refs/notes/; quando esso
inizia con notes/, refs/ e altrimenti refs/notes/ ha il prefisso per formare un nome completo di
il rif.

È possibile combinare più opzioni --notes per controllare quali note vengono visualizzate.
Esempi: "--notes=foo" mostrerà solo le note di "refs/notes/foo"; "--note=pippo
--notes" mostrerà sia le note da "refs/notes/foo" che dalle note predefinite ref(s).

--no-note
Non mostrare note. Ciò nega l'opzione --notes sopra, reimpostando l'elenco di
note rif da cui vengono visualizzate le note. Le opzioni vengono analizzate nell'ordine indicato sul
riga di comando, quindi ad esempio "--notes --notes=foo --no-notes --notes=bar" mostrerà solo
note da "refs/notes/bar".

--show-note[= ], --[no-]note-standard
Queste opzioni sono deprecate. Usa invece le opzioni --notes/--no-note precedenti.

--mostra-firma
Controlla la validità di un oggetto commit firmato passando la firma a gpg --verify
e mostra l'output.

--no-id-commit
git albero differenziale emette una riga con l'ID commit quando applicabile. Questa bandiera è stata soppressa
l'output dell'ID di commit.

-c
Questo flag cambia il modo in cui viene visualizzato un commit di unione (il che significa che è utile solo
quando viene dato il comando uno , o --stdin). Mostra le differenze da
ciascuno dei genitori al risultato dell'unione simultanea invece di mostrare a coppie
diff tra un genitore e il risultato uno alla volta (che è quello che -m l'opzione lo fa).
Inoltre, elenca solo i file che sono stati modificati da tutti i genitori.

--cc
Questo flag cambia il modo in cui viene visualizzata una patch di commit di unione, in modo simile al
-c opzione. Implica il -c e a -p opzioni e comprime ulteriormente l'output della patch di
omettendo pezzi poco interessanti i cui contenuti nei genitori hanno solo due varianti
e il risultato dell'unione ne sceglie uno senza modifiche. Quando tutti i fusti sono
poco interessante, il commit stesso e il messaggio di log del commit non vengono mostrati, proprio come in
qualsiasi altro caso di "differenza vuota".

--sempre
Mostra il commit stesso e il messaggio di log del commit anche se il diff stesso è vuoto.

BELLA FORMATI

Se il commit è un merge e se il pretty-format non lo è una linea, email or crudo, una
la riga aggiuntiva viene inserita prima di Autore: linea. Questa riga inizia con "Unisci: " e
gli sha1 dei commit ancestrali sono stampati, separati da spazi. Si noti che l'elenco
i commit potrebbero non essere necessariamente l'elenco dei dirette il genitore si impegna se hai dei limiti
la tua visione della cronologia: ad esempio, se sei interessato solo alle modifiche relative a a
determinata directory o file.

Esistono diversi formati incorporati ed è possibile definire formati aggiuntivi impostando a
bello. opzione di configurazione a un altro nome di formato o a formato: stringa, come
descritto di seguito (vedi git-config(1)). Ecco i dettagli dei formati integrati:

· una linea



Questo è progettato per essere il più compatto possibile.

· corto

commettere
Autore:



· medie

commettere
Autore:
Data:





· pieno

commettere
Autore:
Commettere:





· Fuller

commettere
Autore:
Autore Data:
Commettere:
Data commit:





· email

A partire dal
A partire dal:
Data:
Oggetto: [PATCH]



· crudo

Le crudo format mostra l'intero commit esattamente come memorizzato nell'oggetto commit.
In particolare, gli SHA-1 vengono visualizzati per intero, indipendentemente dal fatto che --abbrev o
--no-abbrev sono usati, e genitori le informazioni mostrano che il vero genitore si impegna, senza
tenendo conto degli innesti o della semplificazione della storia. Nota che questo formato influisce su
il modo in cui vengono visualizzati i commit, ma non il modo in cui viene mostrato il diff, ad esempio con git log
--crudo. Per ottenere nomi di oggetti completi in un formato diff non elaborato, utilizzare --no-abbrev.

· formato:

Le formato: Il formato consente di specificare quali informazioni si desidera visualizzare.
Funziona un po' come il formato printf, con la notevole eccezione che si ottiene un
nuova riga con %n invece di \n.

Per esempio, formato: "Il autore of %h Prima %un, %ar%nIl titolo Prima >>%s<<%n" mostrerebbe
qualcosa come questo:

L'autore di fe6e0ee era Junio ​​C Hamano, 23 ore fa
Il titolo era >>t4119: test autocomputing -p per ingresso differenziale tradizionale.<

I segnaposto sono:

· %H: commetti hash

· %h: hash commit abbreviato

· %T: albero hash

· %t: hash albero abbreviato

· %P: hash genitore

· %p: hash genitore abbreviato

· %un: nome dell'autore

· %un: nome dell'autore (rispettando .mailmap, vedi git shortlog(1) o colpa del git(1))

· %ae: email dell'autore

· %aE: email dell'autore (rispettando .mailmap, vedi git shortlog(1) o colpa del git(1))

· %anno Domini: data dell'autore (il formato rispetta l'opzione --date=)

· %anno Domini: data dell'autore, stile RFC2822

· %ar: data dell'autore, relativo

· %a: data dell'autore, timestamp UNIX

· %ai: data dell'autore, formato simile a ISO 8601

· %ai: data dell'autore, formato rigoroso ISO 8601

· % cn: nome committente

· %cN: nome committer (rispettando .mailmap, vedi git shortlog(1) o colpa del git(1))

· %ce: email del committente

· %cE: email committer (rispettando .mailmap, vedi git shortlog(1) o colpa del git(1))

· %CD: data committer (il formato rispetta l'opzione --date=)

· %cd: data committer, stile RFC2822

· %cr: data committer, relativo

· %ct: data committer, timestamp UNIX

· %ci: data committer, formato simile a ISO 8601

· %ci: data committer, formato rigoroso ISO 8601

· %d: nomi di riferimento, come l'opzione --decorate di git log(1)

· %D: nomi di riferimento senza il wrapping " (", ")".

· %e: codifica

· %s: soggetto

· %f: riga dell'oggetto sterilizzata, adatta per un nome di file

· %b: corpo

· %B: corpo grezzo (soggetto e corpo non confezionati)

· %N: commit note

· %GG: messaggio di verifica grezzo da GPG per un commit firmato

· %G?: mostra "G" per una firma buona, "B" per una firma cattiva, "U" per una buona,
firma non attendibile e "N" per nessuna firma

· %GS: mostra il nome del firmatario per un commit firmato

· %GK: mostra la chiave utilizzata per firmare un commit firmato

· % gD: selettore reflog, ad es. refs/stash@{1}

· % gd: selettore reflog accorciato, ad es. stash@{1}

· %gn: reflog nome identità

· %gN: reflog identity name (rispettando .mailmap, vedi git shortlog(1) o idiota-
colpa(1))

· %g: reflog email di identità

· %gE: reflog identity email (rispettando .mailmap, vedi git shortlog(1) o idiota-
colpa(1))

· %g: reflog soggetto

· %cred: cambia colore in rosso

· %Cverde: cambia colore in verde

· %Cblu: cambia colore in blu

· %Creset: ripristina il colore

· %C(...): specifica del colore, come descritto nell'opzione di configurazione color.branch.*; aggiungendo
auto, all'inizio emetterà il colore solo quando i colori sono abilitati per l'output del registro
(tramite color.diff, color.ui o --color e rispettando le impostazioni automatiche del
ex se stiamo andando a un terminale). auto da solo (cioè %C(auto)) si accenderà
colorazione automatica sui segnaposto successivi fino a quando il colore non viene cambiato di nuovo.

· %m: sinistra, destra o contrassegno di confine

· %n: nuova linea

· %%: un crudo %

· %x00: stampa un byte da un codice esadecimale

· %w([ [, [, ]]]): cambia il ritorno a capo, come l'opzione -w di idiota-
cortocircuito(1).

· %<( [,trunc|ltrunc|mtrunc]): fai in modo che il segnaposto successivo occupi almeno N colonne,
spazi di riempimento a destra se necessario. Facoltativamente troncare all'inizio
(ltrunc), al centro (mtrunc) o alla fine (trunc) se l'uscita è più lunga di N
colonne. Nota che il troncamento funziona correttamente solo con N >= 2.

· %<|( ): fai in modo che il segnaposto successivo occupi almeno fino all'ennesima colonna, padding
spazi a destra se necessario

· %>( ), %>|( ): simile a %<( ), %<|( ) rispettivamente, ma riempiendo gli spazi
sulla sinistra

· %>>( ), %>>|( ): simile a %>( ), %>|( ) rispettivamente, tranne che se il
il segnaposto successivo occupa più spazi del dato e ci sono spazi alla sua sinistra,
usa quegli spazi

· %><( ), %><|( ): simile a % <( ), %<|( ) rispettivamente, ma riempiendo entrambi
lati (cioè il testo è centrato)

Note:
Alcuni segnaposto possono dipendere da altre opzioni fornite al motore di attraversamento delle revisioni.
Ad esempio, le opzioni %g* reflog inseriranno una stringa vuota a meno che non lo siamo
attraversando le voci di reflog (ad esempio, con git log -g). Verranno utilizzati i segnaposto %d e %D
il formato di decorazione "corto" se --decorate non era già stato fornito sul comando
linea.

Se aggiungi un + (segno più) dopo % di un segnaposto, viene inserito immediatamente un avanzamento riga
prima dell'espansione se e solo se il segnaposto si espande in una stringa non vuota.

Se aggiungi un - (segno meno) dopo % di un segnaposto, feed di riga che precedono immediatamente
le espansioni vengono eliminate se e solo se il segnaposto si espande in una stringa vuota.

Se aggiungi un ` ` (spazio) dopo % di un segnaposto, viene inserito uno spazio immediatamente prima
l'espansione se e solo se il segnaposto si espande in una stringa non vuota.

· formato:

Le formato: il formato funziona esattamente come formato:, tranne che fornisce "terminator"
semantica invece di semantica "separatore". In altre parole, ogni commit ha il
carattere di terminazione del messaggio (di solito una nuova riga) aggiunto, piuttosto che un separatore
posto tra le voci. Ciò significa che l'immissione finale di un formato a riga singola sarà
essere terminato correttamente con una nuova riga, proprio come fa il formato "oneline". Per
esempio:

$ git log -2 --pretty=formato:%h 4da45bef
| perl -pe '$_ .= " -- NO NEWLINE\n" a meno che /\n/'
4da45be
7134973 -- NESSUN NUOVO LINEA

$ git log -2 --pretty=tformat:%h 4da45bef
| perl -pe '$_ .= " -- NO NEWLINE\n" a meno che /\n/'
4da45be
7134973

Inoltre, qualsiasi stringa non riconosciuta che contiene un % viene interpretata come se lo avesse
tformat: davanti ad esso. Ad esempio, questi due sono equivalenti:

$ git log -2 --pretty=tformat:%h 4da45bef
$ git log -2 --pretty=%h 4da45bef

LIMITANTE USCITA

Se sei interessato solo alle differenze in un sottoinsieme di file, ad esempio alcuni
file specifici dell'architettura, potresti fare:

git diff-tree -r arch/ia64 include/asm-ia64

e ti mostrerà solo cosa è cambiato in quelle due directory.

O se stai cercando cosa è cambiato solo in kernel/sched.c, fallo e basta

git diff-tree -r kernel/sched.c

e ignorerà tutte le differenze con altri file.

Il modello è sempre il prefisso e corrisponde esattamente. Non ci sono caratteri jolly. Persino
più rigoroso, deve corrispondere a un componente di percorso completo. Cioè "foo" non raccoglie foobar.h.
"foo" corrisponde a foo/bar.h quindi può essere usato per nominare le sottodirectory.

Un esempio di utilizzo normale è:

torvalds@ppc970:~/git> git diff-tree --abbrev 5319e4
:100664 100664 ac348b... a01513... git-fsck-objects.c

che ti dice che l'ultimo commit ha cambiato solo un file (è da questo:

commit 3c6f7ca19ad4043e9e72fa94106f352897e651a8
tree 5319e4d609cdd282069cc4dce33c1db559539b03
parent b4e628ea30d5ab3606119d2ea5caeab141d38df7
autore Linus Torvaldstorvalds@ppc970.osdl.org> Sab Apr 9 12:02:30 2005
il committente Linus Torvaldstorvalds@ppc970.osdl.org> Sab Apr 9 12:02:30 2005

Fai stampare a "git-fsck-objects" tutti i commit di root che trova.

Una volta eseguito il monitoraggio delle referenze, lo farò stampare anche tutte le
HEAD esegue il commit che trova, il che è ancora più interessante.

nel caso ti interessi).

RAW USCITA FORMATO

Il formato di output non elaborato da "git-diff-index", "git-diff-tree", "git-diff-files" e "git
diff --raw" sono molto simili.

Questi comandi confrontano tutti due insiemi di cose; ciò che viene confrontato differisce:

git-diff-index
confronta il e i file sul filesystem.

git-diff-index --cached
confronta il e l'indice.

git-diff-tree [-r] [ ...]
confronta gli alberi denominati dai due argomenti.

file-git-diff [ ...]
confronta l'indice ei file sul filesystem.

Il comando "git-diff-tree" inizia il suo output stampando l'hash di ciò che è in corso
rispetto. Successivamente, tutti i comandi stampano una riga di output per file modificato.

Una riga di output è formattata in questo modo:

modifica sul posto: 100644 100644 bcd1234... 0123456... M file0
copia-modifica :100644 100644 abcd123... 1234567... C68 file1 file2
rinomina-modifica :100644 100644 abcd123... 1234567... R86 file1 file3
crea :000000 100644 0000000... 1234567... Un file4
cancella :100644 000000 1234567... 0000000... D file5
non unito :000000 000000 0000000... 0000000... U file6

Cioè, da sinistra a destra:

1. due punti.

2. modalità per "src"; 000000 se creato o non fuso.

3. uno spazio.

4. modalità per "dst"; 000000 se cancellato o non fuso.

5. uno spazio.

6. sha1 per "src"; 0{40} se creato o non unito.

7. uno spazio.

8. sha1 per "dst"; 0{40} se creazione, non fusa o "guarda l'albero di lavoro".

9. uno spazio.

10. stato, seguito dal numero di "punteggio" opzionale.

11. una scheda o un NUL quando -z viene utilizzata l'opzione.

12. percorso per "src"

13. una scheda o un NUL quando -z viene utilizzata l'opzione; esiste solo per C o R.

14. percorso per "dst"; esiste solo per C o R.

15. un LF o un NUL quando -z viene utilizzata l'opzione per terminare il record.

Le possibili lettere di stato sono:

· A: aggiunta di un file

· C: copia di un file in uno nuovo

· D: cancellazione di un file

· M: modifica del contenuto o della modalità di un file

· R: ridenominazione di un file

· T: cambia il tipo di file

· U: il file non è stato unito (devi completare l'unione prima che possa essere eseguito il commit)

· X: tipo di modifica "sconosciuto" (molto probabilmente un bug, per favore segnalalo)

Le lettere di stato C e R sono sempre seguite da un punteggio (che indica la percentuale di
somiglianza tra l'origine e la destinazione dello spostamento o della copia). La lettera di stato M potrebbe essere
seguito da un punteggio (che indica la percentuale di dissomiglianza) per le riscritture dei file.

viene mostrato come tutti 1 se un file è nuovo nel filesystem e non è sincronizzato con
l'indice.

Esempio:

:100644 100644 5be4a4...... 000000...... M file.c

Quando l'opzione -z non viene utilizzata, sono rappresentati i caratteri TAB, LF e barra rovesciata nei nomi dei percorsi
rispettivamente come \t, \n e \\.

DIFF FORMATO PER FUSIONI

"git-diff-tree", "git-diff-files" e "git-diff --raw" possono -c or --cc opzione a
genera un output diff anche per i commit di unione. L'output è diverso dal formato descritto
sopra nel seguente modo:

1. ci sono due punti per ogni genitore

2. ci sono più modalità "src" e "src" sha1

3. lo stato è caratteri di stato concatenati per ciascun genitore

4. nessun numero di "punteggio" opzionale

5. singolo percorso, solo per "dst"

Esempio:

::100644 100644 100644 fabadb8... cc95eb0... 4866510... MM descrivere.c

Si noti che combinato diff elenca solo i file che sono stati modificati da tutti i genitori.

GENERARE ETICHETTE RICAMATE CON -P

Quando "git-diff-index", "git-diff-tree" o "git-diff-files" vengono eseguiti con un -p opzione, "git
diff" senza --crudo opzione, o "git log" con l'opzione "-p", non producono il
uscita sopra descritta; invece producono un file di patch. Puoi personalizzare la creazione
di tali patch tramite le variabili di ambiente GIT_EXTERNAL_DIFF e GIT_DIFF_OPTS.

Ciò che l'opzione -p produce è leggermente diverso dal tradizionale formato diff:

1. È preceduto da un'intestazione "git diff" simile a questa:

diff --git a/file1 b/file2

I nomi dei file a/ e b/ sono gli stessi a meno che non sia coinvolta la ridenominazione/copia. Soprattutto, anche
per una creazione o una cancellazione, /dev/null è non è un utilizzato al posto di a/ o b/
nomi di file.

Quando si tratta di rinominare/copiare, file1 e file2 mostrano il nome del file sorgente del
rename/copy e il nome del file che rename/copy produce, rispettivamente.

2. È seguito da una o più righe di intestazione estese:

vecchia modalità
nuova modalità
modalità file cancellato
nuova modalità file
copia da
copia a
rinomina da
rinomina in
indice di somiglianza
indice di dissomiglianza
indice ..

Le modalità file vengono stampate come numeri ottali a 6 cifre, inclusi il tipo di file e il file
bit di autorizzazione.

I nomi di percorso nelle intestazioni estese non includono i prefissi a/ e b/.

L'indice di somiglianza è la percentuale di linee invariate e l'indice di dissimilarità
è la percentuale di righe modificate. È un intero arrotondato per difetto, seguito da a
segno di percentuale. Il valore dell'indice di somiglianza del 100% è quindi riservato a due file uguali,
mentre 100% dissomiglianza significa che nessuna riga del vecchio file è stata inserita nel nuovo
uno.

La riga dell'indice include il checksum SHA-1 prima e dopo la modifica. Il è
incluso se la modalità file non cambia; altrimenti, righe separate indicano il vecchio
e la nuova modalità.

3. I caratteri TAB, LF, virgolette e barra rovesciata nei nomi di percorso sono rappresentati come \t, \n,
\" e \\, rispettivamente. Se c'è bisogno di tale sostituzione allora il tutto
il nome del percorso è racchiuso tra virgolette.

4. Tutti i file file1 nell'output si riferiscono ai file prima del commit e tutti i file2
i file si riferiscono ai file dopo il commit. Non è corretto applicare ogni modifica a ciascuno
file in sequenza. Ad esempio, questa patch scambierà a e b:

diff --git a/ab/b
rinomina da a
rinomina in b
diff --git a/bb/a
rinomina da b
rinomina in a

COMBINATO DIFF FORMATO

Qualsiasi comando che genera differenze può prendere l'opzione -c o --cc per produrre a combinato diff quando
mostrando una fusione. Questo è il formato predefinito quando si mostrano le unioni con git-diff(1) o idiota-
mostrare attraverso le sue creazioni(1). Nota anche che puoi dare l'opzione -m a uno qualsiasi di questi comandi per forzare
generazione di differenze con i singoli genitori di un'unione.

A combinato diff il formato assomiglia a questo:

diff --combined descrivere.c
indice fabadb8,cc95eb0..4866510
--- a/descrivi.c
+++ b/descrivi.c
@@@ -98,20 -98,12 +98,20 @@@
ritorno (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}

- vuoto statico descrivere (char * arg)
-static void descrivere(struct commit *cmit, int last_one)
++static void descrivere(char *arg, int last_one)
{
+ char sha1[20] senza segno;
+ struct commit *cmit;
struttura commit_list *lista;
statico int inizializzato = 0;
struct nome_commissione *n;

+ if (get_sha1(arg, sha1) < 0)
+ utilizzo(describe_usage);
+ cmit = lookup_commit_reference(sha1);
+ se (!cmit)
+ utilizzo(describe_usage);
+
if (!inizializzato) {
inizializzato = 1;
for_each_ref(get_name);

1. È preceduto da un'intestazione "git diff", che assomiglia a questa (quando -c opzione è
Usato):

diff --file combinato

o così (quando --cc viene utilizzata l'opzione):

file diff --cc

2. È seguito da una o più righe di intestazione estese (questo esempio mostra un'unione con
due genitori):

indice , ..
modalità , ..
nuova modalità file
modalità file cancellati ,

Il modo , .. appare solo se almeno uno dei è
diverso dal resto. Intestazioni estese con informazioni sui contenuti rilevati
movimento (rinomina e rilevamento della copia) sono progettati per funzionare con una differenza di due
e non vengono utilizzati dal formato diff combinato.

3. È seguito da un'intestazione di due righe from-file/to-file

--- un file
+++ b/file

Simile all'intestazione a due righe per il tradizionale unificato diff, /dev/null è usato per
segnala i file creati o cancellati.

4. Il formato dell'intestazione del blocco viene modificato per impedire alle persone di alimentarlo accidentalmente a
patch -p1. Il formato diff combinato è stato creato per la revisione delle modifiche al commit di unione e
non era pensato per essere applicato. La modifica è simile alla modifica dell'estensione Index
intestazione:

@@@ @@@

Ci sono (numero di genitori + 1) caratteri @ nell'intestazione del blocco per le differenze combinate
formato.

A differenza del tradizionale unificato diff, che mostra due file A e B con un unico
colonna che ha - (meno - appare in A ma rimosso in B), + (più - mancante in A ma
aggiunto a B), o prefisso " " (spazio — invariato), questo formato confronta due o più file
file1, file2,... con un file X e mostra come X differisce da ciascuno di fileN. Una colonna
per ogni fileN è anteposto alla riga di output per notare come la riga di X è diversa da
esso.

A - il carattere nella colonna N significa che la riga appare in fileN ma non appare
nel risultato. Un carattere + nella colonna N significa che la linea appare nel risultato,
e fileN non ha quella linea (in altre parole, la linea è stata aggiunta, dal punto di
vista di quel genitore).

Nell'output di esempio sopra, la firma della funzione è stata modificata da entrambi i file (quindi due
- rimozioni sia da file1 che da file2, più ++ per indicare che una riga che è stata aggiunta non lo fa
appaiono in file1 o file2). Anche altre otto righe sono le stesse di file1 ma fallo
non appare in file2 (quindi preceduto da +).

Quando mostrato da git diff-tree -c, confronta i genitori di un merge commit con il merge
risultato (cioè file1..fileN sono i genitori). Quando viene mostrato da git diff-files -c, confronta
i due genitori di fusione irrisolti con il file dell'albero di lavoro (cioè file1èla fase 2 aka
"la nostra versione", file2 è la fase 3 alias "la loro versione").

ALTRO DIFF FORMATI

L'opzione --summary descrive i file appena aggiunti, eliminati, rinominati e copiati. Il --stat
l'opzione aggiunge diffstat(1) grafico all'uscita. Queste opzioni possono essere combinate con altre
opzioni, come -p, e sono destinate al consumo umano.

Quando si mostra una modifica che implica una ridenominazione o una copia, l'output --stat formatta il
nomi di percorso in modo compatto combinando prefisso e suffisso comune dei nomi di percorso. Ad esempio, a
la modifica che sposta arch/i386/Makefile in arch/x86/Makefile durante la modifica di 4 righe sarà
mostrato in questo modo:

arch/{i386 => x86}/Makefile | 4 +--

L'opzione --numstat fornisce il diffstat(1) informazioni ma è progettato per una macchina più semplice
consumo. Una voce nell'output --numstat ha il seguente aspetto:

1 2 LEGGIMI
3 1 arch/{i386 => x86}/Makefile

Cioè, da sinistra a destra:

1. il numero di righe aggiunte;

2. una scheda;

3. il numero di righe cancellate;

4. una scheda;

5. percorso (possibilmente con informazioni di ridenominazione/copia);

6. una nuova riga.

Quando l'opzione di output -z è attiva, l'output è formattato in questo modo:

1 2 LEGGIMI NUL
3 1 NUL arch/i386/Makefile NUL arch/x86/Makefile NUL

Cioè:

1. il numero di righe aggiunte;

2. una scheda;

3. il numero di righe cancellate;

4. una scheda;

5. un NUL (esiste solo se rinominato/copiato);

6. percorso in preimage;

7. un NUL (esiste solo se rinominato/copiato);

8. percorso in postimage (esiste solo se rinominato/copiato);

9. un NULLA.

Il NUL aggiuntivo prima del percorso preimage nel caso rinominato è quello di consentire script che leggono il
output per dire se il record corrente da leggere è un record a percorso singolo o un rinomina/copia
registrare senza leggere in anticipo. Dopo aver letto le righe aggiunte ed eliminate, leggere fino a NUL
restituirebbe il nome del percorso, ma se questo è NUL, il record mostrerà due percorsi.

GIT

Parte della git(1) seguito

Usa git-diff-tree online usando i servizi onworks.net