Início / unix / Perguntas / 788816
Accepted
An5Drama
Asked: 2024-12-29 12:35:54 +0800 CST

Como destacar o padrão regex correspondente obtido por muitas expressões regex separadas por `||` no awk?

  • 772

Este recurso de destaque pode ser feito facilmente em grepcom --color. Mas grep não é possível fazer correspondência regular e invertida ao mesmo tempo , por exemplo grep foo -v bar ...(preciso deste recurso, pois ele --colorsó pode ser usado na entrada inicial do pipe |, então o último grep usará os resultados coloridos que grep foo --color=always ... | grep -v "foo bar"não removerão essas linhas com "foo bar").

Então eu usei awkcomo as dicas do link acima, mas falta o recurso de destaque. Podemos extrair os resultados do regex com matchesubstr onde envolvemos o padrão regex em matchcomo /\<no issue\>/. Podemos então destacar apenas o resultado do regex com códigos de cores ANSI por printf substr($0,1,RSTART-1) "\033[1;31m" substr($0,RSTART,RLENGTH) "\033[0m: " substr($0,RSTART+RLENGTH) "\n".

P:

Mas matchnão funciona para o boolean expr /foo/ && !/bar/construído por regex exp's no link de referência. Existe uma solução alternativa elegante (talvez com outras ferramentas)?

Pensei em uma solução temporária /foo/ && !/bar/{match($0,/foo/); printf ...}, mas isso fará com que o regex funcione duas vezes.

Meu comportamento esperado (Aqui 0. "TODO" pode existir no máximo uma vez em uma linha 1. Eu uso *...*para mostrar o que deve ser destacado 2. Eu considero apenas /pattern1/ && !/pattern_included_totally_by_pattern1/, então /foo/ && !/o/oferecido por Ed Morton não é considerado. Isso é como a lógica grep, que eu primeiro grep some e então grep in aqueles resultados obtidos da execução grep anterior):

# fail
$ echo "TODO foo\nTODO" | grep TODO --color=always | grep -v "TODO foo"
*TODO* foo
*TODO*
# expected
$ echo "TODO foo\nTODO" | awk -v RED="\033[1;31m" -v RESET="\033[0m" '/TODO/ && !/TODO foo/ {match($0,/TODO/); printf substr($0,1,RSTART-1) RED substr($0,RSTART,RLENGTH) RESET substr($0,RSTART+RLENGTH) "\n"}'
*TODO*
shell

3 respostas

  1. Eu usaria perlaqui. Para destacar foolinhas que não contêm foo bar:

    perl -pe 's/foo/\e[31;1m$&\e[m/g unless /foo bar/' < your-file

    O mesmo que:

    awk '! /foo bar/ {gsub(/foo/, "\33[1;31m&\33[m")}; {print}' < your-file

    $'...'Ou (assumindo um shell com suporte para o formato de aspas no estilo ksh93 ):

    sed $'/foo bar/! s/foo/\e[1;31m&\e[m/g' < your-file

    Ou para destacar os foos que não são seguidos por bar.

    perl -pe 's/foo(?! bar)/\e[31;1m$&\e[m/g' < your-file

    Não awk, sedequivalente, exceto se o seu sedfor um dos poucos que suportam expressões regulares do tipo Perl, como alguns fazem com -P(como o ast-open) ou -R(como ssedo )), no entanto, é mais comum que grepimplementações suportem perlexpressões regulares do tipo - geralmente com uma -Popção, como o GNU grepfaz quando construído com suporte a expressões regulares do tipo Perl por meio da biblioteca PCRE2 (antigamente PCRE), nesse caso você pode fazer:

    grep -P --color 'foo(?! bar)' < your-file

    Mas isso também descarta linhas sem correspondência.

    Para descartar as linhas que contêm foo bare destacar ocorrências de foonas linhas restantes, você pode fazer:

    perl -ne 'unless (/foo bar/) {
            s/foo/\e[31;1m$&\e[m/g;
            print
          }' < your-file

    Ou:

    awk '! /foo bar/ {gsub(/foo/, "\33[1;31m&\33[m"); print}' < your-file

    $'...'Ou (assumindo um shell com suporte para o formato de aspas no estilo ksh93 ):

    sed  $'/foo bar/d; s/foo/\e[1;31m&\e[m/g' < your-file

    Mas você também pode fazer:

    < your-file grep -v 'foo bar' |
  grep --color -e '^' -e foo

    ( -e '^'para corresponder a todas as linhas, para que não sejam descartadas, -e foopara destacar fooocorrências nessas linhas; < file.in A | B > file.outé como A < file.in | B > file.outou A < file.in | > file.out Bcomo redirecionamentos podem aparecer em qualquer lugar nas linhas de comando, mas usar o primeiro em pipelines é comum, pois torna o fluxo mais evidente).

    Para descartar todas as linhas que contêm foo bare todas as que não contêm fooe destacar fooas restantes:

    perl -ne 'print if ! /foo bar/ && s/foo/\e[1;31m$&\e[m/g' < your-file

    sed -n $'/foo bar/! s/foo/\e[1;31m&\e[m/gp' < your-file

    awk '! /foo bar/ && gsub(/foo/, "\33[1;31m&\33[m")' < your-file

    < your-file grep -v 'foo bar' | grep --color foo

    Detalhes sobre a perlsintaxe:

    • perl -pé o sedmodo (e perl -no sed -nmodo) onde o código (aqui fornecido como uma -eexpressão inline como em sed) é executado para cada linha da entrada com a linha atual em $_(equivalente ao sedespaço de padrões de com a diferença de que em perl, $_contém o delimitador de linha). Veja perldoc perlrunpara detalhes.
    • s/replacement/replacement/é semelhante ao sed's, mas com muitas melhorias, em particular expressões regulares com muito mais recursos, que muitas outras linguagens copiaram desde então.
    • (?! foo)é um desses operadores regexp extras introduzidos pelo perl, que é um operador negativo de look ahead. Veja perldoc perlrepara detalhes.
    • code unless some-conditioné uma forma curta de unless (some-condition) {code}que se lê mais como inglês, mas é equivalente de outra forma. unlesssendo como if !. Veja perldoc perlsynpara detalhes.
    • 2
  2. Best Answer

    Sua solução alternativa é perfeitamente aceitável. Note que, como você parece estar usando o gnu awk, você também pode usar sub()ou gsub()para substituir uma regexp por uma string, com &a substituição sendo feita pela parte correspondente:

    /foo/ && !/bar/ {
  sub(/foo/, "\033[1;31m" "&" "\033[0m: ")  # changes $0
  print
}

    Se você não quiser repetir a expressão regular, você pode dividir os testes

    !/bar/{ if(/foo/){ sub(...); print } }

    ou desde sub()retorna 1 em caso de sucesso

    !/bar/{ if(sub(/foo/, ...)) print }

    ou

    !/bar/ && sub(/foo/, ...) { print }
    • 2

  3. Às vezes, em sua pergunta, parece que você quer destacar uma linha inteira que satisfaça a condição /foo/ && !/bar/que é apenas (substitua REDe RESETpelos códigos de cores que desejar):

    awk '/foo/ && !/bar/ { print "RED" $0 "RESET" }'

    enquanto outras vezes parece que você quer destacar linhas que correspondem foo, mas não foo barquais seriam:

    awk '/foo/ && !/foo bar/ { print "RED" $0 "RESET" }'

    ou para evitar escrever fooduas vezes:

    awk 'match($0,/foo/) && (substr($0,RSTART+RLENGTH) !~ / bar/) {
    print "RED" $0 "RESET"
}'

    enquanto outras vezes ainda parece que você só quer destacar a parte que corresponde fooem uma linha que não contém, barque é apenas:

    awk '!/bar/ && match($0,/foo/) {
    print substr($0,1,RSTART-1) "RED" substr($0,RSTART,RLENGTH) "RESET" substr($0,RSTART+RLENGTH)
}'

    Se você quiser algo diferente de qualquer um desses, mostre um exemplo em sua pergunta. Em particular, se você estiver procurando por uma solução geral que possa destacar partes de linhas dadas múltiplas expressões regulares em uma condição composta, explique em sua pergunta a lógica por trás do que destacar e do que não destacar, incluindo para o caso /foo/ && !/o/.

    • 2

relate perguntas