Risposte:
git diff --name-only SHA1 SHA2
dove è sufficiente includere un numero sufficiente di SHA per identificare i commit. Puoi anche fare, per esempio
git diff --name-only HEAD~10 HEAD~5
per vedere le differenze tra il decimo ultimo commit e il quinto più recente (o giù di lì).
git show --name-only SHA1
.
git diff --name-status [TAG|SHA1]
mostra quali operazioni sono state eseguite anche sui file
git diff --name-status
non sembra voler mostrare i file aggiunti. @sschuberth ha sottolineato git show
, che non sembra funzionare correttamente per me: git show --pretty=format: --name-status
. Basta fare git show --name-status
dà un po 'più di informazioni, ma comunque bello e denso ... quello sarà il mio nuovo comando di goto;)
git diff --name-status [SHA1 [SHA2]]
è come - solo nome, tranne per il fatto che ottieni un semplice prefisso che ti dice cosa è successo al file (modificato, cancellato, aggiunto ...)
git log --name-status --oneline [SHA1..SHA2]
è simile, ma i commit sono elencati dopo il messaggio di commit, quindi puoi vedere quando un file è stato modificato.
se sei interessato a ciò che è accaduto a determinati file / cartelle puoi aggiungere -- <filename> [<filename>...]
alla git log
versione.
se vuoi vedere cosa è successo per un singolo commit, chiamalo SHA1, quindi fallo
git log --name-status --oneline [SHA1^..SHA1]
Flag di stato del file:
M modificato - Il file è stato modificato
C copia-modifica - Il file è stato copiato e modificato
R rinomina-modifica - Il file è stato rinominato e modificato
A aggiunto - Il file è stato aggiunto
D eliminato - Il file è stato eliminato
U non unito - Il file presenta conflitti dopo un'unione
--relative[=<path>]
opzione potrebbe aiutarti, non ne sono sicuro. Altrimenti c'è sempre | erep -v '(.tmp|.foo|.dontwant)$'
...
Sembra che nessuno abbia menzionato l'interruttore --stat
:
$ git diff --stat HEAD~5 HEAD
.../java/org/apache/calcite/rex/RexSimplify.java | 50 +++++++++++++++++-----
.../apache/calcite/sql/fun/SqlTrimFunction.java | 2 +-
.../apache/calcite/sql2rel/SqlToRelConverter.java | 16 +++++++
.../org/apache/calcite/util/SaffronProperties.java | 19 ++++----
.../org/apache/calcite/test/RexProgramTest.java | 24 +++++++++++
.../apache/calcite/test/SqlToRelConverterTest.java | 8 ++++
.../apache/calcite/test/SqlToRelConverterTest.xml | 15 +++++++
pom.xml | 2 +-
.../apache/calcite/adapter/spark/SparkRules.java | 7 +--
9 files changed, 117 insertions(+), 26 deletions(-)
Ci sono anche --numstat
$ git diff --numstat HEAD~5 HEAD
40 10 core/src/main/java/org/apache/calcite/rex/RexSimplify.java
1 1 core/src/main/java/org/apache/calcite/sql/fun/SqlTrimFunction.java
16 0 core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
8 11 core/src/main/java/org/apache/calcite/util/SaffronProperties.java
24 0 core/src/test/java/org/apache/calcite/test/RexProgramTest.java
8 0 core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
15 0 core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
1 1 pom.xml
4 3 spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
e --shortstat
$ git diff --shortstat HEAD~5 HEAD
9 files changed, 117 insertions(+), 26 deletions(-)
Ma per vedere i file cambiati tra il tuo ramo e il suo antenato comune con un altro ramo (diciamo origin / master):
git diff --name-only `git merge-base origin/master HEAD`
git diffstatus master
o simili, che innesca quanto sopra.
git show --pretty=format: --name-only origin/master..
.
git diff --name-only HEAD...master
(nota i tre punti). Per una spiegazione dettagliata, vedere qui .
git diff --name-only master..branch
non corrisponde all'elenco PR di github. In questo modo più preciso. Ma comunque ho 173 file modificati rispetto a 171 in github PR. (senza che merge-base
io abbia 228 contro 171)
Per integrare la risposta di @ artfulrobot, se si desidera mostrare i file modificati tra due rami:
git diff --name-status mybranch..myotherbranch
Fai attenzione alla precedenza. Se si inserisce prima il ramo più recente, i file verranno visualizzati come eliminati anziché aggiunti.
L'aggiunta di una grep
lattina raffina ulteriormente le cose:
git diff --name-status mybranch..myotherbranch | grep "A\t"
Che mostrerà quindi solo i file aggiunti myotherbranch
.
--diff-filter
che dà questa funzionalità in modo nativo, il che significa meno possibilità di risultati errati (ad esempio falsi positivi)
Aggiungi sotto alias al tuo ~/.bash_profile
, quindi esegui source ~/.bash_profile
,; ora ogni volta che devi vedere i file aggiornati nell'ultimo commit, esegui, showfiles
dal tuo repository git.
alias showfiles='git show --pretty="format:" --name-only'
git config --global alias.showfiles 'show --pretty="format:" --name-only'
da fare git showfiles
.
Questo mostrerà le modifiche nei file:
git diff --word-diff SHA1 SHA2
Usa git log --pretty = oneline> C: \ nomefile.log
che registrerà solo un oneline (--pretty = oneline) questo è il nome del file modificato. Inoltre registrerà tutti i dettagli nel tuo file di output.
git log --pretty=oneline
mi dà solo SHA e il messaggio di commit usando git 2.10.1
Come ha detto artfulrobot nella sua risposta:
git diff --name-status [SHA1 [SHA2]]
Il mio esempio:
git diff --name-status 78a09k12067c24d8f117886c4723ccf111af4997
4b95d595812211553070046bf2ebd807c0862cca
M views/layouts/default.ctp
M webroot/css/theme.css
A webroot/img/theme/logo.png
Solo per qualcuno che deve concentrarsi solo su file Java, questa è la mia soluzione:
git diff --name-status SHA1 SHA2 | grep '\.java$'
Quanto segue funziona bene per me:
$ git show --name-only --format=tformat: SHA1..SHA2
Può anche essere utilizzato con un singolo commit:
git show --name-only --format=tformat: SHA1
che è utile per l'uso in Jenkins in cui viene fornito un elenco di modifiche Impostare SHA e si desidera scorrere su di esse per vedere quali file sono stati modificati.
Questo è simile a un paio di risposte sopra, ma usando tformat:
invece di format:
rimuovere lo spazio di separazione tra commit.
Sulla base di git diff --name-status
ho scritto l' estensione git git-diffview che rende una vista ad albero gerarchica di ciò che è cambiato tra due percorsi.