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

Suggested prompts:

Can you explain the difference between the AND and OR logical operators?

What does operator precedence mean in logical expressions?

Can you give more examples of using logical operators in code?

Awesome!

Completion rate improved to 1.96

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