Pesquisa de site

Operadores de teste no Bash [folha de dicas]

Dê uma breve olhada em todos os operadores de teste disponíveis no bash.

Quando você se aprofunda um pouco no Linux, percebe que ele depende muito dos scripts bash e, quando você abre os scripts bash, vê muitos símbolos como !=, -lt e ==.

E tenho certeza que se você não gosta de programação, eles pareceriam confusos.

Portanto, neste tutorial, apresentarei exemplos de todos os operadores de teste disponíveis no bash.

Mas antes de explicar a parte dos exemplos, vamos dar uma olhada em quais operadores de teste você obtém no bash e seu uso.

Lista de operadores de teste no bash

Os operadores de teste em scripts bash ajudam a avaliar as condições, como se você desejasse executar um bloco de código específico com base no fato de a condição ser verdadeira ou não.

E aqui está uma lista de operadores de teste que você obtém no bash:

Operadores de teste para comparação de inteiros

-eq

Igual a

-ne

Não é igual a

-lt

Menor que

-le

Menor ou igual a

-gt

Maior que

-ge

Maior ou igual a

<=

Menor ou igual a (usado dentro de (()))

>=

Maior ou igual a (usado dentro de (()))

Operadores de teste Bash para comparação composta

-a

Operador lógico AND, semelhante a &&

-o

Operador lógico OR, semelhante a ||

Operadores de comparação de strings

=

É igual a (mas para strings)

!=

Diferente de (para strings)

<

Menor que (em ordem alfabética ASCII)

>

Maior que (em ordem alfabética ASCII)

==

Duplo é igual a (usado para comparar duas strings)

-z

A string é nula

-n

A String não é nula

Operadores de teste de arquivo

-e

Verifique se o arquivo existe em um determinado caminho.

-f

Verifique se o caminho do arquivo fornecido aponta para um arquivo normal ou não.

-d

Verifique se o caminho fornecido se refere a um diretório existente ou não.

-h

Descobre se o caminho fornecido é um link simbólico.

-L

Ele verifica o link simbólico como -h, mas também verifica se ele resolve para um arquivo ou diretório real.

-b

Verifica o dispositivo de bloco.

-c

Verifica o arquivo especial de caracteres.

-p

Verifica se há um pipe nomeado (FIFO).

-s

Usado para descobrir se o tamanho do arquivo é maior que zero ou não.

-t

Verifique se o descritor de arquivo está associado ao terminal ou não.

-r

Usado para descobrir se o arquivo é legível ou não.

-w

Verifica se o arquivo tem permissão de gravação ou não.

-x

Ele verifica as permissões executáveis de um arquivo especificado.

-g

Verifica a permissão "set-group-ID" (SGID) definida em um arquivo específico.

-u

Verifica a permissão "set-user-ID" (SUID) definida em um arquivo específico.

-k

Procure se o bit "fixo" está definido ou não em um diretório especificado.

-O

Verifique se o arquivo existe e pertence ao usuário atual.

-G

Verifique se o arquivo existe e pertence ao mesmo grupo que o usuário que está executando o script.

-N

Ajuda a verificar se o arquivo foi modificado desde a última leitura.

-nt

Compara o tempo de modificação de dois arquivos e determina qual deles é mais recente.

-ot

Isso também compara o tempo de modificação de dois arquivos e determina qual deles é mais antigo.

-ef

Verifique se dois caminhos de arquivo referem-se ao mesmo inode no sistema.

!

Reverte o resultado de uma condição ou comando.

Agora, vamos dar uma olhada nos exemplos de cada operador de teste listado acima.

Exemplos de operadores de teste no bash

Esta seção está dividida em quatro categorias:

  • Operadores de comparação inteira

  • Operadores de comparação de strings

  • Comparação composta

  • Operadores de teste de arquivo

Então vamos começar com o primeiro.

Operadores de comparação inteira

Os operadores de comparação de inteiros no bash são usados para comparar valores inteiros com instruções condicionais.

Usando esses operadores, você pode comparar dois números inteiros de várias maneiras, como igualdade, desigualdade, maior que, menor que, etc.

Então, vamos dar uma olhada nos operadores de comparação de números inteiros no bash com exemplos.

1. O operador -eq (igual a)

O operador -eq no bash é usado para comparar dois valores numéricos e verificar se eles são iguais.

Para maior compreensão, aqui usei um script bash simples que irá comparar dois valores e imprimir se eles são iguais ou não:

#!/bin/bash

number1=5
number2=5

if [ "$number1" -eq "$number2" ]; then
    echo "The numbers are equal."
else
    echo "The numbers are not equal."
fi

Quando executei o script acima, ele me deu a seguinte saída:

Como você pode ver, as variáveis number1 e number2 mantinham o mesmo valor, então me deram uma saída dizendo "Os números são iguais".

2. O operador -ne (diferente de)

O operador -ne faz o oposto do -eq comparando dois operadores para verificar se eles não são iguais.

Para sua referência, aqui está um script bash semelhante ao acima, mas desta vez usei valores diferentes para ambas as variáveis:

#!/bin/bash

number1=5
number2=10

if [ "$number1" -ne "$number2" ]; then
    echo "The numbers are not equal."
else
    echo "The numbers are equal."
fi

Quando executei o script acima, ele me deu uma saída dizendo que as variáveis não são iguais:

3. O operador -lt (menor que)

Como o nome sugere, usando o operador -lt, você pode determinar se a primeira variável é menor que a segunda variável.

Aqui está um script simples onde comparei duas variáveis para verificar se number1 é menor que number2 ou não:

#!/bin/bash

number1=5
number2=10

if [ "$number1" -lt "$number2" ]; then
    echo "number1 is less than number2."
else
    echo "number1 is not less than number2."
fi

Quando executei o script acima, recebi a seguinte saída dizendo que o número1 é menor que o número2:

4. O operador -le (menor ou igual a)

Como o nome sugere, o operador -le é usado para comparar dois valores inteiros e verificar se o primeiro inteiro é menor ou igual ao segundo.

Aqui está um script bash simples que explica como você pode usar o operador -le:

#!/bin/bash

number1=5
number2=10

if [ "$number1" -le "$number2" ]; then
    echo "number1 is less than or equal to number2."
else
    echo "number1 is greater than number2."
fi

Você consegue adivinhar a saída? O número1 deve ser menor ou igual ao número2 e me deu a mesma saída quando executei o script acima:

5. O operador -gt (maior que)

O operador -gt é usado para comparar dois valores e descobrir se a primeira variável é maior que a segunda.

Veja como você pode usar o operador -gt no bash para comparar duas variáveis:

#!/bin/bash

number1=10
number2=5

if [ "$number1" -gt "$number2" ]; then
    echo "number1 is greater than number2."
else
    echo "number1 is not greater than number2."
fi

Quando executei o script acima, recebi a seguinte saída dizendo "número1 é maior que número2":

6. O operador -ge (maior ou igual a)

O operador -ge no bash é usado para determinar se um número inteiro é maior ou igual a outro.

Por exemplo, aqui está um script bash comparando dois números inteiros com o operador -ge:

#!/bin/bash

number1=10
number2=5

if [ "$number1" -ge "$number2" ]; then
    echo "number1 is greater than or equal to number2."
else
    echo "number1 is not greater than or equal to number2."
fi

O número1 deve ser maior ou igual ao número2. Certo?:

7. O operador < (menor que)

Quando você usa o operador < dentro de (()), ele pode ser usado para fazer comparações aritméticas entre dois valores.

Por exemplo, aqui usei < para comparar duas variáveis:

#!/bin/bash

number1=5
number2=10

if ((number1 < number2)); then
    echo "number1 is less than number2."
else
    echo "number1 is not less than number2."
fi

Aqui está o que obtive quando executei o script acima:

8. O operador > (maior que)

Ao usar o operador > dentro de (()), você pode comparar duas variáveis e descobrir qual é a maior.

Por exemplo, aqui usei o operador > para comparar duas variáveis:

#!/bin/bash

number1=10
number2=5

if ((number1 > number2)); then
    echo "number1 is greater than number2."
else
    echo "number1 is not greater than number2."
fi

Se você executar o script acima, você receberá uma saída dizendo "número1 é maior que número2.":

9. O operador <= (menor ou igual a)

Quando você usa o operador <= dentro de (()), ele oferece a mesma funcionalidade que o -le. O que significa que usando o operador <=, você pode comparar duas variáveis e descobrir se uma é menor ou igual à outra.

Para demonstrar como você pode usar o operador <=, consulte o seguinte script:

#!/bin/bash

number1=5
number2=10

if ((number1 <= number2)); then
    echo "number1 is less than or equal to number2."
else
    echo "number1 is greater than number2."
fi

Quando executado, me deu a seguinte saída:

10. O operador >= (maior ou igual a)

Você adivinhou certo? Usando o operador >= você pode comparar duas variáveis e descobrir se uma é maior ou igual à outra.

Para referência adicional, você pode usar o seguinte script bash:

#!/bin/bash

number1=5
number2=10

if ((number1 <= number2)); then
    echo "number1 is less than or equal to number2."
else
    echo "number1 is greater than number2."
fi

Como a variável number1 é menor que number2, ela me deu a seguinte saída:

Operadores de comparação de strings

Como o nome sugere, os operadores de comparação de strings são usados para comparar duas strings e para determinar a diferença entre duas strings.

Existem diferentes operadores de comparação de strings, como igualdade, desigualdade, ordem alfabética e muito mais.

Então vamos começar com o primeiro.

1. O operador = (igual a)

O operador = serve para comparar duas strings e descobrir se elas contêm o mesmo conjunto de caracteres (string) ou não.

Para sua referência, comparei aqui duas strings usando o operador =:

#!/bin/bash

str1="apple"
str2="banana"

if [ "$str1" = "$str2" ]; then
    echo "str1 is equal to str2."
else
    echo "str1 is not equal to str2."
fi

Como as strings no script acima possuem um valor diferente, recebi uma saída dizendo "str1 não é igual a str2.":

2. O operador != (diferente de)

O operador != no bash é usado para comparar duas strings e determinar se duas strings não são iguais.

Por exemplo, aqui usei um script bash simples para demonstrar como você pode usar o operador != para comparar strings:

#!/bin/bash

str1="apple"
str2="banana"

if [ "$str1" != "$str2" ]; then
    echo "str1 is not equal to str2."
else
    echo "str1 is equal to str2."
fi

Ambas as strings str1 e str2 contêm diferentes conjuntos de caracteres, me deram uma saída dizendo "str1 não é igual a str2.":

3. O operador == (duplo igual a)

Ao contrário de outros operadores, == se comporta de maneira diferente na forma como você cita a string correspondente.

  • Correspondência de padrões

  • Correspondência literal  (semelhante ao operador =)

Então, vamos começar com a correspondência de padrões.

Correspondência de padrões usando o operador ==

Este é simples. Você usa uma string e, em seguida, usa instruções condicionais para corresponder ao padrão e descobrir se a string é válida de acordo com o padrão.

Por exemplo, aqui usei um script bash simples que encontrará uma string começando com z. (essa é a razão pela qual usei "$a" == z*):

#!/bin/bash

a="zebra"
if [[ "$a" == z* ]]; then
    echo "Pattern matched: 'a' starts with 'z'."
else
    echo "Pattern not matched: 'a' doesn't start with 'z'."
fi

Como a zebra começa com z, ela me deu a seguinte saída:

Correspondência literal usando o operador ==

Como o nome sugere, ele corresponde literalmente à própria string, fornecendo resultados semelhantes aos do operador =.

Para sua referência, aqui usei uma string contendo z* e fiz a correspondência literal usando o operador ==:

#!/bin/bash

a="z*"
if [[ "$a" == "z*" ]]; then
    echo "Literal match: 'a' is 'z*'."
else
    echo "Literal mismatch: 'a' is not 'z*'."
fi

Como a string a contém z*, ela me deu o seguinte resultado:

4. O operador < (menor que) [para strings]

Quando você usa o operador < dentro de [[]], ele compara duas strings e descobre qual delas é menor que a outra em termos de ordem alfabética.

Deixe-me dar um exemplo para melhor compreensão.

Aqui está um script bash simples que compara duas strings apple e banana:

#!/bin/bash

str1="apple"
str2="banana"

if [[ "$str1" < "$str2" ]]; then
    echo "str1 comes before str2."
else
    echo "str1 does not come before str2."
fi

Como a palavra maçã vem antes da palavra banana, recebi uma saída dizendo "str1 vem antes de str2.":

5. O operador > (maior que) [para strings]

Semelhante ao operador <, o operador > quando usado dentro de [[]], ele pode ser usado para comparar duas strings e descobrir qual é maior que o outro em termos de ordem alfabética.

Veja como você pode usar o operador > em um script bash:

#!/bin/bash

str1="apple"
str2="banana"

if [[ "$str1" > "$str2" ]]; then
    echo "str1 comes before str2."
else
    echo "str2 comes before str1."
fi

Como string1 vem antes de string2, você pode esperar a seguinte saída:

6. O operador -z

O operador -z no bash é usado para descobrir se a string está vazia ou não.

Por exemplo, aqui usei uma string vazia para demonstrar como você pode usar o operador -z em um script bash:

#!/bin/bash

my_string=""

if [ -z "$my_string" ]; then
    echo "The string is empty."
else
    echo "The string is not empty."
fi

Como a string estava vazia, me deu a seguinte saída:

7. O operador -n

O operador -n é exatamente o oposto do operador -z, pois é usado para encontrar strings não vazias.

Veja como você pode implementar o operador -n em um script bash para encontrar as strings não vazias:

#!/bin/bash

string="Non-empty string"

if [ -z "$string" ]; then
    echo "The string is empty."
else
    echo "The string is not empty."
fi

Como a string tinha alguns caracteres armazenados dentro dela, ela me deu a seguinte saída:

Operadores de comparação compostos

Os operadores de comparação compostos no bash também são conhecidos como operadores lógicos, pelos quais você pode combinar várias expressões para formar uma expressão complexa.

Existem 3 operadores de comparação compostos no bash:

  • && (operador lógico AND)

  • || (operador lógico OR)

  • ! (operador lógico NÃO )

Então vamos começar com o primeiro.

1. O operador && (AND)

Se você usar o operador && para combinar duas ou mais expressões, elas só serão executadas (retornarão o status de saída 0), se todas as expressões forem verdadeiras.

Por exemplo, aqui está um script simples informando como cada expressão deve ser verdadeira para que a execução seja bem-sucedida:

#!/bin/bash

age=25
income=50000

if [ "$age" -ge 18 ] && [ "$income" -ge 40000 ]; then
    echo "You are eligible for the loan."
else
    echo "You are not eligible for the loan."
fi

Como você pode ver, ambas as condições combinadas por meio do operador && eram verdadeiras e me deram a seguinte saída:

2. O operador || (OR)

Quando você combina duas expressões usando o operador ||, a execução será bem-sucedida se uma delas for verdadeira.

Isso significa que se uma das duas expressões satisfizer a condição fornecida, ela retornará o status de saída 0 (indicando execução bem-sucedida).

Por exemplo, aqui está um script bash simples que exige que a idade seja menor que 18 ou maior que 65:

#!/bin/bash

age=15

if [ "$age" -lt 18 ] || [ "$age" -ge 65 ]; then
    echo "You are eligible for a discount."
else
    echo "You do not qualify for a discount."
fi

Como a variável idade tem valor 15, deu, me deu o seguinte:

3. O operador ! (NÃO)

O operador NOT ! nega o efeito do operador.

Em termos simples, alterará o efeito do operador. Por exemplo, se eu usar o operador NOT após =, isso fará com que não seja igual a.

Aqui está um script bash simples onde inicializei uma variável is_raining como true e mais tarde usei o operador ! para negar o efeito:

#!/bin/bash

is_raining=true

if ! [ "$is_raining" = true ]; then
    echo "It's not raining. You can go outside."
else
    echo "It's raining. Stay indoors."
fi

À medida que o efeito foi alterado, ele falsificou o valor de is_raining e me deu a seguinte saída:

Operadores de teste de arquivo

Como o nome sugere, os operadores de teste de arquivo são usados para realizar vários testes em arquivos e diretórios.

Nesta seção, orientarei você através de vários operadores de teste de arquivo com exemplos simples de script bash para que você possa ter uma ideia melhor de como usá-los.

1. O operador -e

Usando o operador -e, você pode verificar se o arquivo existe ou não usando o caminho absoluto ou relativo.

Por exemplo, no script bash a seguir, verifiquei se o arquivo Hello.txt existe dentro do diretório /home/sagar:

#!/bin/bash

user_file="/home/sagar/Hello.txt"

if [ -e "$user_file" ]; then
    echo "The file $user_file exist at the given path."
else
    echo "The file $user_file does not exist at given path."
fi

No script acima, o user_file foi usado para armazenar o caminho absoluto para o arquivo Hello.txt e quando executado, me deu o seguinte resultado:

2. O operador -f

O operador -f é usado para descobrir se o caminho fornecido aponta para um arquivo normal ou não. Uma maneira fácil de verificar uma entrada válida!

Por exemplo, aqui verifiquei se o file.txt no diretório de trabalho atual é um arquivo normal ou não:

#!/bin/bash

file_path="file.txt"

if [ -f "$file_path" ]; then
    echo "$file_path is a regular file."
else
    echo "$file_path is not a regular file."
fi

Como criei o arquivo file.txt no diretório de trabalho atual (no mesmo diretório onde o script está localizado), obtive a seguinte saída:

3. O operador -d

O operador -d é usado para testar se um determinado ponto está ou não em um diretório.

Por exemplo, no script a seguir, eu queria descobrir se /home/sagar/New é um diretório ou não com a ajuda do operador -d:

#!/bin/bash

directory_path="/home/sagar/New"

if [ -d "$directory_path" ]; then
    echo "$directory_path is a directory."
else
    echo "$directory_path is not a directory or does not exist."
fi

Como /home/sagar/New era um diretório, ele me deu a seguinte saída:

4. O operador -h

Usando o operador -h, você pode identificar se o caminho fornecido aponta para um link simbólico ou não.

Por exemplo, aqui, criei um link simbólico chamado File_link para Hello.txt dentro do meu diretório de trabalho atual:

ln -s ~/Hello.txt Symbolic_Link

Em seguida, usei o operador -h no script bash para identificar o link simbólico:

#!/bin/bash

link_path="File_link"

if [ -h "$link_path" ]; then
    echo "$link_path is a symbolic link."
else
    echo "$link_path is not a symbolic link or does not exist."
fi

Como o File_link era um link simbólico, ele me deu a seguinte saída:

5. O operador -b

O operador -b no bash é usado para descobrir se o caminho do arquivo fornecido está apontando para um dispositivo de bloco ou não.

Por exemplo, no script bash a seguir, usei /dev/sda para testar se o -b operador pode realmente identificar o dispositivo de bloco ou não:

#!/bin/bash

file_path="/dev/sda"

if [ -b "$file_path" ]; then
    echo "$file_path is a block special file (block device)."
else
    echo "$file_path is not a block special file."
fi

Ele me deu o seguinte encontrado quando executado:

6. O operador -c

O operador -c no bash é usado para identificar se o caminho do arquivo fornecido está apontando para um arquivo de caracteres ou não.

Você encontrará vários arquivos de caracteres dentro do diretório /dev/ que podem ser listados usando o comando ls no seguinte caso:

ls -l /dev/

A permissão do arquivo começará com c indicando que o arquivo é um arquivo de caracteres:

Por exemplo, aqui, escrevi um script com um caminho para /dev/full e identifiquei se é um arquivo de caracteres ou não:

#!/bin/bash

file_path="/dev/full"

if [ -c "$file_path" ]; then
    echo "$file_path is a character special file."
else
    echo "$file_path is not a character special file."
fi

Isso me deu a seguinte saída:

7. O operador -p

O operador -p no bash é usado para identificar se o caminho fornecido está apontando para um arquivo de pipe nomeado (FIFO).

Você pode criar um arquivo pipe usando o comando mkfifo. Por exemplo, aqui, criei um arquivo pipe nomeado  LHB_Sagar no diretório de trabalho atual

mkfifo LHB_Sagar

Em seguida, usei o operador -p no script bash para verificar se ele realmente consegue identificar o arquivo pipe nomeado criado:

#!/bin/bash

file_path="LHB_Sagar"

if [ -p "$file_path" ]; then
    echo "$file_path is a named pipe (FIFO)."
else
    echo "$file_path is not a named pipe."
fi

Quando executado, ele identificou com sucesso o arquivo pipe nomeado:

8. O operador -S

O operador -S no bash é usado para identificar se o caminho do arquivo fornecido está apontando para um arquivo de soquete ou não.

Por exemplo, aqui, escrevi um script simples para identificar se o arquivo /var/run/snapd.socket é um arquivo socket ou não:

#!/bin/bash

socket_file="/var/run/snapd.socket"

if [ -S "$socket_file" ]; then
    echo "$socket_file is a socket file."
else
    echo "$socket_file is not a socket file or does not exist."
fi

Ele identificou o arquivo de soquete com sucesso e me deu a seguinte saída:

9. O operador -s

O operador -s no bash serve para identificar se o caminho do arquivo fornecido está apontando para um arquivo não vazio ou não.

Por exemplo, aqui criei um arquivo de texto simples chamado my_file.txt que contém a seguinte linha de texto:

Como o arquivo my_file.txt contém algum conteúdo de texto, agora é um arquivo diferente de zero, então vamos usá-lo no script para testar o operador -s:

#!/bin/bash

file="my_file.txt"

if [ -s "$file" ]; then
    echo "$file is not empty."
else
    echo "$file is empty or does not exist."
fi

Aqui está o que obtive após executar o script acima:

10. O operador -t

O operador -t no bash é usado para descobrir se o descritor de arquivo está associado (stdin, stdout e stderr) ao terminal ou não.

Na maioria dos casos, todos os descritores de arquivo estarão associados ao terminal.

Aqui está um script bash que permitirá que você saiba quais descritores de arquivo estão associados à sessão de terminal atual:

#!/bin/bash

if [ -t 0 ]; then
  echo "File descriptor 0 (standard input) is connected to a terminal."
else
  echo "File descriptor 0 (standard input) is not connected to a terminal."
fi

if [ -t 1 ]; then
  echo "File descriptor 1 (standard output) is connected to a terminal."
else
  echo "File descriptor 1 (standard output) is not connected to a terminal."
fi

if [ -t 2 ]; then
  echo "File descriptor 2 (standard error) is connected to a terminal."
else
  echo "File descriptor 2 (standard error) is not connected to a terminal."
fi

Se você executar o script acima, obterá a seguinte saída:

Mas se eu redirecionar o fluxo de dados de erro, ele não fornecerá mais a mesma saída:

11. O operador -r

O operador -r no bash é usado para identificar se o arquivo especificado tem permissões de leitura ou não para o usuário que executa o script.

Por exemplo, aqui, usei o operador -e primeiro para verificar se o arquivo Hello.txt existe e, se existir, ele usará o Operador -r:

#!/bin/bash

filename="Hello.txt"

if [ -e "$filename" ]; then
  if [ -r "$filename" ]; then
    echo "File '$filename' exists and has read permission."
  else
    echo "File '$filename' exists but does not have read permission."
  fi
else
  echo "File '$filename' does not exist."
fi

Quando executado, me deu a seguinte saída:

12. O operador -w

O operador -w é usado para descobrir se o arquivo tem permissão de gravação para um usuário executando um script ou não.

Por exemplo, aqui, usei o operador -e para validar a existência do arquivo Hello.txt e posteriormente usei o -w operador para descobrir se ele tem permissões de gravação:

#!/bin/bash

filename="Hello.txt"

if [ -e "$filename" ]; then
  if [ -w "$filename" ]; then
    echo "File '$filename' exists and is writable."
  else
    echo "File '$filename' exists but is not writable."
  fi
else
  echo "File '$filename' does not exist."
fi

Como o Hello.txt está no diretório de trabalho atual e tem permissões de gravação para o usuário atual, ele me deu a seguinte saída:

13. O operador -x

O operador -x no bash é usado para descobrir se o arquivo tem permissões de execução ou não.

Por exemplo, aqui, verifiquei as permissões executáveis do Script.sh localizado no diretório de trabalho atual:

#!/bin/bash

script_file="Script.sh"

if [ -x "$script_file" ]; then
  echo "The script '$script_file' is executable."
else
  echo "The script '$script_file' is not executable."
fi

Como o arquivo Script.sh tinha permissões de execução, o script acima me deu a seguinte saída:

Mas se o seu arquivo não for executável, você pode usar o comando chmod para torná-lo executável. Aqui está um guia detalhado sobre esse tópico:

14. O operador -g

O operador -g no bash é usado para descobrir se o arquivo especificado possui um sinalizador SGID (Set-Group-ID) ou não.

Para quem não sabe, quando você habilita o SGID e executa um script ou faz alguma operação em um arquivo, as permissões de grupo de um arquivo serão usadas.

Portanto, qualquer ação que você fizer com o arquivo será realizada se você fizer parte de um grupo que possui o arquivo.

Por exemplo, aqui, usei o operador -g para descobrir se o arquivo Hello.txt tem SGID habilitado ou não:

#!/bin/bash

filename="Hello.txt"

if [ -e "$filename" ]; then
  if [ -g "$filename" ]; then
    echo "The SGID flag is set on '$filename'."
  else
    echo "The SGID flag is not set on '$filename'."
  fi
else
  echo "File '$filename' does not exist."
fi

Mas quando executei o script acima, ele disse "O sinalizador SGID não está definido em Hello.txt". E a maioria dos usuários obterá um resultado semelhante.

Para habilitar o SGID, você precisa usar o comando chmod da seguinte maneira:

chmod g+s Filename

Quando tentei executá-lo depois de usar o comando chmod, obtive os seguintes resultados:

15. O operador -u

O operador -u é usado para verificar se o sinalizador SUID (Set User ID) está definido em um arquivo ou não.

Quando SUID é definido, um usuário obtém o direito temporário de executar um script do proprietário do arquivo, não do usuário que está executando o script.

Por exemplo, aqui, tentei descobrir se o Hello.txt tem SUID definido ou não:

#!/bin/bash

filename="Hello.txt"

if [ -u "$filename" ]; then
  echo "The SUID flag is set on '$filename'."
else
  echo "The SUID flag is not set on '$filename'."
fi

Mas quando executei o script acima, ele disse: The SUID flag was not set on Hello.txt:

Para definir o SGID no arquivo, você pode usar o comando chmod da seguinte maneira:

chmod g+s filename

Feito isso, você pode executar o script novamente:

16. O operador -k

O operador -k no bash é usado para verificar se o arquivo ou diretório tem um sticky bit definido ou não.

Quando você define um bit forte em um arquivo, ele será mantido na memória cache para acesso mais rápido, enquanto se definido em um diretório, restringe o acesso de gravação.

Quando um arquivo ou diretório tem um bife definido, ele mostrará T no final das permissões do arquivo:

Por exemplo, aqui, usei o operador -k para descobrir se o Hello.txt tem um bit forte definido ou não:

#!/bin/bash

filename="Hello.txt"

if [ -k "$filename" ]; then
  echo "The  sticky bit is set on '$filename'."
else
  echo "The  sticky bit is not set on '$filename'."
fi

Quando executado, me deu a seguinte saída:

17. O operador -O

O operador -O no bash é usado para descobrir se o usuário conectado no momento é o proprietário de um arquivo específico ou não.

Por exemplo, aqui, usei o operador -O para testar se Hello.txt pertence ao usuário conectado no momento ou não:

#!/bin/bash

filename="Hello.txt"

if [ -O "$filename" ]; then
  echo "You are the owner of '$filename'."
else
  echo "You are not the owner of '$filename'."
fi

Como eu era o proprietário do arquivo, recebi a seguinte saída:

18. O operador -G

O operador -G no bash é usado para descobrir se o ID do grupo do arquivo especificado é o mesmo que o seu (usuário atualmente logado).

Por exemplo, o script a seguir usará o operador -G e descobrirá se o ID do grupo do usuário conectado no momento (identificado usando $USER) é o mesmo do arquivo :

#!/bin/bash

filename="Hello.txt"

if [ -G "$filename" ]; then
  echo "Group ID of a '$filename' is same as $USER."
else
  echo "Group ID of a '$filename' is not same as $USER."
fi

Quando executado, me deu a seguinte saída:

19. O operador -N

O operador -N no bash é usado para descobrir se o arquivo foi modificado desde a última leitura.

Parece confuso?

Você pode ter arquivos que podem ser acessados e modificados por outros usuários. Quando você usa o operador -N, ele informa se o arquivo foi modificado desde a última leitura por alguém intermediário.

Por exemplo, aqui usei o seguinte script para saber se o arquivo foi modificado desde a última leitura:

#!/bin/bash

filename="Hello.txt"

if [ -N "$filename" ]; then
  echo "The file '$filename' has been modified since it was last read or written."
else
  echo "The file '$filename' has not been modified since it was last read or written."
fi

O outro usuário abhiman recebeu o direito de modificar o arquivo e fez algumas modificações nele, então quando executei o script acima, ele me deu a seguinte saída:

20. O operador -nt

O operador -nt no Linux é usado para descobrir se um arquivo é mais recente que o outro.

Por exemplo, aqui, peguei dois arquivos Hello.txt e LHB.txt e usei o operador -nt para verificar qual deles é mais recente que:

#!/bin/bash

file1="Hello.txt"
file2="LHB.txt"

if [ "$file1" -nt "$file2" ]; then
  echo "$file1 is newer than $file2."
else
  echo "$file1 is not newer than $file2."
fi

Como o Hello.txt é mais antigo que o LHB.txt, ele me deu a seguinte saída:

21. O operador -ot

O operador -ot no bash é usado para comparar dois arquivos e determinar qual deles é mais antigo que o outro.

Aqui, usarei os mesmos dois arquivos que usei anteriormente (Hello.txt e LHB.txt) e os compararei usando o seguinte script:

#!/bin/bash

file1="Hello.txt"
file2="LHB.txt"

if [ "$file1" -ot "$file2" ]; then
  echo "$file1 is older than $file2."
else
  echo "$file1 is not older than $file2."
fi

Como o Hello.txt foi criado antes do LHB.txt, ele me deu o seguinte:

22. O operador -ef

Este é interessante.

Usando o operador -ef, você pode verificar se os dois arquivos estão indicando os mesmos blocos de dados.

Em termos simples, você pode verificar se eles são links físicos para o mesmo arquivo.

Por exemplo, criei dois links físicos chamados HL-1 e HL-2 apontando para o mesmo arquivo para testar se o operador -ef pode verificá-los:

#!/bin/bash

file1="HL-1"
file2="HL-2"

if [ "$file1" -ef "$file2" ]; then
  echo "$file1 and $file2 point to the same file."
else
  echo "$file1 and $file2 do not point to the same file."
fi

Como ambos são links físicos para o mesmo arquivo, obtive a seguinte saída:

Eu perdi algum?

Neste tutorial, passei por todos os operadores de teste disponíveis no bash com exemplos de cada um explicando como você pode usá-los.

Por favor, deixe-me saber se eu perdi algum.

Além disso, sinta-se à vontade para sugerir o que devo abordar a seguir.

Artigos relacionados: