Aby uzupełnić mój poprzedni "diff.external " Config answer above:

Jako wspomniany przez Jakuba , Git1.6.3 wprowadził git difftool, pierwotnie zaproponowane we wrześniu 2008 r.:

Użycie='[--tool=tool] [--commit=ref] [--start=ref --end=ref] [--no-prompt] [file to merge]'
(Zobacz --extcmd w ostatniej części tej odpowiedzi)

$LOCAL zawiera Zawartość pliku z początkowej rewizji i $REMOTE zawiera Zawartość pliku w końcowej rewizji.
$BASE zawiera Zawartość pliku w wor

Jest w zasadzie git-mergetool zmodyfikowany do pracy na indeksach Gita / drzewach roboczych.

Zwyczajowym przypadkiem użycia tego skryptu jest sytuacja, gdy zmiany są ustawione lub nie są ustawione i chcesz je zobaczyć w przeglądarce różnic obok siebie (np. xxdiff, tkdiff, itp.).

git difftool [<filename>*]

Innym przypadkiem użycia jest, gdy chcesz zobaczyć te same informacje, ale porównujesz dowolne commity (jest to część, w której parsowanie revarg może być lepiej)

git difftool --start=HEAD^ --end=HEAD [-- <filename>*]

Ostatni przypadek użycia jest wtedy, gdy chcesz porównać bieżący obszar roboczy z czymś innym niż HEAD (np. tag)

git difftool --commit=v1.0.0 [-- <filename>*]

Uwaga: od wersji Git 2.5, git config diff.tool winmerge wystarczy!
Zobacz "git mergetool winmerge "

I od wersji Git 1.7.11 , masz opcję --dir-diff, aby wywoływać zewnętrzne narzędzia różnicujące, które mogą porównywać dwie hierarchie katalogów na raz po wypełnieniu dwóch katalogów tymczasowych, zamiast uruchamiać wystąpienie narzędzia zewnętrznego raz na parę plików.

Przed Git 2.5:

Praktyczny przypadek konfiguracji difftool za pomocą niestandardowego narzędzia diff:

C:\myGitRepo>git config --global diff.tool winmerge
C:\myGitRepo>git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\""
C:\myGitRepo>git config --global difftool.prompt false

Z winmerge.sh zapisany w części katalogu ścieżki:

#!/bin/sh
echo Launching WinMergeU.exe: $1 $2
"C:/Program Files/WinMerge/WinMergeU.exe" -u -e "$1" "$2" -dl "Local" -dr "Remote"

Jeśli masz inne narzędzie (kdiff3, P4Diff, ...), utworzyć kolejny skrypt powłoki oraz odpowiednią dyrektywę config difftool.myDiffTool.cmd.
Następnie możesz łatwo przełączać narzędzia za pomocą konfiguracji diff.tool.

You have also this blog entry by Dave aby dodać inne szczegóły.
(Lub to pytanie dla opcji winmergeu)

Zainteresowanie tym ustawieniem jest winmerge.shscript : można dostosować go do specjalnych przypadków.

Zobacz na przykład David Marble ' S odpowiedź poniżej dla przykładu, który dotyczy:

• nowe pliki w źródle lub miejscu przeznaczenia
• usunięto pliki w źródle lub miejsce przeznaczenia

Jako Kem Mason wspomina w jego odpowiedź , możesz również uniknąć dowolnego opakowania, używając opcji --extcmd :

--extcmd=<command>

Określa własne polecenie do wyświetlania diffów. git-difftool ignoruje skonfigurowane wartości domyślne i uruchamia $command $LOCAL $REMOTE gdy ta opcja jest określona.

Na przykład, to jest jak gitk jest w stanie uruchomić/użyć dowolnego narzędzia diff .

W duchu odpowiedzi na pytania, które są nieco inne niż zadawane. Spróbuj tego rozwiązania:

$ meld my_project_using_git

Meld rozumie Gita i zapewnia nawigację po ostatnich zmianach.

Z nowym git difftool , jest tak proste, jak dodanie tego do twojego .plik gitconfig :

[diff]
    tool = any-name
[difftool "any-name"]
    cmd = "\"C:/path/to/my/ext/diff.exe\" \"$LOCAL\" \"$REMOTE\""

Opcjonalnie Dodaj również:

[difftool]
    prompt = false

Zobacz też diffall, prosty skrypt, który napisałem, aby rozszerzyć irytujące (IMO) domyślne zachowanie diff otwierania każdego w trybie szeregowym.

Globalny .gitconfig na Windows jest w %USERPROFILE%\.gitconfig

Od wersji git 1.6.3 jest "git difftool" które możesz skonfigurować tak, aby używało Twojego ulubionego graficznego narzędzia różnicującego. Obecnie obsługiwane są kdiff3, kompare, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, diffusei opendiff; Jeśli narzędzia, którego chcesz użyć, nie ma na tej liście, zawsze możesz użyć opcji konfiguracji 'difftool.<tool>.cmd'.

"git difftool" akceptuje te same opcje co"git diff".

Mam jeden dodatek do tego. Lubię regularnie używać aplikacji diff, która nie jest obsługiwana jako jedno z domyślnych narzędzi (np.]}

git difftool -t

Lubię też mieć domyślną diff tylko zwykłą linię poleceń, więc ustawienie zmiennej GIT_EXTERNAL_DIFF nie jest opcją.

Możesz użyć dowolnej aplikacji diff jednorazowo za pomocą tego polecenia:

git difftool --extcmd=/usr/bin/ksdiff

Po prostu przekazuje 2 pliki do podanego polecenia, więc prawdopodobnie nie potrzebujesz też owijarki.

Bazując na odpowiedzi VonC, aby poradzić sobie z usuwaniem plików i dodawaniem, użyj następujących poleceń i skryptów:

> git config --global diff.tool winmerge
> git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\" \"$BASE\""
> git config --global difftool.prompt false

Czyli to samo co umieszczenie tego w Twoim globalnym .gitconfig:

[diff]
    tool = winmerge
[difftool "winmerge"]
    cmd = winmerge.bat "$LOCAL" "$REMOTE" "$BASE"
[difftool]
    prompt = false

Następnie umieść w winmerge.sh, które muszą być na twojej drodze:

#!/bin/sh
NULL="/dev/null"
if [ "$2" = "$NULL" ] ; then
    echo "removed: $3"
elif [ "$1" = "$NULL" ] ; then
    echo "added: $3"
else
    echo "changed: $3"
    "C:/Program Files (x86)/WinMerge/WinMergeU.exe" -e -ub -dl "Base" -dr "Mine" "$1" "$2"
fi

Rozwiązanie dla Windows / msys git

Po przeczytaniu odpowiedzi odkryłem prostszy sposób, który polega na zmianie tylko jednego pliku.

1. Utwórz plik wsadowy do wywołania programu diff, z argumentami 2 i 5. Ten plik musi być gdzieś na twojej ścieżce. (Jeśli nie wiesz gdzie to jest, umieść go w c:\windows). Nazwij to, na przykład, " gitdiff.bat". Moje to:

   @echo off
   REM This is gitdiff.bat
   "C:\Program Files\WinMerge\WinMergeU.exe" %2 %5
   

2. Ustaw zmienną środowiskową tak, aby wskazywała na plik wsadowy. Na przykład: GIT_EXTERNAL_DIFF=gitdiff.bat. Lub przez powershell wpisując git config --global diff.external gitdiff.bat.

   Ważne jest, aby nie używać cudzysłowów ani nie podawać informacji o ścieżce, w przeciwnym razie to nie zadziała. Dlatego gitdiff.nietoperz musi być na twojej drodze.

Teraz, gdy wpiszesz "git diff", wywoła ona twoją zewnętrzną przeglądarkę różnic.

Jeśli robisz to przez cygwin, może być konieczne użycie cygpath :

$ git config difftool.bc3.cmd "git-diff-bcomp-wrapper.sh \$LOCAL \$REMOTE"
$ cat git-diff-bcomp-wrapper.sh
#!/bin/sh
"c:/Program Files (x86)/Beyond Compare 3/BComp.exe" `cygpath -w $1` `cygpath -w $2`

Po przyjrzeniu się innym zewnętrznym narzędziom diff, odkryłem, że Widok diff w IntelliJ IDEA (i Android Studio) jest dla mnie najlepszy.

Krok 1-Konfiguracja IntelliJ IDEA do uruchomienia z linii poleceń

Jeśli chcesz używać IntelliJ IDEA jako narzędzia diff, powinieneś najpierw skonfigurować IntelliJ IDEA, aby był uruchamiany z linii poleceń zgodnie z instrukcjami tutaj :

Na macOS lub UNIX:

1. upewnij się, że IntelliJ IDEA jest bieganie.
2. z menu głównego wybierz Tools | Create Command-line Launcher. Otworzy się okno dialogowe Utwórz skrypt uruchamiający z sugerowaną ścieżką i nazwą skryptu uruchamiającego. Możesz zaakceptować domyślną lub określić własną ścieżkę. Zwróć na to uwagę, ponieważ będziesz go potrzebować później. Poza IntelliJ IDEA Dodaj ścieżkę i nazwę skryptu uruchamiającego do swojej ścieżki.

W Systemie Windows:

1. określ lokalizację pliku wykonywalnego IntelliJ IDEA w zmiennej środowiskowej systemu Path. W tym przypadek, będziesz mógł wywołać plik wykonywalny IntelliJ IDEA i inne polecenia IntelliJ IDEA z dowolnego katalogu.

Krok 2-Skonfiguruj git do używania IntelliJ IDEA jako difftool

Postępując zgodnie z instrukcjami na ten wpis na blogu:

Bash

export INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
PATH=$IDEA_HOME $PATH

Ryby

set INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
set PATH $INTELLIJ_HOME $PATH

Dodaj teraz do swojego Git config:

[merge]
   tool = intellij
[mergetool "intellij"]
   cmd = idea merge $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE") $(cd $(dirname "$BASE") && pwd)/$(basename "$BASE") $(cd $(dirname "$MERGED") && pwd)/$(basename "$MERGED")
   trustExitCode = true
[diff]
   tool = intellij
[difftool "intellij"]
   cmd = idea diff $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE")

Możesz wypróbować z git difftool lub git difftool HEAD~1

To działa dla mnie na windows 7. Nie ma potrzeby stosowania skryptów pośredniczących SH

Spis treści .gitconfig:

    [diff]
      tool = kdiff3

    [difftool]
       prompt = false

    [difftool "kdiff3"]
      path = C:/Program Files (x86)/KDiff3/kdiff3.exe
      cmd = "$LOCAL" "$REMOTE"

Krótkie podsumowanie powyższych wspaniałych odpowiedzi:

git difftool --tool-help
git config --global diff.tool <chosen tool>
git config --global --add difftool.prompt false

Następnie użyj go wpisując (opcjonalnie podając nazwę pliku):

git difftool

Wprowadzenie

W celach informacyjnych chciałbym dołączyć moją wariację na temat odpowiedzi VonC. Pamiętaj, że używam wersji MSYS Git (1.6.0.2 w tej chwili) ze zmodyfikowaną ścieżką i uruchamiam Git z Powershell (lub cmd.exe), a nie powłoka Bash.

Wprowadziłem nową komendę gitdiff. Uruchomienie tego polecenia tymczasowo przekierowuje git diff do użycia wybranego wizualnego programu różnicującego (w przeciwieństwie do rozwiązania VonC, które robi to na stałe). To pozwala mi mieć zarówno domyślna funkcjonalność Git diff (git diff) oraz wizualna funkcjonalność diff (gitdiff). Oba polecenia przyjmują te same parametry, więc na przykład, aby wizualnie odróżnić zmiany w danym pliku, można wpisać

gitdiff path/file.txt

Setup

Zauważ, że $GitInstall jest używany jako symbol zastępczy dla katalogu, w którym Git jest zainstalowany.

1. Utwórz nowy plik, $GitInstall\cmd\gitdiff.cmd

   @echo off
   setlocal
   for /F "delims=" %%I in ("%~dp0..") do @set path=%%~fI\bin;%%~fI\mingw\bin;%PATH%
   if "%HOME%"=="" @set HOME=%USERPROFILE%
   set GIT_EXTERNAL_DIFF=git-diff-visual.cmd
   set GIT_PAGER=cat
   git diff %*
   endlocal
   

2. Utwórz nowy plik, $GitInstall\bin\git-diff-visual.cmd (zastępujący [visual_diff_exe] symbol zastępczy pełną ścieżką do programu diff twój wybór)

   @echo off
   rem diff is called by git with 7 parameters:
   rem path old-file old-hex old-mode new-file new-hex new-mode
   echo Diffing "%5"
   "[visual_diff_exe]" "%2" "%5"
   exit 0
   

3. Już po tobie. Uruchamianie gitdiff z repozytorium Git powinno teraz wywoływać wizualny program różnicujący dla każdego pliku, który został zmieniony.

Oto plik wsadowy, który działa Dla Windows-zakłada, że DiffMerge jest zainstalowany w domyślnej lokalizacji, obsługuje x64, obsługuje do przodu do wymiany ukośnika w razie potrzeby i ma możliwość instalacji się. Powinno być łatwo zastąpić DiffMerge ulubionym programem diff.

Aby zainstalować:

gitvdiff --install 

@echo off

REM ---- Install? ----
REM To install, run gitvdiff --install

if %1==--install goto install



REM ---- Find DiffMerge ----

if DEFINED ProgramFiles^(x86^) (
    Set DIFF="%ProgramFiles(x86)%\SourceGear\DiffMerge\DiffMerge.exe"
) else (
    Set DIFF="%ProgramFiles%\SourceGear\DiffMerge\DiffMerge.exe"
)



REM ---- Switch forward slashes to back slashes ----

set oldW=%2
set oldW=%oldW:/=\%
set newW=%5
set newW=%newW:/=\%


REM ---- Launch DiffMerge ----

%DIFF% /title1="Old Version" %oldW% /title2="New Version" %newW%

goto :EOF



REM ---- Install ----
:install
set selfL=%~dpnx0
set selfL=%selfL:\=/%
@echo on
git config --global diff.external %selfL%
@echo off


:EOF

Jeśli jesteś na komputerze Mac i masz XCode, masz zainstalowany FileMerge. Polecenie terminal to opendiff, więc możesz po prostu wykonać git difftool -t opendiff

Install meld

 # apt-get install meld

Następnie wybierz to jako difftool

 $ git config --global diff.tool meld

Jeśli chcesz uruchomić go na konsoli wpisz:

 $ git difftool

Jeśli chcesz użyć trybu graficznego wpisz:

 $ git mergetool

A wyjście będzie:

 'git mergetool' will now attempt to use one of the following tools:
 meld opendiff kdiff3 tkdiff xxdiff tortoisemerge gvimdiff diffuse
 diffmerge ecmerge p4merge araxis bc3 codecompare emerge vimdiff
 Merging:
 www/css/style.css
 www/js/controllers.js

 Normal merge conflict for 'www/css/style.css':
   {local}: modified file
   {remote}: modified file
 Hit return to start merge resolution tool (meld):

Więc po prostu naciśnij enter, aby użyć meld (Domyślnie), to otworzy tryb graficzny, zrobić magiczny Zapisz i naciśnij, że rozwiązać scalanie. To wszystko

Dla linuksowej wersji jak skonfigurować narzędzie diff na Git w wersjach poprzedzających 1.6.3 (1.6.3 dodano difftool do git) ten {[4] } jest świetnym zwięzłym tutorialem,

W skrócie:

Krok 1: dodaj to do swojego .gitconfig

[diff]
  external = git_diff_wrapper
[pager]
  diff =

Krok 2: Utwórz plik o nazwie git_diff_wrapper i umieść go gdzieś w $PATH

#!/bin/sh

vimdiff "$2" "$5"

Na Mac OS X,

git difftool -t diffuse 

Robi to za mnie w folderze git. Do instalacji rozproszonej można użyć port -

sudo port install diffuse

Możesz użyć git difftool.

Na przykład jeśli masz meld , możesz edytować gałęzie master i devel przez:

git config --global diff.external meld
git difftool master..devel

Z innych odpowiedzi tutaj można wyciągnąć następujące wnioski, ale dla mnie jest to trudne, (za dużo informacji), więc oto odpowiedź "po prostu wpisz" dla tkdiff:

git difftool --tool=tkdiff <path to the file to be diffed>

Możesz zastąpić nazwę wykonywalną swojego ulubionego narzędzia do różnicowania tkdiff. Tak długo jak (np. tkdiff), (lub Twoje ulubione narzędzie do różnicowania) znajduje się na twojej ścieżce, zostanie ono uruchomione.

[1]} spróbowałem tu tych fantazyjnych rzeczy (z tkdiffem) i nic mi nie wyszło. Więc napisałem następujący scenariusz, tkgitdiff. Robi to, czego potrzebuję.

$ cat tkgitdiff
#!/bin/sh

#
# tkdiff for git.
# Gives you the diff between HEAD and the current state of your file.
#

newfile=$1
git diff HEAD -- $newfile > /tmp/patch.dat
cp $newfile /tmp
savedPWD=$PWD
cd /tmp
patch -R $newfile < patch.dat
cd $savedPWD
tkdiff /tmp/$newfile $newfile

Używam kompare na ubuntu:

sudo apt-get install kompare

Aby porównać dwie gałęzie:

git difftool -t kompare <my_branch> master

Używam tego bitu w ~/.gitconfig od dłuższego czasu:

[diff]
    external = ~/Dropbox/source/bash/git-meld

Z git-meld:

#!/bin/bash
if [ "$DISPLAY" = "" ];
then
    diff $2 $5
else
    meld $2 $5
fi

Ale teraz zmęczyło mnie używanie meld w środowisku graficznym, i nie jest trywialne wywoływanie normalnego Diffa z tą konfiguracją, więc przełączyłem się na to:

[alias]
    v =  "!sh -c 'if [ $# -eq 0 ] ; then git difftool -y -t meld ; else git difftool -y $@ ; fi' -"

Z tą konfiguracją, takie rzeczy działają:

git v
git v --staged
git v -t kompare
git v --staged -t tkdiff

I nadal mogę zatrzymać stare dobre git diff.

Jeśli zdarzy ci się, że masz już narzędzie różnicujące powiązane z typami plików (powiedzmy, ponieważ zainstalowałeś TortoiseSVN, który jest dostarczany z przeglądarką różnic), możesz po prostu przekierować zwykłe wyjście git diff do pliku "temp", a następnie po prostu otworzyć ten plik bezpośrednio bez potrzeby wiedzy o przeglądarce:

git diff > "~/temp.diff" && start "~/temp.diff"

Ustawienie go jako alias globalny działa jeszcze lepiej: git what

[alias]
    what = "!f() { git diff > "~/temp.diff" && start "~/temp.diff"; }; f"

Jeśli nie jesteś jednym z linii poleceń, to jeśli zainstalujesz tortoise git, możesz kliknąć prawym przyciskiem myszy na pliku, aby uzyskać podmenu tortoisegit z opcją "diff later".

Po wybraniu tego na pierwszym pliku możesz kliknąć prawym przyciskiem myszy na drugim pliku, przejść do podmenu tortoisegit i wybrać " Diff with==yourfilehere = = " To da tortoisegitmerge gui dla wyniku.

Może chcesz wypróbować xd http://github.com/jiqingtang/xd , który jest wrapperem GUI dla GIT/SVN diff. Nie jest to samo narzędzie do różnicowania. Uruchamiasz xd gdy chcesz uruchomić git diff lub svn diff i wyświetli Ci listę plików, okno podglądu i możesz uruchomić dowolne narzędzie diff, w tym tkdiff, xxdiff, gvimdiff, emacs(ediff), xemacs (ediff), meld, diffuse, kompare i kdiff3. Możesz również uruchomić dowolne niestandardowe narzędzie.

Niestety narzędzie nie obsługuje Okna.

Disclosure: jestem autorem tego narzędzia.