Início / unix / Perguntas / 520916
Accepted
LL3
Asked: 2019-05-25 08:49:13 +0800 CST

Como substituir substrings por valores retirados de um dicionário indexado pelas substrings

  • 772

Eu preciso analisar um arquivo grande substituindo substrings possivelmente ocorrendo, que fazem parte de strings possivelmente ocorrendo que correspondem a um regex, com um valor obtido de uma matriz cujos índices são as substrings em questão.

O arquivo é um arquivo de texto normal, ou seja, possui linhas separadas por caractere de nova linha, e cada linha pode ter qualquer caractere arbitrário entre ASCII 32 e ASCII 126, basicamente qualquer caractere imprimível, exceto os de controle na localidade C.

O regex estendido que corresponde precisamente às strings interessantes é \<prefix-[[:alnum:]]{2,}\>, enquanto a substring em questão é o que vem após o sinal de traço.

Com uma entrada de amostra (sintetizada) como:

# arbitrary number of comment lines of any length
:prefix-foo ; arbitrary strings
# arbitrary number of comment lines of any length foo -prefix-foo-
-bar -foo-xx arbitrary string -yet-more strings prefix-foo-bar MORE strings
YET more --STRINGS prefix-bar -prefix-foo-STRingS--
even MORE strings ; prefix -foo -yy--more-and-prefix-bar-and-more

e ter um dicionário de exemplo como:

dictionary["foo"] = 2
dictionary["bar"] = 15

a saída desejada seria:

# arbitrary number of comment lines of any length
:prefix-2 ; arbitrary strings
# arbitrary number of comment lines of any length foo -prefix-2-
-bar -foo-xx arbitrary string -yet-more strings prefix-2-bar MORE strings
YET more --STRINGS prefix-15 -prefix-2-STRingS--
even MORE strings ; prefix -foo -yy--more-and-prefix-15-and-more

Eu pensei awkque seria a melhor ferramenta, especialmente por sua capacidade nativa de reescrever um $0registro inteiro apenas substituindo os $1...$ncampos únicos. Por isso, criei o seguinte script:

#!/usr/bin/gawk -f

BEGIN {
    # first fill in dictionary
    while ("cmd-providing-dictionary" | getline) {
            dictionary[$1] = $2
    }
    close("cmd-providing-dictionary")
    # pattern that matches interesting fields
    field_regex = "\\<prefix-[[:alnum:]]{2,}\\>"
    # I don't care default splitting of line
    FS = OFS = ""
}
{
    # split line in fields as per regex
    if (patsplit($0, fields, field_regex, seps)) {
        FS = OFS = "-"
        # for each field, split it on dash character,
        # modify its substring as per dictionary,
        # and finally rebuild it
        for (fn in fields) {
            $0 = fields[fn]
            if ($2 in dictionary) {
                    $2 = dictionary[$2]
                    fields[fn] = $0
            }
        }
        FS = OFS = ""
        # clear whole record and rebuild it with
        # fields computed above + original separators
        $0 = ""
        for (fn in fields)
            $fn = seps[fn - 1] fields[fn]
        $(fn+1) = seps[fn]
    }
    print
}

Embora eu não seja forte com o Awk, o acima parece estar fazendo o trabalho correto com rapidez suficiente, mas parece um pouco desajeitado e parece que estou forçando awkas coisas de uma maneira não natural. Eu estou querendo saber se há uma maneira melhor de obter o mesmo resultado. Ou também uma ferramenta melhor.

Minha primeira ideia foi uma simples substituição de regex usando gsub()ou gensub(), mas não encontrei uma maneira (limpa) de usar a subexpressão de uma regex (que seria \<prefix-([[:alnum:]]{2,})\>) como a chave para pesquisar a matriz e usar esse valor na string de substituição. Por outro lado, fazer um loop sobre todas as chaves do dicionário para aplicar sempre todos os gsubs não é realmente viável porque o dicionário é muito grande e, portanto, seria muito ineficiente.

awk gawk

1 respostas

  1. Best Answer

    Apenas para comparação, aqui está uma versão perl não especializada que ganha muito por poder chamar uma função de dentro de uma substituição. É como se você pudesse dizer

    gsub(regexp, call_function(matched_part), variable_to_change)

    onde a função retorna a string de substituição.

    #!/usr/bin/perl
use strict;
my %d;
sub fix{
  my ($prefix,$str) = @_;
  $str = $d{$str} if defined $d{$str};
  return "$prefix$str";
}
open(D,"dictionary") or die;
while(<D>){
  $d{$1} = $2 if $_ =~ m/^([^ ]+) ([^ \n]+)/;
}
close(D);
while(<>){
  $_ =~ s/\b(prefix-)([[:alnum:]]{2,})\b/fix($1,$2)/ge;
  print;
}

    Aqui, o comando replace $_ =~ s/regex/fix($1,$2)/gealtera a linha atual $_globalmente (g) e executa (e) a string de substituição fix(), onde $1e $2são os grupos capturados (dentro ()de ) da regex.

    • 1

relate perguntas