English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Operadores Básicos do Shell

O Shell, como outras linguagens de programação, suporta vários operadores, incluindo:

  • Operadores aritméticos

  • Operadores de relação

  • 0: ${a} é menor ou igual a ${b}

  • Operadores de string

  • Operadores de teste de arquivo

O bash nativo não suporta operações matemáticas simples, mas pode ser realizado por outros comandos, como awk e expr, sendo o expr o mais usado.

O expr é uma ferramenta de cálculo de expressões, que pode ser usada para avaliar expressões.

Por exemplo, a soma de dois números (Atenção: está sendo usado o backtick `` em vez do aspas simples '"):

#!/bin/bash
val=`expr 2 + 2`
echo "A soma dos dois números é: $val"

Executar o script, o resultado de saída é como follows:

A soma dos dois números é: 4

Dois pontos de atenção:

  •             Deve haver espaços entre a expressão e o operador, por exemplo 2+2 Está errado, deve ser escrito 2 + 2Isso é diferente de muitos dos nossos linguagens de programação familiares.

  •             A expressão completa deve ser contida em ` `, note que este caractere não é o aspas simples comuns, localizado abaixo da tecla Esc.

Operadores aritméticos

A tabela abaixo lista os operadores aritméticos comuns, assumindo que a variável a é 10,a variável b é 2A tabela a seguir lista os operadores booleanos comuns, supondo que a variável ${a} seja

                Operadores                Descrição                Exemplo
                +                Adição                `expr $a + $b` resulta em 30.
                -                Subtração                `expr $a - $b` resulta em -10。
                *                                `expr $a ",* $b` resulta em  200.
                /                Divisão                `expr $b / $a` resulta em 2。
                %                Módulo                `expr $b % $a` resulta em 0.
                =                Atribuição                a=$b atribui o valor da variável b à variável a.
                ==                Igual. Usado para comparar dois números, se iguais, retorna true.                [ $a == $b ] retorna false.
                !=                Diferente. Usado para comparar dois números, se diferentes, retorna true.                [ $a != $b ] retorna true.

Atenção:A expressão de condição deve estar entre colchetes, e deve haver espaços, por exemplo: [$a==$b] está errado, deve ser escrito [ $a == $b ]

Exemplo Online

Exemplos de operadores aritméticos estão abaixo:

Exemplo Online

#!/bin/bash
# autor: Guia Básico
# url:pt.oldtoolbag.com
a=10
b=20
 + $b`
echo "a + b : $val"
 - $b`
echo "a - b : $val"
val=`expr $a ",* $b`
echo "a * b : $val"
val=`expr $b / $a`
echo "b / a : $val"
val=`expr $b % $a`
echo "b % a : $val"
if [ $a == $b ]
then
   echo "a é igual a b"
fi
if [ $a != $b ]
then
   echo "a não é igual a b"
fi

Executar o script, o resultado de saída é como follows:

a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a não é igual a b

Atenção:

  •                     O multiplicador (*O multiplicador (;) deve ser precedido de um backslash (\) para realizar a operação de multiplicação;

  •                     if...then...fi é uma estrutura de controle condicional, que será explicada mais à frente.

  • O sintaxe do expr no shell no MAC é:$((expressão))Aqui, a expressão dentro do "*"Não é necessário escapar o caractere ".\".

Operadores de relação

Operadores de relação suportam apenas números, não suportam strings, a menos que o valor da string seja um número.

Operadores de relação 10,a variável b é 2A tabela a seguir lista os operadores booleanos comuns, supondo que a variável ${a} seja

                    Operadores                    Descrição                    Exemplo
                    -le ${b}: ${a} é maior que ${b}"                    A tabela a seguir lista os operadores de relação comuns, supondo que a variável ${a} seja                    [ ${a} -Verifica se os dois números são iguais, se forem iguais, retorna true.
                    -eq                    eq ${b}] retorna false.                    [ ${a} -Verifica se os dois números são diferentes, se forem diferentes, retorna true.
                    -gt                    ne ${b}] retorna true.                    [ ${a} -Verifica se o número à esquerda é maior que o número à direita, se for, retorna true.
                    -lt                    gt ${b}] retorna false.                    [ ${a} -Verifica se o número à esquerda é menor que o número à direita, se for, retorna true.
                    -0: ${a} não é maior que ${b}                    lt ${b}] retorna true.                    [ ${a} -Verifica se o número à esquerda é maior ou igual ao número à direita, se for, retorna true.
                    -0: ${a} é menor que ${b}                    ge ${b}] retorna false.                    [ ${a} -Verifica se o número à esquerda é menor ou igual ao número à direita, se for, retorna true.

Exemplo Online

le ${b}] retorna true.

#!/bin/bash
# autor:Basic Tutorial Website
# url:pt.oldtoolbag.com
a=10
b=20
if [ $a -Exemplos de operadores de relação a seguir:
then
   le ${b}: ${a} é menor ou igual a ${b}" -eq ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -eq ${b}: ${a} é igual a ${b}"
fi
if [ $a -eq ${b}: ${a} não é igual a ${b}"
then
   le ${b}: ${a} é menor ou igual a ${b}" -ne ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -ne ${b}: ${a} não é igual a ${b}"
fi
if [ $a -ne ${b}: ${a} é igual a ${b}"
then
   le ${b}: ${a} é menor ou igual a ${b}" -gt ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -gt ${b}: ${a} é maior que ${b}"
fi
if [ $a -gt ${b}: ${a} não é maior que ${b}"
then
   le ${b}: ${a} é menor ou igual a ${b}" -lt ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -lt ${b}: ${a} é menor que ${b}"
fi
if [ $a -lt ${b}: ${a} não é menor que ${b}"
then
   le ${b}: ${a} é menor ou igual a ${b}" -ge ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -ge ${b}: ${a} é maior ou igual a ${b}"
fi
if [ $a -ge ${b}: ${a} é menor que ${b}"
then
   le ${b}: ${a} é menor ou igual a ${b}" -le ${b}]
else
   le ${b}: ${a} é menor ou igual a ${b}" -echo "${a}
fi

Executar o script, o resultado de saída é como follows:

10 -le ${b}: ${a} é maior que ${b}" 2ne
10 -eq 2ne
10 -gt 20: ${a} não é igual a ${b}
10 -lt 2ge
10 -0: ${a} não é maior que ${b} 2ge
10 -0: ${a} é menor que ${b} 2le

0: ${a} é menor ou igual a ${b}

Operadores booleanos 10,a variável b é 2A tabela a seguir lista os operadores booleanos comuns, supondo que a variável ${a} seja

                    Operadores                    Descrição                    Exemplo
                    0:                    !                    [ ! false ] retorna true.
                    -o                    Operação lógica OR, retorna true se pelo menos uma das expressões for true.                    [ ${a} -lt 20 -o ${b} -gt 100 ] retorna true.
                    -a                    Operação lógica AND, retorna true apenas se ambos os expressões forem true.                    [ ${a} -lt 20 -a ${b} -gt 100 ] retorna false.

Exemplo Online

Exemplos de operadores booleanos a seguir:

#!/bin/bash
# autor: Guia Básico
# url:pt.oldtoolbag.com
a=10
b=20
if [ $a != $b ]
then
   echo "$a != $b: a não é igual a b"
else
   echo "${a} == ${b}: ${a} é igual a ${b}"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
   echo "$a menor 100: e $b maior 15 : retorna true"
else
   echo "$a menor 100: e $b maior 15 : retorna false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
   echo "$a menor 100: ou $b maior 100: retorna true"
else
   echo "$a menor 100: ou $b maior 100: retorna false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
   echo "$a menor 5 ou $b maior 100: retorna true"
else
   echo "$a menor 5 ou $b maior 100: retorna false"
fi

Executar o script, o resultado de saída é como follows:

10 != 20: a não é igual a b
10 menor 100: e 20: maior 15 : retorna true
10 menor 100: ou 20: maior 100: retorna true
10 menor 5 ou 20: maior 100: retorna false

Operadores lógicos

A seguir, apresentamos os operadores lógicos do Shell, supondo que a variável a seja 10,a variável b é 20:

                    Operadores                    Descrição                    Exemplo
                    &&                    AND lógico                    [[ $a -lt 100 && $b -gt 100 ]] retorna false
                    ||                    OR lógico                    [[ $a -lt 100 || $b -gt 100 ]] retorna true

Exemplo Online

Exemplos de operadores lógicos como follows:

#!/bin/bash
# autor:Basic Tutorial Website
# url:pt.oldtoolbag.com
a=10
b=20
if [[ $a -lt 100 && $b -gt 100 ]]
then
   echo "Retorna true"
else
   echo "Retorna false"
fi
if [[ $a -lt 100 || $b -gt 100 ]]
then
   echo "Retorna true"
else
   echo "Retorna false"
fi

Executar o script, o resultado de saída é como follows:

Retorna false
Retorna true

Operadores de string

A tabela a seguir lista os operadores de string comuns, supondo que a variável a seja "abc", a variável b seja "efg":

                    Operadores                    Descrição                    Exemplo
                    =                    Verificar se duas strings são iguais, se forem iguais retorna true.                    [ $a = $b ] retorna false.
                    !=                    Verificar se duas strings são diferentes, se forem diferentes retorna true.                    [ $a != $b ] retorna true.
                    -z                    Verificar se o comprimento da string é 0, se for 0 retorna true.                    [ -z $a ] retorna false.
                    -n                    Verificar se o comprimento da string não é 0, se não for 0 retorna true.                    [ -n "$a" ] retorna true.
                    $                    Verificar se a string está vazia, se não estiver vazia retorna true.                    [ $a ] retorna true.

Exemplo Online

Exemplos de operadores de string como follows:

#!/bin/bash
# autor:Basic Tutorial Website
# url:pt.oldtoolbag.com
a="abc"
b="efg"
if [ $a = $b ]
then
   echo "$a = $b: a é igual a b"
else
   echo "$a = $b: a não é igual a b"
fi
if [ $a != $b ]
then
   echo "$a != $b: a não é igual a b"
else
   echo "$a != $b: a é igual a b"
fi
if [ -z $a ]
then
   echo "}}-z $a: comprimento da string é 0"
else
   echo "}}-z $a: comprimento da string não é 0"
fi
if [ -n "$a" ]
then
   echo "}}-n $a: comprimento da string não é 0"
else
   echo "}}-n $a : o comprimento da string é 0"
fi
if [ $a ]
then
   echo "$a : a string não está vazia"
else
   echo "$a : a string está vazia"
fi

Executar o script, o resultado de saída é como follows:

abc = efg: a não é igual a b
abc != efg : a não é igual a b
-z abc : o comprimento da string não é 0
-n abc : o comprimento da string não é 0
abc : a string não está vazia

Operadores de teste de arquivo

Os operadores de teste de arquivo são usados para verificar várias propriedades de arquivos Unix.

A descrição das propriedades dos atributos dos arquivos é como follows:

                    Operador                    Descrição                    Exemplo
                    -b file                    Verifica se o arquivo é um arquivo de dispositivo de bloco, se sim, retorna true.                    [ -b $file ] retorna false.
                    -c file                    Verifica se o arquivo é um arquivo de dispositivo de caractere, se sim, retorna true.                    [ -c $file ] retorna false.
                    -d file                    Verifica se o arquivo é um diretório, se sim, retorna true.                    [ -d $file ] retorna false.
                    -f file                    Verifica se o arquivo é um arquivo comum (não é diretório, nem dispositivo), se sim, retorna true.                    [ -f $file ] retorna true.
                    -g file                    Verifica se o arquivo tem o bit SGID configurado, se sim, retorna true.                    [ -g $file ] retorna false.
                    -k file                    Verifica se o arquivo tem o bit Sticky Bit configurado, se sim, retorna true.                    [ -k $file ] retorna false.
                    -p file                    Verifica se o arquivo é um pipe nomeado, se sim, retorna true.                    [ -p $file ] retorna false.
                    -u file                    Verifica se o arquivo tem o bit SUID configurado, se sim, retorna true.                    [ -u $file ] retorna false.
                    -r file                    Verifica se o arquivo é legível, se sim, retorna true.                    [ -r $file ] retorna true.
                    -w file                    Verifica se o arquivo é gravável, se sim, retorna true.                    [ -w $file ] retorna true.
                    -x file                    Verifica se o arquivo é executável, se sim, retorna true.                    [ -x $file ] retorna true.
                    -s file                    Verifica se o arquivo está vazio (se o tamanho do arquivo é maior que 0), se não estiver vazio, retorna true.                    [ -s $file ] retorna true.
                    -e file                    Verifica se o arquivo (inclusive dos diretórios) existe, se sim, retorna true.                    [ -e $file ] retorna true.

Outros símbolos de verificação:

  • -S: Determinar se um arquivo é socket.

  • -L: Verificar se o arquivo existe e é um link simbólico.

Exemplo Online

A variável file representa o arquivo /var/www/w3codebox/test.shtamanho de 100 bytes, com rwx Permissões. O código a seguir verificará as várias propriedades do arquivo:
#!/bin/bash
# autor:Basic Tutorial Website
# url:pt.oldtoolbag.com
file="/var/www/w3codebox/test.sh"
if [ -r $file ]
then
   echo "O arquivo é legível"
else
   echo "O arquivo não é legível"
fi
if [ -w $file ]
then
   echo "O arquivo é gravável"
else
   echo "O arquivo não é gravável"
fi
if [ -x $file ]
then
   echo "O arquivo é executável"
else
   echo "O arquivo não é executável"
fi
if [ -f $file ]
then
   echo "O arquivo é um arquivo comum"
else
   echo "O arquivo é um arquivo especial"
fi
if [ -d $file ]
then
   echo "O arquivo é um diretório"
else
   echo "O arquivo não é um diretório"
fi
if [ -s $file ]
then
   echo "O arquivo não está vazio"
else
   echo "O arquivo está vazio"
fi
if [ -e $file ]
then
   echo "O arquivo existe"
else
   echo "O arquivo não existe"
fi

Executar o script, o resultado de saída é como follows:

O arquivo é legível
O arquivo é gravável
O arquivo é executável
O arquivo é um arquivo comum
O arquivo não é um diretório
O arquivo não está vazio
O arquivo existe