diff innerhalb einer Zeile

Ich habe einige SQL-Dumps, die ich auf die Unterschiede zwischen. diffkann mir natürlich den Unterschied zwischen zwei Zeilen zeigen, aber ich bin verrückt, wenn ich versuche herauszufinden, welche Werte in der langen Liste der durch Kommas getrennten Werte tatsächlich dazu führen, dass die Zeilen unterschiedlich sind.

Mit welchem ​​Tool kann ich auf die genauen Zeichenunterschiede zwischen zwei Zeilen in bestimmten Dateien hinweisen?

Es gibt wdiff , das Wort diff dafür.

Auf dem Desktop kann meld die Unterschiede innerhalb einer Zeile für Sie hervorheben.

Nur eine andere Methode mit Git-Diff:

git diff -U0 --word-diff --no-index -- foo bar | grep -v ^@@

grep -v falls nicht interessiert an positionen der diffs.

Ich habe dafür verwendet vimdiff.

Hier ist ein Screenshot (nicht von mir), der kleinere Unterschiede zwischen ein oder zwei Zeichen zeigt, die ziemlich gut herausragen. Ein kurzes Tutorial auch .

Hier ist eine "..haar des Hundes, der dich beißt" -Methode ... brachte
diffdich an diesen Punkt; benutze es, um dich weiter zu bringen ...

Hier ist die Ausgabe aus der Verwendung der Sample-Linienpaare ... ☻zeigt eine TAB an

Paris in the     spring 
Paris in the the spring 
             vvvv      ^

A ca t on a hot tin roof.
a cant on a hot  in roof 
║   v           ^       ^

the quikc brown box jupps ober the laze dogs 
The☻qui ckbrown fox jumps over the lazy dogs 
║  ║   ^ ║      ║     ║    ║          ║     ^

Hier ist das Skript. Sie müssen nur die Leitungspaare irgendwie heraussuchen. (Ich habe Diff bisher nur einmal (zweimal?) Verwendet, daher kenne ich die vielen Optionen nicht und sortiere die Optionen dafür aus Drehbuch war genug für mich, für einen Tag :) .. Ich denke, es muss einfach genug sein, aber ich muss eine Kaffeepause einlegen ....

#
# Name: hair-of-the-diff
# Note: This script hasn't been extensively tested, so beware the alpha bug :) 
#   
# Brief: Uses 'diff' to identify the differences between two lines of text
#        $1 is a filename of a file which contains line pairs to be processed
#
#        If $1 is null "", then the sample pairs are processed (see below: Paris in the spring 
#          
# ║ = changed character
# ^ = exists if first line, but not in second 
# v = exists if second line, but not in first

bname="$(basename "$0")"
workd="/tmp/$USER/$bname"; [[ ! -d "$workd" ]] && mkdir -p "$workd"

# Use $1 as the input file-name, else use this Test-data
# Note: this test loop expands \t \n etc ...(my editor auto converts \t to spaces) 
if [[ "$1" == '' ]] ;then
  ifile="$workd/ifile"
{ while IFS= read -r line ;do echo -e "$line" ;done <<EOF
Paris in the spring 
Paris in the the spring
A cat on a hot tin roof.
a cant on a hot in roof
the quikc brown box jupps ober the laze dogs 
The\tquickbrown fox jumps over the lazy dogs
EOF
} >"$ifile"
else
  ifile="$1"
fi
#
[[ -f "$ifile" ]] || { echo "ERROR: Input file NOT found:" ;echo "$ifile" ;exit 1 ; }
#  
# Check for balanced pairs of lines
ilct=$(<"$ifile" wc -l)
((ilct%2==0)) || { echo "ERROR: Uneven number of lines ($ilct) in the input." ;exit 2 ; }
#
ifs="$IFS" ;IFS=$'\n' ;set -f
ix=0 ;left=0 ;right=1
while IFS= read -r line ;do
  pair[ix]="$line" ;((ix++))
  if ((ix%2==0)) ;then
    # Change \x20 to \x02 to simplify parsing diff's output,
    #+   then change \x02 back to \x20 for the final output. 
    # Change \x09 to \x01 to simplify parsing diff's output, 
    #+   then change \x01 into ☻ U+263B (BLACK SMILING FACE) 
    #+   to the keep the final display columns in line. 
    #+   '☻' is hopefully unique and obvious enough (otherwise change it) 
    diff --text -yt -W 19  \
         <(echo "${pair[0]}" |sed -e "s/\x09/\x01/g" -e "s/\x20/\x02/g" -e "s/\(.\)/\1\n/g") \
         <(echo "${pair[1]}" |sed -e "s/\x09/\x01/g" -e "s/\x20/\x02/g" -e "s/\(.\)/\1\n/g") \
     |sed -e "s/\x01/☻/g" -e "s/\x02/ /g" \
     |sed -e "s/^\(.\) *\x3C$/\1 \x3C  /g" \
     |sed -n "s/\(.\) *\(.\) \(.\)$/\1\2\3/p" \
     >"$workd/out"
     # (gedit "$workd/out" &)
     <"$workd/out" sed -e "s/^\(.\)..$/\1/" |tr -d '\n' ;echo
     <"$workd/out" sed -e "s/^..\(.\)$/\1/" |tr -d '\n' ;echo
     <"$workd/out" sed -e "s/^.\(.\).$/\1/" -e "s/|/║/" -e "s/</^/" -e "s/>/v/" |tr -d '\n' ;echo
    echo
    ((ix=0))
  fi
done <"$ifile"
IFS="$ifs" ;set +f
exit
#

wdiffist eigentlich eine sehr alte Methode, um Dateien Wort für Wort zu vergleichen. Es funktionierte, indem Dateien neu formatiert, dann mit Hilfe diffvon Unterschieden gesucht und wieder zurückgegeben wurden. Ich selbst habe vorgeschlagen, den Kontext hinzuzufügen, damit er nicht wortweise verglichen wird, sondern mit jedem Wort, das von anderen "Kontext" -Wörtern umgeben ist. Auf diese Weise kann sich der Diff bei häufigen Passagen in Dateien viel besser synchronisieren, insbesondere wenn sich Dateien mit nur wenigen Blöcken gemeinsamer Wörter zumeist unterscheiden. Zum Beispiel beim Vergleichen von Text auf Plagiate oder bei der Wiederverwendung.

dwdiffwurde später erstellt von wdiff. Aber dwdiff nutzt diese Funktion zur Neuformatierung von Text, um eine gute Wirkung zu erzielen dwfilter. Dies ist eine großartige Entwicklung - es bedeutet, dass Sie einen Text neu formatieren können, um ihn mit einem anderen abzugleichen, und diese dann mit jedem zeilenweisen grafischen Diff-Display vergleichen können. Zum Beispiel mit "diffusem" grafischem Diff ....

dwfilter file1 file2 diffuse -w

Dies formatiert file1das Format neu file2und gibt es diffusefür einen visuellen Vergleich an. file2ist unverändert, so dass Sie Wortunterschiede direkt in bearbeiten und zusammenführen können diffuse. Wenn Sie bearbeiten möchten, file1können Sie hinzufügen, -rum umzukehren, welche Datei neu formatiert wird. Probieren Sie es aus und Sie werden feststellen, dass es extrem leistungsstark ist!

Ich bevorzuge den grafischen Unterschied (siehe oben), diffuseda er sich viel sauberer und nützlicher anfühlt. Es ist auch ein eigenständiges Python-Programm, was bedeutet, dass es einfach zu installieren und auf andere UNIX-Systeme zu verteilen ist.

Andere grafische Unterschiede scheinen viele Abhängigkeiten zu haben, können aber auch verwendet werden (Sie haben die Wahl). Dazu gehören kdiff3oder xxdiff.

Auf der Grundlage der @ Peter.O- Lösung habe ich sie umgeschrieben, um einige Änderungen vorzunehmen.

• Jede Zeile wird nur einmal gedruckt, wobei die Unterschiede farblich hervorgehoben werden.
• Es werden keine temporären Dateien geschrieben, stattdessen wird alles weitergeleitet.
• Sie können zwei Dateinamen angeben, und es werden die entsprechenden Zeilen in jeder Datei verglichen. ./hairOfTheDiff.sh file1.txt file2.txt
• Wenn Sie das Originalformat verwenden (eine einzelne Datei, bei der jede zweite Zeile mit der vorherigen verglichen werden muss), müssen Sie sie jetzt einfach einlesen. Es muss keine Datei zum Lesen vorhanden sein. Schauen Sie sich demodie Quelle an. Dies kann die Tür für ausgefallene Rohrleitungen öffnen, damit keine Dateien für zwei separate Eingaben mit pasteund mehreren Dateideskriptoren benötigt werden.

Keine Hervorhebung bedeutet, dass sich das Zeichen in beiden Zeilen befand. Hervorhebung bedeutet, dass es sich in der ersten befand, und Rot bedeutet, dass es sich in der zweiten befand.

Die Farben können über Variablen oben im Skript geändert werden. Sie können sogar ganz auf Farben verzichten, indem Sie normale Zeichen verwenden, um Unterschiede auszudrücken.

#!/bin/bash

same='-' #unchanged
up='△' #exists in first line, but not in second 
down='▽' #exists in second line, but not in first
reset=''

reset=$'\e[0m'
same=$reset
up=$reset$'\e[1m\e[7m'
down=$reset$'\e[1m\e[7m\e[31m'

timeout=1


if [[ "$1" != '' ]]
then
    paste -d'\n' "$1" "$2" | "$0"
    exit
fi

function demo {
    "$0" <<EOF
Paris in the spring 
Paris in the the spring
A cat on a hot tin roof.
a cant on a hot in roof
the quikc brown box jupps ober the laze dogs 
The quickbrown fox jumps over the lazy dogs
EOF
}

# Change \x20 to \x02 to simplify parsing diff's output,
#+   then change \x02 back to \x20 for the final output. 
# Change \x09 to \x01 to simplify parsing diff's output, 
#+   then change \x01 into → U+1F143 (Squared Latin Capital Letter T)
function input {
    sed \
        -e "s/\x09/\x01/g" \
        -e "s/\x20/\x02/g" \
        -e "s/\(.\)/\1\n/g"
}
function output {
    sed -n \
        -e "s/\x01/→/g" \
        -e "s/\x02/ /g" \
        -e "s/^\(.\) *\x3C$/\1 \x3C  /g" \
        -e "s/\(.\) *\(.\) \(.\)$/\1\2\3/p"
}

ifs="$IFS"
IFS=$'\n'
demo=true

while IFS= read -t "$timeout" -r a
do
    demo=false
    IFS= read -t "$timeout" -r b
    if [[ $? -ne 0 ]]
    then
        echo 'No corresponding line to compare with' > /dev/stderr
        exit 1
    fi

    diff --text -yt -W 19  \
        <(echo "$a" | input) \
        <(echo "$b" | input) \
    | \
    output | \
    {
        type=''
        buf=''
        while read -r line
        do
            if [[ "${line:1:1}" != "$type" ]]
            then
                if [[ "$type" = '|' ]]
                then
                    type='>'
                    echo -n "$down$buf"
                    buf=''
                fi

                if [[ "${line:1:1}" != "$type" ]]
                then
                    type="${line:1:1}"

                    echo -n "$type" \
                        | sed \
                            -e "s/[<|]/$up/" \
                            -e "s/>/$down/" \
                            -e "s/ /$same/"
                fi
            fi

            case "$type" in
            '|')
                buf="$buf${line:2:1}"
                echo -n "${line:0:1}"
                ;;
            '>')
                echo -n "${line:2:1}"
                ;;
            *)
                echo -n "${line:0:1}"
                ;;
            esac
        done

        if [[ "$type" = '|' ]]
        then
            echo -n "$down$buf"
        fi
    }

    echo -e "$reset"
done

IFS="$ifs"

if $demo
then
    demo
fi

Hier ist ein einfacher Einzeiler:

diff -y <(cat a.txt | sed -e 's/,/\n/g') <(cat b.txt | sed -e 's/,/\n/g')

Die Idee ist, Kommas (oder welche Trennzeichen Sie verwenden möchten) durch Zeilenumbrüche zu ersetzen sed. diffkümmert sich dann um den Rest.

• xxdiff: Ein weiteres Tool ist xxdiff (GUI), das zuerst installiert werden muss.
• Tabellenkalkulation: Für Datenbankdaten kann auf .csveinfache Weise eine Tabellenkalkulation erstellt und eine Formel (A7==K7) ? "" : "diff"oder Ähnliches eingefügt und kopiert und eingefügt werden.

In der Befehlszeile würde ich vor dem Vergleichen von Dateien sicherstellen, dass vernünftige neue Zeilen hinzugefügt werden. Sie können sed, awk, perl oder alles andere verwenden, um Zeilenumbrüche auf systematische Weise einzufügen. Achten Sie jedoch darauf, nicht zu viele Zeilen hinzuzufügen.

Aber ich finde, das Beste ist, vim zu verwenden, da es die Wortunterschiede hervorhebt. vim ist gut, wenn es nicht zu viele unterschiede gibt und die unterschiede einfach sind.

kdiff3 wird zum Standard-GUI-Diff-Viewer unter Linux. Es ist ähnlich wie xxdiff , aber ich denke, kdiff3 ist besser. Es macht viele Dinge gut, einschließlich Ihrer Aufforderung, "genaue Zeichenunterschiede zwischen zwei Zeilen in bestimmten Dateien" anzuzeigen.

Wenn ich Ihre Frage richtig lese, verwende ich diff -yfür solche Dinge.

Das Vergleichen eines Nebeneinander-Vergleichs vereinfacht das Auffinden, welche Linien die Unterschiede auslösen.

Ich hatte das gleiche Problem und löste es mit PHP Fine Diff , einem Online-Tool, mit dem Sie die Granularität festlegen können. Ich weiß, dass es technisch gesehen kein * nix-Tool ist, aber ich wollte eigentlich kein Programm herunterladen, nur um einen einmaligen Unterschied auf Zeichenebene zu machen.