Como posso ver diffentre uma filial local e uma filial remota?

Para atualizar ramificações de rastreamento remoto, você precisa digitar git fetchprimeiro e depois:

git diff <masterbranch_path> <remotebranch_path>

Você pode git branch -alistar todas as filiais (local e remota) e escolher o nome da filial (basta remover remotes/do nome da filial remota).

Exemplo: git diff master origin/master(onde "mestre" é a filial principal local e "origem / mestre" é um remoto, a saber, origem e filial principal.)

git diff <local branch> <remote>/<remote branch>

Por exemplo git diff master origin/master, ougit diff featureA origin/next

É claro que para ter dito o ramo de rastreamento remoto, você precisa git fetchprimeiro; e você precisa ter informações atualizadas sobre ramificações no repositório remoto.

Primeiro tipo

git branch -a

para obter a lista de ramificações disponíveis. Na saída, você pode ver algo como

* master
  remotes/main/master
  remotes/origin/HEAD -> origin/master
  remotes/origin/master
  remotes/origin/mt
  remotes/upstream/master
  remotes/upstream/mt

Então mostre o diff

git diff --stat --color remotes/main/master..origin/master
git diff remotes/main/master..origin/master

Se você estiver em um determinado ramo e quiser compará-lo com um ramo upstream que estiver rastreando, use

git diff @{upstream}

se o seu upstream não estiver configurado (normalmente, obrigado Arijoon nos comentários)

git diff @{push}

Como cortesia desta resposta , a documentação do git para especificar revisões tem:

<branchname>@{upstream}, por exemplo master@{upstream}, @{u}
o sufixo @{upstream}para um nome da filial (formato abreviado <branchname>@{u}) refere-se à ramificação que a ramificação especificada por branchnameestá configurada para construir em cima de (configurada com branch.<name>.remotee branch.<name>.merge). Um branchnamepadrão ausente é o atual.

Eu entendo muito melhor a saída de:

git diff <remote-tracking branch> <local branch>

isso me mostra o que será descartado e o que será adicionado se eu pressionar a filial local. Claro que é o mesmo, apenas o inverso, mas para mim é mais legível e estou mais confortável olhando o que vai acontecer.

O caminho fácil:

git fetch
git log -p HEAD..FETCH_HEAD

Isso buscará primeiro as alterações no seu controle remoto padrão (origem). Isso será criado automaticamente quando você clonar um repo. Você também pode ser explícito:git fetch origin master .

Em seguida, o git log é usado para comparar sua ramificação atual com a recém-obtida. (A opção -p(gerar patch) é o que mostra as diferenças .)

É assim que eu faço.

#To update your local.
git fetch --all

isso buscará tudo do controle remoto; portanto, quando você verificar a diferença, ele comparará a diferença com a ramificação remota.

#to list all branches
git branch -a

o comando acima exibirá todos os ramos.

#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

Agora, você pode verificar a diferença da seguinte maneira.

git diff origin/<branch_name>

isso comparará sua filial local com a filial remota

Deixe seu ramo de trabalho ser desenvolvimento e queira diferenciar entre ramo de desenvolvimento local e ramo de desenvolvimento remoto; nesse caso, a sintaxe deve ser semelhante git diff remotes/origin/development..development
ou

git fetch origin git diff origin/development

tl; dr :git diff <local branch> <remote branch>

Ao usar o git no shell, primeiro gosto de me orientar olhando em volta. Aqui está um comando para mostrar todos os ramos

$ 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

Aqui eu tenho dois ramos locais ( my-branche master) e 4 (Remote some-branch, some-other-branch, master, emy-branch ).

Além disso, o asterisco próximo a my-branchsinaliza o fato de que estou atualmente nesse ramo (você também saberia disso usando o comando git statusque produziria:) On branch my-branch..

Nota: as ramificações remotas no shell do git bash são mostradas em vermelho, enquanto as ramificações locais são mostradas em verde.

Se você quer apenas mostrar ramificações remotas :

$ git branch -r # (or git branch --remotes)
  origin/some-branch
  origin/HEAD -> origin/master
  origin/my-branch
  origin/some-other-branch
  origin/master

Para mostrar apenas ramificações locais, você pode ser tentado a usar, git branch -lmas esse é um comando completamente diferente. Para mostrar filiais locais, use git branchsem opções

$ git branch
* my-branch 
  master

Para concluir uma revisão das opções básicas de ramificação, existe o --listcontrário do que você pode esperar para permitir a filtragem . Use-o com um padrão como este:

$ git branch --list 'my*'
* my-branch

Você também pode combinar --listcom as opções -ae -rmas certifique-se de adaptar o seu padrão de conformidade ( lembre-se: filiais remotas começar com "controles remotos" ). Exemplo:

# 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

Documentos: https://git-scm.com/docs/git-branch

Agora você pode comparar dois ramos de todas as disponíveis (você também pode comparar dois locais ou dois controles remotos).

Aqui estou comparando o local com o controle remoto my-branch, eles são sincronizados para que eu não obtenha nenhuma saída:

$ git diff my-branch remotes/origin/my-branch

Nota: você deve fornecer o nome completo dos ramos sem aspas.

Também posso comparar o local my-branchcom o remoto master. Aqui recebo alguma saída porque o controle remoto my-branchnão foi mesclado na ramificação principal.

$ 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 você quiser ver a diferença como apenas os nomes dos arquivos foram alterados, use :, caso contrário

git diff --name-status <remote-branch> <local-branch>,

isso mostraria todas as diferenças entre os dois ramos:

git diff <remote-branch> <local-branch>

Aqui está uma resposta abreviada se você estiver comparando sua ramificação atual e com algo que deseja git pull.

git fetch
git diff FETCH_HEAD

O primeiro comando descobrirá qual ramificação remota corresponde à sua ramificação atual. Um artefato desse cálculo na FETCH_HEADreferência. Em seguida, o segundo comando usa essa comparação de referência versus a que sua filial atual possui.

Eu sei que já existem várias respostas para essa pergunta, mas estava recebendo um erro estranho ao tentar a maioria delas.

No meu caso, tenho um segundo controle remoto chamado herokuque não é o origine, como não estava sincronizado, recebi esse erro ao tentar executar o git diff master heroku/master:

fatal: ambiguous argument 'heroku/master': unknown revision or path not in the working tree.

ou isso ao tentar a outra abordagem git diff master..heroku/master:

fatal: bad revision 'master..heroku/master'

A solução mencionava explicitamente o nome remoto git fetchantes de executar git diff, no meu caso:

$ git fetch heroku
$ git diff master heroku/master

Espero que ajude outras pessoas com esse mesmo problema.

git difftool <commit> .

Isso irá comparar a confirmação que você deseja com seus arquivos locais. Não esqueça o ponto no final (para local).

Por exemplo, para comparar seus arquivos locais com algumas confirmações:

git difftool 1db1ef2490733c1877ad0fb5e8536d2935566341.

(e você não precisa de busca por git, a menos que seja necessário comparar com novas confirmações)

Exemplo

git diff 'master' 'testlocalBranch'

Se você estiver usando um editor como o webstorm, clique com o botão direito do mouse no arquivo selecione comparar com o ramo e digite / selecione seu ramo.

No VS 2019, basta executar FETCH Não puxe o código.

Foi o que eu fiz. Adicionado abaixo no arquivo .gitconfig para que eu possa usar o Beyond Compare

File location: C:\Users\[username]\.gitconfig

Adicionado abaixo

[diff]
    tool = bc
[difftool "bc"]
    path = c:/Program Files/Beyond Compare 4/bcomp.exe

Abra o prompt de comando e vá para o diretório de trabalho. Eu dei abaixo para comparar a filial local do DEV com a filial remota do DEV

git difftool dev origin/dev --dir-diff

Isso abrirá o Beyond Compare e os diretórios que possuem arquivos diferentes. Se não houver alterações, o Beyond Compare não será iniciado.

Gostaria de saber se há alguma mudança no meu ramo mestre ...

1. Em primeiro lugar, você precisa alterar sua ramificação (se você já está sob essa ramificação, não precisa fazer isso!)

mestre de verificação geral do git

2. Você pode ver qual arquivo foi modificado em sua ramificação principal por este comando

status git

3. Listar os ramos

git branch -a

• mestre
  remotes / origin / master

4. Encontre as diferenças

origem / mestre do git diff

Configuração

git config alias.udiff 'diff @{u}'

Diferenciando HEAD com HEAD @ {upstream}

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

Diferenciando com uma ramificação remota arbitrária

Isso responde à pergunta em seu cabeçalho ("seu controle remoto"); se você quiser fazer uma comparação com "um controle remoto" (que não esteja configurado como upstream para a ramificação), será necessário direcioná-lo diretamente. Você pode ver todas as ramificações remotas com o seguinte:

git branch -r

Você pode ver todos os controles remotos configurados com o seguinte:

git remote show

Você pode ver a configuração de ramificação / rastreamento de um único controle remoto (por exemplo, origem) da seguinte maneira:

git remote show origin

Depois de determinar o ramo de origem apropriado, basta fazer uma comparação normal :)

git diff [MY_LOCAL] MY_REMOTE_BRANCH

Isto é bem simples. Você pode usar:git diff remote/my_topic_branch my_topic_branch

Onde my_topic_branchestá o seu ramo de tópico.

Digamos que você já configurou o seu origincomo repositório remoto. Então,

git diff <local branch> <origin>/<remote branch name>

tentar:

git diff origin HEAD

Supondo que você queira diferenciar as ramificações locais atuais em HEADrelação à origem. E supondo que você esteja no ramo local. :)

Se você usa o TortoiseGit (fornece GUI para Git), clique com o botão direito do mouse na pasta de repositório do Git e clique em Git Sync.

Você pode selecionar suas ramificações para comparar se não estiver selecionado. Do que você pode ver as diferenças comprometidas. Você também pode clicar com o botão direito em qualquer confirmaçãoCompare with previous revision visualizar as diferenças lado a lado.