Início / coding / Perguntas / 77991498
Accepted
eramm
Asked: 2024-02-14 08:04:19 +0800 CST

AWK - processando partidas antes de passar para a próxima partida

  • 772

eu tenho um arquivo que contém vários parágrafos que usam colchetes como separadores como este

{
KEYWORD
a = 1
b = 2
c = 3
}
{
d = 4
KEYWORD
e = 5
f = 6
}

Gostaria de fazer um loop em cada parágrafo e atribuí-lo a uma variável $foo enquanto preserva as quebras de linha, de modo que echo $foo resultará na saída do parágrafo em formato de várias linhas. Depois de processar a saída de $foo, por exemplo, echo $foo | grep baro programa deve ir para o próximo parágrafo e sobrescrever $foo

Tenho brincado com o awk porque parece ser a melhor ferramenta neste caso, mas não consigo descobrir como fazer algum tipo de loop while para poder processar cada parágrafo separadamente.

O que tenho até agora é:

grep -Pzo "{[^}]*KEYWORD[^}]*}" FILENAME | awk "/{/{flag=1; 

paragraph=\"\"; next} /}/{flag=0; print paragraph} flag {paragraph = 

paragraph \$0 \"\\n\"}"

isso produz parágrafos legais como este

KEYWORD
a = 1
b = 2
c = 3

d = 4
KEYWORD
e = 5
f = 6

O que estou travando é que quero realizar outras ações no parágrafo 1 antes de passar para o parágrafo 2.

O mais próximo que cheguei de uma solução foi escrever os resultados em um array, mas perdi o parágrafo e tudo estava em uma linha e não consegui fazer o processamento pós-correspondência que queria.

ATUALIZAR:

No espírito de que existe mais de uma maneira de fazer isso e se você só tiver um martelo então tudo parece um prego, ofereço minha solução:

# Read paragraphs into an array
while IFS= read -r paragraph; do
    paragraphs+=("$paragraph")
done < <(awk '/\{/{flag=1; paragraph=""; next} /\}/{flag=0; print paragraph} flag {paragraph = paragraph $0}' testoutput.txt)

# Print each paragraph separately
for ((i=0; i<${#paragraphs[@]}; i++)); do
    # Assign each paragraph to a variable using eval
    eval "foo_$i=\"${paragraphs[$i]}\""

    # Print the variable recreating the line breaks
    echo "Variable foo_$i:"
    eval "echo \"\$foo_$i\"|sed 's/\s\{2,\}/\n/g'"
done

A chave para o sucesso foi usar sed 's/\s\{2,\}/\n/g'e não \sou \s+um ou mais versus dois ou mais.

loops

4 respostas

  1. Aqui está uma abordagem usando um whileloop nas linhas do arquivo de entrada. As linhas são lidas read -rem uma variável line. Se for a {, redefina a variável foo. Se for um }, faça algo com $foo(aqui estou imprimindo seu conteúdo bruto, seu comprimento e algum texto estático). Em qualquer outro caso, anexe o conteúdo de lineao conteúdo atual de foo.

    #!/bin/sh

while read -r line; do
  case "$line" in
    '{') foo=;;
    '}') printf "Here's another foo:"
         printf '%s\n' "$foo"
         printf 'It has a length of %d.\n' "${#foo}";;
    *) foo="$(printf '%s\n' "$foo" "$line")";;
  esac
done < input.txt

    Here's another foo:
KEYWORD
a = 1
b = 2
c = 3
It has a length of 26.
Here's another foo:
d = 4
KEYWORD
e = 5
f = 6
It has a length of 26.
    • 3

  2. Modificando o script atual do OP awkpara gerar cada parágrafo em uma única linha onde os linefeeds incorporados ( \n) são substituídos pelos caracteres literais \+ n:

    $ cat braces.awk
/{/   { flag = 1
        paragraph = ""
        next
      }
/}/   { flag = 0
        print paragraph
      }
flag  { paragraph = paragraph (paragraph ? "\\n" :"") $0 }

    Executando isso na entrada de amostra:

    $ awk -f braces.awk data
KEYWORD\na = 1\nb = 2\nc = 3
d = 4\nKEYWORD\ne = 5\nf = 6

    Podemos então alimentá-los com basho builtin printfpara preencher a variável foo:

    while read -r raw
do
    echo "############# ${raw}"

    printf -v foo "%b" "${raw}"

    echo "${foo}"
done < <(awk -f ./braces.awk data)

    NOTA: printf -v requerbash 3.1+

    Isso gera:

    ############# KEYWORD\na = 1\nb = 2\nc = 3
KEYWORD
a = 1
b = 2
c = 3
############# d = 4\nKEYWORD\ne = 5\nf = 6
d = 4
KEYWORD
e = 5
f = 6
    • 3
  3. Best Answer

    Uma ideia para mapfileler os 'parágrafos' em uma matriz:

    $ mapfile -d '}' paragraphs < data              # use '}' as our delimiter (instead of the default `\n`)

$ typeset -p paragraphs
declare -a paragraphs=([0]=$'{\nKEYWORD\na = 1\nb = 2\nc = 3\n}' [1]=$'\n{\nd = 4\nKEYWORD\ne = 5\nf = 6\n}' [2]=$'\n')

    Existem alguns itens de interesse:

    • índices de array começam em0
    • queremos ignorar a última entrada do array (index= 2), pois ela captura tudo após a última }no arquivo
    • para o segundo ao enésimo 'parágrafo' há um entrelinha \nque precisaremos remover

    Levando essas questões em consideração... um bash/forloop para processar um 'parágrafo' por vez

    for ((i=0; i<(${#paragraphs[@]}-1); i++))       # subtract 1 from number of array indices; in this case this gives us i<2
do
    echo "######### paragaphs[$i]"

    foo="${paragraphs[i]#$'\n'}"                # parameter substitution to remove a leading \n

    echo "${foo}"
done

    Isso gera:

    ######### paragaphs[0]
{
KEYWORD
a = 1
b = 2
c = 3
}
######### paragaphs[1]
{
d = 4
KEYWORD
e = 5
f = 6
}

    NOTA: Se o arquivo não estiver formatado exatamente como mostrado no exemplo (por exemplo, o arquivo real contém linhas em branco; há espaço em branco extra antes/depois dos caracteres {e }, isso pode não funcionar como esperado e/ou pode ser necessário executar alguns substituições de parâmetros adicionais para massagear foono formato desejado.

    Um exemplo de algumas substituições de parâmetros adicionais para remover o {\nand }\n:

    for ((i=0; i<(${#paragraphs[@]}-1); i++))
do
    echo "######### paragaphs[$i]"

    foo="${paragraphs[i]#$'\n'}"
    foo="${foo/$'{\n'}"
    foo="${foo/$'\n}'}"

    echo "${foo}"
done

    Isso gera:

    ######### paragaphs[0]
KEYWORD
a = 1
b = 2
c = 3
######### paragaphs[1]
d = 4
KEYWORD
e = 5
f = 6
    • 2

  4. O que eu faria:

    count=(grep -c '}' file)
for ((i=2; i<=count+1; i++)); do
    foo="$(awk -v p=$i 'BEGIN{RS="{\n"} NR==p{print "{\n"$0}' file)"
done

    A ideia é dividir a saída nos caracteres {\npara usar o padrão multilinha em awk.

    • 0

relate perguntas