Início / unix / Perguntas / 766709
Accepted
Big McLargeHuge
Asked: 2024-01-12 06:20:52 +0800 CST

Construa o comando find a partir de argumentos

  • 772

Muitas vezes preciso encontrar um arquivo, mas não tenho certeza de qual é o nome, algo assim:

$ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

Isso é um pouco tedioso. Gostaria de criar um alias que seja mais fácil de usar, assim:

$ findany foo bar blah

Aqui está minha tentativa:

findany() {
    args=("-iname" "'*$1*'")
    shift

    while [ $# -gt 0 ]; do
        args+=("-o" "-iname" "'*$1*'")
        shift
    done

    find ${args[@]}
}

O problema é que nunca produz nenhum resultado, mesmo que os arquivos estejam ali:

$ ls
bar.txt  blah.txt  foo.txt

$ findany foo bar blah
# nothing

Se eu adicionar echona frente do comando, parece correto:

$ findany foo bar blah                     
find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

E se eu copiar a saída acima e executá-la, funcionará bem:

$ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'
./bar.txt
./foo.txt
./blah.txt

Acho que tem a ver com divisão de argumentos ou aspas, mas não sei como depurá-lo.

Normalmente uso zsh, mas verifiquei o mesmo comportamento no bash.

bash

3 respostas

  1. Best Answer

    Você estava muito perto! Mas, por algum motivo, você incluiu aspas simples nos próprios nomes dos arquivos, para que nunca correspondessem.

    Além disso, você deve fazer uma cotação "${args[@]}"para que funcione corretamente. Caso contrário, estará sujeito à divisão de palavras e quaisquer globs se expandirão no shell antes de findserem vistos.

    Em vez disso, tente isto (especificamente para bash):

    findany() {
    local args=('-iname' "*$1*")
    shift

    while [ "$#" -gt 0 ]; do
        args+=('-o' '-iname' "*$1*")
        shift
    done

    find . "${args[@]}"
}
    • 3

  2. Com zsh, você poderia simplesmente usar:

    set -o extendedglob # usually in your ~/.zshrc, here used for (#i) for
                    # case insensitive matching

    print -rC1 -- **/*(#i)(foo|bar|blah)*(ND)

    Para construir esse padrão a partir de uma matriz, você pode usar o j[|]sinalizador de expansão de parâmetro para unir os elementos da matriz combinado |com o ~sinalizador de expansão de parâmetro para que |seja tratado como um operador de padrão glob ou com o ~operador de expansão de parâmetro para que qualquer caracteres curinga na string unida (mesmo aqueles encontrados em elementos da matriz) são tratados como padrões.

    findany1() print -rC1 -- **/*(#i)(${(~j[|])argv})*(ND)

    Ou:

    findany2() print -rC1 -- **/*(#i)(${(j[|])~argv})*(ND)

    Por exemplo, findany1 '??'encontraria os arquivos cujo nome contém ??enquanto findany2encontraria os arquivos cujo nome contém pelo menos 2 caracteres. Você precisaria findany2 '\?\?'encontrar findany2 '[?][?]'os arquivos cujo nome ??contém findany2.

    Para fazer a mesma distinção com find, seria:

    findany2() (
  for arg do
    argv+=( -o -iname "$arg" )
    shift
  done
  shift
  find . "$@"
)

    findany1() (
  set -o extendedglob
  for arg do
    argv+=( -o -iname "${arg//(#m)[][\\?*]/\\$MATCH}" )
    shift
  done
  shift
  find . "$@"
)

    Onde escapamos dos curingas reconhecidos por find( ?, *, [...]e \) com \(o único operador de aspas suportado por find/ fnmatch()).

    • 3 
  3. $ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

    essa é uma maneira de fazer isso, mas, francamente, em termos de resultados é semelhante a

    shopt -s globstar  ## enable recursive globbing operator **
shopt -s extglob   ## enable (|) pattern lists
shopt -s nocasematch  ## take a guess!

echo **/*@(foo|bar|blah)*

    (mas faz isso sem a ajuda de find).

    Podemos construir rapidamente um script de shell a partir disso.

    #! /bin/bash -
shopt -s globstar  ## enable recursive globbing operator **
shopt -s extglob   ## enable (|) pattern lists
shopt -s nullglob  ## don't error if nothing matches
shopt -s nocasematch  ## take a guess!

IFS='|' # "$*" joins with the first character of IFS
pattern="**/*@(${*})*"

IFS= # do globbing but not splitting upon unquoted expansion:
matches=( $pattern )

for element in "${matches[@]}"; do
  printf '%s\n' "${element}"
done

    Se você quiser tê-lo como uma função, basta colocar pattern=…to doneem uma declaração de função.

    • 1

relate perguntas