Operadores lógicos y de comparación

Aquí les comparto una supermega guía muy útil de Go
https://devhints.io/go

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.

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 😄