diff dans une ligne

J'ai quelques draps SQL que je regarde les différences entre. diffJe peux évidemment me montrer la différence entre deux lignes, mais je me rend fou en essayant de trouver quelles valeurs de la longue liste de valeurs séparées par des virgules sont en réalité celles qui font que les lignes sont différentes.

Quel outil puis-je utiliser pour indiquer les différences de caractères exactes entre deux lignes dans certains fichiers?

Il y a wdiff , le mot-diff pour cela.

Sur le bureau, meld peut mettre en évidence les différences au sein d’une ligne.

Juste une autre méthode utilisant git-diff:

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

grep -v si vous n'êtes pas intéressé par les positions des diffs.

J'ai utilisé vimdiffpour cela.

Voici une capture d'écran (pas la mienne) montrant des différences mineures d'un ou deux caractères qui ressort assez bien. Un tutoriel rapide aussi .

Voici une méthode ".. poil du chien qui vous a mordu" ...
diffvous en êtes à ce point; utilisez-le pour vous emmener plus loin ...

Voici le résultat de l'utilisation des paires de lignes de l'échantillon ... ☻indique une tabulation

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 
║  ║   ^ ║      ║     ║    ║          ║     ^

Voici le script .. Vous avez juste besoin de fouiller les paires de lignes d'une manière ou d'une autre .. (Je n'ai utilisé diff qu'une fois (deux??) Avant aujourd'hui, donc je ne connais pas ses nombreuses options, et en trier les options pour cela le script me suffisait, pour un jour :) .. Je pense que ça doit être assez simple, mais je dois prendre une pause café ....

#
# 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
#

wdiffest en fait une très ancienne méthode de comparaison de fichiers mot par mot. Cela fonctionnait en reformatant les fichiers, en utilisant ensuite diffpour trouver les différences et en les renvoyant. J'ai moi-même suggéré d'ajouter un contexte afin que, plutôt que de comparer mot par mot, il le fasse avec chaque mot entouré de mots «context». Cela permet au diff de se synchroniser beaucoup mieux sur les passages communs dans les fichiers, en particulier lorsque les fichiers sont très différents avec seulement quelques blocs de mots communs. Par exemple, lorsque vous comparez du texte pour un plagiat ou que vous le réutilisez.

dwdiffa été créé plus tard wdiff. Mais dwdiff utilise cette fonction de reformatage de texte à bon escient dans dwfilter. C'est un grand développement - cela signifie que vous pouvez reformater un texte pour en faire correspondre un autre, puis les comparer à l'aide de tout afficheur de diff graphique par ligne. Par exemple, en l'utilisant avec un diff graphique "diffus" ....

dwfilter file1 file2 diffuse -w

Cette reformate file1au format de file2et donne que diffusepour une comparaison visuelle. file2est non modifié, vous pouvez donc éditer et y fusionner les différences de mots directement dans diffuse. Si vous voulez éditer file1, vous pouvez ajouter -rpour inverser le fichier qui est reformaté. Essayez-le et vous constaterez qu'il est extrêmement puissant!

Ma préférence pour le diff graphique (illustré ci-dessus) est diffusede se sentir beaucoup plus propre et utile. En outre, il s'agit d'un programme python autonome, ce qui signifie qu'il est facile à installer et à distribuer sur d'autres systèmes UNIX.

D'autres différences graphiques semblent avoir beaucoup de dépendances, mais peuvent aussi être utilisées (à vous de choisir). Ceux-ci incluent kdiff3ou xxdiff.

En utilisant la solution de @ Peter.O comme base, je l'ai réécrite pour apporter un certain nombre de modifications.

• Il n'imprime que chaque ligne une fois, en utilisant la couleur pour vous montrer les différences.
• Il n'écrit aucun fichier temporaire, mais passe tout à la tuyauterie.
• Vous pouvez fournir deux noms de fichier et comparer les lignes correspondantes dans chaque fichier. ./hairOfTheDiff.sh file1.txt file2.txt
• Sinon, si vous utilisez le format d'origine (un fichier avec une ligne sur chaque seconde devant être comparée à celle qui précède), vous pouvez maintenant le transférer en un seul fichier, il ne doit plus exister de fichier pour être lu. Regardez demodans la source. cela peut ouvrir la porte à une tuyauterie sophistiquée afin de ne pas nécessiter de fichiers pour deux entrées distinctes également, à l'aide de pasteplusieurs descripteurs de fichiers.

Pas de surbrillance signifie que le personnage était dans les deux lignes, surligner signifie qu'il était dans la première, et le rouge signifie qu'il était dans la seconde.

Les couleurs sont modifiables par le biais de variables en haut du script et vous pouvez même renoncer entièrement à des couleurs en utilisant des caractères normaux pour exprimer des différences.

#!/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

Voici une simple ligne:

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

L'idée est de remplacer les virgules (ou le délimiteur que vous souhaitez utiliser) par newlines sed. diffprend ensuite soin du reste.

• xxdiff: Un autre outil est xxdiff (GUI), qui doit être installé en premier.
• feuille de calcul: pour les données de base de données, une feuille de calcul .csvest facile à créer, et une formule (A7==K7) ? "" : "diff"ou similaire insérée et copiée-collée.

Sur la ligne de commande, je voudrais m'assurer d'ajouter de nouvelles lignes judicieuses avant de comparer des fichiers. Vous pouvez utiliser sed, awk, perl ou autre chose vraiment pour ajouter des sauts de ligne de manière systématique - assurez-vous de ne pas en ajouter trop.

Mais je trouve que le mieux est d’utiliser vim car il met en évidence les différences entre les mots. vim est bon s’il n’ya pas trop de différences et que les différences sont simples.

kdiff3 est en train de devenir le visualiseur standard de diff graphiques sur Linux. C'est similaire à xxdiff , mais je pense que kdiff3 est meilleur. Cela fait beaucoup de choses, y compris votre demande d'afficher "les différences de caractère exactes entre deux lignes dans certains fichiers".

Si je lis bien votre question, je l’utilise diff -ypour ce genre de chose.

Il est beaucoup plus simple de comparer une comparaison côte à côte pour déterminer les lignes qui génèrent les différences.

J'ai eu le même problème et l'ai résolu avec PHP Fine Diff , un outil en ligne qui vous permet de spécifier la granularité. Je sais que ce n'est pas techniquement un outil * nix, mais je ne voulais pas vraiment télécharger un programme juste pour faire un diff unique, au niveau du personnage.