Comment savoir si un fichier texte est un sous-ensemble d'un autre

J'essaie de trouver un moyen de déterminer si un fichier texte est un sous-ensemble d'un autre ..

Par exemple:

foo
bar

est un sous-ensemble de

foo
bar
pluto

Tandis que:

foo
pluto

et

foo
bar

ne sont pas un sous-ensemble les uns des autres ...

Existe-t-il un moyen de le faire avec une commande?

Ce chèque doit être un contre-chèque et il doit renvoyer:

file1 subset of file2 :    True
file2 subset of file1 :    True
otherwise             :    False

Si les contenus de fichiers sont appelés file1, file2et file3dans l' ordre de apearance vous pouvez le faire avec la seule ligne suivante:

 # python -c "x=open('file1').read(); y=open('file2').read(); print x in y or y in x"
 True
 # python -c "x=open('file2').read(); y=open('file1').read(); print x in y or y in x"
 True
 # python -c "x=open('file1').read(); y=open('file3').read(); print x in y or y in x"
 False

Avec perl:

if perl -0777 -e '$n = <>; $h = <>; exit(index($h,$n)<0)' needle.txt haystack.txt
then echo needle.txt is found in haystack.txt
fi

-0octaldéfinit le délimiteur d'enregistrement. Lorsque ce nombre octal est supérieur à 0377 (la valeur d'octet maximale), cela signifie qu'il n'y a pas de délimiteur, c'est équivalent à faire $/ = undef. Dans ce cas, <>renvoie le contenu complet d'un seul fichier, c'est le mode slurp .

Une fois que nous avons le contenu des fichiers en deux $het $nvariables, nous pouvons utiliser index()pour déterminer si l'un se trouve dans l'autre.

Cela signifie cependant que tous les fichiers sont stockés en mémoire, ce qui signifie que cette méthode ne fonctionnera pas pour les fichiers très volumineux.

Pour les fichiers mmappables (inclut généralement les fichiers standard et les fichiers les plus recherchés comme les périphériques de bloc), cela peut être contourné en utilisant mmap()les fichiers, comme avec le Sys::Mmapmodule perl:

if 
  perl -MSys::Mmap -le '
    open N, "<", $ARGV[0] || die "$ARGV[0]: $!";
    open H, "<", $ARGV[1] || die "$ARGV[1]: $!";
    mmap($n, 0, PROT_READ, MAP_SHARED, N);
    mmap($h, 0, PROT_READ, MAP_SHARED, H);
    exit (index($h, $n) < 0)' needle.txt haystack.txt
then
  echo needle.txt is found in haystack.txt
fi

J'ai trouvé une solution grâce à cette question

Fondamentalement, je teste deux fichiers a.txtet b.txtavec ce script:

#!/bin/bash

first_cmp=$(diff --unchanged-line-format= --old-line-format= --new-line-format='%L' "$1" "$2" | wc -l)
second_cmp=$(diff --unchanged-line-format= --old-line-format= --new-line-format='%L' "$2" "$1" | wc -l)

if [ "$first_cmp" -eq "0" -o "$second_cmp" -eq "0" ]
then
    echo "Subset"
    exit 0
else
    echo "Not subset"
    exit 1
fi

Si l'un est un sous-ensemble de l'autre, le script revient 0pour le Truecontraire 1.

Si f1 est un sous-ensemble de f2, alors f1 - f2 est un ensemble vide. En s'appuyant sur cela, nous pouvons écrire une fonction is_subset et une fonction qui en dérive. Selon la différence entre 2 fichiers texte

sort_files () {
  f1_sorted = "$ 1.sorted"
  f2_sorted = "$ 2.sorted"

  si [ ! -f $ f1_sorted]; ensuite
    chat 1 $ | trier | uniq> $ f1_sorted
  Fi

  si [ ! -f $ f2_sorted]; ensuite
    chat 2 $ | trier | uniq> $ f2_sorted
  Fi
}

remove_sorted_files () {
  f1_sorted = "$ 1.sorted"
  f2_sorted = "$ 2.sorted"
  rm -f $ f1_sorted
  rm -f $ f2_sorted
}

set_union () {
  sort_files $ 1 $ 2
  chat "$ 1. trié" "$ 2. trié" | trier | uniq
  remove_sorted_files $ 1 $ 2
}

set_diff () {
  sort_files $ 1 $ 2
  chat "$ 1. trié" "$ 2. trié" "$ 2. trié" | trier | uniq -u
  remove_sorted_files $ 1 $ 2
}

rset_diff () {
  sort_files $ 1 $ 2
  chat "$ 1. trié" "$ 2. trié" "$ 1. trié" | trier | uniq -u
  remove_sorted_files $ 1 $ 2
}

is_subset () {
  sort_files $ 1 $ 2
  sortie = $ (set_diff $ 1 $ 2)
  remove_sorted_files $ 1 $ 2

  if [-z $ output]; ensuite
    retour 0
  autre
    retour 1
  Fi

}

Depuis http://www.catonmat.net/blog/set-operations-in-unix-shell/ :

Comm compare deux fichiers triés ligne par ligne. Il peut être exécuté de telle sorte qu'il génère des lignes qui n'apparaissent que dans le premier fichier spécifié. Si le premier fichier est un sous-ensemble du second, alors toutes les lignes du 1er fichier apparaissent également dans le 2e, donc aucune sortie n'est produite:

$ comm -23 <(sort subset | uniq) <(sort set | uniq) | head -1
# comm returns no output if subset ⊆ set
# comm outputs something if subset ⊊ set