Quelle est la manière la plus simple de scripter de vérifier si une variable shell est exportée?

Pour certaines sessions shell, je veux pouvoir imprimer un indicateur d'avertissement si une variable shell n'est pas définie et exportée.

Il est assez simple de faire quelque chose comme ça pour imprimer "Erreur" dans l'invite si SET_MEest non défini ou nul.

test_var () { test -z "$1" && echo Error; }
PS1='$(test_var "$SET_ME") \$ '

Cependant, cela ne parvient pas à marquer si j'ai défini SET_MEsans l'exporter, ce qui est une erreur que je veux pouvoir détecter. À court de quelque chose comme $(bash -c 'test -z "$SET_ME" && echo Error;')ou de saluer la sortie de export, y a-t-il une simple vérification que je peux faire pour tester si elle SET_MEa été exportée?

Une solution non POSIX, bash uniquement est tout à fait acceptable.

Utilisez la declarecommande et l'opérateur de correspondance d'expressions régulières:

test_var () {
    # $1 - name of a shell variable
    var=$1
    [[ -z "${!var}" ]] && echo Error
    [[ $(declare -p $1)  =~ ^declare\ -[aAilrtu]*x[aAilrtu]*\  ]] || echo Error
}

Je sais que la question a 3 ans, mais on peut trouver la solution suivante plus simple:

[ "$(bash -c 'echo ${variable}')" ]

répond, si la variable est exportée et a une valeur non vide.

Dans Bash 4.4 ou version ultérieure , vous pouvez utiliser l' ${parameter@a} expansion des paramètres du shell pour obtenir une liste des attributs d'un paramètre, y compris s'il est exporté.

Voici une fonction simple démontrant ${parameter@a}, qui vous dira si une variable donnée est exportée, compte tenu de son nom:

function is_exported {
    local name="$1"
    if [[ "${!name@a}" == *x* ]]; then
        echo "Yes - '$name' is exported."
    else
        echo "No - '$name' is not exported."
    fi
}

Exemple d'utilisation:

$ is_exported PATH
Yes - 'PATH' is exported.
$ foo=1 is_exported foo
Yes - 'abc' is exported.
$ bar=1; is_exported bar
No - 'abc' is not exported.
$ export baz=1; is_exported baz
Yes - 'baz' is exported.
$ export -n baz; is_exported baz
No - 'baz' is not exported.
$ declare -x qux=3; is_exported qux
Yes - 'qux' is exported.

Comment ça fonctionne:

Le format renvoyé par ${parameter@a}est d'un caractère par attribut, avec la signification de chaque caractère d'attribut provenant des options correspondantes de la commande declare - dans ce cas, nous voulons rechercher x- exporté.

Vous pouvez utiliser compgenavec son -Xoption pour déterminer si une variable est exportée:

compgen -e -X "!$MAY_BE_EXPORTED_VARIABLE"

Par exemple:

$ NOT_EXPORTED="xxx"
$ compgen -e -X '!SHELL'
SHELL
$ compgen -e -X '!NOT_EXPORTED'
$ echo $?
1

Si je me résigne à devoir utiliser exportet grep, le test le plus simple est probablement quelque chose comme ça.

export | grep -Eq '^declare -x SET_ME='

ou si je veux aussi non nul:

export | grep -Eq '^declare -x SET_ME=".+"'

La exportcommande, donnée sans paramètres, donne une liste des noms exportés dans l'environnement actuel:

$ FOO1=test
$ FOO2=test
$ export | grep FOO
$ export FOO2
$ export | grep FOO
declare -x FOO2="test"

Quelques coupures et sédiments se débarrassent des peluches:

export | cut -d' ' -f 3- | sed s/=.*//

Voici votre liste d'exportations, prête pour un traitement ultérieur.

La méthode la plus simple à laquelle je pense actuellement:

[ bash -c ': ${v1?}' 2>/dev/null ]