Condições e o Comando test - Linux

Comando test

O comando test verifica a correspondência a uma determinada condição. Ele aceita as seguintes opções:

• test -e $1: verifica se $1 é um arquivo.

• test -f $1: verifica se $1 é um arquivo regular, não um arquivo de dispositivo, diretório ou executável.

• test -d $1: verifica se $1 é um diretório.

• test -x $1: verifica se $1 é um executável. Observe que você também pode verificar outras permissões, como -g, que verifica se a permissão SGID está configurada.

• test $1 -nt $2: verifica se $1 é mais recente que $2.

• test $1 -ot $2: verifica se $1 é mais antigo que $2.

• test $1 -eq $2: verifica se os números $1 e $2 são iguais.

• test $1 -ne $2: verifica se os números $1 e $2 não são iguais.

• test $1 -gt $2: verifica se o número $1 é maior que o número $2.

• test $1 -lt $2: verifica se o número $1 é menor que o número $2.

• test $1 -ge $2: verifica se o número $1 é maior ou igual ao número $2.

• test $1 -le $2: verifica se o número $1 é menor ou igual ao número $2.

• test -z $1: verifica se a variável $1 é uma string vazia.

• test $1: verifica se a variável $1 está definida e não vazia.

• test $1=$2: verifica se as strings $1 e $2 são iguais.

• test $1 != $2: verifica se as strings $1 e $2 são diferentes. Você também pode usar ! com todos os outros comandos test para verificar a negação de uma afirmação.

Para verificar condições, também é possível usar uma forma abreviada, onde todo o comando é colocado entre colchetes e a palavra test é omitida. Por exemplo, em vez de test -f $1, escreve-se [ -f $1 ] (observe os espaços após o colchete de abertura e antes do colchete de fechamento).

Combinação de Condições

Com os operadores especiais && e ||, é possível combinar várias condições em uma única, criando condições mais complexas. Eles têm o seguinte formato:

• comando1 && comando2: se comando1 for bem-sucedido, comando2 será executado.

• comando1 || comando2: se comando1 falhar, comando2 será executado.

Os operandos dessas operações são comandos (qualquer comando). Frequentemente, essas operações usam a condição do comando test.

Por exemplo, para verificar se $path é um arquivo e exibir uma mensagem:

[ -f $path ] && echo $path is a file

A condição inversa seria assim:

[ -f $path ] || echo $path is not a file

Exemplo completo

programicio@Programicio:~$ path=~/Documents/hello.txt
programicio@Programicio:~$ [ -f $path ] && echo $path is a file
/home/programicio/Documents/hello.txt is a file
programicio@Programicio:~$ path=~/Documents/
programicio@Programicio:~$ [ -f $path ] && echo $path is a file
programicio@Programicio:~$ [ -f $path ] || echo $path is not a file
/home/programicio/Documents/ is not a file

Os operadores && e || também podem combinar comandos simples, não necessariamente condições. Por exemplo:

programicio@Programicio:~$ echo "hello" && echo "world"
hello
world

Aqui, dois comandos echo são combinados. A ação do operador && faz com que o segundo comando echo "world" seja executado se o primeiro comando for bem-sucedido.

Outro exemplo:

programicio@Programicio:~$ mkdir ~/Documents/test3 && echo "Folder created"
Folder created

Aqui, o segundo comando, que exibe a mensagem, é executado se a pasta /Documents/test3 for criada com sucesso no diretório pessoal do usuário. Se a pasta não puder ser criada, o segundo comando não será executado:

programicio@Programicio:~$ mkdir ~/Documents/test3 && echo "Folder created"
mkdir: cannot create directory '/home/programicio/Documents/test3': File exists

Neste caso, como a pasta já havia sido criada anteriormente, ocorre um erro e o segundo comando não é executado.

O operador || executa o segundo comando se o primeiro não puder ser executado. Por exemplo:

programicio@Programicio:~$ mkdir ~/Documents/test3 || echo "Unable to create a folder"
mkdir: cannot create directory '/home/programicio/Documents/test3': File exists
Unable to create a folder

De fato, este é o exemplo anterior, onde novamente não é possível criar a pasta no diretório raiz. Como o primeiro comando falha, o segundo comando, que exibe a mensagem apropriada, é executado.

Também podemos combinar ambos os operadores para criar condições mais complexas:

programicio@Programicio:~$ mkdir ~/Documents/test4 && echo "Folder created" || echo "Unable to create a folder"
Folder created
programicio@Programicio:~$ mkdir ~/Documents/test4 && echo "Folder created" || echo "Unable to create a folder"
mkdir: cannot create directory '/home/programicio/Documents/test4': File exists
Unable to create a folder

programicio@Programicio:~$ mkdir ~/Documents/test4 && echo "Folder created" || echo "Unable to create a folder"
Folder created
programicio@Programicio:~$ mkdir ~/Documents/test4 && echo "Folder created" || echo "Unable to create a folder"
mkdir: cannot create directory '/home/programicio/Documents/test4': File exists
Unable to create a folder

Aqui, combinamos três comandos. O primeiro comando cria a pasta:

mkdir ~/Documents/test4

Se a pasta for criada com sucesso, o segundo comando será executado:

echo "Folder created"

Se houver um erro ao criar a pasta, o terceiro comando será executado:

echo "Unable to create a folder"