Verifica se un glob ha delle corrispondenze in bash

Se voglio verificare l'esistenza di un singolo file, posso provarlo usando test -e filenameo [ -e filename ].

Supponiamo di avere un glob e voglio sapere se esistono file i cui nomi corrispondono al glob. Il glob può abbinare 0 file (nel qual caso non devo fare nulla) oppure può corrispondere a 1 o più file (nel qual caso devo fare qualcosa). Come posso verificare se un glob ha delle corrispondenze? (Non mi importa quante partite ci siano, e sarebbe meglio se potessi farlo con una iffrase e senza loop (semplicemente perché trovo che sia più leggibile).

( test -e glob*non riesce se il glob corrisponde a più di un file.)

Soluzione specifica per Bash :

compgen -G "<glob-pattern>"

Sfuggire allo schema o verrà pre-espanso nelle partite.

Lo stato di uscita è:

• 1 per nessuna corrispondenza,
• 0 per "una o più partite"

stdoutè un elenco di file corrispondenti al glob .
Penso che questa sia l'opzione migliore in termini di concisione e minimizzazione dei potenziali effetti collaterali.

AGGIORNAMENTO : esempio di utilizzo richiesto.

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

L'opzione shell nullglob è davvero un bashismo.

Per evitare la necessità di un noioso salvataggio e ripristino dello stato nullglob, lo imposto solo all'interno della subshell che espande il glob:

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

Per una migliore portabilità e un globbing più flessibile, usare find:

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

Le azioni esplicite -quit -quit vengono utilizzate per trovare anziché l' azione predefinita -print implicita in modo che find venga chiuso non appena trova il primo file che corrisponde ai criteri di ricerca. Laddove molti file corrispondono, questo dovrebbe essere eseguito molto più velocemente di echo glob*o ls glob*ed evita anche la possibilità di sovrastampare la riga di comando espansa (alcune shell hanno un limite di lunghezza 4K).

Se find sembra eccessivo e il numero di file che possono corrispondere è piccolo, usa 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

mi piace

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

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

Questo è sia leggibile che efficiente (a meno che non ci sia un numero enorme di file).
Lo svantaggio principale è che è molto più sottile di quanto sembri, e a volte mi sento in dovere di aggiungere un lungo commento.
Se c'è una corrispondenza, "glob*"viene espansa dalla shell e tutte le partite vengono passate exists(), il che controlla la prima e ignora il resto.
Se non vi è alcuna corrispondenza, "glob*"viene passato exists()e non viene trovato neanche lì.

Modifica: potrebbe esserci un falso positivo, vedi commento

Se hai impostato globfail puoi usare questo pazzo (cosa che non dovresti davvero)

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

o

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

test -e ha lo sfortunato avvertimento che ritiene che non esistano collegamenti simbolici rotti. Quindi potresti voler controllare anche quelli.

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

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

Semplificare in qualche modo la risposta di MYYN, in base alla sua idea:

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

Basato sulla risposta di flabdablet , per me sembra che il modo più semplice (non necessariamente più veloce) sia solo quello di trovare se stesso, lasciando l'espansione glob su shell, come:

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

O ifcome:

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

Ho ancora un'altra soluzione:

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

Questo funziona bene per me. Ci sono alcuni casi angolari che mi mancano?

In Bash, puoi glob a un array; se il glob non corrisponde, il tuo array conterrà una singola voce che non corrisponde a un file esistente:

#!/bin/bash

shellglob='*.sh'

scripts=($shellglob)

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

Nota: se hai nullglobimpostato, scriptssarà un array vuoto e dovresti testare con [ "${scripts[*]}" ]o con [ "${#scripts[*]}" != 0 ]invece. Se stai scrivendo una libreria che deve funzionare con o senza nullglob, ti consigliamo

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

Un vantaggio di questo approccio è che hai quindi l'elenco dei file con cui vuoi lavorare, piuttosto che dover ripetere l'operazione glob.

Questo abominio sembra funzionare:

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

Probabilmente richiede bash, non sh.

Questo funziona perché l'opzione nullglob fa sì che il glob valuti una stringa vuota se non ci sono corrispondenze. Pertanto, qualsiasi output non vuoto dal comando echo indica che il glob corrisponde a qualcosa.

Non ho visto questa risposta, quindi ho pensato di metterlo là fuori:

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

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

Spiegazione

Quando non c'è una corrispondenza per glob*, allora $1conterrà 'glob*'. Il test -f "$1"non sarà vero perché il glob*file non esiste.

Perché questo è meglio delle alternative

Funziona con sh e derivati: ksh e bash. Non crea alcuna sotto-shell. $(..)e i `...`comandi creano una sotto-shell; forzano un processo e quindi sono più lenti di questa soluzione.

In questo modo bash(file di test contenenti 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

È molto meglio di compgen -G: perché possiamo discriminare più casi e più precisamente.

Può funzionare con un solo carattere jolly *

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

Nota che ciò può richiedere molto tempo se ci sono molte corrispondenze o l'accesso ai file è 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.*"

Non è la soluzione più efficiente (se ci sono tonnellate di file nella directory potrebbe essere lenta), ma è semplice, facile da leggere e ha anche il vantaggio che le regex sono più potenti dei semplici pattern glob bash.

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