Come faccio a confrontare una variabile con una stringa (e fare qualcosa se corrispondono)?

Utilizzo delle variabili in istruzioni if

if [ "$x" = "valid" ]; then
  echo "x has the value 'valid'"
fi

Se vuoi fare qualcosa quando non corrispondono, sostituiscilo =con !=. Puoi leggere ulteriori informazioni sulle operazioni sulle stringhe e sulle operazioni aritmetiche nella rispettiva documentazione.

Perché usiamo le virgolette $x?

Vuoi le virgolette in giro $x, perché se è vuoto, il tuo script Bash rileva un errore di sintassi come mostrato di seguito:

if [ = "valid" ]; then

Uso non standard ==dell'operatore

Si noti che Bash consente ==di essere utilizzato per l'uguaglianza con [, ma questo non è standard .

Utilizzare il primo caso in cui le virgolette intorno $xsono facoltative:

if [[ "$x" == "valid" ]]; then

o usa il secondo caso:

if [ "$x" = "valid" ]; then

Oppure, se non hai bisogno di un'altra clausola:

[ "$x" == "valid" ] && echo "x has the value 'valid'"

a="abc"
b="def"

# Equality Comparison
if [ "$a" == "$b" ]; then
    echo "Strings match"
else
    echo "Strings don't match"
fi

# Lexicographic (greater than, less than) comparison.
if [ "$a" \< "$b" ]; then
    echo "$a is lexicographically smaller then $b"
elif [ "$a" \> "$b" ]; then
    echo "$b is lexicographically smaller than $a"
else
    echo "Strings are equal"
fi

Appunti:

1. Gli spazi tra ife [e ]sono importanti
2. >e <sono operatori di reindirizzamento, quindi evitatelo con \>e \<rispettivamente per le stringhe.

Per confrontare le stringhe con i caratteri jolly utilizzare

if [[ "$stringA" == *$stringB* ]]; then
  # Do something here
else
  # Do Something here
fi

Devo dissentire su uno dei commenti in un punto:

[ "$x" == "valid" ] && echo "valid" || echo "invalid"

No, non è un folle oneliner

Sembra solo uno a, hmm, il non iniziato ...

Utilizza modelli comuni come lingua, in un certo senso;

E dopo aver imparato la lingua.

In realtà, è bello da leggere

È una semplice espressione logica, con una parte speciale: valutazione pigra degli operatori logici.

[ "$x" == "valid" ] && echo "valid" || echo "invalid"

Ogni parte è un'espressione logica; il primo può essere vero o falso, gli altri due sono sempre veri.

(
[ "$x" == "valid" ] 
&&
echo "valid"
)
||
echo "invalid"

Ora, quando viene valutato, viene verificato il primo. Se è falso, il secondo operando della logica e && dopo non è rilevante. Il primo non è vero, quindi non può essere il primo e il secondo essere vero, comunque.
Ora, in questo caso è il primo lato della logica o || falso, ma potrebbe essere vero se l'altro lato - la terza parte - è vero.

Quindi verrà valutata la terza parte, principalmente scrivendo il messaggio come effetto collaterale. (Ha il risultato 0per true, che non usiamo qui)

Gli altri casi sono simili, ma più semplici - e - lo prometto! sono - possono essere - facili da leggere!
(Non ne ho uno, ma penso che essere un veterano UNIX con la barba grigia aiuta molto in questo.)

puoi anche usare use case / esac

case "$string" in
 "$pattern" ) echo "found";;
esac

Lo script seguente legge da un file denominato "testonthis" riga per riga e quindi confronta ogni riga con una stringa semplice, una stringa con caratteri speciali e un'espressione regolare. Se non corrisponde, lo script stamperà la riga, altrimenti no.

Lo spazio in Bash è molto importante. Quindi funzionerà quanto segue:

[ "$LINE" != "table_name" ] 

Ma quanto segue non lo farà:

["$LINE" != "table_name"] 

Quindi per favore usa come è:

cat testonthis | while read LINE
do
if [ "$LINE" != "table_name" ] && [ "$LINE" != "--------------------------------" ] && [[ "$LINE" =~ [^[:space:]] ]] && [[ "$LINE" != SQL* ]]; then
echo $LINE
fi
done

Probabilmente userei le corrispondenze regexp se l'input ha solo poche voci valide. Ad esempio, solo "start" e "stop" sono azioni valide.

if [[ "${ACTION,,}" =~ ^(start|stop)$ ]]; then
  echo "valid action"
fi

Nota che ho minuscolo la variabile $ACTIONusando la doppia virgola. Inoltre, questo non funzionerà su versioni bash troppo vecchie là fuori.

Bash 4+ esempi. Nota: non usare le virgolette causerà problemi quando le parole contengono spazi, ecc. Citano sempre in Bash, IMO.

Ecco alcuni esempi in Bash 4+:

Esempio 1, controlla 'yes' nella stringa (senza distinzione tra maiuscole e minuscole):

    if [[ "${str,,}" == *"yes"* ]] ;then

Esempio 2, controlla "yes" nella stringa (senza distinzione tra maiuscole e minuscole):

    if [[ "$(echo "$str" | tr '[:upper:]' '[:lower:]')" == *"yes"* ]] ;then

Esempio 3, controlla 'yes' nella stringa (case sensitive):

     if [[ "${str}" == *"yes"* ]] ;then

Esempio 4, controlla 'yes' nella stringa (case sensitive):

     if [[ "${str}" =~ "yes" ]] ;then

Esempio 5, corrispondenza esatta (maiuscole e minuscole):

     if [[ "${str}" == "yes" ]] ;then

Esempio 6, corrispondenza esatta (senza distinzione tra maiuscole e minuscole):

     if [[ "${str,,}" == "yes" ]] ;then

Esempio 7, corrispondenza esatta:

     if [ "$a" = "$b" ] ;then

Godere.

L'ho fatto in questo modo compatibile con Bash e Dash (sh):

testOutput="my test"
pattern="my"

case $testOutput in (*"$pattern"*)
    echo "if there is a match"
    exit 1
    ;;
(*)
   ! echo there is no coincidence!
;;esac