Ho messo in scena alcune modifiche da impegnare; come posso vedere il diff di tutti i file messi in scena per il prossimo commit? Sono a conoscenza dello stato di git , ma mi piacerebbe vedere le differenze effettive, non solo i nomi dei file che vengono messi in scena.

Ho visto che dice la pagina man git-diff (1)

git diff [--options] [-] […]

Questo modulo consente di visualizzare le modifiche apportate rispetto all'indice (area di gestione temporanea per il prossimo commit). In altre parole, le differenze sono ciò che potresti dire a Git di aggiungere ulteriormente all'indice ma non l'hai ancora fatto. Puoi mettere in scena queste modifiche usando git-add (1).

Sfortunatamente, non riesco proprio a capirlo. Ci deve essere un pratico one-liner per il quale potrei creare un alias, giusto?

Dovrebbe essere solo:

git diff --cached

--cachedsignifica mostrare le modifiche nella cache / indice (cioè le modifiche graduali) rispetto alla corrente HEAD. --stagedè sinonimo di --cached.

--stagede --cachednon indica HEAD, solo la differenza rispetto a HEAD. Se scegli cosa commettere usando git add --patch(o git add -p), --stagedrestituirà ciò che viene messo in scena.

Una semplice grafica rende questo più chiaro:

git diff

Mostra le modifiche tra la directory di lavoro e l'indice. Questo mostra ciò che è stato modificato, ma non viene messo in scena per un commit.

git diff - cache

Mostra le modifiche tra l'indice e HEAD (che è l'ultimo commit su questo ramo). Questo mostra ciò che è stato aggiunto all'indice e messo in scena per un commit.

git diff HEAD

Mostra tutte le modifiche tra la directory di lavoro e HEAD (che include le modifiche nell'indice). Questo mostra tutte le modifiche dall'ultimo commit, indipendentemente dal fatto che siano state organizzate o meno per il commit.

Inoltre :

C'è qualche dettaglio in più su 365Git.

Se desideri essere interessati a una vista visivo side-by-side, il diffuso strumento diff visiva può farlo. Mostrerà anche tre riquadri se vengono messi in scena alcuni ma non tutti i cambiamenti. In caso di conflitti, ci saranno anche quattro riquadri.

Invocalo con

diffuse -m

nella tua copia di lavoro di Git.

Se me lo chiedi, la migliore differenza visiva che abbia mai visto per un decennio. Inoltre, non è specifico di Git: interagisce con una pletora di altri VCS, tra cui SVN, Mercurial, Bazaar, ...

Vedi anche: Mostra l'albero in scena e quello funzionante in git diff?

Nota che mostra git status -v anche le modifiche organizzate! (nel senso che è necessario aver messo in scena - git add- alcune modifiche. Nessuna modifica in fasi, nessuna differenza con git status -v.
A partire da Git 1.2.0, febbraio 2006 )

Nella sua forma lunga (impostazione predefinita), git statusha un'opzione "verbosa" non documentata che mostra effettivamente la differenza tra HEAD e indice.

E sta per diventare ancora più completo: vedi " Mostra l'albero in scena e quello funzionante in git diff? " (Git 2.3.4+, Q2 2015):

git status -v -v

Puoi usare questo comando.

git diff --cached --name-only

L' --cachedopzione di git diffmezzi per ottenere file in fasi, e l' --name-onlyopzione significa ottenere solo i nomi dei file.

Dalla versione 1.7 e successive dovrebbe essere:

git diff --staged

UTILIZZANDO UNO STRUMENTO DIFF. VISIVO

La risposta predefinita (dalla riga di comando)

Le risposte principali qui mostrano correttamente come visualizzare le modifiche memorizzate nella cache / in fasi nel Index:

$ git diff --cached

o $ git diff --stagedche è un alias.

Avvio invece di Visual Diff Tool

La risposta predefinita sputerà le modifiche diff su git bash (cioè sulla riga di comando o nella console). Per coloro che preferiscono una rappresentazione visiva delle differenze di file gestite, all'interno di git è disponibile uno script che avvia uno strumento di visualizzazione visiva per ogni file visualizzato anziché mostrarli sulla riga di comando, chiamato difftool:

$ git difftool --staged

Questo farà lo stesso di git diff --staged, tranne ogni volta che viene eseguito lo strumento diff (cioè ogni volta che un file viene elaborato da diff), avvierà lo strumento diff predefinito di visualizzazione (nel mio ambiente, questo è kdiff3 ).

Dopo l'avvio dello strumento, lo script git diff verrà messo in pausa fino alla chiusura dello strumento di visualizzazione visiva. Pertanto, sarà necessario chiudere ciascun file per visualizzare quello successivo.

Puoi sempre usare difftoolal posto dei diffcomandi in git

Per tutte le tue esigenze di diff visivo, git difftoolfunzionerà al posto di qualsiasi git diffcomando, comprese tutte le opzioni.

Ad esempio, per avviare lo strumento di visualizzazione visiva senza chiedere se farlo per ogni file, aggiungi l' -yopzione (penso che di solito lo vorrai !!):

$ git difftool -y --staged

In questo caso, tirerà su ogni file nello strumento di visual visual, uno alla volta, facendo apparire quello successivo dopo la chiusura dello strumento.

O per guardare il diff di un particolare file che viene messo in scena in Index:

$ git difftool -y --staged <<relative path/filename>>

Per tutte le opzioni, vedere la pagina man:

$ git difftool --help

Impostazione di Visual Git Tool

Per usare uno strumento visual git diverso da quello predefinito, usa l' -t <tool>opzione:

$ git difftool -t <tool> <<other args>>

Oppure, vedere la pagina man difftool per come configurare git per usare un diverso strumento di visualizzazione differenziale predefinito.

.gitconfigVoci di esempio per vscode come strumento diff / merge

Parte della configurazione di un difftool comporta la modifica del .gitconfigfile, sia tramite comandi git che lo modificano dietro le quinte, sia modificandolo direttamente.

Puoi trovarlo .gitconfignella tua home directory, come ~in Unix o normalmente c:\users\<username>su Windows).

Oppure, puoi aprire l'utente .gitconfignel tuo editor Git predefinito con git config -e --global.

Ecco alcune voci di esempio nel mio utente globale .gitconfigper VS Code come strumento diff e merge:

[diff]
    tool = vscode
    guitool = vscode
[merge]
    tool = vscode
    guitool = vscode
[mergetool]
    prompt = true
[difftool "vscode"]
    cmd = code --wait --diff \"$LOCAL\" \"$REMOTE\"
    path = c:/apps/vscode/code.exe
[mergetool "vscode"]
    cmd = code --wait \"$MERGED\"
    path = c:/apps/vscode/code.exe

Per l'utilizzo di confronto Area di staging vs Repository (ultimo commit)

 $git diff --staged

Il comando confronta le $ git add fileNamemodifiche gestite ( ) all'ultimo commit. Se vuoi vedere cosa hai messo in scena che andrà al tuo prossimo commit, puoi usare git diff --staged. Questo comando confronta le modifiche temporanee all'ultimo commit.

Per il confronto tra lavoro e stadiazione

$ git diff 

Il comando confronta ciò che si trova nella directory di lavoro con ciò che si trova nell'area di gestione temporanea. È importante notare che git diff da solo non mostra tutte le modifiche apportate dall'ultimo commit, ma solo quelle non ancora messe in scena. Se hai messo in scena tutte le tue modifiche ( $ git add fileName), git diff non ti darà alcun output.

Inoltre, se metti in scena un file ( $ git add fileName) e poi lo modifichi, puoi usare git diff per vedere le modifiche nel file che sono messe in scena e quelle che non sono messe in scena.

Se le tue intenzioni sono di indirizzare il push su un ramo repo remoto e il tuo primo passaggio in un registro delle modifiche di commit era incompleto, puoi correggere l'istruzione di commit prima di eseguire il push in questo modo.

localmente

... apporta alcune modifiche ...

git diff # look at unstaged changes

git commit -am"partial description of changes"

... richiama più modifiche non menzionate in commit ...

git diff origin / master # guarda le modifiche organizzate ma non inviate

... modifica dichiarazione commit in corso ...

git commit --amend -m"i missed mentioning these changes ...."

git push

Se hai più di un file con modifiche graduali, può essere più pratico da usare git add -i, quindi selezionare 6: diffe infine selezionare i file che ti interessano.

Di default git diff è usato per mostrare le modifiche che non sono state aggiunte all'elenco dei file aggiornati di git. Ma se si desidera mostrare le modifiche aggiunte o contrassegnate, è necessario fornire opzioni extra che consentano a Git di sapere che si è interessati alla differenza dei file contrassegnati o aggiunti .

$ git diff          # Default Use
$ git diff --cached # Can be used to show difference after adding the files 
$ git diff --staged # Same as 'git diff --cached' mostly used with latest version of git 

Esempio

$ git diff 
diff --git a/x/y/z.js  b/x/y/z.js index 98fc22b..0359d84 100644
--- a/x/y/z.js 
+++ b/x/y/z.js @@ -43,7 +43,7 @@ var a = function (tooltip) {

-        if (a)
+        if (typeof a !== 'undefined')
             res = 1;
         else
             res = 2;

$ git add x/y/z.js
$ git diff
$

Una volta aggiunti i file, non è possibile utilizzare il valore predefinito di 'git diff'. Devi fare così: -

$ git diff --cached
diff --git a/x/y/z.js  b/x/y/z.js index 98fc22b..0359d84 100644
    --- a/x/y/z.js 
    +++ b/x/y/z.js @@ -43,7 +43,7 @@ var a = function (tooltip) {

    -        if (a)
    +        if (typeof a !== 'undefined')
                 res = 1;
             else
                 res = 2;

git guie git-colasono utility grafiche che ti consentono di visualizzare e manipolare l'indice. Entrambi includono semplici differenze visive per i file in scena e git-colapossono anche lanciare uno strumento di visualizzazione visiva affiancato più sofisticato.

Vedi la mia risposta strettamente correlata in Come rimuovere un file dall'indice in git? e anche questo catalogo ufficiale dei clienti Git - GUI .

Pensa anche allo gitkstrumento, fornito con git e molto utile per vedere i cambiamenti