Contenido del curso
Operadores de Comparación y Lógicos en Go
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:
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 &&.
Ejemplo1: 1>0 && 2 >0 Esto retornará TRUE porque tanto la primera como la segunda condición son verdaderas.
Ejemplo2: 2<0 && 1 > 0 Esto retornará FALSE porque una de las condiciones no es verdadera.
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 ||.
Ejemplo: 2<0 || 1 > 0 Esto retornará TRUE porque la segunda condición se cumple, a pesar que la primera no.
Operador NOT:
Este operador retornará el opuesto al boleano que está dentro de la variable. Ejemplo:
myBool := true fmt.Println(!myBool) // Esto retornará false
Una vez ya estudiado la teoría, en la siguiente clase vamos a ver cómo utilizarlo con más detalles en Go.
Luis Arturo Cruz Cruz
Estudiante
Kebyn Enrique Ajin Elías
Estudiante
David Arias Fuentes
Estudiante
Daniel Jordano Gutierrez Janampa
Estudiante
Harold German Granados Guerrero
EstudianteHarold German Granados Guerrero
Estudiante
Jhimy Michel
Estudiante
Sergio Antonio Ochoa Martinez
Estudiante
Roberto Medina
Estudiante
Pineda Ordoñez David Steven
Estudiante
Jefferson Arenas
Estudiante
Arturo Sair García Amador
Estudiante
Enzo Venturi
Estudiante
Víctor Manuel Briseño León
Estudiante
Oscar Jaramillo
Estudiante
Flavio César Sandoval Muñoz
Estudiante
Osman Edmundo Ulloa Vásquez
Estudiante
Eliaz Bobadilla
EstudianteHola 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) }
Buen aporte, compañero :)
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. !Tabla de la verdad
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 :D
