Hola mundo en Go

1

Introducción al Curso de Golang

2

¿Qué es, por qué y quienes utilizan Go?

3

Instalar Go en Linux

4

Instalar Go en Mac

5

Instalar Go en Windows

6

Nuestras primeras líneas de código con Go

Variables, funciones y documentación

7

Variables, constantes y zero values

8

Operadores aritméticos

9

Tipos de datos primitivos

10

Paquete fmt: algo más que imprimir en consola

11

Uso de funciones

12

Go doc: La forma de ver documentación

Estructuras de control de flujo y condicionales

13

El poder de los ciclos en Golang: for, for while y for forever

14

Operadores lógicos y de comparación

15

El condicional if

16

Múltiple condiciones anidadas con Switch

17

El uso de los keywords defer, break y continue

Estructuras de datos básicas

18

Arrays y Slices

19

Recorrido de Slices con Range

20

Llave valor con Maps

21

Structs: La forma de hacer clases en Go

22

Modificadores de acceso en funciones y Structs

Métodos e interfaces

23

Structs y Punteros

24

Stringers: personalizar el output de Structs

25

Interfaces y listas de interfaces

Concurrencia y Channels

26

¿Qué es la concurrencia?

27

Primer contacto con las Goroutines

28

Channels: La forma de organizar las goroutines

29

Range, Close y Select en channels

Manejo de paquetes y Go Modules

30

Go get: El manejador de paquetes

31

Go modules: Ir más allá del GoPath con Echo

32

Modificando módulos con Go

Despedida del curso

33

Despedida

Bonus

34

Cheat Sheet Go

35

Librerías para desarrollo web con Go

36

Data Science con Go

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

El condicional if

15/36
Recursos

Aportes 61

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Me parece que está mal editado el video, habla de funciones para convertir texto a un entero, pero no usó eso :thi

Retos 1 y 2

package main

import "fmt"

func main()  {
	if isPair(6) {
		fmt.Println("Number is pair")
	} else {
		fmt.Println("Number is odd")
	}
	if isValidUser("Alpha5", "MyPassword") {
		fmt.Println("Credentials are valid")
	} else {
		fmt.Println("Credentials aren't valid")
	}
}

func isPair(num int) bool {
	return num % 2 == 0
}

func isValidUser(userName, pass string) bool {
	return userName == "Alpha" && pass == "MyPassword"
}

Reto 😃

Reto 1:

func esPar(num int) bool {
	result := num%2 == 0
	if result {
		fmt.Println(num, "es par")
	} else {
		fmt.Println(num, "NO es par")
	}
	return result
}

Reto 2:

func validUser(username, pass string) bool {
	return username == "kuro" && pass == "kuro"
}

Puertas lógicas 😅 años que no escuchaba a los operadores lógicos, me regresé a la uni ❣️

package main

import "fmt"

// 1. se requiere crear una funcion de un numero que recibe
// esa funcion es par o impar

// 2. se requiere una funcion que reciba un usuario
// un pasword y revise si es valido o no, se espera un retorno
// true

func main() {

	// 1. Declaracion de variable optima
	const num int8 = 100
	// Hacemos comprobacion de valores usando el operador de Modulo
	if num%2 == 0 {
		// Se imprime en pantalla usando el printf para construir un mesaje
		fmt.Printf("El numero %d es un numero PAR\n", num)
		// Agrego else en caso de que no se cumpla la condicion
	} else {
		fmt.Println("El numero es IMPAR")
	}

	// 2. Guardamos los datos del usuario optimizados
	const user string = "Max"
	const pasword int16 = 1995
	// Validamos los datos con operador and, para comprobar ambos
	if user == "Max" && pasword == 1995 {
		// imprimimos con Printf para mensaje personalizado
		fmt.Printf("EL usuario %s tiene permiso para iniciar secion\n", user)
		// Agrego else en caso de que no se cumpla la condicion
	} else {
		fmt.Print("Parece hay un error en los datos")
	}

}

Este es mi aporte

package main

import "fmt"

func main() {
	num := 9
	if num%2 == 0 {
		fmt.Println("es par")

	} else {

		fmt.Println("es impar")
	}
	password := "quesochedar"
	if password == "quesochedar" {
		fmt.Println("esta es la contraseña")
	} else {
		fmt.Println("vuelvelo a intentar")
	}

}
package main

import (
	"fmt"
)

func pairOdd(){
    var num int

    fmt.Print("Ingresa tu número: ")
    // Para leer datos en la terminal
    fmt.Scanf("%d\n", &num)

    for num >= 2 {
        num = num - 2
    }

    if num < 0 {
        println("Ingrese un número mayor a 0")
    } else {
        if num == 0 {
            fmt.Println("Es par")
        } else {
            fmt.Println("Es impar")
        }
    }
}

func passwordCheck(){
    var userPass string
    const pass = "password"
    fmt.Print("Ingrese su contraseña: ")
    // Para leer datos en la terminal
    fmt.Scanf("%s\n", &userPass)
    if pass == userPass {
        fmt.Println("Acceso permitido")
    } else {
        fmt.Println("Acceso denegado")
    }
}

func main(){
    pairOdd()
    fmt.Println("")
    passwordCheck()
}

El condicional If


Regularmente cuando programamos nuestros algoritmos, llega un momento donde las acciones que se deben realizar dependerán un poco o mucho del valor o el estado de alguna variable (o constante) que especifiquemos.

<aside>
<img src=“https://static.platzi.com/media/achievements/badge-go-57d6b6ee-c9de-4d9e-9e2c-29a0c879748d-1859b16d-1c87-4b38-bf0a-aee1256cc355.webp” alt=“https://static.platzi.com/media/achievements/badge-go-57d6b6ee-c9de-4d9e-9e2c-29a0c879748d-1859b16d-1c87-4b38-bf0a-aee1256cc355.webp” width=“40px” /> La sentencia if (si, en inglés) verifica que la expresión que se le indique sea verdadera para entonces ejecutar la sección de código destinada solamente a ejecutarse cuando eso suceda. Si la condicional es falsa, se continúa ejecutando el código de forma secuencial.

</aside>

package main
import "fmt"
func main() {
  /*variable local de tipo entero*/
  var calificacion int = 5
  /*Sentencia if, que verifica si calificación es menor a 6*/
  if calificacion < 6 {
    /*Si la condición se cumple, imprime*/
    fmt.Println("Reprobaste")
  }
  fmt.Println("Tu calificación fue de: ", calificacion)
}

Cuando necesitamos que el programa ejecute ciertas sentencias cuando la condición es verdadera, pero a su vez necesitamos que ejecute otras sentencias solamente cuando la condición es falsa, necesitamos una sentencia condicional if-else
.

package main
import "fmt"
func main() {
  /*variable local de tipo entero*/
  var calificacion int = 7
  /*Sentencia if, verifica calificación menor 6*/
  if calificacion < 6 {
    /*Si la condición se cumple*/
    fmt.Println("Reprobaste")
  }else{
    /*Si la condición no se cumple*/
    fmt.Println("Aprobaste")
  }
  fmt.Println("Tu calificación fue de: ", calificacion)
}
  • Un if puede tener 0 o 1 else que funciona para señalar las sentencias que se ejecutan cuando no se cumplió ninguna de las condiciones anteriores.
  • Un if puede tener de 0 a N else if siempre y cuando no estén después de un else (ya que el ***else***, en caso de que exista, debe ser la sentencia final).
package main

import "fmt"

func is_even(n int) bool{
	if n % 2 == 0 {
		return true
	} else {
		return false
	}
}

func user_password(user, password string) string {
	if user == "platzi" && password == "nuncaparesdeaprender"{
		return "Bienvenido"
	} else {
		return "Usuario o contraseña incorrecta"
		
	}
}


func main() {
	fmt.Println(is_even(7))
	fmt.Println(user_password("platzi", "nuncaparesdeaprender"))
}

Solución a los dos restos

func isPar(a int) bool {
	return a%2 == 0
}

func matchPassword(a, b string) bool {
	return a == b
}

Esta es mi solución para los retos

package main

import (
	"fmt"
)

func tipoNumero(n int) {
	if n%2 == 0 {
		fmt.Println("Es un número par")
	} else {
		fmt.Println("No es un número impar")
	}
}

func seguridad(user, password string) {
	if user == "Pancho" && password == "cocacola123" {
		fmt.Println("Acceso autorizado")
	} else {
		fmt.Println("Acceso denegado")
	}
}

func main() {
	// Reto 1: Determinar si un número es par o impar
	tipoNumero(10)
	// Reto 2: Comparar usuario y password para dar acceso a una plataforma
	seguridad("Pancho", "cocacola123")
}

package main

import (
“fmt”
)

func main() {
parImpar(4)

if verification("Nicolas", "12345") {
	fmt.Println("Acceso permitido")
} else {
	fmt.Println("Acceso denegado")
}

}

func parImpar(value int) {
if value%2 == 0 {
fmt.Println(value, “Es par”)
} else {
fmt.Println(value, “Es impar”)
}
}

func verification(userName, pass string) bool {
return userName == “Nicolas” && pass == “123”
}

Aquí va mi solución:

func oddOrEven(num int) bool {
	return num%2 == 0
}

func userPassComparison(user string, pass string) bool {
	const realUser string = "luciano"
	const realPass string = "admin123"
	return realUser == user && realPass == pass
}

func main() {
	val1 := 1
	val2 := 2
	fmt.Println("oddOrEven:", oddOrEven(val1))
	fmt.Println("oddOrEven:", oddOrEven(val2))
	fmt.Println("userPassComparison:", userPassComparison("luciano", "admin123"))
	fmt.Println("userPassComparison:", userPassComparison("jose", "larralde"))
}

Saludos!!

~Reto 1 :

func numero_Par_Impar(numero int) {

	if numero%2 == 0 {

		fmt.Println(true)

	} else {

		fmt.Println(false)
	}

}

~Reto 2 :

func comparador_usuario_contraseña(nombre_usuario, contraseña_usuario string) {

	if nombre_usuario == "John" {
		fmt.Println(true)
		contraseña_usuario, err := strconv.Atoi(contraseña_usuario)
		if err != nil {
			log.Fatal(err)

		} else {

			if contraseña_usuario == 1234 {

				fmt.Println(true)
				fmt.Println("acceso Permitido.")
			}
		}
	}
}

~Funcion Main :

func main() {
	
	var numero int = 2
	numero_Par_Impar(numero)
	var nombre string = "John"
	var clave string = "1234"
	comparador_usuario_contraseña(nombre, clave)


}

Mi solucion al reto:
//RETO DE PAR O IMPAR:

func parImpar(value int64) string {
	if value%2 == 0 {
		return "Es par"
	} else {
		return "Es impar"
	}

}

//RETO DE VERIFICACION:

func verification(user, password string) bool {
	myuser := "Adrian"
	mypassword := "12345678"
	if user == myuser && password == mypassword {
		return true
	} else {
		return false
	}
}

Retos 1 y 2

func isPar(numero int) string {
	if numero%2 == 0 {
		return "Es par"
	} else {
		return "No es par"
	}
}

func login(username, password string) bool {

	return username == "armandoperez" && password == "Test123"

}

func main() {

	numero := 3

	esPar := isPar(numero)
	fmt.Println(esPar)

	auth := login("armandoperez", "Test123")

	if auth {
		fmt.Println("Esta logueado")
	} else {
		fmt.Println("No esta logueado")
	}

}

Retos 1 y 2

package main

import "fmt"

func isEven(value int) bool {
	return value%2 == 0
}
func passwordMatch(password1 string, password2 string) bool {
	return password1 == password2
}

func main() {
	// challenge 1
	const value int = 5
	fmt.Printf("Is %d even? %t\n", value, isEven(value))

	// challenge 2
	const password1 string = "pass1"
	const password2 string = "pass2"
	if passwordMatch(password1, password2) {
		fmt.Println("Passwords Match")
	} else {
		fmt.Println("Passwords are different")
	}
}

😄 esta muy cool

package main

import "fmt"

func isOdd(number int)	bool {
	if number % 2 == 0 {
		return 	true
	} 
	return false
}

func isAuth(user, password string) string {
	if(user == "marco" && password == "hola1234") {
		return "You're authenticated, come in"
	}
	return "Error to auth"
}

func main(){
	fmt.Println(isOdd(300))
	fmt.Println(isOdd(301))
	fmt.Println(isAuth("marco", "hola12"))
	fmt.Println(isAuth("marco", "hola1234"))
}
package main

import (
	"fmt"
)

func main() {
	isAPair := isPair(8)
	fmt.Println(isAPair)

	messageE := isCorrectPassword("HOLA", "HOLA")
	fmt.Println(messageE)

	messageE = isCorrectPassword("HOLA", "HOLA1")
	fmt.Println(messageE)

}

func isCorrectPassword(username, password string) string {

	if "HOLA" == username && "HOLA" == password {
		return "Correct password"
	}

	return "wrong password"

}

func isPair(number int) bool {
	return number%2 == 0
}

Hey devs! Normalmente suelo ejecutar la lógica de las funciones dentro de las mismas, de esta manera:

//Nombre del paquete
package main

import "fmt"

func loginUsuario(usuario, password string) {
	if usuario == "Pepe" && password == "1234" {
		println("Bienvenido al sistema")
	} else {
		println("Error al autenticar")
	}
}

func parImpar(numero int) {
	//Si el resultado de la div es exacta, el resto es cero
	if numero%2 == 0 {
		fmt.Println("El número es par")
	} else {
		fmt.Println("El número es impar")
	}
}

func main() {

	//Funcion de logueo
	loginUsuario("Pepe", "1234")

	//Para detectar si un número es par
	parImpar(2)

}

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.

Retos.

var numero int
fmt.Print(“Ingrese un numero:”)
fmt.Scan(&numero)

if numero%2 == 0 {
	fmt.Println(numero, " Es par.")
} else {
	fmt.Println(numero, " Es impar.")
}

var usuario, password string
fmt.Print("Ingrese su usuario: ")
fmt.Scan(&usuario)
fmt.Print("Ingrese su contraseña: ")
fmt.Scan(&password)

if usuario == "RiverPlate" && password == "elmasgrandelejos" {
	fmt.Printf("Usuario y contraseña coinciden, Bienvenido %s", usuario)
} else {
	fmt.Println("Los datos ingresados no coinciden, ingreselos nuevamente.")
}
func main() {
	if isPar(10) {
		fmt.Println("Es par")
	} else {
		fmt.Println("No es par")
	}

	if authenticate("platzi", "platzi") {
		fmt.Println("Bienvenido")
	} else {
		fmt.Println("Credenciales erroneas")
	}
}

func isPar(number int) bool {
	return number%2 == 0
}

func authenticate(username, password string) bool {
	return username == "platzi" && password == "Pl4Tz1"
}

Reto usando funciones anonimas:

package main

import ("fmt")

var(
  ispar = func(n int)            bool {return n % 2 == 0 }
  isuse = func(a, b string)  bool {return a == "egzt" && b == "123"}
)

func main(){
  fmt.Println(ispar(4))
  fmt.Println(isuse("egzt", "123"))
}

Yo lo hice de esa manera 😃

package main

import "fmt"

func isOddOrEven(value int) (info string)  {
	if value % 2 == 0 {
		return `is Even`
	}
	return `is Odd`
}

func validUserAndPassword(user, pass string) (result string)  {
	const (
		userName = "mrWork"
		password = "[email protected]"
	)

	if userName == user && password == pass{
		return `user valid`
	}

	return `user invalid`
}

func main()  {
	response := isOddOrEven(11)
	user := validUserAndPassword("mrWork", "[email protected]")
	fmt.Println(response, ` - `, user)
}

Mis respuestas

func main {
	// Practica: Determinar si un numero es par o impar
	numeroParImpar(8)
	numeroParImpar(3)

	// Practica: Comprobar usuario y password
	revisarOne := checkUserPass("peramon", "123456787")
	revisarTwo := checkUserPass("peramon", "123456")

	fmt.Println("Intento 1 -> ", revisarOne, "\nIntento 2 -> ", revisarTwo)
}

// Par o impar
func numeroParImpar(numero int) {
	if numero != 0 && numero%2 == 0 {
		fmt.Println("El numero es par")
	} else {
		fmt.Println("El numero es impar")
	}
}

// Usuario y pass
func checkUserPass(user, pass string) bool {
	if user == "peramon" && pass == "123456" {
		return true
	} else {
		return false
	}
}

😃

Retos

//Numero Par o Impar
	numero := 10
	if numero%2 == 0 {
		fmt.Println("el numero es par")

	} else {

		fmt.Println("el numero es impar")
	}

	//Ingreso al sistemas comprando contraseña

	contra := "JhoFlo10."
	if contra == "JhoFlo10." {
		fmt.Println("Datos Correctos")
	} else {
		fmt.Println("Datos Incorrectos")
	}

Command Line Interface (CLI) para verificar si los números escritos son pares o impares.

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func isEven(number uint64) bool {
	return number % 2 == 0
}

func isOdd(number uint64) bool {
	return number % 2 == 1
}

func main() {
	// Usage: go run src/main.go
	// ----------------------------------------------
	// Command Line Interface for Odds & Even Numbers
	// ----------------------------------------------
	// $ 1
	// The number 1 is an odd number.
	// $ 2
	// The number 2 is an even number.
	// $ 5
	// The number 5 is an odd number.
	// $ 7
	// The number 7 is an odd number.
	// $ 8
	// The number 8 is an even number.
	// $ exit

	reader := bufio.NewReader(os.Stdin)
	fmt.Println("----------------------------------------------")
	fmt.Println("Command Line Interface for Odds & Even Numbers")
	fmt.Println("----------------------------------------------")

	for {
		fmt.Print("$ ")

		text, _ := reader.ReadString('\n')
		// Convert CRLF to LF
		text = strings.Replace(text, "\n", "", -1)

		if text == "exit" {
			break
		}

		textToInteger, _ := strconv.ParseUint(text, 10, 64)

		if isEven(textToInteger) {
			fmt.Printf("The number %d is an even number.", textToInteger)
		} else if isOdd(textToInteger) {
			fmt.Printf("The number %d is an odd number.", textToInteger)
		}

		fmt.Println()
	}
}

Reto:

package main

import “fmt”

func checkData(U, P string) {
user1 := "Example1"
password := "1234pass"
if user1 == U && password == P {
fmt.Println(“Logged successfully !!”)
} else {
fmt.Println(“Incorrect username or password”)
}

}

func main() {
checkData(“Example1”, “1234pass”)
}

sencillo pero funcional

func esPar(num int) bool {
	return num%2 == 0
}

func login(user, pass string) bool {
	const USER = "admin"
	const PASS = "root"
	return user == USER && pass == PASS
}

Reto 😀

package main

import "fmt"

func esPar(number int) bool {
	return number%2 == 0
}

func validateUser(user, password string) bool {
	return user == "jhon" && password == "123456"
}

func main() {
	var number int = 17

	if esPar(number) {
		fmt.Println("El número",number,"es par")
	} else {
		fmt.Println("El número",number,"es impar")
	}

	var user = "jhon"
	var pass = "123456"

	if validateUser(user, pass) {
		fmt.Println("Logueado correctamente")
	} else {
		fmt.Println("Usuario o contraseña incorrectas")
	}
}

Reto de la clase:

package main
import "fmt"

func main () {
	username := "rober16"
	password := "123456"

	if username == "rober16" && password == "123456" {
		fmt.Println("Las credenciales son correctas")
	} else {
		fmt.Println("Ups! sus credenciales no son correctas")
	}

	par := 8

	if par % 2 == 0 {
		fmt.Println("El número", par, "es par")
	} else {
		fmt.Println("El número", par, "no es par")
	}

}
<
package main

import "fmt"

// Una funcion que valida si un número es par o no
func esPar(numero int) string {
	if numero%2 == 0 {
		return "El número es par"
	} else {
		return "El número es impar"
	}

}

// Una funcion que resive un usuario y un password y verifica si son correctos para iniciar sesión
func iniciarSesion(usuario string, password string) string {
	if usuario == "Cesarsan28" && password == "contraseña" {
		return "Bienvenido"
	} else {
		return "Usuario o contraseña incorrectos"
	}
}

func main() {
	// Variables para funcion de iniciar sesion
	var usuario string
	var password string

	// Preguntamos por el usuario
	fmt.Println("Introduce tu usuario:")
	fmt.Scanln(&usuario)

	// Preguntamos por el password
	fmt.Println("Introduce tu contraseña:")
	fmt.Scanln(&password)

	// Imprimimos el resultado de la funcion
	fmt.Println(iniciarSesion(usuario, password))

	// Variables para funcion de validar si es par o no
	var numero int

	// Preguntamos por el numero
	fmt.Println("Introduce un número:")
	fmt.Scanln(&numero)

	// Imprimimos el resultado de la funcion
	fmt.Println(esPar(numero))
}
> 

Otra visión a la clase:

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("=================")
	fmt.Println("El condicional IF")
	fmt.Println("=================")
	fmt.Println()

	fmt.Println("Como se indica en los videos la instrucción IF se declara igual que en C, Java, kotlin pero sin añadir entre" +
		" paréntesis las condiciones. El caso es que se puede con estos paréntesis y funciona, compila, pero el corrector" +
		" de estilo del editor los quita.")
	fmt.Println()

	fmt.Println("En el siguiente ejemplo se usa el operador de comparación de igualdad y los operadores lógicos AND '&&' y OR '||'")
	fmt.Println()

	fmt.Println("Declaración:")
	fmt.Println()

	fmt.Println("if (valor1 == 1 && valor2 == 2) || valor3 == 3 { fmt.Println(\"IF > Se cumplen las condiciones.\") } else { fmt.Println(\"ELSE > No se cumplen las condiciones del IF\") }")
	fmt.Println()

	fmt.Println("Para la declaración de valores en el código, el resultado es:")
	fmt.Println()

	const valor1 int8 = 11
	var valor2 int16 = 22
	valor3 := 33

	if (valor1 == 1 && valor2 == 2) || valor3 == 3 {
		fmt.Println("IF > Se cumplen las condiciones.")
	} else {
		fmt.Println("ELSE > No se cumplen las condiciones del IF")
	}

	fmt.Println()

	fmt.Println("Finalmente dejo un experimento con FMT y decisiones lógicas")
	fmt.Println()

	fmt.Printf("Con el valor >>> %t <<< confirmo que la siguiente sentencia da Verdadero:\n" + 
	"(valor1 == 1 && valor2 == 2) || valor3 == 33\n\n", (valor1 == 1 && valor2 == 2) || valor3 == 33)
}

El reto:

	if number%2 == 0 {
		fmt.Println("This is odd")
	} else {
		fmt.Println("This is even")
	}
}

func passwordValidation(user, password string) bool {
	nickname := "alvaro"
	pass := "alvaro"
	return user == nickname && password == pass

No sé hasta que punto vea cambios, llevo años desarrollando en Java y JavaScript, por ahora veo la forma de declarar variables, el tipo de dato y declarar con asignación a una variable tipo const.

Vamos a ver como va el curso

Reto 1, escribiendo input desde consola

var number int

	fmt.Println("Write any number")
	fmt.Scan(&number)

	numberType := number % 2

	if numberType == 0 {
		fmt.Printf("%d is even", number)
	} else {
		fmt.Printf("%d is odd", number)
	}

Reto 2, ingresando datos desde consola

defaultUser := "admin"
	defaultPassword := "12345"
	var inputUser string
	var inputPassword string

	fmt.Print("Username: ")
	fmt.Scanln(&inputUser)
	fmt.Print("Password: ")
	fmt.Scanln(&inputPassword)

	if inputUser == defaultUser && inputPassword == defaultPassword {
		fmt.Print("Success login")
	} else {
		fmt.Print("Failed login")
	}

package main

import “fmt”

func main() {
numberOne := 2
numberTwo := 3

if isPair(numberOne) == true {
	fmt.Println("the numberOne", numberOne, "is pair.")
} else {
	fmt.Println("the numberOne", numberOne, "is not pair.")
}

if isPair(numberOne) == true {
	fmt.Println("the numberTwo", numberTwo, "is pair.")
} else {
	fmt.Println("the numberTwo", numberTwo, "is not pair.")
}

userTest := "admin"
pwdTest := "admin123"

if login(userTest,pwdTest) == true {
	fmt.Println("Login Ok")
} else {
	fmt.Println("Access denied")
}

}

func isPair(number int) bool {

if number % 2 == 0 {
	return true

} else {
	return false
}

}

func login(user string, password string) bool {
if user == “admin” && password == “admin123”{
return true
} else {
return false
}
}

Comparto mi solución a los 2 retos 😃

package main

import "fmt"

func esPar(a int) bool {
	return a%2 == 0
}

func comp(a, b string) bool {
	return a == "erick" && b == "1a2b3c"
}

func main() {

	n := 11
	res := esPar(n)

	if res == true {
		fmt.Printf("El %d es par\n", n)
	} else {
		fmt.Printf("El %d no es par\n", n)
	}

	acceso := comp("erick", "1a2b3c")
	if acceso == true {
		fmt.Println("Bienvenido\n")
	} else {
		fmt.Println("Los datos son incorrectos\n")
	}

}
package main

import (
	"fmt"
)

func nParImpar(n int) {
	if n%2 == 0 {
		println("n ingresado es par")
	} else {
		fmt.Println("n ingresado es impar")
	}

}

func compare(id, pass string) {
	if id == pass {
		fmt.Println("el id y la contrasenha son iguales")
	} else {
		fmt.Println("el id y la contrasenha no son iguales")
	}
}

func main() {
	nParImpar(8)
	compare("kevin", "kevdin")
}

Reto 1

func isPar(x int){
	if x%2==0 {
		fmt.Printf("¡%d es par!\n",x)
	} else {
		fmt.Printf("Lo siento bro, %d no es par :/",x)
	}
}

Reto 2

func iniSesion(username, password string){
	var usernameCorrecto string = "Lalo Quita"
	var passwordCorrecto string = "password"
	if username == usernameCorrecto && password==passwordCorrecto {
		fmt.Println("Sesion iniciada")
	} else if username == usernameCorrecto {
		fmt.Println("Contraseña incorrecta")
	} else if password == passwordCorrecto {
		fmt.Println("Nombre de usuario incorrecto")
	} else {
		fmt.Println("Nombre y contraseña incorrectos")
	}
}

Mi solución al reto:

package main

import "fmt"

func esPar(n int) bool {
	if n%2 == 0 {
		fmt.Printf("%d es un número par.\n", n)
		return true
	} else {
		fmt.Printf("%d es un número impar.\n", n)
		return false
	}
}

func validarUsuario(usr, pwd string) bool {
	const usrBase = "Miguel"
	const pwdBase = "qwerty"
	if usr == usrBase && pwd == pwdBase {
		fmt.Println("Usuario y contraseña validos")
		fmt.Printf("¡Bienvenido %s!\n", usr)
		return true
	} else {
		fmt.Println("Usuario o contraseña incorrectos")
		fmt.Println("¡Acceso denegado!")
		return false
	}
}

func main() {
	esPar(15) //15 es un número impar.
	esPar(12) //12 es un número par.
	fmt.Println("")

	validarUsuario("Eustaquio", "qwerty")
	fmt.Println("")
	// Usuario o contraseña incorrectos
	// ¡Acceso denegado!

	validarUsuario("Miguel", "12345")
	fmt.Println("")
	// Usuario o contraseña incorrectos
	// ¡Acceso denegado!

	validarUsuario("Miguel", "qwerty")
	fmt.Println("")
	// Usuario y contraseña validos
	// ¡Bienvenido Miguel!
}

Resultado:

15 es un número impar.
12 es un número par.

Usuario o contraseña incorrectos
¡Acceso denegado!

Usuario o contraseña incorrectos
¡Acceso denegado!

Usuario y contraseña validos
¡Bienvenido Miguel!

Her i go 😄

package main

import "fmt"

func check_even(num int) string {
	if num%2 == 0 {
		return "even"
	} else {
		return "odd"
	}

}

func check_pwd(user, pwd string) bool {
	if user == "user" && pwd == "1234" {
		return true
	} else {
		return false
	}
}

func main() {
	var result string = check_even(1)
	var user string
	var pwd string
	fmt.Printf("Number is %s\n", result)
	fmt.Print("give me your user: ")
	fmt.Scanf("%s", &user)
	fmt.Print("give me your password: ")
	fmt.Scanf("%s", &pwd)
	var check_user = check_pwd(user, pwd)
	fmt.Println("is user in?", check_user)
}

Even or Odd

func main() {
	result := oddOrEven(15)
	println(result)
	result = oddOrEven(6)
	println(result)
	result = oddOrEven(1523)
	println(result)
}

func oddOrEven(number int) string {
	if number % 2 == 0 {
		return "Odd"
	} else {
		return "Even"
	}
}

Terminal Output

λ developer src → λ git main* → go run main.go
Even
Odd
Even

Respuesta de los retos 1 y 2

package main

import "fmt"

func main() {
	valor1 := 1
	valor2 := 2

	if valor1 == 1 {
		fmt.Println("Es 1")
	} else {
		fmt.Println("No es 1")
	}

	//With and
	if valor1 == 1 && valor2 == 2 {
		fmt.Println("Es verdad")
	}

	//With or
	if valor1 == 0 || valor2 == 2 {
		fmt.Println("Es verdad con alguno de los 2")
	}

	numeroPar := 8
	numeroImpar := 11

	result := isPar(numeroPar)

	if result {
		fmt.Printf("El numero %d es Par\n", numeroPar)
	}

	result = isPar(numeroImpar)

	if result {
		fmt.Printf("El numero %d es Par\n", numeroPar)
	} else {
		fmt.Printf("El numero %d es Impar\n", numeroImpar)
	}

	password1 := "Password123"
	password2 := "Password123"
	password3 := "Password789"

	if isValidPassword(password1, password2) {
		fmt.Println("El password es valido!!")
	} else {
		fmt.Println("El password Incorrecto!!")
	}

	if isValidPassword(password1, password3) {
		fmt.Println("El password es valido!!")
	} else {
		fmt.Println("El password Incorrecto!!")
	}

}

func isPar(number int) (result bool) {
	if number%2 == 0 {
		return true
	}
	return false
}

func isValidPassword(password1, password2 string) (result bool) {
	if password1 == password2 {
		return true
	}
	return false
}

Primer reto:

package main

import "fmt"

func parOImpar(numero int) {
	if numero % 2 == 0 {
		fmt.Printf("El número %d es par", numero)
	} else {
		fmt.Printf("El número %d es impar", numero)
	}
}

func main() {
	parOImpar(13)
}

Segundo reto:

package main

import "fmt"

func validateUser(user string, password string) {
	if user == "admin" && password == "admin123" {
		fmt.Printf("Acceso permitido")
	} else {
		fmt.Printf("Acceso denegado")
	}
}

func main() {
	validateUser("admin", "admin123")
}

Reto 1 (Saber si un numero es par o impar):

package main

import "fmt"

func esPar(num int) {
	if num%2 == 0 {
		fmt.Println("Es par")
	} else {
		fmt.Println("Es impar")
	}
}

func main() {
	var num = 10
	esPar(num)
}

Output:
Es par

Reto 2 (Saber si la contraseña es correcta o incorrecta):

package main

import "fmt"

func validarContrasena(contrasena, ingresado string) {
	if contrasena == ingresado {
		fmt.Println("Contraseña correcta")
	} else {
		fmt.Println("Contraseña incorrecta")
	}
}

func main() {
	var contrasena = "123Alex"
	var ingresado = "123alex"
	validarContrasena(contrasena, ingresado)
}

Output:
Contraseña incorrecta

CODIGO:

package main

import (
	"fmt"
)

var users = map[string]string {
	"user1": "pass1",
	"user2r": "pass2",
	"user3": "pass4",
	"user4": "pass4",
	"user5": "pass5",
}

func isOddOrEven(number int) {
	var result string
	isEven := number%2 == 0
	if isEven {
		result = "par"
	} else {
		result = "impar"
	}
	fmt.Printf("El numero = \"%d\" es %s\n", number, result)
}

func validate(username, password string) bool {
	validUser := users[username] == password
	if validUser  {
		fmt.Printf("Las credenciales del usuario \"%s\" son validas\n", username)
	} else {
		fmt.Printf("Las credenciales del usuario \"%s\" son invalidas\n", username)
	}
	return 	validUser
}

func main() {
	// Un numero es par o impar
	isOddOrEven(2020)
	isOddOrEven(2021)

	// Validar credenciales
	validate("user1", "pass1")
	validate("user3", "pass2")
	validate("user7", "pass7")
} 

RESULTADO:

El numero = "2020" es par
El numero = "2021" es impar
Las credenciales del usuario "user1" son validas
Las credenciales del usuario "user3" son invalidas
Las credenciales del usuario "user7" son invalidas 

Ejemplo de condicionales:

//CONDITIONALS
	//IF
	value1 := 5
	value2 := 8

	if value1 == 6 {
		fmt.Println("Value 6")
	} else {
		fmt.Println("Not 6")
	}

	if value1 == 6 && value2 == 8 {
		fmt.Println("Both, 6 and 8 are correct")
	} else {
		fmt.Println("One or both are wrong")
	}

	if value1 == 6 || value2 == 8 {
		fmt.Println("One or both, 6 and 8 are correct")
	} else {
		fmt.Println("Both are wrong")
	}

	if value1 != 6 {
		fmt.Println("Isn't 6")
	} else {
		fmt.Println("Is 6")
	}

Aquí mi solución a los retos

func isEven(n int) bool {
	//Function to determine if a number is odd or even
	if n%2 == 0 {
		return true
	}
	return false
}

func validateUserCredentials(user, password string) bool {
	// Validate that the credentials are correct
	if user != "" && password != "" {
		return true
	}
	return false
}

func main() {
	var number int
	fmt.Print("Enter a number to determine if it is even: ")
	fmt.Scan(&number)
	fmt.Println("Is the number even?", isEven(number))

	var username, password string
	fmt.Print("Enter you username and your password separated by spaces: ")
	fmt.Scanf("%s %s", &username, &password)
	if validateUserCredentials(username, password) {
		fmt.Println("VALID LOGIN!")
	} else {
		fmt.Println("WRONG USERNAME AND PASSWORD")
	}
}

Reto 2 con la posibilidad de ingresar la contraseña desde la terminal:

Reto 1:

les presento mi versión de los retos 🤠

package main

import "fmt"

func parImpar(numero int )(string){
	if numero % 2 == 0{
		return "Es par"
	}else{
		return "Es impar"
	}
}
func validar(usuario string, password string) (string) { 
	root:="platzi"
	pass:="platzii"
	if  usuario==root && password==pass {
		return "Acceso Correcto 🚀"
	}else{
		return "Vuelve a intentarlo 💥💥"
	}
}

func main() {
	fmt.Println(parImpar(10))
	fmt.Println(parImpar(5))

	usuario := "Platzi"
	password:= "root"
	fmt.Println(validar(usuario, password))
	
	usuario = "platzi"
	password = "platzii"
	
	fmt.Println(validar(usuario, password))
	
}

los resultados

Solución de los retos:

unc evenOdd(number int) bool {
	return number%2 == 0
}

func userAuth(userName, password string) bool {
	_userName := "gouser"
	_password := "12345"

	if userName == _userName && password == _password {
		return true
	}
	return false
}

func main() {
	if evenOdd(6) {
		fmt.Println("Es Par")
	} else {
		fmt.Println("Es Impar")
	}

	if userAuth("gouser1", "12345") {
		fmt.Println("Usuario autenticado")
	} else {
		fmt.Println("Usuario no existe")
	}
}

🔐 Login simulation

func main() {
	isLogin := login("platzerito", "nuncaParesDeAprender")
	fmt.Println(isLogin)
}

func login(username, password string) bool {
	usernameStorage := "platzerito"
	passwordStorage := "nuncaParesDeAprender"

	if username == usernameStorage && password == passwordStorage {
		return true
	}

	return false
}

Solución del ejercicio 1

package main

import (
	"fmt"
)

func isOdd(numToCheck int) bool {
	if numToCheck % 2 == 0 {
		return false
	} else {
		return true
	}
}

func evenChecker()  {
	
	fmt.Println("Ingresa un número: ")
	
	var usrNum int
	fmt.Scanln(&usrNum)
	if isOdd(usrNum) {
		fmt.Printf("El número %d es impar\n", usrNum)
	} else {
		fmt.Printf("El número %d es par\n", usrNum)
	}
}

func main()  {
	/* Reto 1 : Revisar si el número dado por el usuario es par o no */
	evenChecker()
}

Solución reto 2:

Para este reto usé una librería de go que recibe el password sin mostrarlo en pantalla

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"syscall"
	"golang.org/x/crypto/ssh/terminal"
)

func usrValidator() {
	
	allowedUsr := "test"
	allowedPass := string("securepass00")
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Ingresa tu usuario: ")
	username, _ := reader.ReadString('\n')
	fmt.Print("Ingresa tu contraseña: ")
	bytePass, _ := terminal.ReadPassword(syscall.Stdin)
	password := string(bytePass)
	
	username = strings.TrimSpace(username)
	password = strings.TrimSpace(password)

	if username == allowedUsr && password == allowedPass {
		fmt.Print("\nUsuario autorizado\n")
	} else {
		fmt.Print("\nOpps! No tienes permisos para ver esta información\n")
	}

}

func main()  {
	/* Reto 2 : Validar si un usuario y contraseña está autorizado para acceder a una platadorma */
	usrValidator()
}
func ispar(numero int) bool {
	if numero%2 == 0 {
		fmt.Println("Es par")
		return true
	} else {
		fmt.Println("Es inpar")
		return false
	}
}

func passwordPass(pass1 string, pass2 string) bool {
	if pass1 == pass2 {
		fmt.Println("Son iguales")
		return true
	} else {
		fmt.Println("No son iguales")
		return false
	}
}

En Go, un statement puede ser parte de un condicional. Por ejemplo, para convertir un string a un int se puede utilizar la función Atoi del paquete strconv. La función devuelve un int si la conversión es exitosa. De lo contrario, devuelve un error. Así:

func main() {
	a := "10"
        // n y err están en el scope de main
	n, err := strconv.Atoi(a)
	if err != nil {
		panic(err)
	}
	fmt.Printf("The value of a is %d\n", n)
}

El statement strconv.Atoi puede ejecutarse en la misma declaración del condicional:

func main() {
	a := "10"
        // Inline
	if n, err := strconv.Atoi(a); err != nil {
		panic(err)
	} else {
		fmt.Printf("The value of a is %d\n", n)
	}
}

Aquí hace falta la rama else porque las variables declaradas en el statement (n y err) sólo están disponibles en el scope del condicional y no en el de la función main. Todo depende del caso de uso, pero a ustedes, ¿cuál versión les gusta más?

// Reto 1
func isPair(num int) {
	if num%2 == 0 {
		fmt.Printf("El numero %d es par \n", num)
	} else {
		fmt.Printf("El numero %d es impar \n", num)
	}
}

// Reto 2
func login(username string, password string) {
	if username == "david" && password == "sanchez" {
		fmt.Printf("Bienvenido %s \n", username)
	} else {
		fmt.Printf("Credenciales incorrectas \n")
	}
}