Aprende Operadores Lógicos | Estructuras de Control

Otra clase de operadores son los 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:

Operator	Logic
NO
OR
`&&`	AND

El operador NOT (!) se utiliza para negar (invertir) una expresión booleana. He aquí 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 sentencia Print no se ejecutará porque la condición es false por defecto. Sin embargo, si incluimos un operador NOT en la expresión, ésta será negada y, por 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, escribiremos !(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 utilizado como entrada para un operador en una sentencia 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 es siempre 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 sentencia produce true porque uno de los operandos de la expresión true || false es true. Por el contrario, la segunda sentencia da como resultado false ya que ambos operandos son false en esa expresión. A continuación se muestra la tabla verdadero-falso 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 correspondientes valores de salida.

Entrada	Salida
`verdadero
Verdadero: Falso.
Falso: Verdadero.
Falso Falso Falso

Podemos encadenar operadores lógicos OR para combinar varios 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 de 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 sólo si ambos operandos tienen el valor true. A continuación se muestra la tabla verdadero-falso de la operación lógica AND (&&):

Entrada	Salida
verdadero && verdadero` verdadero
verdadero y falso falso
Falso y verdadero Falso
Falso y falso Falso

He aquí 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 entender 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 varios operadores y valores para crear una condición más compleja. Durante la ejecución, la expresión se evalúa en función de la prioridad del operador. Los operadores de alta prioridad se evalúan primero, y es importante entender 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 el orden 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

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?

Desliza para mostrar el menú

Operator	Logic
NO
OR
`&&`	AND

El operador NOT (!) se utiliza para negar (invertir) una expresión booleana. He aquí 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 utilizado como entrada para un operador en una sentencia 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 es siempre 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 correspondientes valores de salida.

Entrada	Salida
`verdadero
Verdadero: Falso.
Falso: Verdadero.
Falso Falso Falso

Podemos encadenar operadores lógicos OR para combinar varios 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 de la expresión anterior es el siguiente:

Nota

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

Entrada	Salida
verdadero && verdadero` verdadero
verdadero y falso falso
Falso y verdadero Falso
Falso y falso Falso

He aquí 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 entender 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 el orden 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

Operadores Lógicos

Awesome!

Operadores Lógicos