Operações Booleanas Shell

$ se for verdadeiro; então echo SIM; senão echo NÃO; fiYES$ se for falso; então echo SIM;

Exemplo: operação AND

 $ se verdadeiro && verdadeiro; então echo SIM; senão echo NÃO $ se verdadeiro && falso; então echo SIM $ se falso && falso; ;então echo SIM; senão echo NÃO;

Exemplo: operação OR

 $ se verdadeiro || verdadeiro; então echo SIM; senão echo NÃO; então echo SIM $ se falso || falso; então echo SIM; senão echo NO;

Exemplo: operação NOT, ou seja, negação

 $ if ! false;então echo SIM; senão echo NÃO;

Pode ser visto

 verdadeiro

e

 falso

Procedemos de acordo com nosso entendimento de operações lógicas, mas para entender melhor a implementação de operações lógicas da Shell, temos que descobrir,

 verdadeiro

e

 falso

Como funciona?

Verdadeiro e falso no Bash são 1 e 0 em que normalmente pensamos?

A resposta é: Não.

Exemplo: valor de retorno versus valor lógico

 verdadeiro

e

 falso

Eles não são valores lógicos em si, são todos comandos internos do Shell, mas seu valor de retorno é um "valor lógico":

 $ verdadeiro$ echo $?0$ falso$ echo $?1

pode ser visto

 verdadeiro

retornou 0 e

 falso

Então 1 é retornado. Não corresponde aos verdadeiros valores 1 e 0 que aprendemos na matemática discreta, mas é o oposto.

Exemplo: visualizar ajuda e tipos de verdadeiro e falso

 $ help true falsetrue: true Retorna um resultado bem-sucedido.false: false Retorna um resultado malsucedido.$ type true falsetrue é um shell embutidofalse é um shell embutido

ilustrar:

 $?

É uma variável especial que armazena o status final (código de status de saída) do último processo.

A partir das operações acima, não é difícil pensar por que a ênfase é colocada na programação em linguagem C.

 principal

Adicione na frente da função

 interno

e adicione no final

 retornar 0

. Porque no Shell, 0 será usado como um sinal de que o programa foi encerrado com sucesso.

 verdadeiro

e

 falso

Em essência, eles são usados ​​para refletir se um determinado programa termina corretamente, em vez dos tradicionais valores verdadeiro e falso (1 e 0, pelo contrário, eles retornam 0 e 1). Felizmente, não precisamos nos preocupar com isso ao realizar operações lógicas.

teste de condição

Na seção anterior, entendemos claramente o que é o "valor lógico" no Shell: é o valor de retorno quando o processo termina. Se retornar com sucesso, é verdadeiro, se retornar sem sucesso, é falso.

E o teste condicional usa apenas

 teste

Essa instrução é usada para realizar testes numéricos (vários testes de atributos numéricos), testes de string (vários testes de atributos de string) e testes de arquivo (vários testes de atributos de arquivo). , juntamente com a combinação lógica de vários testes, tarefas mais complexas podem ser concluídas.

Uso básico de testes condicionais

Exemplo: Teste Numérico

 $ se teste 5 -eq 5; então echo SIM; senão echo NÃO;

Exemplo: teste de string

 $ se teste -n não estiver vazio; então echo SIM; senão echo NÃO; então echo SIM $; se teste -n ;então echo SIM; senão echo NO;

Exemplo: teste de arquivo

 $ if test -f /boot/System.map; então echo YES; senão echo NO;

Uma combinação de vários testes lógicos

Exemplo: Se a, b, c forem todos iguais aos valores correspondentes abaixo, imprima SIM e teste com -a

 $ a=5;b=4;c=6;$ if teste $a -eq 5 -a $b -eq 4 -a $c -eq 6;

Exemplo: para testar se uma determinada “coisa” é um arquivo ou diretório, use -o para realizar uma operação “OR”

 $ if test -f /etc/profile -o -d /etc/profile;então echo SIM;

Exemplo: teste se uma "coisa" é um arquivo, teste

 !

NÃO operação

 $ if teste ! -f /etc/profile; então echo SIM;

O que foi dito acima apenas demonstra

 teste

Comande alguns testes muito simples que você pode passar

 teste de ajuda

Pegar

 teste

Mais usos de . Deve-se notar que

 teste

Existem algumas diferenças entre as operações lógicas dentro do comando e os operadores lógicos do Shell.

 -um

e

 &&

,

 -o

e

 ||

, os dois não podem ser confundidos. Em vez de as operações serem

 !

, compare-os abaixo.

Compare -a com &&, -o com ||, !

Exemplo: para exigir que um arquivo seja executável e tenha conteúdo, use -a e && para conseguir isso, respectivamente.

 $ cat > test.sh#!/bin/bashecho test[CTRL+D] # Pressione a combinação de teclas CTRL e D para finalizar a entrada cat, o mesmo que abaixo, não especifique mais $ chmod +x test.sh$ if test -s test .sh -a -x test.sh; então echo senão echo NÃO;

Exemplo: exigir que uma string esteja vazia ou igual a uma string

 $ str1=teste$ str2=teste$ if teste -z $str2 -o $str2 == $str2 == $str1; então ecoe SIM; caso contrário, ecoe NÃO;

Exemplo: teste se um número não atende a todas as condições especificadas

 $ i=5$ if teste $i -lt 5 -a $i -ne 6; então echo SIM; ; senão ecoe NÃO;

É fácil identificar a diferença entre eles,

 -um

e

 -o

Como parâmetro do comando de teste, é usado dentro do comando de teste, e

 &&

e

 ||

É usado para calcular o valor de retorno do teste,

 !

Comum a ambos. O que precisa de atenção é:

Às vezes não é necessário

 !

operadora, como

 -eq

e

 -ne

Pelo contrário, pode ser usado para testar se dois valores são iguais;

 -z

e

 -n

Também é correspondente e usado para testar se uma determinada string está vazia.

existir

 Bash

dentro,

 teste

Os comandos podem ser substituídos pelo operador [], mas deve-se observar que [

 Depois com

] precisa ser precedido por espaços extras

Ao testar uma string, é recomendado que todas as variáveis ​​sejam colocadas entre aspas duplas para evitar a situação em que há apenas parâmetros de teste e nenhum conteúdo de teste quando o conteúdo da variável está vazio.

Abaixo usamos exemplos para demonstrar as três precauções acima:

 -ne

e

 -eq

Da mesma forma, às vezes podemos dispensar

 !

Operação

 $ i=5$ if teste $i -eq 5; então echo SIM; senão echo NÃO $i -eq 5; então ecoe SIM; senão ecoe NÃO;

usar

 [ ]

pode substituir

 teste

, ficará muito mais “bonito”

 $ if [ $i -eq 5 ]; então echo SIM; senão echo NÃO;

Lembre-se de adicionar algumas variáveis ​​de string

,Lembrar

 [

Depois com

 ]

Adicione um espaço extra antes

 $ str=$ if [ $str = teste]; então echo SIM; então echo fi-bash: [: faltando `]'NO$ if [ $str = teste ]; bash: [: =: operador unário esperadoNO$ if [$str = teste]; então echo YES;

Neste ponto, o teste condicional foi introduzido. A lista de comandos é apresentada abaixo. Na verdade, já a usamos, ou seja, uma combinação de vários comandos de teste.

 &&

,

 ||

e

 !

Uma sequência de comandos combinados. Esta sequência de comandos substitui efetivamente

 se/então

estrutura de ramificação condicional. Não é difícil pensar nas seguintes questões de múltipla escolha que costumamos fazer na programação em linguagem C (exemplo muito chato, mas significativo): O seguinte será impresso?

 j

, se impresso, o que será impresso?

 #incluir <stdio.h>int main(){ int i, j;j;j=1; retornar 0;}

É fácil saber que o número 5 será impresso porque

 eu==5

Esta condição é válida e, posteriormente,

 &&

, para julgar se toda a condição está estabelecida, temos que fazer um julgamento subsequente, mas este julgamento não é um julgamento convencional, mas primeiro

 j

Modifique-o para 5 e depois converta-o para um valor verdadeiro, para que a condição seja verdadeira e 5 seja impresso. Portanto, esta frase pode ser interpretada como: Se

 eu

é igual a 5, então coloque

 j

Atribua um valor de 5 se

 j

é maior que 1 (porque já era verdade antes), então imprima

 j

valor. Use desta forma

 &&

A declaração de julgamento concatenada substitui dois

 se

Instrução de ramificação condicional.

É precisamente com base nas propriedades únicas das operações lógicas que podemos passar

 &&

,

 ||

substituir

 se/então

Aguarde a estrutura da ramificação condicional, gerando assim uma lista de comandos.

lista de comandos

Regras de execução da lista de comandos

As regras de execução da lista de comandos estão em conformidade com as regras de operação de operações lógicas.

 &&

Para comandos conectados, se o primeiro retornar com sucesso, o comando a seguir será executado, caso contrário, use;

 ||

Se os comandos conectados retornarem com sucesso, os comandos subsequentes não serão executados e vice-versa.

Exemplo: Se executar ping www.lzu.edu.cn, imprima as informações de conexão

 $ ping -c 1 www.lzu.edu.cn -W 1 && echo =======conectado========

Surge uma questão muito interessante, que é a que mencionamos acima: por que o programa C deveria ser

 principal()

A função retorna 0 no final? Caso contrário, quais seriam as consequências de colocar esse tipo de programa na lista de comandos? Escreva você mesmo um programa C simples e coloque-o na lista de comandos para ver.

O papel da lista de comandos

Às vezes, uma lista de comandos é usada

 se/então

A estrutura de ramificação condicional pode salvar algum código e tornar o programa mais bonito e fácil de ler, por exemplo:

Exemplo: Determinar o número de parâmetros e tipos de parâmetros de um programa em um script

 #!/bin/bashecho $#echo $1if [ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null);então echo YESfi

Nota: O exemplo acima requer que o número de parâmetros seja 1 e o tipo seja numérico.

Mais

 saída 1

, vamos omitir

 se/então

estrutura

 #!/bin/bashecho $#echo $1 ([ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null)) && exit 1echo SIM

Após esse processamento, o julgamento dos parâmetros do programa requer apenas uma simples linha de código e fica mais bonito.

resumo

Esta seção apresenta operações lógicas, testes condicionais e listas de comandos na programação Shell.