Aprende Operadores Lógicos | Estructuras de Control

Otra clase de operadores se conoce como operadores lógicos. A diferencia de otros operadores que trabajan con valores numéricos, los operadores lógicos están diseñados para manejar valores booleanos. Existen tres operadores lógicos:

Operador	Lógica
`!`	NOT
`\|\|`	OR
`&&`	AND

El operador NOT (!) se utiliza para negar (invertir) una expresión booleana. Aquí tienes un ejemplo sencillo que incluye una sentencia if:

index.go


              12345678
            
package main
import "fmt"

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

En el código anterior, la instrucción Print no se ejecutará porque la condición es false por defecto. Sin embargo, si incluimos un operador NOT en la expresión, esta será negada y, por lo tanto, equivalente a true:

index.go


              12345678
            
package main
import "fmt"

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

También podemos utilizar el operador NOT (!) en casos más complejos. Sin embargo, es necesario encerrar las expresiones entre paréntesis antes de negarlas. Por ejemplo, si queremos negar 3 > 4, escribiríamos !(3 > 4):

index.go


              12345678
            
package main
import "fmt"

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

El operador OR (||) evalúa dos operandos y devuelve true si al menos uno de los operandos es true.

Nota

Un operando se refiere a un valor o expresión que se utiliza como entrada para un operador en una instrucción o expresión. Por ejemplo, en la expresión 1 + 2, los valores 1 y 2 son operandos. En el caso de los operadores lógicos, un operando siempre es una expresión o valor booleano.

A continuación, se muestra un ejemplo que ilustra el uso básico de los operadores lógicos:

index.go


              1234567
            
package main
import "fmt"

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

La primera instrucción muestra true porque uno de los operandos en la expresión true || false es true. En cambio, la segunda instrucción muestra false ya que ambos operandos son false en esa expresión. A continuación se presenta la tabla de verdad para la operación lógica OR:

Nota

Una tabla de verdad es una representación lógica que muestra todas las combinaciones posibles de entradas y sus valores de salida correspondientes.

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

Es posible encadenar operadores lógicos OR para combinar múltiples operandos. En este caso, la expresión se evalúa de izquierda a derecha:

index.go


              123456
            
package main
import "fmt"

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

El orden de evaluación para la expresión anterior es el siguiente:

Nota

Por defecto, todas las expresiones lógicas se evalúan de izquierda a derecha.

El operador lógico AND (&&) es similar al operador OR (||), pero devuelve true solo si ambos operandos tienen un valor de true. La tabla de verdad para la operación lógica AND (&&) se muestra a continuación:

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

A continuación se muestra un ejemplo más complejo que demuestra un uso práctico de los operadores lógicos. Tómese un momento para examinar el código y comprender cómo 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)
    }
}

Tenga en cuenta que en el ejemplo anterior, utilizamos múltiples operadores y valores para crear una condición más compleja. Durante la ejecución, la expresión se evalúa según la prioridad de los operadores. Los operadores de alta prioridad se evalúan primero, y es importante comprender el orden en que se procesan. Los operadores de comparación tienen mayor prioridad que los operadores lógicos.

A continuación se muestra un diagrama que ilustra la jerarquía de prioridad de los operadores lógicos:

El siguiente diagrama ilustra cómo se evalúa la expresión 1 <= x && x <= 10 || 90 <= x && x <= 100:

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 4

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Awesome!

Completion rate improved to 1.96

Desliza para mostrar el menú

Operador	Lógica
`!`	NOT
`\|\|`	OR
`&&`	AND

El operador NOT (!) se utiliza para negar (invertir) una expresión booleana. Aquí tienes un ejemplo sencillo que incluye una sentencia 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")
    }
}

El operador OR (||) evalúa dos operandos y devuelve true si al menos uno de los operandos es true.

Nota

Un operando se refiere a un valor o expresión que se utiliza como entrada para un operador en una instrucción o expresión. Por ejemplo, en la expresión 1 + 2, los valores 1 y 2 son operandos. En el caso de los operadores lógicos, un operando siempre es una expresión o valor booleano.

A continuación, se muestra un ejemplo que ilustra el uso básico de los operadores lógicos:

index.go


              1234567
            
package main
import "fmt"

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

Nota

Una tabla de verdad es una representación lógica que muestra todas las combinaciones posibles de entradas y sus valores de salida correspondientes.

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

Es posible encadenar operadores lógicos OR para combinar múltiples operandos. En este caso, la expresión se evalúa de izquierda a derecha:

index.go


              123456
            
package main
import "fmt"

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

El orden de evaluación para la expresión anterior es el siguiente:

Nota

Por defecto, todas las expresiones lógicas se evalúan de izquierda a derecha.

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

A continuación se muestra un ejemplo más complejo que demuestra un uso práctico de los operadores lógicos. Tómese un momento para examinar el código y comprender cómo 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)
    }
}

A continuación se muestra un diagrama que ilustra la jerarquía de prioridad de los operadores lógicos:

El siguiente diagrama ilustra cómo se evalúa la expresión 1 <= x && x <= 10 || 90 <= x && x <= 100:

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 4