¿Cómo comparo una variable con una cadena (y hago algo si coinciden)?

Usar variables en declaraciones if

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

Si desea hacer algo cuando no coinciden, reemplace =con !=. Puede leer más sobre las operaciones de cadena y las operaciones aritméticas en su documentación respectiva.

¿Por qué usamos citas $x?

Desea las comillas $x, porque si está vacío, su script Bash encuentra un error de sintaxis como se ve a continuación:

if [ = "valid" ]; then

Uso no estándar del ==operador

Tenga en cuenta que Bash permite ==ser utilizado para igualdad con [, pero esto no es estándar .

Utilice el primer caso en el que las comillas $xson opcionales:

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

o use el segundo caso:

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

O, si no necesita otra cláusula:

[ "$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

Notas:

1. Los espacios entre ify [y ]son importantes
2. >y <son operadores de redireccionamiento, así que escapa con \>y \<respectivamente para cadenas.

Para comparar cadenas con comodines use

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

Tengo que estar en desacuerdo con uno de los comentarios en un punto:

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

No, eso no es una línea loca loca

Es solo que parece uno para, hmm, los no iniciados ...

Utiliza patrones comunes como lenguaje, en cierto modo;

Y después de que aprendiste el idioma.

En realidad, es bueno leer

Es una expresión lógica simple, con una parte especial: evaluación perezosa de los operadores lógicos.

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

Cada parte es una expresión lógica; el primero puede ser verdadero o falso, los otros dos siempre son verdaderos.

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

Ahora, cuando se evalúa, se comprueba el primero. Si es falso, el segundo operando de la lógica y && después no es relevante. El primero no es cierto, por lo que no puede ser el primero y el segundo, de todos modos.
Ahora, en este caso es el primer lado de la lógica o || falso, pero podría ser cierto si el otro lado, la tercera parte, es verdadero.

Entonces se evaluará la tercera parte, principalmente escribiendo el mensaje como un efecto secundario. (Tiene el resultado 0verdadero, que no usamos aquí)

Los otros casos son similares, pero más simples, ¡y lo prometo! son - pueden ser - fáciles de leer!
(No tengo uno, pero creo que ser un veterano de UNIX con barba gris ayuda mucho con esto).

también puedes usar use case / esac

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

El siguiente script lee un archivo llamado "testonthis" línea por línea y luego compara cada línea con una cadena simple, una cadena con caracteres especiales y una expresión regular. Si no coincide, el script imprimirá la línea, de lo contrario no.

El espacio en Bash es muy importante. Entonces lo siguiente funcionará:

[ "$LINE" != "table_name" ] 

Pero lo siguiente no lo hará:

["$LINE" != "table_name"] 

Así que por favor use como está:

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

Probablemente usaría coincidencias regexp si la entrada tiene solo unas pocas entradas válidas. Por ejemplo, solo "iniciar" y "detener" son acciones válidas.

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

Tenga en cuenta que pongo en minúscula la variable $ACTIONusando las comas dobles. También tenga en cuenta que esto no funcionará en versiones de bash demasiado antiguas.

Bash 4+ ejemplos. Nota: no usar comillas causará problemas cuando las palabras contengan espacios, etc. Comillas siempre en Bash, IMO.

Aquí hay algunos ejemplos en Bash 4+:

Ejemplo 1, verifique 'sí' en la cadena (no distingue entre mayúsculas y minúsculas):

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

Ejemplo 2, verifique 'sí' en la cadena (no distingue entre mayúsculas y minúsculas):

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

Ejemplo 3, verifique 'sí' en la cadena (distingue entre mayúsculas y minúsculas):

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

Ejemplo 4, verifique 'sí' en la cadena (distingue entre mayúsculas y minúsculas):

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

Ejemplo 5, coincidencia exacta (mayúsculas y minúsculas):

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

Ejemplo 6, coincidencia exacta (sin distinción entre mayúsculas y minúsculas):

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

Ejemplo 7, coincidencia exacta:

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

Disfrutar.

Lo hice de esta manera que es compatible con Bash y 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