Como eu comparo uma variável a uma string (e faço alguma coisa se ela corresponder)?

Usando variáveis ​​em instruções if

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

Se você quiser fazer algo quando não corresponder, substitua =por !=. Você pode ler mais sobre operações de string e operações aritméticas na respectiva documentação.

Por que usamos aspas $x?

Você quer as aspas $x, porque se estiver vazio, seu script Bash encontrará um erro de sintaxe, como mostrado abaixo:

if [ = "valid" ]; then

Uso não padrão do ==operador

Observe que o Bash permite ==ser usado para igualdade com [, mas isso não é padrão .

Use o primeiro caso em que as aspas $xsão opcionais:

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

ou use o segundo caso:

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

Ou, se você não precisar de outra 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. Espaços entre ife [e ]são importantes
2. >e <são operadores de redirecionamento, portanto, escape-o com \>e \<respectivamente para cadeias.

Para comparar seqüências de caracteres com caracteres curinga, use

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

Eu tenho que discordar de um dos comentários em um ponto:

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

Não, isso não é um delineador louco

É só que parece que um, hum, o não iniciado ...

Ele usa padrões comuns como uma linguagem, de certa forma;

E depois que você aprendeu o idioma.

Na verdade, é bom ler

É uma expressão lógica simples, com uma parte especial: avaliação lenta dos operadores lógicos.

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

Cada parte é uma expressão lógica; o primeiro pode ser verdadeiro ou falso, os outros dois são sempre verdadeiros.

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

Agora, quando é avaliado, o primeiro é verificado. Se for falso, então o segundo operando da lógica e && depois não é relevante. O primeiro não é verdadeiro, portanto, não pode ser o primeiro e o segundo, de qualquer maneira.
Agora, nesse caso, é o primeiro lado da lógica ou || falso, mas pode ser verdade se o outro lado - a terceira parte - for verdadeiro.

Portanto, a terceira parte será avaliada - principalmente escrevendo a mensagem como efeito colateral. (Tem o resultado 0para true, que não usamos aqui)

Os outros casos são semelhantes, mas mais simples - e - eu prometo! são - podem ser - fáceis de ler!
(Eu não tenho um, mas acho que ser um veterano do UNIX com barba grisalha ajuda muito nisso.)

você também pode usar caso de uso / esac

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

O script a seguir lê de um arquivo chamado "testonthis" linha por linha e, em seguida, compara cada linha com uma string simples, uma string com caracteres especiais e uma expressão regular. Se não corresponder, o script imprimirá a linha, caso contrário não.

O espaço no Bash é muito importante. Portanto, o seguinte funcionará:

[ "$LINE" != "table_name" ] 

Mas o seguinte não:

["$LINE" != "table_name"] 

Então, 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

Eu provavelmente usaria correspondências regexp se a entrada tiver apenas algumas entradas válidas. Por exemplo, apenas o "start" e "stop" são ações válidas.

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

Observe que eu minúscula a variável $ACTIONusando as vírgulas duplas. Observe também que isso não funcionará em versões muito antigas do bash por aí.

Bash 4+ exemplos. Nota: não usar aspas causará problemas quando as palavras contiverem espaços, etc. Sempre cite no Bash, IMO.

Aqui estão alguns exemplos no Bash 4+:

Exemplo 1, verifique 'yes' na string (não faz distinção entre maiúsculas e minúsculas):

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

Exemplo 2, verifique 'yes' na string (não faz distinção entre maiúsculas e minúsculas):

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

Exemplo 3, verifique se 'yes' na string (diferencia maiúsculas de minúsculas):

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

Exemplo 4, verifique se 'yes' na string (diferencia maiúsculas de minúsculas):

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

Exemplo 5, correspondência exata (diferencia maiúsculas de minúsculas):

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

Exemplo 6, correspondência exata (sem distinção entre maiúsculas e minúsculas):

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

Exemplo 7, correspondência exata:

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

Aproveitar.

Fiz dessa maneira que é compatível com 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