Devo verificare l'esistenza di una variabile in una ifdichiarazione. Qualcosa per l'effetto di:

if [ -v $somevar ]
then
    echo "Variable somevar exists!"
else
    echo "Variable somevar does not exist!"

E la domanda più vicina a questa era questa , che in realtà non risponde alla mia domanda.

In bash moderno (versione 4.2 e successive):

[[ -v name_of_var ]]

Da help test:

-v VAR, True se è impostata la variabile shell VAR

Dipende da cosa vuoi dire esiste .

Ha una variabile che è stato dichiarato, ma non assegnato esiste ?

Does una variabile di matrice (o hash) che è stata assegnata una lista vuota esistono ?

Ha una variabile nameref che punta a una variabile che attualmente non è assegnato esiste ?

Lei ritiene $-, $#, $1variabili? (POSIX no).

Nelle conchiglie tipo Bourne, il modo canonico è:

if [ -n "${var+set}" ]; then
  echo '$var was set'
fi

Che lavora per variabili scalari e altri parametri per sapere se una variabile è stato assegnato un valore (vuoto o meno, automaticamente, dall'ambiente, assigments, read, foro altro).

Per le shell che hanno un comando typeseto declare, che non riporta come impostato le variabili che sono state dichiarate ma non assegnate se non in zsh.

Per le shell che supportano le matrici, ad eccezione di yashe zshche non riportano come variabili array impostate a meno che non sia stato impostato l'elemento di indice 0.

Per bash(ma non ksh93ne zsh), per le variabili di tipo array associativo , che sarebbe senza segnalarli come insieme a meno che il loro elemento di tasto "0" è stato impostato.

Per ksh93e bash, per le variabili di tipo nameref , ciò restituisce true solo se la variabile a cui fa riferimento nameref viene considerata impostata .

Per ksh, zshe bash, un approccio potenzialmente migliore potrebbe essere:

if ((${#var[@]})); then
  echo '$var (or the variable it references for namerefs) or any of its elements for array/hashes has been set'
fi

Per ksh93, zshe bash4.4 o superiore, c'è anche:

if typeset -p var 2> /dev/null | grep -q '^'; then
  echo '$var exists'
fi

Che riporterà le variabili che sono state impostate o dichiarate.

Come menzionato nella risposta su SO , ecco un modo per verificare:

if [ -z ${somevar+x} ]; then echo "somevar is unset"; else echo "somevar is set to '$somevar'"; fi

dove $ {somevar + x} è un'espansione del parametro che restituisce valore null se var non è impostato e sostituisce la stringa "x" in caso contrario.

L'uso -n, come suggerito dall'altra risposta, verificherà solo se la variabile contiene una stringa vuota. Non verificherà la sua esistenza.

POSIXly:

! (: "${somevar?}") 2>/dev/null && echo somevar unset

oppure puoi lasciare che la tua shell mostri il messaggio per te:

(: "${somevar?}")
zsh: somevar: parameter not set

if set|grep '^somevar=' >/dev/null;then
    echo "somevar exists"
else
    echo "does not exist"
fi

printf ${var+'$var exists!\n'}

... non stampa nulla quando non lo fa. O...

printf $"var does%${var+.}s exist%c\n" \ not !

... te lo dirò in entrambi i modi.

è possibile utilizzare il valore restituito di un test per espandere dinamicamente la stringa di formato appropriata per la propria condizione:

[ "${var+1}" ]
printf $"var does%.$?0s exist%c\n" \ not !

Puoi anche printffallire in base a una sostituzione ...

printf $"var does%${var+.}s exist%c\n%.${var+b}d" \
        \ not ! \\c >&"$((2${var+-1}))" 2>/dev/null

... che stampa $var does not exist!su stderr e restituisce diverso da 0 quando $varnon è impostato, ma stampa $var does exist!su stdout e restituisce 0 quando $varè impostato.

Questa semplice linea funziona (e funziona sulla maggior parte delle shell POSIX):

${var+"false"} && echo "var is unset"

Oppure, scritto in una forma più lunga:

unset var

if ${var+"false"}
then
   echo "var is unset"
fi

L'espansione è:

• Se var ha un valore (anche null), false viene sostituito
• Se var ha "nessun valore", viene sostituito "nessun valore" (null).

L' ${var+"false"}espansione si espande in "null" di "false".
Quindi, "niente" o "falso" viene eseguito e il codice di uscita impostato.

Non è necessario chiamare il comando test( [o [[) poiché il valore di uscita è impostato dall'esecuzione dell'espansione stessa.

Il modo di guscio puro:

[ "${var+1}" ] || echo "The variable has not been set"

Script di prova:

#!/bin/sh
echo "Test 1, var has not yet been created"
[ "${var+1}" ] || echo "The variable has not been set"

echo "Test 2, var=1"
var=1
[ "${var+1}" ] || echo "The variable has not been set"

echo "Test 3, var="
var=
[ "${var+1}" ] || echo "The variable has not been set"

echo "Test 4, unset var"
unset var
[ "${var+1}" ] || echo "The variable has not been set"
echo "Done"

risultati:

Test 1, var has not yet been created
The variable has not been set
Test 2, var=1
Test 3, var=
Test 4, unset var
The variable has not been set
Done

Con bash 4.4.19 per me ha funzionato. Ecco un esempio completo

$export MAGENTO_DB_HOST="anyvalue"

#!/bin/bash

if [ -z "$MAGENTO_DB_HOST" ]; then
    echo "Magento variable not set"
else
    echo $MAGENTO_DB_HOST
fi

Non è possibile utilizzare il ifcomando per verificare l'esistenza delle variabili dichiarate in bash, tuttavia l' -vopzione esiste nella bash più recente, ma non è portatile e non è possibile utilizzarla nelle bashversioni precedenti . Perché quando si utilizza una variabile, se non esiste, nascerà allo stesso tempo.

Ad esempio, immagina di non aver usato o assegnato un valore alla MYTESTvariabile, ma quando usi il comando echo non ti mostra nulla! O se lo stai usando if [ -z $MYTEST ]ha restituito un valore zero! Non ha restituito un altro stato di uscita, che indica che questa variabile non esiste!

Ora hai due soluzioni (senza -vopzione):

2. Usando il declarecomando.
3. Usando il setcomando.

Per esempio:

MYTEST=2
set | grep MYTEST
declare | grep MYTEST

Ma sfortunatamente questi comandi mostrano anche le funzioni caricate in memoria! È possibile utilizzare il declare -p | grep -q MYTEST ; echo $?comando per un risultato più pulito.

Funzione per verificare se la variabile è dichiarata / non impostata

compreso vuoto $array=()

Oltre alla risposta di @ Gilles

case " ${!foobar*} " in
  *" foobar "*) echo "foobar is declared";;
  *) echo "foobar is not declared";;
esac

- che non ho trovato un modo per incapsulare all'interno di una funzione - Vorrei aggiungere una versione semplice, che si basa in parte su Richard Hansen 's risposta , ma lo fa anche l'indirizzo della trappola che si verifica con un vuoto array=():

# The first parameter needs to be the name of the variable to be checked.
# (See example below)

var_is_declared() {
    { [[ -n ${!1+anything} ]] || declare -p $1 &>/dev/null;}
}

var_is_unset() {
    { [[ -z ${!1+anything} ]] && ! declare -p $1 &>/dev/null;} 
}

• Testando prima se la variabile è (un) impostata, la chiamata a dichiarare può essere evitata, se non necessaria.
• Se tuttavia $1contiene il nome di un vuoto $array=(), la chiamata a dichiarare assicurerebbe che otteniamo il risultato giusto
• Non ci sono mai molti dati passati a / dev / null poiché declare viene chiamato solo se la variabile non è impostata o un array vuoto.

Con il seguente codice è possibile testare le funzioni:

( # start a subshell to encapsulate functions/vars for easy copy-paste into the terminal
  # do not use this extra parenthesis () in a script!

var_is_declared() {
    { [[ -n ${!1+anything} ]] || declare -p $1 &>/dev/null;}
}

var_is_unset() {
    { [[ -z ${!1+anything} ]] && ! declare -p $1 &>/dev/null;} 
}

:;       echo -n 'a;       '; var_is_declared a && echo "# is declared" || echo "# is not declared"
a=;      echo -n 'a=;      '; var_is_declared a && echo "# is declared" || echo "# is not declared"
a="sd";  echo -n 'a="sd";  '; var_is_declared a && echo "# is declared" || echo "# is not declared"
a=();    echo -n 'a=();    '; var_is_declared a && echo "# is declared" || echo "# is not declared"
a=("");  echo -n 'a=("");  '; var_is_declared a && echo "# is declared" || echo "# is not declared"
unset a; echo -n 'unset a; '; var_is_declared a && echo "# is declared" || echo "# is not declared"
echo ;
:;       echo -n 'a;       '; var_is_unset a && echo "# is unset" || echo "# is not unset"
a=;      echo -n 'a=;      '; var_is_unset a && echo "# is unset" || echo "# is not unset"
a="foo"; echo -n 'a="foo"; '; var_is_unset a && echo "# is unset" || echo "# is not unset"
a=();    echo -n 'a=();    '; var_is_unset a && echo "# is unset" || echo "# is not unset"
a=("");  echo -n 'a=("");  '; var_is_unset a && echo "# is unset" || echo "# is not unset"
unset a; echo -n 'unset a; '; var_is_unset a && echo "# is unset" || echo "# is not unset"
)

Lo script dovrebbe tornare

a;       # is not declared
a=;      # is declared
a="foo"; # is declared
a=();    # is declared
a=("");  # is declared
unset a; # is not declared

a;       # is unset
a=;      # is not unset
a="foo"; # is not unset
a=();    # is not unset
a=("");  # is not unset
unset a; # is unset

funzione bash che funziona sia per i tipi scalari che per quelli di array :

definizione

has_declare() { # check if variable is set at all
    local "$@" # inject 'name' argument in local scope
    &>/dev/null declare -p "$name" # return 0 when var is present
}

invocazione

if has_declare name="vars_name" ; then
   echo "variable present: vars_name=$vars_name"
fi