Comment grep-inverse-match et exclure les lignes «avant» et «après»

Considérez un fichier texte avec les entrées suivantes:

aaa
bbb
ccc
ddd
eee
fff
ggg
hhh
iii

Étant donné un modèle (par exemple fff), je voudrais grep le fichier ci-dessus pour obtenir la sortie:

all_lines except (pattern_matching_lines  U (B lines_before) U (A lines_after))

Par exemple, si B = 2et A = 1, la sortie avec pattern = fffdevrait être:

aaa
bbb
ccc
hhh
iii

Comment puis-je le faire avec grep ou d'autres outils de ligne de commande?

Remarque, lorsque j'essaie:

grep -v 'fff'  -A1 -B2 file.txt

Je n'obtiens pas ce que je veux. Je reçois à la place:

aaa
bbb
ccc
ddd
eee
fff
--
--
fff
ggg
hhh
iii

Don peut être mieux dans la plupart des cas, mais juste au cas où le fichier est vraiment gros et que vous ne pouvez pas sedgérer un fichier de script aussi volumineux (ce qui peut arriver à environ 5000+ lignes de script) , le voici avec plain sed:

sed -ne:t -e"/\n.*$match/D" \
    -e'$!N;//D;/'"$match/{" \
            -e"s/\n/&/$A;t" \
            -e'$q;bt' -e\}  \
    -e's/\n/&/'"$B;tP"      \
    -e'$!bt' -e:P  -e'P;D'

Ceci est un exemple de ce qu'on appelle une fenêtre coulissante en entrée. Il fonctionne en construisant une anticipation tampon$B lignes -count avant même d' essayer d'imprimer quoi que ce soit.

Et en fait, je devrais probablement clarifier mon point précédent: le limiteur de performance principal pour cette solution et pour Don sera directement lié à l'intervalle. Cette solution va ralentir avec un intervalle de plus grandes tailles , alors que don de ralentiront avec un intervalle de plus grandes fréquences . En d'autres termes, même si le fichier d'entrée est très volumineux, si l'occurrence réelle de l'intervalle est encore très peu fréquente, sa solution est probablement la voie à suivre. Cependant, si la taille de l'intervalle est relativement gérable et est susceptible de se produire souvent, c'est la solution que vous devez choisir.

Voici donc le workflow:

• Si $matchse trouve dans l'espace de motif précédé d'une ligne \nélectronique, supprimera sedrécursivement Dchaque ligne \nélectronique qui la précède.
  • J'éclaircissais $match train de vider complètement l'espace des motifs avant - mais pour gérer facilement les chevauchements, laisser un point de repère semble fonctionner beaucoup mieux.
  • J'ai également essayé s/.*\n.*\($match\)/\1/d'essayer de l'obtenir en une seule fois et d'esquiver la boucle, mais lorsqu'elle $A/$Best grande, la Dboucle elete se révèle considérablement plus rapide.
• Ensuite, nous tirons sur la Nligne d'entrée ext précédée d'un \ndélimiteur ewline et essayons une fois de plus d' Déliminer un /\n.*$match/en se référant à notre expression régulière w / la plus récemment utilisée //.
• Si l'espace de motif correspond, $matchil ne peut le faire qu'avec $matchen tête de ligne - toutes les $Blignes précédentes ont été effacées.
  • Nous commençons donc en boucle sur $After.
  • Chaque terme de cette boucle , nous allons tenter de s///ubstitute pour &lui - même le $Ae \ncaractère ewline dans l' espace de modèle, et, en cas de succès, l' tEst nous branche - et tout notre $Atampon de près avoir - sur le script entièrement pour lancer le script au- dessus de la partie supérieure avec la ligne d'entrée suivante, le cas échéant.
  • Si l' test ne réussit pas, nous allons branch vers l' :tétiquette d'opération et recurse pour une autre ligne d'entrée - éventuellement recommencer la boucle si $matchse produit lors de la collecte $After.
• Si nous obtenons passé une $matchboucle de fonction, nous allons essayer de pRint la $dernière ligne si cela est, et si !ne pas essayer de s///ubstitute pour &lui - même le $Be \ncaractère ewline dans l' espace modèle.
  • Nous l' testimerons également, et si cela réussit, nous passerons à l' :Pétiquette rint.
  • Si ce n'est pas le cas, nous allons revenir à :top et obtenir une autre ligne d'entrée ajoutée au tampon.
• Si nous faisons à :PRint nous PRint alors Délete jusqu'à la première \newline dans l' espace de configuration et exécutez à nouveau le script du haut avec ce qui reste.

Et donc cette fois, si nous faisions A=2 B=2 match=5; seq 5 | sed...

L'espace de motif pour la première itération à :Print ressemblerait à:

^1\n2\n3$

Et c'est ainsi que sedrassemble son $Btampon efore. Et donc sedimprime sur les $Blignes de sortie -comptes derrière l'entrée qu'il a recueillies. Cela signifie que, compte tenu de notre exemple précédent, sedse PRint 1à la sortie, puis Delete et que renvoyer au début du script un espace de motif qui ressemble à :

^2\n3$

... et en haut du script, la Nligne d'entrée ext est récupérée et donc l'itération suivante ressemble à:

^2\n3\n4$

Et donc quand nous trouvons la première occurrence de 5in input, l'espace de motif ressemble en fait à:

^3\n4\n5$

Ensuite, la Dboucle elete entre en jeu et quand elle est terminée, elle ressemble à:

^5$

Et lorsque la Nligne d'entrée ext est tirée, sedfrappe EOF et quitte. À ce moment-là, il n'a encore Pimprimé que les lignes 1 et 2.

Voici un exemple d'exécution:

A=8 B=7 match='[24689]0'
seq 100 |
sed -ne:t -e"/\n.*$match/D" \
    -e'$!N;//D;/'"$match/{" \
            -e"s/\n/&/$A;t" \
            -e'$q;bt' -e\}  \
    -e's/\n/&/'"$B;tP"      \
    -e'$!bt' -e:P  -e'P;D'

Cela imprime:

1
2
3
4
5
6
7
8
9
10
11
12
29
30
31
32
49
50
51
52
69
70
71
72
99
100

Vous pouvez utiliser gnu grepavec -Aet -Bpour imprimer exactement les parties du fichier que vous souhaitez exclure, mais ajoutez le -ncommutateur pour imprimer également les numéros de ligne, puis formatez la sortie et passez-la en tant que script de commande sedpour supprimer ces lignes:

grep -n -A1 -B2 PATTERN infile | \
sed -n 's/^\([0-9]\{1,\}\).*/\1d/p' | \
sed -f - infile

Cela devrait également fonctionner avec des fichiers de modèles transmis grepvia -fpar exemple:

grep -n -A1 -B2 -f patterns infile | \
sed -n 's/^\([0-9]\{1,\}\).*/\1d/p' | \
sed -f - infile

Je pense que cela pourrait être légèrement optimisé s'il effondrait trois numéros de ligne consécutifs ou plus dans des plages de manière à avoir, par exemple, 2,6dau lieu de 2d;3d;4d;5d;6d... bien que si l'entrée n'a que quelques correspondances, cela ne vaut pas la peine de le faire.

Autres moyens qui ne préservent pas l'ordre des lignes et sont probablement plus lents:
avec comm:

comm -13 <(grep PATTERN -A1 -B2 <(nl -ba -nrz -s: infile) | sort) \
<(nl -ba -nrz -s: infile | sort) | cut -d: -f2-

commnécessite l' intervention Sorted ce qui signifie que l'ordre de ligne ne serait pas conservée dans la sortie finale ( à moins que votre fichier est déjà triée) donc nlest utilisé pour numéroter les lignes avant de tri, comm -13imprime des lignes uniques au 2ème FICHIER puis cutsupprime la partie qui a été ajoutée par nl(c'est-à-dire le premier champ et le délimiteur :)
avec join:

join -t: -j1 -v1 <(nl -ba -nrz -s:  infile | sort) \
<(grep PATTERN -A1 -B2 <(nl -ba -nrz -s:  infile) | sort) | cut -d: -f2-

Si cela ne vous dérange pas d'utiliser vim:

$ export PAT=fff A=1 B=2
$ vim -Nes "+g/${PAT}/.-${B},.+${A}d" '+w !tee' '+q!' foo
aaa
bbb
ccc
hhh
iii

• -Nesactive le mode ex silencieux non compatible. Utile pour l'écriture de scripts.
• +{command}dites à vim de s'exécuter {command}sur le fichier.
• g/${PAT}/- sur toutes les lignes correspondantes /fff/. Cela devient difficile si le modèle contient des caractères spéciaux d'expression régulière que vous n'aviez pas l'intention de traiter de cette façon.
• .-${B} - à partir d'une ligne au-dessus de celle-ci
• .+${A}- à 2 lignes en dessous de celle-ci (voir :he cmdline-rangespour ces deux)
• d - supprimez les lignes.
• +w !tee écrit ensuite sur la sortie standard.
• +q! se ferme sans enregistrer les modifications.

Vous pouvez ignorer les variables et utiliser directement le modèle et les nombres. Je les ai utilisés juste pour des raisons de clarté.

Que diriez-vous (en utilisant GNU grepet bash):

$ grep -vFf - file.txt < <(grep -B2 -A1 'fff' file.txt)
aaa
bbb
ccc
hhh
iii

Ici, nous trouvons les lignes devant être supprimées grep -B2 -A1 'fff' file.txt, puis en l'utilisant comme fichier d'entrée pour trouver les lignes souhaitées les rejetant.

Vous pouvez obtenir un résultat satisfaisant en utilisant des fichiers temporaires:

my_file=file.txt #or =$1 if in a script

#create a file with all the lines to discard, numbered
grep -n -B1 -A5 TBD "$my_file" |cut -d\  -f1|tr -d ':-'|sort > /tmp/___"$my_file"_unpair

#number all the lines
nl -nln "$my_file"|cut -d\  -f1|tr -d ':-'|sort >  /tmp/___"$my_file"_all

#join the two, creating a file with the numbers of all the lines to keep
#i.e. of those _not_ found in the "unpair" file
join -v2  /tmp/___"$my_file"_unpair /tmp/___"$my_file"_all|sort -n > /tmp/___"$my_file"_lines_to_keep

#eventually use these line numbers to extract lines from the original file
nl -nln $my_file|join - /tmp/___"$my_file"_lines_to_keep |cut -d\  -f2- > "$my_file"_clean

Le résultat est assez bon car vous pouvez perdre une indentation dans le processus, mais s'il s'agit d'un fichier xml ou insensible à l'indentation, cela ne devrait pas poser de problème. Étant donné que ce script utilise un lecteur RAM, l'écriture et la lecture de ces fichiers temporaires sont aussi rapides que de travailler en mémoire.

De plus, si vous souhaitez simplement exclure certaines lignes avant un marqueur donné, vous pouvez utiliser:

awk -v nlines=2 '/Exception/ {for (i=0; i<nlines; i++) {getline}; next} 1'

(Glenn Jackman sur /programming//a/1492538 )

En canalisant certaines commandes, vous pouvez obtenir le comportement avant / après:

awk -v nlines_after=5 '/EXCEPTION/ {for (i=0; i<nlines_after; i++) {getline};print "EXCEPTION" ;next} 1' filename.txt|\
tac|\
awk -v nlines_before=1 '/EXCEPTION/ {for (i=0; i<nlines_before; i++) {getline}; next} 1'|\
tac

Une façon d'y parvenir, peut-être la manière la plus simple serait de créer une variable et de faire ce qui suit:

grep -v "$(grep "fff" -A1 -B2 file.txt)" file.txt

De cette façon, vous avez toujours votre structure. Et vous pouvez facilement voir de la doublure que vous essayez de supprimer.

$ grep -v "$(grep "fff" -A1 -B2 file.txt)" file.txt
aaa
bbb
ccc
hhh
iii

S'il n'y a qu'un seul match:

A=1; B=2; n=$(grep -n 'fff' file.txt | cut -d: -f1)
head -n $((n-B-1)) file.txt ; tail -n +$((n+A+1)) file.txt

Sinon (awk):

# -vA=a -vB=b -vpattern=pat must be provided
BEGIN{

    # add file again. assume single file
    ARGV[ARGC]=ARGV[ARGC-1]
    ++ARGC
}

# the same as grep -An -Bn pattern
FNR==NR && $0 ~ pattern{
    for (i = 0; i <= B; ++i)
        a[NR-i]++
    for (i = 1; i <= A; ++i)
        a[NR+i]++
}

FNR!=NR && !(FNR in a)