Posso usare git diff su file non tracciati?

È possibile chiedere a git diff di includere file non tracciati nel suo output diff? O è la mia scommessa migliore per aggiungere i nuovi file che ho creato e i file esistenti che ho modificato e utilizzare

git diff --cached

?

Con le recenti versioni di git è possibile git add -Nil file (o --intent-to-add), che aggiunge un BLOB di lunghezza zero all'indice in quella posizione. Il risultato è che il tuo file "non tracciato" ora diventa una modifica per aggiungere tutto il contenuto a questo file di lunghezza zero e che appare nell'output "git diff".

git diff

echo "this is a new file" > new.txt
git diff

git add -N new.txt
git diff
diff --git a/new.txt b/new.txt
index e69de29..3b2aed8 100644
--- a/new.txt
+++ b/new.txt
@@ -0,0 +1 @@
+this is a new file

Purtroppo, come sottolineato, non puoi farlo git stashmentre hai un --intent-to-addfile in sospeso come questo. Anche se se hai bisogno di stash, aggiungi semplicemente i nuovi file e poi li stash. Oppure puoi usare la soluzione alternativa di emulazione:

git update-index --add --cacheinfo \
100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 new.txt

(la creazione di un alias è il tuo amico qui).

Credo che tu possa differenziare i file nel tuo indice e i file non tracciati semplicemente fornendo il percorso di entrambi i file.

git diff --no-index tracked_file untracked_file

Per il mio gitting interattivo di tutti i giorni (in cui diffondo sempre l'albero di lavoro contro HEAD e vorrei avere file non tracciati inclusi nel diff), add -N/--intent-to-addè inutilizzabile, perché si rompe git stash .

Quindi ecco la mia git diffsostituzione. Non è una soluzione particolarmente pulita, ma dal momento che la uso solo in modo interattivo, sto bene con un trucco:

d() {
    if test "$#" = 0; then
        (
            git diff --color
            git ls-files --others --exclude-standard |
                while read -r i; do git diff --color -- /dev/null "$i"; done
        ) | `git config --get core.pager`
    else
        git diff "$@"
    fi
}

La digitazione dincluderà solo file non tracciati nel diff (che è ciò che mi interessa nel mio flusso di lavoro) e d args...si comporterà come un normale git diff.

Appunti:

• Stiamo usando il fatto che in git diffrealtà sono solo i differenziali concatenati, quindi non è possibile distinguere l' doutput da un "vero diff", tranne per il fatto che tutti i file non tracciati vengono ordinati per ultimi.
• L'unico problema con questa funzione è che l'output è colorato anche quando reindirizzato; ma non posso preoccuparmi di aggiungere la logica per quello.
• Non sono riuscito a trovare alcun modo per includere i file non tracciati semplicemente assemblando un elenco di argomenti chiari per git diff. Se qualcuno scopre come fare questo, o se forse una funzione verrà aggiunta ad un gitcerto punto in futuro, si prega di lasciare una nota qui!

Non al 100% al punto, ma se per qualche motivo non vuoi aggiungere i tuoi file all'indice come suggerito dalla risposta accettata, ecco un'altra opzione:

Se i file non sono tracciati, ovviamente il diff è l'intero file, quindi puoi semplicemente visualizzarli con meno:

less $(git ls-files --others --exclude-standard)

Naviga tra loro con :ne :pper il prossimo e il precedente.

Aggiornamento dai commenti: se hai bisogno di un formato patch puoi anche combinarlo con git diff:

git ls-files --others --exclude-standard | xargs -n 1 git --no-pager diff /dev/null | less

Puoi anche reindirizzare l'output su un file o utilizzare un altro comando diff in questo caso.

git add -A
git diff HEAD

Genera patch se necessario, quindi:

git reset HEAD

questo funziona per me:

git add my_file.txt
git diff --cached my_file.txt
git reset my_file.txt

L'ultimo passaggio è facoltativo, lascerà il file nello stato precedente (non tracciato)

utile se stai creando anche una patch:

  git diff --cached my_file.txt > my_file-patch.patch

Le modifiche funzionano se messe in scena e non messe in scena con questo comando. I nuovi file funzionano quando messi in scena:

$ git diff HEAD

Se non vengono messi in scena, vedrai solo differenze di file.

Per un file:

git diff --no-index /dev/null new_file

Per tutti i nuovi file:

for next in $( git ls-files --others --exclude-standard ) ; do git --no-pager diff --no-index /dev/null $next; done;

Come alias:

alias gdnew="for next in \$( git ls-files --others --exclude-standard ) ; do git --no-pager diff --no-index /dev/null \$next; done;"

Per tutti i file modificati e nuovi combinati come un solo comando:

{ git --no-pager diff; gdnew }

di solito quando lavoro con team di localizzazione remoti è importante per me avere una conoscenza preliminare del cambiamento fatto da altri team nello stesso file, prima di seguire git stages untrack -> messo in scena -> commit per quello ho scritto uno script bash che aiutami a evitare inutili risoluzioni di unione in conflitto con il team remoto o crea un nuovo ramo locale e confronta e unisci sul ramo principale

#set -x 
branchname=`git branch | grep -F '*' |  awk '{print $2}'`
echo $branchname
git fetch origin ${branchname}
for file in `git status | grep "modified" | awk "{print $2}" `
do
echo "PLEASE CHECK OUT GIT DIFF FOR "$file 
git difftool FETCH_HEAD $file ;
done

nello script sopra prendo il ramo principale remoto (non necessario il suo ramo principale) per FETCH_HEAD li faccio un elenco del mio file modificato e confronta i file modificati con git difftool

qui molti difftool supportati da git, configuro 'Meld Diff Viewer' per un buon confronto della GUI.

Supponendo che non ci siano commit locali,

git diff origin/master