Testez si un glob a des correspondances dans bash

Si je veux vérifier l'existence d'un seul fichier, je peux le tester en utilisant test -e filenameou [ -e filename ].

Supposons que j'ai un glob et que je veuille savoir s'il existe des fichiers dont les noms correspondent au glob. Le glob peut correspondre à 0 fichier (auquel cas je n'ai rien à faire), ou il peut correspondre à 1 ou plusieurs fichiers (auquel cas je dois faire quelque chose). Comment puis-je tester si un glob a des correspondances? (Je me fiche du nombre de correspondances, et il serait préférable que je puisse le faire avec une seule ifinstruction et sans boucles (simplement parce que je trouve cela plus lisible).

( test -e glob*échoue si le glob correspond à plusieurs fichiers.)

Solution spécifique à Bash :

compgen -G "<glob-pattern>"

Échappez au motif ou il sera pré-développé en matchs.

Le statut de sortie est:

• 1 pour match nul,
• 0 pour «un ou plusieurs matchs»

stdoutest une liste de fichiers correspondant au glob .
Je pense que c'est la meilleure option en termes de concision et de minimisation des effets secondaires potentiels.

MISE À JOUR : Exemple d'utilisation demandée.

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

L'option shell nullglob est en effet un bashisme.

Pour éviter la nécessité d'une sauvegarde et d'une restauration fastidieuses de l'état nullglob, je ne le définirais qu'à l'intérieur du sous-shell qui étend le glob:

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

Pour une meilleure portabilité et une globalisation plus flexible, utilisez find:

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

Les actions explicites -print -quit sont utilisées pour rechercher au lieu de l'implicite par défaut action -print sorte que find se ferme dès qu'il trouve le premier fichier correspondant aux critères de recherche. Lorsque de nombreux fichiers correspondent, cela devrait fonctionner beaucoup plus rapidement que echo glob*ou ls glob*et cela évite également la possibilité de surcharger la ligne de commande étendue (certains shells ont une limite de longueur 4K).

Si find semble exagéré et que le nombre de fichiers susceptibles de correspondre est petit, utilisez 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

J'aime

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

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

C'est à la fois lisible et efficace (sauf s'il y a un grand nombre de fichiers).
Le principal inconvénient est qu'il est beaucoup plus subtil qu'il n'y paraît, et je me sens parfois obligé d'ajouter un long commentaire.
S'il y a une correspondance, "glob*"est développé par le shell et toutes les correspondances sont passées à exists(), qui vérifie la première et ignore le reste.
S'il n'y a pas de correspondance, "glob*"est passé àexists() et trouvé comme n'existant pas non plus.

Edit: il peut y avoir un faux positif, voir commentaire

Si vous avez défini globfail, vous pouvez utiliser ce fou (ce que vous ne devriez vraiment pas)

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

ou

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

test -e a la fâcheuse mise en garde qu'il considère que les liens symboliques rompus n'existent pas. Donc, vous voudrez peut-être aussi les vérifier.

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

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

Pour simplifier quelque peu la réponse de MYYN, basée sur son idée:

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

Sur la base de la réponse de flabdablet , pour moi, il semble que le plus simple (pas nécessairement le plus rapide) consiste à utiliser find lui-même, tout en laissant l'expansion de glob sur le shell, comme:

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

Ou ifcomme:

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

J'ai encore une autre solution:

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

Cela fonctionne bien pour moi. Y a-t-il des cas d'angle qui me manquent?

Dans Bash, vous pouvez glob à un tableau; si le glob ne correspond pas, votre tableau contiendra une seule entrée qui ne correspond pas à un fichier existant:

#!/bin/bash

shellglob='*.sh'

scripts=($shellglob)

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

Remarque: si vous avez nullglobdéfini, scriptssera un tableau vide, et vous devriez tester avec [ "${scripts[*]}" ]ou avec à la [ "${#scripts[*]}" != 0 ]place. Si vous écrivez une bibliothèque qui doit fonctionner avec ou sans nullglob, vous voudrez

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

Un avantage de cette approche est que vous disposez alors de la liste des fichiers avec lesquels vous souhaitez travailler, plutôt que de devoir répéter l'opération glob.

Cette abomination semble fonctionner:

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

Cela nécessite probablement bash, pas sh.

Cela fonctionne car l'option nullglob oblige le glob à évaluer une chaîne vide s'il n'y a pas de correspondance. Ainsi, toute sortie non vide de la commande echo indique que le glob correspond à quelque chose.

Je n'ai pas vu cette réponse, alors j'ai pensé l'avoir mise là:

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

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

Explication

Lorsqu'il n'y a pas de correspondance pour glob*, alors $1contiendra 'glob*'. Le test -f "$1"ne sera pas vrai car leglob* fichier n'existe pas.

Pourquoi c'est mieux que des alternatives

Cela fonctionne avec sh et ses dérivés: ksh et bash. Il ne crée aucun sous-shell. $(..)et les `...`commandes créent un sous-shell; ils bifurquent un processus, et sont donc plus lents que cette solution.

Comme ça dans frapper(fichiers de test contenant 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

C'est bien mieux que compgen -G: parce que nous pouvons discriminer plus de cas et plus précisément.

Peut fonctionner avec un seul caractère générique *

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

Notez que cela peut prendre beaucoup de temps s'il y a beaucoup de correspondances ou si l'accès aux fichiers est lent.

#!/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.*"

Ce n'est pas la solution la plus efficace (s'il y a une tonne de fichiers dans le répertoire, cela peut être lent), mais c'est simple, facile à lire et a également l'avantage que les expressions régulières sont plus puissantes que les modèles de glob bash ordinaires.

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