Teste se um glob possui correspondências no bash

Se eu quiser verificar a existência de um único arquivo, posso testá-lo usando test -e filenameou [ -e filename ].

Supondo que eu tenha um globo e quero saber se existem arquivos cujos nomes correspondam ao globo. O glob pode corresponder a 0 arquivo (nesse caso, não preciso fazer nada) ou pode corresponder a 1 ou mais arquivos (nesse caso, preciso fazer algo). Como posso testar se uma glob tem alguma correspondência? (Eu não ligo para quantas correspondências existem, e seria melhor se eu pudesse fazer isso com uma ifdeclaração e sem loops (simplesmente porque eu acho isso mais legível).

( test -e glob*falha se o glob corresponder a mais de um arquivo.)

Solução específica do Bash :

compgen -G "<glob-pattern>"

Escape do padrão ou ele será pré-expandido nas partidas.

O status de saída é:

• 1 para não correspondência,
• 0 para 'uma ou mais correspondências'

stdouté uma lista de arquivos que correspondem ao glob .
Eu acho que essa é a melhor opção em termos de concisão e minimização de possíveis efeitos colaterais.

UPDATE : Exemplo de uso solicitado.

if compgen -G "/tmp/someFiles*" > /dev/null; then
    echo "Some files exist."
fi

A opção de shell nullglob é de fato um basismo.

Para evitar a necessidade de um tedioso salvamento e restauração do estado nullglob, eu o configuraria apenas dentro do subshell que expande a glob:

if test -n "$(shopt -s nullglob; echo glob*)"
then
    echo found
else
    echo not found
fi

Para melhor portabilidade e globbing mais flexível, use find:

if test -n "$(find . -maxdepth 1 -name 'glob*' -print -quit)"
then
    echo found
else
    echo not found
fi

As ações explícitas -print -quit são usadas para localização, em vez da ação implícita -impressão padrão , para que a localização saia assim que encontrar o primeiro arquivo que corresponda aos critérios de pesquisa. Onde muitos arquivos coincidem, isso deve ser executado muito mais rápido que echo glob*ouls glob* e também evita a possibilidade de estofar demais a linha de comando expandida (algumas shells têm um limite de comprimento de 4K).

Se encontrar parecer um exagero e o número de arquivos que provavelmente corresponderem for pequeno, use stat:

if stat -t glob* >/dev/null 2>&1
then
    echo found
else
    echo not found
fi

#!/usr/bin/env bash

# If it is set, then an unmatched glob is swept away entirely -- 
# replaced with a set of zero words -- 
# instead of remaining in place as a single word.
shopt -s nullglob

M=(*px)

if [ "${#M[*]}" -ge 1 ]; then
    echo "${#M[*]} matches."
else
    echo "No such files."
fi

Eu gosto

exists() {
    [ -e "$1" ]
}

if exists glob*; then
    echo found
else
    echo not found
fi

Isso é legível e eficiente (a menos que haja um grande número de arquivos).
A principal desvantagem é que é muito mais sutil do que parece, e às vezes me sinto compelido a adicionar um longo comentário.
Se houver uma correspondência, ela "glob*"é expandida pelo shell e todas as correspondências são passadas exists(), o que verifica a primeira e ignora o restante.
Se não houver correspondência, "glob*"é passado para exists()e também não existe.

Editar: pode haver um falso positivo, veja o comentário

Se você tiver um conjunto de globfail, você pode usar esse louco (o que você realmente não deveria)

shopt -s failglob # exit if * does not match 
( : * ) && echo 0 || echo 1

ou

q=( * ) && echo 0 || echo 1

test -e tem a advertência infeliz que considera que links simbólicos quebrados não existem. Então, você também pode procurar por eles.

function globexists {
  test -e "$1" -o -L "$1"
}

if globexists glob*; then
    echo found
else
    echo not found
fi

Para simplificar um pouco a resposta do MYYN, com base em sua ideia:

M=(*py)
if [ -e ${M[0]} ]; then
  echo Found
else
  echo Not Found
fi

Com base na resposta do flabdablet , para mim parece que o mais fácil (não necessariamente o mais rápido) é apenas usar o encontrar- se, deixando a expansão glob no shell, como:

find /some/{p,long-p}ath/with/*globs* -quit &> /dev/null && echo "MATCH"

Ou em if:

if find $yourGlob -quit &> /dev/null; then
    echo "MATCH"
else
    echo "NOT-FOUND"
fi

Eu tenho outra solução:

if [ "$(echo glob*)" != 'glob*' ]

Isso funciona muito bem para mim. Há alguns casos de canto que sinto falta?

No Bash, você pode enviar para uma matriz; se o glob não corresponder, sua matriz conterá uma única entrada que não corresponde a um arquivo existente:

#!/bin/bash

shellglob='*.sh'

scripts=($shellglob)

if [ -e "${scripts[0]}" ]
then stat "${scripts[@]}"
fi

Nota: se você nullglobconfigurou, scriptshaverá uma matriz vazia e você deve testar com [ "${scripts[*]}" ]ou com [ "${#scripts[*]}" != 0 ]. Se você estiver escrevendo uma biblioteca que deve funcionar com ou sem nullglob, você desejará

if [ "${scripts[*]}" ] && [ -e "${scripts[0]}" ]

Uma vantagem dessa abordagem é que você tem a lista de arquivos com os quais deseja trabalhar, em vez de precisar repetir a operação glob.

Essa abominação parece funcionar:

#!/usr/bin/env bash
shopt -s nullglob
if [ "`echo *py`" != "" ]; then
    echo "Glob matched"
else
    echo "Glob did not match"
fi

Provavelmente requer bash, não sh.

Isso funciona porque a opção nullglob faz com que o globo seja avaliado como uma sequência vazia se não houver correspondências. Portanto, qualquer saída não vazia do comando echo indica que a glob correspondeu a algo.

Não vi essa resposta, então pensei em publicá-la:

set -- glob*
[ -f "$1" ] && echo "found $@"

set -- glob*
if [ -f "$1" ]; then
  echo "It matched"
fi

Explicação

Quando não houver uma correspondência para glob*, $1ela conterá 'glob*'. O teste -f "$1"não será verdadeiro porque o glob*arquivo não existe.

Por que isso é melhor do que alternativas

Isso funciona com sh e derivados: ksh e bash. Não cria nenhum sub-shell. $(..)e `...`comandos criam um sub-shell; eles bifurcam um processo e, portanto, são mais lentos que esta solução.

Assim em festança(arquivos de teste contendo pattern):

shopt -s nullglob
compgen -W *pattern* &>/dev/null
case $? in
    0) echo "only one file match" ;;
    1) echo "more than one file match" ;;
    2) echo "no file match" ;;
esac

É muito melhor do que compgen -G: porque podemos discriminar mais casos e com mais precisão.

Pode trabalhar com apenas um curinga *

if ls -d $glob > /dev/null 2>&1; then
  echo Found.
else
  echo Not found.
fi

Observe que isso pode levar muito tempo se houver muitas correspondências ou o acesso ao arquivo for lento.

#!/bin/bash
set nullglob
touch /tmp/foo1 /tmp/foo2 /tmp/foo3
FOUND=0
for FILE in /tmp/foo*
do
    FOUND=$((${FOUND} + 1))
done
if [ ${FOUND} -gt 0 ]; then
    echo "I found ${FOUND} matches"
else
    echo "No matches found"
fi

(ls glob* &>/dev/null && echo Files found) || echo No file found

ls | grep -q "glob.*"

Não é a solução mais eficiente (se houver uma tonelada de arquivos no diretório, pode ser lento), mas é simples, fácil de ler e também tem a vantagem de que as expressões regulares são mais poderosas do que os padrões simples do bash glob.

[ `ls glob* 2>/dev/null | head -n 1` ] && echo true