Início / unix / Perguntas / 671949
Accepted
YorSubs
Asked: 2021-10-06 06:15:20 +0800 CST

Bash, encontrando funções cujo conteúdo corresponde a uma string de pesquisa

  • 772

Eu quero pesquisar todas as funções definidas no bash por alguma string de pesquisa. O abaixo é um começo, mas quero então eliminar todos os termos que não são seguidos de espaço em branco na próxima linha (ou seja, eliminar todas as entradas que não foram encontradas $1no corpo dessa função).

fu() { declare -f | grep -e \(\) -e $1; }

por exemplo, esta saída:

...
tt ()
untargz ()
urlfix ()
ver ()
    [ -f /etc/lsb-release ] && RELEASE="$(cat /etc/lsb-release | grep DESCRIPTION | sed 's/^.*=//g' | sed 's/\"//g') ";
vi. ()
vi.su ()
...

reduziria a

...
ver ()
    [ -f /etc/lsb-release ] && RELEASE="$(cat /etc/lsb-release | grep DESCRIPTION | sed 's/^.*=//g' | sed 's/\"//g') ";
...

Uma maneira ainda muito melhor (se possível) seria se todas as funções correspondentes pudessem ser determinadas e exibidas na íntegra.

Eu imagino isso mais ou menos como:

  • Colete os nomes das funções com a string de pesquisa em seu corpo (o nome da função é sempre uma única palavra em uma linha antes da correspondência, começando em ^seguido por um espaço e depois a linha terminando com ()$), depois usando command -Vem cada uma dessas names, OR, fazendo um declare -fnovamente, mas desta vez, usando esses nomes e combinando tudo depois deles de {até }(onde {e }estão em linhas únicas por si mesmos em ^- eu sei que grep/awk/sed pode fazer coisas incríveis para aqueles que têm esse conhecimento .

O resultado final estaria em execução fu awke me mostraria a definição de cada função que contém awkno corpo da função.

bash text-processing

2 respostas

  1. Best Answer

    O seguinte awkcomando na extremidade receptora do pipe vem à mente:

    declare -f | awk -v srch="pattern" 'NF==2 && $2=="()"{if (m) print buf; buf=""; m=0}
                                    buf && index($0,srch){m=1}
                                    {buf=buf ORS $0}
                                    END{if (m) print buf}'

    A ideia é armazenar a declaração e o corpo de cada função em um buffer bufenquanto analisa a saída de declare -f, mas apenas imprimir o buffer se a string de pesquisa for encontrada.

    • O programa reconhecerá o início de uma nova definição de função se encontrar uma linha que consiste em apenas dois campos (= "palavras" separadas por espaço), onde o segundo campo é (). Se uma correspondência foi encontrada durante a análise da função anterior (indicada pelo sinalizador msendo 1), o buffer bufserá impresso. Tanto o buffer quanto o sinalizador serão redefinidos.
    • A palavra de pesquisa é passada para o programa como awkvariável srch. Se for encontrado na linha atual (a indexfunção retorna um resultado diferente de zero), o msinalizador é definido como 1, mas somente se não estivermos na linha em que a declaração da função começa (indicada por bufnão estar vazia), caso contrário, corresponde no nome da função também contaria.
    • Cada linha será anexada ao buffer bufe separada do conteúdo anterior pelo separador de registro de saída ORS(que por padrão é nova linha).
    • Ao final, é realizada outra verificação se a correspondência foi encontrada e, em caso afirmativo, o buffer impresso. Sem essa verificação, a última definição de função nunca seria considerada.

    Observação

    O programa executa uma pesquisa de string completa usando a index()função de awk. Se você quiser que a pesquisa seja baseada na correspondência de expressões regulares, você precisará alterar a condição de

    index($0,srch)

    para

    $0~srch

    (mas, como sempre, esteja ciente de que procurar strings que contenham caracteres que tenham significados especiais para expressões regulares se torna mais complicado).

    • 5

  2. Para aqueles que desejam fazer a mesma coisa em zsh, para obter as definições de funções cujo corpo corresponde a um padrão, você faria:

    typeset -f '<dummy>' ${(k)functions[(R)pattern]}

    o <dummy>para cobrir o caso em que não há função correspondente. Ou uma maneira mais limpa:

    () { (($#)) && typeset -f -- "$@"; } ${(k)functions[(R)pattern]}

    Em bash, você poderia fazer algo semelhante com:

    compgen -A function | (
  ret=1
  while IFS= read -r fn; do
    def=$(typeset -f -- "$fn") &&
      [[ ${def#*'()'} = pattern ]] &&
      printf '%s\n' "$def" &&
      ret=0
  done
  exit "$ret"
)

    Embora isso seja bastante ineficiente, pois a lista de nomes de funções é lida um byte por vez (já que reada entrada de ' é um pipe) e um processo é bifurcado para cada função. Pode ser otimizado com:

    compgen -A function | (
  readarray -t functions
  for fn in "${functions[@]}"; do
    typeset -f -- "$fn" && printf '\0'
  done
) | (
  ret=1
  readarray -td '' fn_definitions
  for def in "${fn_definitions[@]}"; do
    [[ ${def#*'()'} = pattern ]] &&
      printf '%s\n' "$def" &&
      ret=0
  done
  exit "$ret"
)

    readarray, ao contrário de read, não precisa ler a entrada um byte por vez, pois consome toda a entrada de qualquer maneira. Delimitamos as definições de função com caracteres NUL, pois de qualquer maneira bash(ao contrário de zsh) não podemos armazenar esse caractere em suas definições/nomes de função nem no conteúdo de variáveis ​​e, em seguida, podemos usar readarray -td ''(o que requer bash-4.4+) para quebrá-lo em um array.

    Isso evita ter que confiar em heurísticas como a presença de ()(que também pode ocorrer no corpo de uma função) para adivinhar onde cada definição de função começa na saída de typeset -f.

    • 4

relate perguntas