Aprenda Operadores Lógicos | Estruturas de Controle

Outra classe de operadores é conhecida como operadores lógicos. Diferentemente de outros operadores que trabalham com valores numéricos, os operadores lógicos são projetados para manipular valores booleanos. Existem três operadores lógicos:

Operador	Lógica
`!`	NÃO
`\|\|`	OU
`&&`	E

O operador NOT (!) é utilizado para negar (inverter) uma expressão booleana. Aqui está um exemplo simples que inclui uma instrução if:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (false) {
        fmt.Println("Print if True")
    }
}

No código acima, a instrução print não será executada porque a condição é false por padrão. No entanto, se incluirmos um operador NOT na expressão, ela será negada e, portanto, equivalente a true:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!false) {
        fmt.Println("Print if True")
    }
}

Também podemos usar o operador NOT (!) em casos mais complexos. No entanto, precisamos encerrar as expressões em parênteses antes de negá-las. Por exemplo, se quisermos negar 3 > 4, nós escreveríamos !(3 > 4):

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!(3 > 4)) {
        fmt.Println("Print if True")
    }
}

O operador OU (||) avalia dois operandos e retorna true se pelo menos um dos operandos for true.

Nota

Um operando refere-se a um valor ou expressão usado como entrada para um operador em uma declaração ou expressão. Por exemplo, na expressão 1 + 2, os valores 1 e 2 são operandos. No caso de operadores lógicos, um operando é sempre uma expressão ou valor booleano.

Aqui está um exemplo que ilustra o uso básico de operadores lógicos:

index.go


              1234567
            
package main
import "fmt"

func main() {
    fmt.Println(true || false)
    fmt.Println(false || false)
}

A primeira afirmação retorna true porque um dos operandos na expressão true || false é true. Em contraste, a segunda afirmação retorna false, já que ambos os operandos são false nessa expressão. Abaixo está a tabela-verdade para a operação lógica OU:

Nota

Uma tabela-verdade é uma representação lógica que exibe todas as combinações possíveis de entradas e seus respectivos valores de saída.

Entrada	Saída
`true
`true
`false
`false

Podemos encadear operadores lógicos OU para combinar múltiplos operandos. Neste caso, a expressão é avaliada da esquerda para a direita:

index.go


              123456
            
package main
import "fmt"

func main() {
    fmt.Println(false || false || true || false)
}

A ordem de avaliação para a expressão acima é a seguinte:

Nota

Por padrão, todas as expressões lógicas são avaliadas da esquerda para a direita.

O operador lógico E (&&) é semelhante ao operador OU (||), mas retorna true apenas se ambos os operandos tiverem o valor true. A tabela verdade para a operação lógica E (&&) é fornecida abaixo:

Entrada	Saída
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Aqui está um exemplo mais complexo que demonstra um uso prático dos operadores lógicos. Reserve um momento para examinar o código e entender como ele funciona:

index.go


              1234567891011
            
package main
import "fmt"

func main() {
    var x int = 99
    if (1 <= x && x <= 10 || 90 <= x && x <= 100) {
        fmt.Printf("The value %d is in the range 1-10 or 90-100", x)
    } else {
        fmt.Printf("The value %d is not in the range 1-10 or 90-100", x)
    }
}

Por favor, note que no exemplo acima, usamos múltiplos operadores e valores para criar uma condição mais complexa. Durante a execução, a expressão é avaliada com base na prioridade dos operadores. Operadores de alta prioridade são avaliados primeiro, e é importante entender a ordem pela qual são processados. Operadores de comparação têm prioridade mais alta que operadores lógicos.

Abaixo está um diagrama ilustrando a classificação de prioridade dos operadores lógicos:

O diagrama a seguir ilustra como a expressão 1 <= x && x <= 10 || 90 <= x && x <= 100 é avaliada:

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 4

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

Can you explain the difference between the AND and OR operators with more examples?

What is the order of precedence for logical operators?

Can you show how to use logical operators in a real-world scenario?

Deslize para mostrar o menu

Operador	Lógica
`!`	NÃO
`\|\|`	OU
`&&`	E

O operador NOT (!) é utilizado para negar (inverter) uma expressão booleana. Aqui está um exemplo simples que inclui uma instrução if:

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (false) {
        fmt.Println("Print if True")
    }
}

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!false) {
        fmt.Println("Print if True")
    }
}

index.go


              12345678
            
package main
import "fmt"

func main() {
    if (!(3 > 4)) {
        fmt.Println("Print if True")
    }
}

O operador OU (||) avalia dois operandos e retorna true se pelo menos um dos operandos for true.

Nota

Um operando refere-se a um valor ou expressão usado como entrada para um operador em uma declaração ou expressão. Por exemplo, na expressão 1 + 2, os valores 1 e 2 são operandos. No caso de operadores lógicos, um operando é sempre uma expressão ou valor booleano.

Aqui está um exemplo que ilustra o uso básico de operadores lógicos:

index.go


              1234567
            
package main
import "fmt"

func main() {
    fmt.Println(true || false)
    fmt.Println(false || false)
}

Nota

Uma tabela-verdade é uma representação lógica que exibe todas as combinações possíveis de entradas e seus respectivos valores de saída.

Entrada	Saída
`true
`true
`false
`false

Podemos encadear operadores lógicos OU para combinar múltiplos operandos. Neste caso, a expressão é avaliada da esquerda para a direita:

index.go


              123456
            
package main
import "fmt"

func main() {
    fmt.Println(false || false || true || false)
}

A ordem de avaliação para a expressão acima é a seguinte:

Nota

Por padrão, todas as expressões lógicas são avaliadas da esquerda para a direita.

Entrada	Saída
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Aqui está um exemplo mais complexo que demonstra um uso prático dos operadores lógicos. Reserve um momento para examinar o código e entender como ele funciona:

index.go


              1234567891011
            
package main
import "fmt"

func main() {
    var x int = 99
    if (1 <= x && x <= 10 || 90 <= x && x <= 100) {
        fmt.Printf("The value %d is in the range 1-10 or 90-100", x)
    } else {
        fmt.Printf("The value %d is not in the range 1-10 or 90-100", x)
    }
}

Abaixo está um diagrama ilustrando a classificação de prioridade dos operadores lógicos:

O diagrama a seguir ilustra como a expressão 1 <= x && x <= 10 || 90 <= x && x <= 100 é avaliada:

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 4

Operadores Lógicos

Awesome!

Operadores Lógicos