git-diff - Online nel cloud

PROGRAMMA:

NOME

git-diff - Mostra le modifiche tra commit, commit e albero di lavoro, ecc

SINOSSI

git diff [opzioni] [ ] [--] [ ...]
git diff [opzioni] --cached [ ] [--] [ ...]
git diff [opzioni] [--] [ ...]
git diff [opzioni]
git diff [opzioni] [--no-indice] [--]

DESCRIZIONE

Mostra le modifiche tra l'albero di lavoro e l'indice o un albero, le modifiche tra l'indice
e un albero, cambiamenti tra due alberi, cambiamenti tra due oggetti blob o cambiamenti
tra due file su disco.

git diff [--opzioni] [--] [ ...]
Questo modulo serve per visualizzare le modifiche apportate rispetto all'indice (area di sosta per il
prossimo impegno). In altre parole, le differenze sono ciò che tu potuto dì a Git di andare oltre
aggiungi all'indice ma non l'hai ancora fatto. Puoi mettere in scena questi cambiamenti usando idiota-
aggiungere(1).

git diff --no-index [--opzioni] [--] [ ...]
Questo modulo serve per confrontare i due percorsi dati sul filesystem. Puoi omettere il
opzione --no-index quando si esegue il comando in un albero funzionante controllato da Git e at
almeno uno dei percorsi punta all'esterno dell'albero di lavoro o durante l'esecuzione del comando
all'esterno di un albero funzionante controllato da Git.

git diff [--opzioni] --cached [ ] [--] [ ...]
Questo modulo serve per visualizzare le modifiche che hai messo in scena per il prossimo commit relativo al named
. In genere vorresti il ​​confronto con l'ultimo commit, quindi se non lo fai
dare , il valore predefinito è HEAD. Se HEAD non esiste (es. rami non ancora nati) e
non è dato, mostra tutte le modifiche in scena. --staged è sinonimo di --cached.

git diff [--opzioni] [--] [ ...]
Questo modulo serve per visualizzare le modifiche che hai nel tuo albero di lavoro rispetto al nome
. Puoi usare HEAD per confrontarlo con l'ultimo commit o un nome di ramo per
confrontare con la punta di un ramo diverso.

git diff [--opzioni] [--] [ ...]
Questo è per visualizzare i cambiamenti tra due arbitrari .

git diff [--opzioni] .. [--] [ ...]
Questo è sinonimo della forma precedente. Se da un lato viene omesso, lo farà
hanno lo stesso effetto dell'utilizzo di HEAD.

git diff [--opzioni] ... [--] [ ...]
Questo modulo serve per visualizzare le modifiche sul ramo contenente e fino al secondo
, a partire da un antenato comune di entrambi . "git diff A...B" è
equivalente a "git diff $(git-merge-base AB) B". Puoi ometterne uno qualsiasi ,
che ha lo stesso effetto dell'utilizzo di HEAD.

Nel caso in cui tu stia facendo qualcosa di esotico, va notato che tutti i
nella descrizione di cui sopra, tranne nelle ultime due forme che utilizzano notazioni "..",
può essere qualsiasi .

Per un elenco più completo di modi di scrivere , vedere la sezione "SPECIFICARE LE REVISIONI" in
gitrevisioni(7). Tuttavia, "diff" riguarda il confronto di due endpoint, non intervalli, e il
notazioni di intervallo (" .. " e " ... ") non significa un intervallo come
definito nella sezione "SPECIFICA DEGLI RANGE" in gitrevisioni(7).

git diff [opzioni]
Questo modulo serve per visualizzare le differenze tra i contenuti non elaborati di due oggetti BLOB.

VERSIONI

-p, -u, --patch
Genera patch (vedere la sezione sulla generazione di patch). Questa è l'impostazione predefinita.

-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.

--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. Può essere modificato da color.ui e
impostazioni di configurazione color.diff.

--no-colore
Disattiva le differenze colorate. Questo può essere usato per sovrascrivere le impostazioni di configurazione. È il
come --color=mai.

--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).

...
Il i parametri, quando forniti, vengono utilizzati per limitare il diff ai percorsi denominati (tu
può dare nomi di directory e ottenere differenze per tutti i file sottostanti).

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 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.

ESEMPI

Vari modi per controllare il tuo albero funzionante

$git diff (1)
$ git diff -- memorizzato nella cache (2)
$ git diff TESTA (3)

1. Modifiche nell'albero di lavoro non ancora organizzate per il prossimo commit.
2. Modifiche tra l'indice e il tuo ultimo commit; cosa commetteresti se tu?
esegui "git commit" senza l'opzione "-a".
3. Modifiche nell'albero di lavoro dall'ultimo commit; cosa commetteresti se
esegui "git commit -a"

Confronto con commit arbitrari

$ git prova diff (1)
$ git diff TESTA -- ./test (2)
$ git diff TESTA^ TESTA (3)

1. Invece di usare la punta del ramo corrente, confronta con la punta di "test"
ramo.
2. Invece di confrontare con la punta del ramo "test", confronta con la punta del
ramo corrente, ma limita il confronto al file "test".
3. Confronta la versione prima dell'ultimo commit e dell'ultimo commit.

Rami a confronto

$ git diff argomento principale (1)
$ git diff topic..master (2)
$ git diff argomento... maestro (3)

1. Cambiamenti tra i suggerimenti dell'argomento e i rami principali.
2. Come sopra.
3. Modifiche avvenute sul ramo master da quando è stato avviato il ramo topic
fuori di esso.

Limitazione dell'uscita differenziale

$ git diff --diff-filter=MRC (1)
$ git diff --nome-stato (2)
$ git diff arch/i386 include/asm-i386 (3)

1. Mostra solo modifica, rinomina e copia, ma non aggiunta o eliminazione.
2. Mostra solo i nomi e la natura della modifica, ma non l'output effettivo delle differenze.
3. Limita l'output delle differenze ai sottoalberi denominati.

Mungendo l'uscita differenziale

$ git diff --find-copys-harder -B -C (1)
$git diff -R (2)

1. Spendi cicli extra per trovare rinomina, copie e riscritture complete (molto costoso).
2. Differenza di uscita al contrario.

Usa git-diff online usando i servizi onworks.net