Comparaison de deux fichiers dans le terminal Linux

Il existe deux fichiers appelés "a.txt" et "b.txt" qui ont tous deux une liste de mots. Maintenant, je veux vérifier quels mots sont supplémentaires dans "a.txt" et ne sont pas dans "b.txt" .

J'ai besoin d'un algorithme efficace car j'ai besoin de comparer deux dictionnaires.

si vous avez installé vim, essayez ceci:

vimdiff file1 file2

ou

vim -d file1 file2

vous le trouverez fantastique.

Triez-les et utilisez comm:

comm -23 <(sort a.txt) <(sort b.txt)

commcompare les fichiers d'entrée (triés) et génère par défaut trois colonnes: les lignes uniques à a, les lignes uniques à b et les lignes présentes dans les deux. En spécifiant -1, -2et / ou -3vous pouvez supprimer la sortie correspondante. Par conséquent comm -23 a b, ne répertorie que les entrées uniques à un fichier. J'utilise la <(...)syntaxe pour trier les fichiers à la volée, s'ils sont déjà triés, vous n'en avez pas besoin.

Essayez sdiff( man sdiff)

sdiff -s file1 file2

Vous pouvez utiliser l' diffoutil sous Linux pour comparer deux fichiers. Vous pouvez utiliser les options --changed-group-format et --unchanged-group-format pour filtrer les données requises.

Les trois options suivantes peuvent être utilisées pour sélectionner le groupe approprié pour chaque option:

• '% <' récupère les lignes de FILE1

• '%>' récupère les lignes de FILE2

• '' (chaîne vide) pour supprimer des lignes des deux fichiers.

Par exemple: diff --changed-group-format = "% <" --unchanged-group-format = "" file1.txt file2.txt

[root@vmoracle11 tmp]# cat file1.txt 
test one
test two
test three
test four
test eight
[root@vmoracle11 tmp]# cat file2.txt 
test one
test three
test nine
[root@vmoracle11 tmp]# diff --changed-group-format='%<' --unchanged-group-format='' file1.txt file2.txt 
test two
test four
test eight

Si vous préférez le style de sortie diff git diff, vous pouvez l'utiliser avec l' --no-indexindicateur pour comparer des fichiers qui ne se trouvent pas dans un référentiel git:

git diff --no-index a.txt b.txt

En utilisant quelques fichiers avec environ 200k chaînes de noms de fichiers chacun, j'ai comparé (avec la timecommande intégrée ) cette approche par rapport à certaines des autres réponses ici:

git diff --no-index a.txt b.txt
# ~1.2s

comm -23 <(sort a.txt) <(sort b.txt)
# ~0.2s

diff a.txt b.txt
# ~2.6s

sdiff a.txt b.txt
# ~2.7s

vimdiff a.txt b.txt
# ~3.2s

commsemble être de loin la plus rapide, alors qu'elle git diff --no-indexsemble être l'approche la plus rapide pour la sortie de style diff.

Mise à jour 25/03/2018 Vous pouvez en fait omettre l' --no-indexindicateur sauf si vous êtes dans un référentiel git et que vous souhaitez comparer les fichiers non suivis dans ce référentiel. Depuis les pages de manuel :

Ce formulaire permet de comparer les deux chemins donnés sur le système de fichiers. Vous pouvez omettre l'option --no-index lors de l'exécution de la commande dans un arbre de travail contrôlé par Git et au moins l'un des chemins pointe en dehors de l'arbre de travail, ou lors de l'exécution de la commande en dehors d'un arbre de travail contrôlé par Git.

Vous pouvez également utiliser: colordiff : affiche la sortie de diff avec des couleurs.

À propos de vimdiff : Il vous permet de comparer des fichiers via SSH, par exemple:

vimdiff /var/log/secure scp://192.168.1.25/var/log/secure

Extrait de: http://www.sysadmit.com/2016/05/linux-diferencias-entre-dos-archivos.html

N'oubliez pas non plus mcdiff - Visualiseur de différences internes de GNU Midnight Commander .

Par exemple:

mcdiff file1 file2

Prendre plaisir!

Utilisation comm -13 (nécessite des fichiers triés) :

$ cat file1
one
two
three

$ cat file2
one
two
three
four

$ comm -13 <(sort file1) <(sort file2)
four

Voici ma solution pour cela:

mkdir temp
mkdir results
cp /usr/share/dict/american-english ~/temp/american-english-dictionary
cp /usr/share/dict/british-english ~/temp/british-english-dictionary
cat ~/temp/american-english-dictionary | wc -l > ~/results/count-american-english-dictionary
cat ~/temp/british-english-dictionary | wc -l > ~/results/count-british-english-dictionary
grep -Fxf ~/temp/american-english-dictionary ~/temp/british-english-dictionary > ~/results/common-english
grep -Fxvf ~/results/common-english ~/temp/american-english-dictionary > ~/results/unique-american-english
grep -Fxvf ~/results/common-english ~/temp/british-english-dictionary > ~/results/unique-british-english

Utiliser awk pour cela. Fichiers de test:

$ cat a.txt
one
two
three
four
four
$ cat b.txt
three
two
one

Le awk:

$ awk '
NR==FNR {                    # process b.txt  or the first file
    seen[$0]                 # hash words to hash seen
    next                     # next word in b.txt
}                            # process a.txt  or all files after the first
!($0 in seen)' b.txt a.txt   # if word is not hashed to seen, output it

Les doublons sont générés:

four
four

Pour éviter les doublons, ajoutez chaque mot nouvellement rencontré dans a.txt au seenhachage:

$ awk '
NR==FNR {
    seen[$0]
    next
}
!($0 in seen) {              # if word is not hashed to seen
    seen[$0]                 # hash unseen a.txt words to seen to avoid duplicates 
    print                    # and output it
}' b.txt a.txt

Production:

four

Si les listes de mots sont séparées par des virgules, comme:

$ cat a.txt
four,four,three,three,two,one
five,six
$ cat b.txt
one,two,three

vous devez faire quelques tours supplémentaires ( forboucles):

awk -F, '                    # comma-separated input
NR==FNR {
    for(i=1;i<=NF;i++)       # loop all comma-separated fields
        seen[$i]
    next
}
{
    for(i=1;i<=NF;i++)
        if(!($i in seen)) {
             seen[$i]        # this time we buffer output (below):
             buffer=buffer (buffer==""?"":",") $i
        }
    if(buffer!="") {         # output unempty buffers after each record in a.txt
        print buffer
        buffer=""
    }
}' b.txt a.txt

Sortie cette fois:

four
five,six