Operadores lógicos y de comparación

14/36

Lectura

Son operadores que nos permiten hacer una comparación de condiciones y en caso de cumplirse como sino ejecutarán un código determinado. Si se cumple es VERDADERO/TRUE y si no se cumple son FALSO/FALSE.

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 18

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Hola a todos, quisiera compartir un código que hice para poder ejemplificar el uso de los operadores lógicos en Golang:

package main

import "fmt"

func igualdad(v1, v2 bool) bool {
	return v1 == v2
}

func distinto(v1, v2 bool) bool {
	return v1 != v2
}

func comparacion(i1, i2 int) (ans1, ans2, ans3, ans4 bool) {
	return i1 > i2, i1 < i2, i1 >= i2, i1 <= i2
}

func logicGates(v1, v2 bool) (ans1, ans2, ans3 bool) {
	return v1 && v2, v1 || v2, !v1
}

func main() {

	var valor1 bool = false
	var valor2 bool = true
	var entero1 int = 5
	var entero2 int = -5

	eq := igualdad(valor1, valor2)
	ds := distinto(valor1, valor2)

	comp1, comp2, comp3, comp4 := comparacion(entero1, entero2)
	andGate, orGate, notGate := logicGates(valor1, valor2)

	fmt.Printf("%t == %t : %t\n", valor1, valor2, eq)
	fmt.Printf("%t != %t : %t\n", valor1, valor2, ds)
	fmt.Printf("%d > %d : %t\n", entero1, entero2, comp1)
	fmt.Printf("%d < %d : %t\n", entero1, entero2, comp2)
	fmt.Printf("%d >= %d : %t\n", entero1, entero2, comp3)
	fmt.Printf("%d <= %d : %t\n", entero1, entero2, comp4)
	fmt.Printf("%t && %t : %t\n", valor1, valor2, andGate)
	fmt.Printf("%t || %t : %t\n", valor1, valor2, orGate)
	fmt.Printf("!%t : %t\n", valor1, notGate)

}

Yo dándome cuenta que la mascota de go viene de la expresión

:=

BOOOOM tu cabeza explotando

Acá les dejo este valioso recurso para los que están haciendo operaciones entre operadores lógicos, la tabla de la verdad. Es muy útil para saber el posible resultado.

para los que conozcan c esto es muy muy parecido también me da una sensación similar a python. Como una mezcla de ambos.

Tod el codigo de loe que vamos del curso por aqui... `package main` `import (    "fmt")` `func main() {    //Declaracion de constantes    const pi float64 = 3.14    const pi2 = 3.14    fmt.Println("pi: ", pi2)    fmt.Println("pi2: ", pi2)` `    //Declaracion de variables enteras    base := 12    var altura int = 14    var area int` `    fmt.Println(base, altura, area)` `    //Zero values` `    var a int    var b float64    var c string    var d bool` `    fmt.Println(a, b, c, d)` `    //Area cuadrado    const baseCuadrado = 10    areaCuadrado := baseCuadrado * baseCuadrado    fmt.Println("Area del cuadrado: ", areaCuadrado)` `    //////////////////////////////////////////////////////    //Operadores aritmeticos    x := 10    y := 50` `    //Suma    resultado := x + y    fmt.Println("Suma: ", resultado)` `    //Resta    resultado = y - x    fmt.Println("Resta: ", resultado)` `    //Multiplicacion    resultado = x * y    fmt.Println("Suma: ", resultado)` `    //Divicion    resultado = y / x    fmt.Println("División: ", resultado)` `    //Modulo    resultado = y % x    fmt.Println("Modulo: ", resultado)` `    //Incremento    x++    fmt.Println("Incremento: ", x)` `    //Divicion    x--    fmt.Println("Decremento: ", x)` `    //Printf    nombre := "Platzi"    cursos := 500    //%s String    //%d entero    //%f float64    //%t booleano    //%p direccion de memoria    //%e numero en notacion cientifica    //%x numero en hexadecimal    //%o numero en octal    //%q cadena entre comillas simples    //%c caracter Unicode    //%T tipo de dato    //%v valor    //%p dirección de memoria    //%+v agregar nombre al campo    //%#v formato en hexadecimal    //%[1]v campo con indice 1    //%[2]v campo con indice 2    //...    //%n salto de linea    //%t indicador de verdadero/falso    //%b binario    //%x hexadecimal    //%o    //Se agrega %v cuando no se sabe el tipo de dato    fmt.Printf("Hola %s, tienes %d cursos\n", nombre, cursos)` `    //Sprintf    message := fmt.Sprintf("Hola %s, tienes %d cursos\n", nombre, cursos)    fmt.Println(message)` `    //Tipo de dato    fmt.Printf("HelloMessage: %T\n", "helloMessage")    fmt.Printf("Cursos: %T\n", cursos)` `    normalFuncion("Hola Mundo")    tripleArgumento(1, 2, "tres")    result := returnValue(4)    fmt.Println("Return value: ", result)` `    value1, value2 := dobleReturn(2)    fmt.Println("Value1: ", value1, "Value2: ", value2)` `    value3, _ := dobleReturn(2)    fmt.Println("Value3: ", value3)` `    fmt.Println("///// CICLO FOR ")    cicloFor()` `    fmt.Println("///// CICLO FOR WHILE ")    cicloForWhile()` `    fmt.Println("///// CICLO FOR COUNTER FOREVER ")    cicloForForever()` `    fmt.Println("///// OPERADORES LOGICOS ")` `    var valor1 bool = false    var valor2 bool = true    var entero1 int = 5    var entero2 int = -5` `    eq := igualdad(valor1, valor2)    ds := distinto(valor1, valor2)` `    comp1, comp2, comp3, comp4 := comparacion(entero1, entero2)    andGate, orGate, notGate := logicGates(valor1, valor2)` `    fmt.Printf("%t == %t : %t\n", valor1, valor2, eq)    fmt.Printf("%t != %t : %t\n", valor1, valor2, ds)    fmt.Printf("%d > %d : %t\n", entero1, entero2, comp1)    fmt.Printf("%d < %d : %t\n", entero1, entero2, comp2)    fmt.Printf("%d >= %d : %t\n", entero1, entero2, comp3)    fmt.Printf("%d <= %d : %t\n", entero1, entero2, comp4)    fmt.Printf("%t && %t : %t\n", valor1, valor2, andGate)    fmt.Printf("%t || %t : %t\n", valor1, valor2, orGate)    fmt.Printf("!%t : %t\n", valor1, notGate)` `}` `// ////////////////////////////////////////////////////// Funcinesfunc normalFuncion(message string) {    fmt.Println(message)}` `func tripleArgumento(a int, b int, c string) {    fmt.Println(a, b, c)}` `func returnValue(a int) int {    return a * 3}` `func dobleReturn(a int) (c, d int) {    return a, a * 2}func dobleReturn2(a int) (c, d int) {    return a, a * 2}` `// ////////////////////////////////////////////////////// Ciclos` `func cicloFor() {    for i := 0; i < 10; i++ {        fmt.Println(i)    }}` `func cicloForWhile() {    counter := 0    for counter < 10 {        fmt.Println(counter)        counter++    }}` `func cicloForForever() {    counterForever := 0    for {        fmt.Println(counterForever)        counterForever++        /*            if counterForever == 1000 {                break            }        */` `        if counterForever == 100 {            break        }    }}` `// ////////////////////////////////////////////////////// Operadores Logicos` `func igualdad(v1, v2 bool) bool {    return v1 == v2}` `func distinto(v1, v2 bool) bool {    return v1 != v2}` `func comparacion(i1, i2 int) (ans1, ans2, ans3, ans4 bool) {    return i1 > i2, i1 < i2, i1 >= i2, i1 <= i2}` `func logicGates(v1, v2 bool) (ans1, ans2, ans3 bool) {    return v1 && v2, v1 || v2, !v1}`
Todo el codigo de lo que vamos del curso por aqui... package main import (    "fmt") func main() {    //Declaracion de constantes    const pi float64 = 3.14    const pi2 = 3.14    fmt.Println("pi: ", pi2)    fmt.Println("pi2: ", pi2)     //Declaracion de variables enteras    base := 12    var altura int = 14    var area int     fmt.Println(base, altura, area)     //Zero values     var a int    var b float64    var c string    var d bool     fmt.Println(a, b, c, d)     //Area cuadrado    const baseCuadrado = 10    areaCuadrado := baseCuadrado \* baseCuadrado    fmt.Println("Area del cuadrado: ", areaCuadrado)     //////////////////////////////////////////////////////    //Operadores aritmeticos    x := 10    y := 50     //Suma    resultado := x + y    fmt.Println("Suma: ", resultado)     //Resta    resultado = y - x    fmt.Println("Resta: ", resultado)     //Multiplicacion    resultado = x \* y    fmt.Println("Suma: ", resultado)     //Divicion    resultado = y / x    fmt.Println("División: ", resultado)     //Modulo    resultado = y % x    fmt.Println("Modulo: ", resultado)     //Incremento    x++    fmt.Println("Incremento: ", x)     //Divicion    x--    fmt.Println("Decremento: ", x)     //Printf    nombre := "Platzi"    cursos := 500    //%s String    //%d entero    //%f float64    //%t booleano    //%p direccion de memoria    //%e numero en notacion cientifica    //%x numero en hexadecimal    //%o numero en octal    //%q cadena entre comillas simples    //%c caracter Unicode    //%T tipo de dato    //%v valor    //%p dirección de memoria    //%+v agregar nombre al campo    //%#v formato en hexadecimal    //%\[1]v campo con indice 1    //%\[2]v campo con indice 2    //...    //%n salto de linea    //%t indicador de verdadero/falso    //%b binario    //%x hexadecimal    //%o    //Se agrega %v cuando no se sabe el tipo de dato    fmt.Printf("Hola %s, tienes %d cursos\n", nombre, cursos)     //Sprintf    message := fmt.Sprintf("Hola %s, tienes %d cursos\n", nombre, cursos)    fmt.Println(message)     //Tipo de dato    fmt.Printf("HelloMessage: %T\n", "helloMessage")    fmt.Printf("Cursos: %T\n", cursos)     normalFuncion("Hola Mundo")    tripleArgumento(1, 2, "tres")    result := returnValue(4)    fmt.Println("Return value: ", result)     value1, value2 := dobleReturn(2)    fmt.Println("Value1: ", value1, "Value2: ", value2)     value3, \_ := dobleReturn(2)    fmt.Println("Value3: ", value3)     fmt.Println("///// CICLO FOR ")    cicloFor()     fmt.Println("///// CICLO FOR WHILE ")    cicloForWhile()     fmt.Println("///// CICLO FOR COUNTER FOREVER ")    cicloForForever()     fmt.Println("///// OPERADORES LOGICOS ")     var valor1 bool = false    var valor2 bool = true    var entero1 int = 5    var entero2 int = -5     eq := igualdad(valor1, valor2)    ds := distinto(valor1, valor2)     comp1, comp2, comp3, comp4 := comparacion(entero1, entero2)    andGate, orGate, notGate := logicGates(valor1, valor2)     fmt.Printf("%t == %t : %t\n", valor1, valor2, eq)    fmt.Printf("%t != %t : %t\n", valor1, valor2, ds)    fmt.Printf("%d > %d : %t\n", entero1, entero2, comp1)    fmt.Printf("%d < %d : %t\n", entero1, entero2, comp2)    fmt.Printf("%d >= %d : %t\n", entero1, entero2, comp3)    fmt.Printf("%d <= %d : %t\n", entero1, entero2, comp4)    fmt.Printf("%t && %t : %t\n", valor1, valor2, andGate)    fmt.Printf("%t || %t : %t\n", valor1, valor2, orGate)    fmt.Printf("!%t : %t\n", valor1, notGate) } // ////////////////////////////////////////////////////// Funcinesfunc normalFuncion(message string) {    fmt.Println(message)} func tripleArgumento(a int, b int, c string) {    fmt.Println(a, b, c)} func returnValue(a int) int {    return a \* 3} func dobleReturn(a int) (c, d int) {    return a, a \* 2}func dobleReturn2(a int) (c, d int) {    return a, a \* 2} // ////////////////////////////////////////////////////// Ciclos func cicloFor() {    for i := 0; i < 10; i++ {        fmt.Println(i)    }} func cicloForWhile() {    counter := 0    for counter < 10 {        fmt.Println(counter)        counter++    }} func cicloForForever() {    counterForever := 0    for {        fmt.Println(counterForever)        counterForever++        /\*            if counterForever == 1000 {                break            }        \*/         if counterForever == 100 {            break        }    }} // ////////////////////////////////////////////////////// Operadores Logicos func igualdad(v1, v2 bool) bool {    return v1 == v2} func distinto(v1, v2 bool) bool {    return v1 != v2} func comparacion(i1, i2 int) (ans1, ans2, ans3, ans4 bool) {    return i1 > i2, i1 < i2, i1 >= i2, i1 <= i2} func logicGates(v1, v2 bool) (ans1, ans2, ans3 bool) {    return v1 && v2, v1 || v2, !v1}
Y para comparar types puedes hacer algo como esto: `package main` `import (` ` "fmt"` ` "reflect"` `)` `func main() {` ` var a int` ` var b string` ` var c float64` ` // Check if a and b have the same type` ` if reflect.TypeOf(a) == reflect.TypeOf(b) {` ` fmt.Println("a and b have the same type")` ` } else {` ` fmt.Println("a and b have different types")` ` }` ` // Check if a and c have the same type` ` if reflect.TypeOf(a) == reflect.TypeOf(c) {` ` fmt.Println("a and c have the same type")` ` } else {` ` fmt.Println("a and c have different types")` ` }` `}`

Un ejemplo que realize les comparto

package main

import "fmt"

func main() {
	price := 200
	fmt.Println("price =", price)

	// AND (&&) Operator
	if price > 10 && price < 1600 {
		fmt.Println("price > 10 && price < 1600 is 'true'")
	}

	// Operador AND (&&)
	if price > 10 && price < 200 {
		fmt.Println("price > 10 && price < 200 is 'true'")
	} else {
		fmt.Println("price > 10 && price < 200 is 'false'")
	}

	// Operador OR (||)
	if price > 10 || price < 1600 {
		fmt.Println("price > 10 || price < 1600 is 'true'")
	}

	// Operador OR (||)
	if price > 10 || price > 1600 {
		fmt.Println("price > 10 || price > 1600 is 'true'")
	}

	// Operador NOT (!)
	if !(price < 10) {
		fmt.Println("!(price < 10) is 'true'")
	}

}

a) Operadores de comparación:
Igualdad: ==
diferente: !=
menor que: <
mayor que: >
mayor o igual que: >=
menor o igual que: <=

b) Operadores lógicos:
And: &&
Or: ||
Not: !

Para el caso a) y b) siempre regresará un true o false. Por eso la importancia de conocer lo que significa cada operador.

Excelente un solo for…

	for i := 15; i >= 0; i-- {
		fmt.Println(i)
	}

Todo quedó muy !claro

Semejante a JavaScript. Muy bueno!

Llevo mucho en JavaScript y por el momento todo me ha parecido muy similar, si hay cosas diferentes, pero por el momento estoy comodo, veremos como nos va.

Bien, buena lectura

<
package main

import "fmt"

func main() {

	// Operadores lógicos y de comparación
	// Son operadores que nos permiten hacer una comparación de condiciones y en caso de cumplirse como sino ejecutarán un código determinado. Si se cumple es VERDADERO/TRUE y si no se cumple son FALSO/FALSE.

	// Empecemos con los operadores de comparación:

	// Operadores de comparación
	// Son aquellos que retornan TRUE o FALSE en caso de cumplirse o no una expresión. Son los siguientes:

	//Retorna TRUE si valor1 y valor2 son exactamente iguales.
	valor1 := 10
	valor2 := 10
	fmt.Println(valor1 == valor2)

	//Retorna TRUE si valor1 es diferente de valor2.
	valor1 = 5
	fmt.Println(valor1 != valor2)

	//Retorna TRUE si valor1 es menor que valor2
	fmt.Println(valor1 < valor2)

	//Retorna TRUE si valor1 es mayor que valor2
	valor1 = 15
	fmt.Println(valor1 > valor2)

	//Retorna TRUE si valor1 es igual o mayor que valor2
	fmt.Println(valor1 >= valor2)

	//Retorna TRUE si valor1 es menor o igual que valor2.
	valor2 = 20
	fmt.Println(valor1 <= valor2)

	// Operadores lógicos
	// Son aquellos que retorna TRUE o FALSE
	// si cumplen o no una condición utilizando puertas lógicas.

	// Operador AND:
	// Este operador indica que todas las condiciones declaradas
	// deben cumplirse para poderse marcar como TRUE.
	// En Go, se utiliza este símbolo &&.

	// Esto retornará TRUE porque tanto la primera
	// como la segunda condición son verdaderas.
	fmt.Println(1 > 0 && 2 > 0)

	// Esto retornará FALSE porque una de las condiciones
	// no es verdadera.
	fmt.Println(2 < 0 && 1 > 0)

	// Operador OR:
	// Este operador indica que al menos una de las condiciones
	// debe cumplirse para marcarse como TRUE.
	// En Go, se representa con el símbolo ||.

	// Esto retornará TRUE porque la segunda condición se cumple,
	// a pesar que la primera no.
	fmt.Println(2 < 0 || 1 > 0)

	//Operador NOT:
	// Este operador retornará el opuesto al boleano
	// que está dentro de la variable

	myBool := true
	// Esto retornará false
	fmt.Println(!myBool)
}
> 
package main

import "fmt"

func main() {

	fmt.Printf("\n")

	// For decremental
	for j := 20; j > 0; j-- {
		fmt.Println(j)
	}
}

Es muy util tener la información mostrada de esta forma 😄