Come posso vedere diff
tra un ramo locale e un ramo remoto?
git diff HEAD origin/HEAD
che sembra indicare un ramo remoto diverso da quello che intendevo. L'uso del nome completo del ramo funziona come previsto.
Come posso vedere diff
tra un ramo locale e un ramo remoto?
git diff HEAD origin/HEAD
che sembra indicare un ramo remoto diverso da quello che intendevo. L'uso del nome completo del ramo funziona come previsto.
Risposte:
Per aggiornare i rami di tracciamento remoto, devi git fetch
prima digitare e poi:
git diff <masterbranch_path> <remotebranch_path>
Puoi git branch -a
elencare tutti i rami (locali e remoti) quindi scegliere il nome del ramo dall'elenco (basta rimuoverlo remotes/
dal nome del ramo remoto.
Esempio: git diff master origin/master
(dove "master" è il ramo master locale e "origin / master" è un ramo remoto, ovvero origine e master).
git fetch
)
[diff] tool = vscode [difftool] prompt = false [difftool "vscode"] cmd = \"C:\\Program Files (x86)\\Microsoft VS Code\\Code.exe\" \"$LOCAL\" \"$REMOTE\" --diff --wait trustExitCode = false
Assicurati che il tuo percorso al file code.exe sia corretto.
git diff <local branch> <remote>/<remote branch>
Ad esempio git diff master origin/master
, oppuregit diff featureA origin/next
Ovviamente per avere detto ramo di localizzazione remota devi git fetch
prima; e ne hai bisogno per avere informazioni aggiornate sulle filiali nel repository remoto.
git diff <remote>/<remote branch> <local branch>
per vedere cosa farà la mia spinta al repository remoto.
git diff origin
è sufficiente se si confronta con il ramo a monte.
git fetch
all'inizio, causa problemi ai principianti come me
git diff <remote>/<remote branch> <local branch>
? Altrimenti, ricevo le aggiunte e le eliminazioni attivate sul mio computer (versione git 2.7.0.windows.2)
Primo tipo
git branch -a
per ottenere l'elenco dei rami disponibili. Sull'output potresti vedere qualcosa di simile
* master
remotes/main/master
remotes/origin/HEAD -> origin/master
remotes/origin/master
remotes/origin/mt
remotes/upstream/master
remotes/upstream/mt
Quindi mostra il diff
git diff --stat --color remotes/main/master..origin/master
git diff remotes/main/master..origin/master
...
piuttosto che ..
?
git log origin/my_branch..
che prenderà HEAD
come riferimento locale, che è principalmente quello che vuoi dire.
fatal: bad revision
o fatal: ambiguous argument
. Tutto quello che volevo era vedere il diff sullo stesso file da un altro ramo, era chiedere troppo? Sì, sì lo era. :-) git diff remotes/origin/<base branch> <current branch> -- <filename>
funziona alla grande su git 1.8.3.1
Se ti trovi in un determinato ramo e desideri confrontarlo con un ramo a monte che stai monitorando, utilizza
git diff @{upstream}
se il tuo upstream non è impostato (comunemente il caso, grazie Arijoon nei commenti)
git diff @{push}
Per gentile concessione di questa risposta , la documentazione git per specificare le revisioni ha:
<branchname>@{upstream}
, ad esempiomaster@{upstream}
,@{u}
il suffisso@{upstream}
per un nome di ramo (forma abbreviata<branchname>@{u}
) si riferisce al ramo che il ramo specificato dabranchname
è impostato per costruire sopra (configurato conbranch.<name>.remote
ebranch.<name>.merge
). Unbranchname
valore predefinito mancante a quello corrente.
git diff @ @{upstream}
. Il extra @
è HEAD
, che è dove sei ora, quindi stai confrontando HEAD
con l'upstream che sta monitorando il tuo ramo. Puoi usare @{push}
invece di upstream per ottenere diff tra il ramo che sei pronto a spingere
fatal: ambiguous argument '@upstream': unknown revision or path not in the working tree
. Dovevo usare git diff @\{upstream\}
invece. 😥
git fetch
prima, altrimenti questo non fa nulla, non mostra alcun output; testato eliminando un file nell'origine repository ed eseguito questo comando localmente. .. funziona solo dopo il recupero.
Capisco molto meglio l'output di:
git diff <remote-tracking branch> <local branch>
ciò mi mostra cosa verrà eliminato e cosa verrà aggiunto se spingo il ramo locale. Ovviamente è lo stesso, proprio il contrario, ma per me è più leggibile e mi sento più a mio agio guardando cosa sta per succedere.
Il modo semplice:
git fetch
git log -p HEAD..FETCH_HEAD
Questo prima recupererà le modifiche dal tuo telecomando predefinito (origine). Questo verrà creato automaticamente quando clonerai un repository. Si può anche essere espliciti: git fetch origin master
.
Quindi git log viene utilizzato per confrontare il ramo corrente con quello appena recuperato. (L' -p
opzione (genera patch) è ciò che mostra le differenze .)
Questo è come lo faccio.
#To update your local.
git fetch --all
questo recupererà tutto dal telecomando, quindi quando controlli la differenza, confronterà la differenza con il ramo remoto.
#to list all branches
git branch -a
il comando sopra mostrerà tutti i rami.
#to go to the branch you want to check difference
git checkout <branch_name>
#to check on which branch you are in, use
git branch
(or)
git status
Ora puoi controllare la differenza come segue.
git diff origin/<branch_name>
questo confronterà la tua filiale locale con la filiale remota
Lascia che il tuo ramo operativo sia sviluppo e desideri distinguere tra ramo di sviluppo locale e ramo di sviluppo remoto, in tal caso, la sintassi dovrebbe essere come git diff remotes/origin/development..development
o
git fetch origin
git diff origin/development
tl; dr :git diff <local branch> <remote branch>
Quando uso git sulla shell, mi piace prima orientarmi guardandomi intorno. Ecco un comando per mostrare tutti i rami
$ git branch -a # (or git branch --all)
* my-branch
master
remotes/origin/some-branch
remotes/origin/HEAD -> origin/master
remotes/origin/my-branch
remotes/origin/some-other-branch
remotes/origin/master
Qui ho due sezioni locali ( my-branch
e master
) e 4 (remote some-branch
, some-other-branch
, master
, e my-branch
).
Inoltre, l'asterisco accanto a my-branch
segnala il fatto che sono attualmente in quel ramo (lo sapresti anche usando il comando git status
che produrrebbe:) On branch my-branch.
.
Nota: i rami remoti nella shell git bash sono mostrati in rosso mentre quelli locali sono mostrati in verde.
Se vuoi solo mostrare filiali remote :
$ git branch -r # (or git branch --remotes)
origin/some-branch
origin/HEAD -> origin/master
origin/my-branch
origin/some-other-branch
origin/master
Per mostrare solo i rami locali potresti essere tentato di usare git branch -l
ma questo è un comando completamente diverso. Per mostrare le filiali locali utilizzare git branch
senza opzioni
$ git branch
* my-branch
master
Per completare una revisione delle opzioni di base del ramo c'è il --list
contrario di quello che ci si potrebbe aspettare è lì per consentire il filtraggio . Usalo con un modello come questo:
$ git branch --list 'my*'
* my-branch
Puoi anche combinare --list
con le opzioni -a
e -r
assicurarti di adattare di conseguenza il tuo modello ( ricorda: i rami remoti iniziano con "telecomandi" ). Esempio:
# this will show all branches (local & remote) that start with my
$ git branch --list 'my*' -a
* my-branch
# better: the pattern includes the remote
$ git branch --list '*my*' -a
* my-branch
remotes/origin/my-branch
Documenti: https://git-scm.com/docs/git-branch
Ora puoi confrontare due rami qualsiasi tra tutti quelli disponibili (puoi anche confrontare due locali o due telecomandi).
Qui sto confrontando il locale con il telecomando my-branch
, sono sincronizzati, quindi non ottengo alcun output:
$ git diff my-branch remotes/origin/my-branch
Nota: devi dare i nomi completi dei rami senza virgolette.
Posso anche confrontare il locale my-branch
con il telecomando master
. Qui ottengo un output perché il telecomando my-branch
non è stato unito al ramo principale.
$ git diff my-branch remotes/origin/master
diff --git a/src/controllers/call.controller.js b/src/controllers/call.controller.js
index fd79b98..df3d798 100644
--- a/src/controllers/call.controller.js
+++ b/src/controllers/call.controller.js
@@ -261,7 +261,7 @@ function callController() {
/*
* Function: doCall
[ . . . ]
Se volete vedere la differenza come solo i nomi dei file modificati, allora l'uso:
git diff --name-status <remote-branch> <local-branch>
,
altrimenti questo avrebbe mostrato tutte le differenze tra i due rami:
git diff <remote-branch> <local-branch>
Ecco una risposta abbreviata se stai confrontando il tuo ramo attuale e qualcosa che desideri git pull
.
git fetch
git diff FETCH_HEAD
Il primo comando scoprirà quale ramo remoto corrisponde al ramo corrente. Un artefatto di quel calcolo nel FETCH_HEAD
riferimento. Quindi il secondo comando usa quel confronto di riferimento rispetto a quello che ha il tuo ramo attuale.
So che ci sono già diverse risposte a questa domanda, ma stavo ricevendo uno strano errore quando provavo la maggior parte di esse.
Nel mio caso ho un secondo telecomando chiamato heroku
che non è il origin
e poiché non era sincronizzato ho ricevuto questo errore quando ho provato a eseguire il git diff master heroku/master
:
fatal: ambiguous argument 'heroku/master': unknown revision or path not in the working tree.
o questo quando provi l'altro approccio git diff master..heroku/master
:
fatal: bad revision 'master..heroku/master'
La soluzione menzionava esplicitamente il nome remoto git fetch
prima di eseguire git diff
, nel mio caso:
$ git fetch heroku
$ git diff master heroku/master
Spero che aiuti gli altri con questo stesso problema.
git difftool <commit> .
Questo confronterà il commit che desideri con i tuoi file locali. Non dimenticare il punto alla fine (per locale).
Ad esempio, per confrontare i file locali con alcuni commit:
git difftool 1db1ef2490733c1877ad0fb5e8536d2935566341.
(e non hai bisogno di git fetch, a meno che non sia necessario il confronto con i nuovi commit)
Esempio
git diff 'master' 'testlocalBranch'
Se si utilizza l'editor come webstorm, è possibile fare clic con il pulsante destro del mouse sul file selezionare confronta con ramo e digitare / selezionare il ramo.
In VS 2019, esegui FETCH Non estrarre il codice.
Questo è quello che ho fatto. Aggiunto di seguito nel file .gitconfig in modo da poter usare Beyond Compare
File location: C:\Users\[username]\.gitconfig
Aggiunto di seguito
[diff]
tool = bc
[difftool "bc"]
path = c:/Program Files/Beyond Compare 4/bcomp.exe
Apri il prompt dei comandi e vai alla directory di lavoro. Ho fornito di seguito per confrontare il ramo DEV locale con il ramo DEV remoto
git difftool dev origin/dev --dir-diff
Questo aprirà Beyond Compare e aprirà le directory che hanno file diversi. Se nessuna modifica Beyond Compare non verrà avviata.
Mi chiedo se c'è qualche cambiamento nel mio ramo principale ...
git checkout master
stato git
ramo git -a
- maestri
telecomandi / origin / master
git diff origin / master
git config alias.udiff 'diff @{u}'
git fetch # Do this if you want to compare with the network state of upstream; if the current local state is enough, you can skip this
git udiff
Questo risponde alla domanda nella tua rubrica ("il suo telecomando"); se si desidera diff su "un telecomando" (che non è configurato come upstream per il ramo), è necessario indirizzarlo direttamente. Puoi vedere tutti i rami remoti con il seguente:
git branch -r
Puoi vedere tutti i telecomandi configurati con i seguenti:
git remote show
È possibile visualizzare la configurazione di diramazione / tracciamento per un singolo telecomando (ad es. Origine) come segue:
git remote show origin
Una volta determinato il ramo di origine appropriato, fai una normale differenza :)
git diff [MY_LOCAL] MY_REMOTE_BRANCH
Questo è abbastanza semplice Puoi usare:git diff remote/my_topic_branch my_topic_branch
Dov'è il my_topic_branch
tuo argomento.
provare:
git diff origin HEAD
Supponendo di voler diffondere le filiali locali correnti HEAD
rispetto all'origine. E supponendo che tu sia nella filiale locale. :)
Se si utilizza TortoiseGit (fornisce la GUI per Git), è possibile fare clic con il tasto destro del mouse sulla cartella repository Git, quindi fare clic suGit Sync
.
È possibile selezionare i rami da confrontare se non selezionati. Di quanto è possibile visualizzare le differenze commit. È inoltre possibile fare clic con il pulsante destro del mouse su qualsiasi commit Compare with previous revision
per visualizzare le differenze fianco a fianco.