Aprenda Operadores Lógicos | Estruturas de Controle

Outra classe de operadores é conhecida como operadores lógicos. Diferente 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 NÃO (!) é utilizado para negar (inverter) uma expressão booleana. Veja 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, é necessário colocar as expressões entre parênteses antes de negá-las. Por exemplo, se quisermos negar 3 > 4, devemos escrever !(3 > 4):

index.go


              12345678
            
package main
import "fmt"

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

O operador OR (||) 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 utilizado como entrada para um operador em uma instrução ou expressão. Por exemplo, na expressão 1 + 2, os valores 1 e 2 são operandos. No caso dos operadores lógicos, um operando é sempre uma expressão ou valor booleano.

Veja um exemplo que ilustra o uso básico dos operadores lógicos:

index.go


              1234567
            
package main
import "fmt"

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

A primeira instrução exibe true porque um dos operandos na expressão true || false é true. Em contraste, a segunda instrução exibe false, pois 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.

Input	Output
`true \|\| true`	true
`true \|\| false`	true
`false \|\| true`	true
`false \|\| false`	false

É possível encadear operadores lógicos OU para combinar múltiplos operandos. Nesse 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 AND (&&) é semelhante ao operador OR (||), mas retorna true apenas se ambos os operandos tiverem valor true. A tabela verdade para a operação lógica AND (&&) é apresentada abaixo:

Input	Output
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Veja um exemplo mais complexo que demonstra um uso prático dos operadores lógicos. Reserve um momento para analisar o código e compreender 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)
    }
}

Observe que, no exemplo acima, utilizamos 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 compreender a ordem em que são processados. Operadores de comparação possuem prioridade maior do que operadores lógicos.

Abaixo está um diagrama que ilustra o ranking 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

Deslize para mostrar o menu

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

O operador NÃO (!) é utilizado para negar (inverter) uma expressão booleana. Veja 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 OR (||) 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 utilizado como entrada para um operador em uma instrução ou expressão. Por exemplo, na expressão 1 + 2, os valores 1 e 2 são operandos. No caso dos operadores lógicos, um operando é sempre uma expressão ou valor booleano.

Veja um exemplo que ilustra o uso básico dos 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.

Input	Output
`true \|\| true`	true
`true \|\| false`	true
`false \|\| true`	true
`false \|\| false`	false

É possível encadear operadores lógicos OU para combinar múltiplos operandos. Nesse 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.

Input	Output
`true && true`	true
`true && false`	false
`false && true`	false
`false && false`	false

Veja um exemplo mais complexo que demonstra um uso prático dos operadores lógicos. Reserve um momento para analisar o código e compreender 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 que ilustra o ranking 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