Início / unix / Perguntas / 720025
Accepted
Peter Petigru
Asked: 2022-10-07 07:32:58 +0800 CST

Como grep tudo, menos a partida E a linha anterior

  • 772

Eu tenho um arquivo de texto e tenho um padrão que quero que o grep não corresponda. A coisa é, eu também quero que a linha antes não corresponda.

Meu arquivo:

line 1
line 2
pattern
line 4

E eu tentei cat file | grep -v pattern, que gera:

line 1
line 2
line 4

Então eu tentei cat file | grep -B 1 pattern, que resulta:

line 2
pattern

No entanto, quando uso os dois juntos cat file | grep -v -B 1 pattern, recebo:

line 2

Como posso fazer isso para que a saída seja:

line 1
line 4
shell-script text-processing

7 respostas

  1. Best Answer

    Costumo usar apenas ao grepextrair linhas únicas de arquivos, então quando preciso realizar edições mais complicadas em um texto, uso outras ferramentas.

    Todas as soluções aqui assumem que o padrão pode ocorrer várias vezes no texto e removerá as linhas em que ocorre e as linhas imediatamente anteriores a elas. As duas primeiras soluções terão problemas se o padrão corresponder em linhas consecutivas.

    Você pode usar sedpara corresponder a um padrão /pattern/e permitir que isso acione os comandos Ne d, que anexa a próxima linha ao buffer e descarta ambos:

    sed '/pattern/ { N; d; }' file

    Como você deseja descartar a linha antes da correspondência do padrão, alimentamos os dados para trás em sed, começando com a última linha e avançando em direção ao início do arquivo. Em seguida, revertemos os dados novamente quando sedterminar.

    tac file | sed '/pattern/ { N; d; }' | tac

    O tacutilitário faz parte do GNU coreutils. A maioria dos sistemas não GNU pode usar tail -rno lugar de tac(verifique seu tail(1)manual).

    Se o padrão corresponder a duas linhas consecutivas, isso não removerá a linha anterior à primeira dessas linhas (já que a primeira linha seria excluída).

    Usando o ededitor:

    printf '%s\n' 'g/pattern/ -1,. d' ,p Q | ed -s file

    Isso aplica o comando g/pattern/ -1,. dao conteúdo do arquivo. Esse comando procura cada linha que corresponda a patterne exclui essa linha e a linha anterior a ela.

    O comando final ,pe Qde edição imprime o arquivo inteiro e sai do editor sem salvar.

    Se o padrão corresponder a duas linhas consecutivas, isso removerá a linha que se torna anterior à segunda linha após remover a linha anterior à primeira linha.

    (Essa última frase estava correta quando a escrevi, mas obviamente é uma frase somente para escrita.)

    Também podemos usar grepe sua opção não padrão, mas comumente implementada -B, para nos fornecer os números de linha que precisam ser excluídos. Esses números podem ser convertidos em um sedscript que executamos nos dados originais:

    grep -n -B1 'pattern' file | sed 's/[:-].*/d/' | sed -f /dev/stdin file

    O grepcomando, dado o texto na pergunta, produziria

    2-line 2
3:pattern

    ... e o primeiro sedcomando converte isso no sedcomando de edição 2dseguido por 3d("delete line 2 and 3"). O último sedcomando no pipeline pega esse script de edição e o aplica ao texto original.

    Essa variante não tem problemas com linhas consecutivas que correspondem ao padrão, pois usa uma abordagem de 2 passos, primeiro encontrando todas as linhas que devem ser excluídas e, em seguida, excluindo-as (em vez de excluir linhas ao ler o texto pela primeira vez).

    • 6

  2. Usando qualquer awk com tac, você pode excluir qualquer número de linhas antes de um padrão correspondente:

    $ tac file | awk '/pattern/{c=2} !(c&&c--)' file | tac
line 2
line 1

    Basta alterar c=2para c=5ou qualquer número de linhas que você deseja excluir até e incluindo a linha correspondente, por exemplo, para excluir uma linha contendo o número 97 e as 94 linhas anteriores:

    $ seq 100 | tac | awk '/97/{c=95} !(c&&c--)' | tac
1
2
98
99
100

    Agora tente fazer isso com sed em vez de awk :-).

    Veja imprimir-com-sed-ou-awk-a-line-following-a-matching-pattern para obter uma explicação deste e de outros idiomas relacionados.

    • 5

  3. Nota: Este código só funciona se filenão existirem linhas ou substrings duplicadas de cada linha que correspondam à saída de grep -B1 pattern file.

    Por exemplo, se filecontém as seguintes linhas:

    line 1
line 2
line 2
pattern
line 1 line 2
line 3

    E eu uso grep -B1 pattern file | grep -v "$(cat)" filea saída não será como você esperava:

    line 1
line 3

    A melhor maneira de resolver isso é usando a resposta de Kusalananda

    Solução (este se aplica apenas aos casos em que não há linhas ou substrings duplicadas como expliquei acima)

    Isso bashfunciona para mim (acho que existem maneiras melhores):

    grep -B1 pattern file | grep -v "$(cat)" file

    Nos zshcomandos acima não vai funcionar. Eu não sei por quê. Mas você pode usar:

    grep -B1 pattern file | { val="$(cat)" ; grep -v "$val" file; }

    PS Você não precisa usar cat your_file | grep patternisso é redundante. Você deveria usargrep pattern your_file

    • 1

  4. As soluções de Kusalananda e Ed Morton são as mais simples e práticas, mas exigem a leitura do conteúdo duas vezes ou a leitura do conteúdo inteiro antes de começar. Pipes não podem ser relidos nem são sempre finitos. Uma solução que funciona com qualquer fluxo de texto pode ser algo assim:

    $ awk -v pat='^pattern$' '
  function set_prev() { prev_present = 1; prev = $0 }
  NR == 1 { set_prev() }
  $0 ~ pat { prev_present = 0; next }
  NR != 1 { if (prev_present) print prev; set_prev() }
  END { if ($0 !~ pat) print }
' << EOF
pattern
line 1
line 2
pattern
pattern
line 4
line 5
pattern
EOF
line 1
line 4

    Se você quiser fazer com que o número de linhas não impressas seja variável, isso fica um pouco mais complicado:

    $ awk -v n=2 -v pat='^pattern$' '
  function ring_empty() { i = 0; ring_is_full = 0 }
  function ring_is_empty() { return i == 0 && !ring_is_full }
  function ring_add() { ring[i++%n] = $0; ring_is_full = i >= n }
  function ring_starting_index() { return ring_is_full ? i%n : 0 }
  function ring_print_oldest() { print ring[ring_starting_index()] }
  function ring_print_all() {
    if (ring_is_empty()) return
    j = ring_starting_index()
    do {
      print ring[j%n]
    } while (++j%n != i%n)
  }
  function ring_push_out() {
    if (ring_is_full) ring_print_oldest()
    ring_add()
  }

  { ring_push_out() }
  $0 ~ pat { ring_empty() }
  END { ring_print_all() }
' << EOF
pattern
line 1
line 2
pattern
pattern
line 4
line 5
pattern
EOF
line 1
line 4

    Nenhuma dessas soluções tem problemas com partidas consecutivas, btw.

    • 1

  5. Você pode usar pcregrepe seu Mmodo ultiline:

    pcregrep -Mv '\n.*pattern'

    Observe que, se a primeira linha corresponder ao padrão, ela não será removida. Isso pode ser contornado usando:

    pcregrep -Mv '(\n)?.*pattern'

    (a (...)volta \naparentemente necessária, não sei porque não funciona com \n?.*patternou [\n]?.*patterncom a versão 8.39 aqui).

    • 1

  6. Usando Raku (anteriormente conhecido como Perl_6)

    raku -e 'for lines.join("\n") { print .subst(:global, / \N* \n pattern [ \n | $ ]/) };'     

#OR

raku -e 'for lines.join("\n") { print .split(/ \N* \n pattern [ \n | $ ] /).join };'

    Essas duas primeiras respostas (acima) basicamente detectam um padrão de duas linhas e o excluem. Assim, as ocorrências consecutivas da palavra patternnão são tratadas, nem a ocorrência de patternna primeira linha. Para ambas as respostas, linessão lidos de um arquivo e editados joinnovamente em \nnovas linhas (já que linesautochomps por padrão). Em seguida, o regex de duas linhas desejado é procurado e 1). substitutado (sem nada, ou seja, deletado) ou 2). splitna regex de duas linhas e joined a saída put.

    As próximas duas respostas (abaixo) tratam da ocorrência de patternna primeira linha, bem como tratam de ocorrências consecutivas da palavra pattern. Eles usam o agrupamento [\N* \n]?no início do Regex:

    raku -e 'for lines.join("\n") { print .subst(:global, / [\N* \n]?  pattern [ \n | $ ]/) };'     

#OR

raku -e 'for lines.join("\n") { print .split(/ [\N* \n]?  pattern [ \n | $ ] /).join };'

    Entrada de amostra:

    pattern
line 1
line 2
pattern
pattern
line 5
line 6
pattern

    Saída de amostra (os primeiros 2 exemplos que excluem um Regex de 2 linhas):

    pattern
line 1
pattern
line 5

    Saída de amostra (exemplos 3 e 4 que lidam adicionalmente patternna primeira linha, bem como ocorrências consecutivas de pattern):

    line 1
line 5

    FYI: A rotina de Raku linesé anunciada para agir preguiçosamente, então potencialmente um arquivo pode ser analisado sem ter que ler o arquivo inteiro primeiro. Para comentários sobre a rotina de Raku lines, veja a URL abaixo.

    https://speakerdeck.com/util/reading-files-cant-be-this-simple
    https://raku.org

    Agradecimentos especiais ao usuário @JoL por uma crítica perspicaz dos regexes originais nesta resposta.

    • 0

  7. Você pode armazenar a linha que contém patterne a linha acima dela em uma variável. Então você pode usar esta variável para grep novamente em seu arquivo.

    match=$(grep pattern -B1 file)
grep "$match" -v file
    • -2

relate perguntas