Prueba si un globo tiene alguna coincidencia en bash

Si quiero verificar la existencia de un solo archivo, puedo probarlo usando test -e filenameo [ -e filename ].

Supongamos que tengo un glob y quiero saber si existen archivos cuyos nombres coincidan con el glob. El globo puede coincidir con 0 archivos (en cuyo caso no necesito hacer nada), o puede coincidir con 1 o más archivos (en cuyo caso necesito hacer algo). ¿Cómo puedo probar si un globo tiene alguna coincidencia? (No me importa cuántas coincidencias hay, y sería mejor si pudiera hacer esto con una ifdeclaración y sin bucles (simplemente porque me parece más legible).

( test -e glob*falla si el globo coincide con más de un archivo).

Solución específica de Bash :

compgen -G "<glob-pattern>"

Escápese del patrón o se expandirá previamente en coincidencias.

El estado de salida es:

• 1 para no partido,
• 0 para 'uno o más partidos'

stdoutes una lista de archivos que coinciden con el glob .
Creo que esta es la mejor opción en términos de concisión y minimizar los posibles efectos secundarios.

ACTUALIZACIÓN : Ejemplo de uso solicitado.

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

La opción de shell nullglob es de hecho un bashism.

Para evitar la necesidad de guardar y restaurar tediosamente el estado de globo nulo, solo lo configuro dentro de la subshell que expande el globo:

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

Para una mejor portabilidad y un globbing más flexible, use find:

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

Las acciones explícitas -print -quit se utilizan para buscar en lugar de la acción implícita -print implícita , de modo que find se cerrará tan pronto como encuentre el primer archivo que coincida con los criterios de búsqueda. Cuando coinciden muchos archivos, esto debería ejecutarse mucho más rápido que echo glob*o ls glob*y también evita la posibilidad de sobrecargar la línea de comando expandida (algunos shells tienen un límite de longitud 4K).

Si find se siente como una exageración y el número de archivos que probablemente coincidan es pequeño, 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

me gusta

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

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

Esto es legible y eficiente (a menos que haya una gran cantidad de archivos).
El principal inconveniente es que es mucho más sutil de lo que parece, y a veces me siento obligado a agregar un comentario largo.
Si hay una coincidencia, "glob*"se expande por el shell y se pasan todas las coincidencias exists(), que comprueba la primera e ignora el resto.
Si no hay coincidencia, "glob*"se pasa exists()y tampoco se encuentra allí.

Editar: puede haber un falso positivo, ver comentario

Si tienes un conjunto de globfail puedes usar este loco (que realmente no deberías)

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

o

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

test -e tiene la desafortunada advertencia de que considera que los enlaces simbólicos rotos no existen. Por lo tanto, es posible que también desee verificarlos.

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

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

Para simplificar un poco la respuesta de MYYN, basada en su idea:

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

Basado en la respuesta de flabdablet , para mí parece que lo más fácil (no necesariamente el más rápido) es usar find , mientras deja la expansión global en el shell, como:

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

O en ifcomo:

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

Tengo otra solución más:

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

Esto funciona muy bien para mí. ¿Hay algunos casos de esquina que echo de menos?

En Bash, puede pasar a una matriz; Si el glob no coincide, su matriz contendrá una sola entrada que no corresponde a un archivo existente:

#!/bin/bash

shellglob='*.sh'

scripts=($shellglob)

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

Nota: si ha nullglobconfigurado, scriptsserá una matriz vacía, y debe probar con [ "${scripts[*]}" ]o con [ "${#scripts[*]}" != 0 ]. Si está escribiendo una biblioteca que debe funcionar con o sin nullglob, querrá

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

Una ventaja de este enfoque es que tiene la lista de archivos con los que desea trabajar, en lugar de tener que repetir la operación global.

Esta abominación parece funcionar:

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

Probablemente requiere bash, no sh.

Esto funciona porque la opción nullglob hace que el glob se evalúe como una cadena vacía si no hay coincidencias. Por lo tanto, cualquier salida no vacía del comando echo indica que el globo coincide con algo.

No vi esta respuesta, así que pensé en ponerla ahí:

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

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

Explicación

Cuando no hay una coincidencia para glob*, entonces $1contendrá 'glob*'. La prueba -f "$1"no será verdadera porque el glob*archivo no existe.

¿Por qué esto es mejor que las alternativas?

Esto funciona con sh y derivados: ksh y bash. No crea ningún sub-shell. $(..)y los `...`comandos crean un sub-shell; bifurcan un proceso y, por lo tanto, son más lentos que esta solución.

Me gusta esto en intento(archivos de prueba que contienen 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

Es mucho mejor que compgen -G: porque podemos discriminar más casos y con mayor precisión.

Puede funcionar con un solo comodín *

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

Tenga en cuenta que esto puede llevar mucho tiempo si hay muchas coincidencias o si el acceso al archivo es 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.*"

No es la solución más eficiente (si hay una tonelada de archivos en el directorio, puede ser lento), pero es simple, fácil de leer y también tiene la ventaja de que las expresiones regulares son más potentes que los patrones simples de globo de bash.

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