Switch

Clase 9 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Avelino Sánchez

student•

El operador switch nos sirve para resolver o facilitar los casos que requieran múltiples comparaciones; en especial cuando se tienen más de 3 comparaciones. Lo anterior es debido a que sino se podrían resolver con un if, else if y else.

La sintaxis en Go para el operador switch es la siguiente:

switch val {
case &quot;a&quot;:
	fmt.Println(&quot;Case A&quot;)
case &quot;b&quot;:
	fmt.Println(&quot;Case B&quot;)
case &quot;c&quot;:
	fmt.Println(&quot;Case C&quot;)
default:
	fmt.Println(&quot;Invalid input&quot;)
}

Para aquellos casos en los que ninguna de las comparaciones puede manejarlo, utilizamos la palabra reservada default. Esta tiene una funcionalidad muy similar a else, que se ejecuta cuando ninguna de las comparaciones se realizó.

Enrique Montes Trejo

student•

gracias por el aporte

Elmer Padilla Espinoza

student•

De bastante utilidad.

Anthony Smith Quispe De la cruz

student•

Aquí os dejo mi calculadora:

package main

import (
	"bufio"
	"errors"
	"fmt"
	"os"
	"regexp"
	"strconv"
)

const ( //Raw strings para el control con expresiones regulares de las operaciones que recibira la calculadora.
	operationRegexp string = `[0-9]+(\.[0-9]+)?[\+\-\*/][0-9]+(\.[0-9]+)?` //Comprueba que inserte un float operador float
	operatorsRegexp string = `[\+\-\*/]`                                   //Comprueba si se trata de un operador permitido.
)

func getInput() string {
	fmt.Println("Insert an operation")
	input := bufio.NewScanner(os.Stdin)
	input.Scan()
	return input.Text()
}

func obtainOperation() (string, error) {
	operation := getInput()
	expr := operationRegexp
	patern := regexp.MustCompile(expr)
	if patern.MatchString(operation) { //Comprobamos si la entrada concuerda con nuestra expresion, en caso contrario devolvemos un error.
		return operation, nil
	}
	return "", errors.New("Lexical: Input is not an operation")
}

func obtainNumbers(operation string) (float64, float64) {
	expr := operatorsRegexp
	patern := regexp.MustCompile(expr)
	numbers := patern.Split(operation, 2)
	operand1, _ := strconv.ParseFloat(numbers[0], 32)
	operand2, _ := strconv.ParseFloat(numbers[1], 32)
	return operand1, operand2
}

func obtainOperator(operation string) byte {
	expr := operatorsRegexp
	patern := regexp.MustCompile(expr)
	indexes := patern.FindIndex([]byte(operation))[0]
	return operation[indexes]
}

func operate() float64 {
	operation, err := obtainOperation() //Obtener la operacion del usuario
	if err != nil {
		os.Exit(1)
	}
	value1, value2 := obtainNumbers(operation)                  //Obtener los valores
	return calculate(value1, value2, obtainOperator(operation)) //Devolver el calculo obtenido a partir de los valores y el operador.
}

func calculate(value1 float64, value2 float64, operator byte) float64 {
	var ans float64
	switch operator {
	case '+':
		ans = value1 + value2
	case '-':
		ans = value1 - value2
	case '*':
		ans = value1 * value2
	case '/':
		ans = value1 / value2
	}
	return ans
}

func main() {
	ans := operate() //Funcion que realizara el calculo
	fmt.Printf("The output value is %f\n", ans)
}

David Esteban Solorzano Taborda

student•

Para tener en cuenta y a diferencia de otros lenguajes, no se requiere agregar el break despues de cada case

William Rodriguez

student•

Interesante si una analiza no tiene lógica tener que colocar el break un caso termina donde comienza el otro o el caso por default.

Asdrubal Granados

student•

si es importante recalcar que en otros lenguajes de programacion un break se usa para saber cuando debemos salir del flujo. porque por ejemplo un switch en go con multiples casos quedaria asi

switch a {
case 5:
	fmt.Printl(a)
case 5,6:
	fmt.Println(&quot; a tiene un valor de 5 o 6&quot;)
default:
	fmt.Println(&quot;a es un valor distinto a 5 o 6&quot;)
}

que diferencia al switch de golang del switch de otros lenguajes? que en otros lenguajes tienes control de cuando salir de la evaluacion de las variables. porque en teoria entraria en el primer caso q coincida. aca en el switch que he descrito ambos casos coinciden.

Leonardo Valdivieso

student•

A mi me da error:

duplicate case 1 (constant of type int) in expression switch

Jorge Quevedo

student•

Algunos controles que agregaria yo son los siguientes:

Chequeo de correcto spliteo de operadores

if len(valores) &gt; 1 {
	// logica normal
} else {
	// manejo de error
}

Chequeo de division por cero

if operador2 != 0 {
	resultado = operador1 / operador2
} else {
	fmt.Println(&quot;No se puede dividir por cero&quot;)
}

Esto hace mas robusto el programa usando lo ya enseñado. Muy bueno el curso, bien explicado todo. Saludos!

Camilo Cadavid Cardona

student•

Les dedo mi calculador con suma, resta, multiplicaciòn y diviciòn

package main

import (
	&quot;os&quot;
	&quot;bufio&quot;
	&quot;fmt&quot;
	&quot;strings&quot;
	&quot;strconv&quot;
	&quot;regexp&quot;
)

func main(){
	scanner:= bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operation := scanner.Text()
	//fmt.Println(operator)
	re := regexp.MustCompile(&quot;[^0-9]+&quot;)
	operatorr:= re.FindAllString(operation, -1)
	fmt.Println(operatorr)
	var operator string = strings.Join(operatorr,&quot;&quot;)
	valores := strings.Split(operation,operator)
	num1,_ := strconv.Atoi(valores[0])
	num2,_ := strconv.Atoi(valores[1])
	switch operator{
	case &quot;+&quot;: fmt.Println(num1+num2)
	case &quot;-&quot;: fmt.Println(num1-num2)
	case &quot;*&quot;: fmt.Println(num1*num2)
	case &quot;/&quot;: fmt.Println(num1/num2)
	default: fmt.Println(&quot;operacion no valida&quot;)
	}
}

Cristian Vargas

student•

Tiene una sintaxis curiosa pero agradable este lenguaje.

Carlos Javier Bazan Huaman

student•

el switch se ve mas sencillo que en otros lenguajes.

Brian Toro

student•

Aquí les dejo mi solución a crear una calculadora

package main

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

func main(){
	scanner := bufio.NewScanner(os.Stdin)
	fmt.Println("Inserte la operacion (numero operador numero) Ejem: 2 + 2")
	scanner.Scan()
	operacion := scanner.Text()
	valores := separar(operacion)
	operador1, err1 := strconv.Atoi(valores[0])
	operador2, err2 := strconv.Atoi(valores[2])
	if err1 != nil || err2 != nil {
		controlDeErrores()
	} else {
		resultado := definirOperacion(operador1, operador2, valores[1])
		fmt.Println(resultado)
	}
}

func controlDeErrores(){
	fmt.Println("Operacion invalida")
}

func definirOperacion(num1 int, num2 int, operador string)(int){
	var resultado int
	switch operador {
	case "+":
		resultado = num1 + num2
		break
	case "-":
		resultado = num1 - num2
		break
	case "*", "x":
		resultado = num1 * num2
		break
	case "/":
		resultado = num1 / num2
		break
	default:
		resultado = num1 + num2
	}
	return resultado
}

func separar(cadena string)([]string){
	valores :=  strings.Split(cadena, " ")
	return valores
}

Jonathan Stephen Tellez Rincon

student•

Comparto una función para detectar el operador, sin necesidad de tener un menu

var separadores = [4]string{"+","-","*","/"}
func detectarSeparador(operacion string) (string, error) {
	var separador = ""
	for i := 0; i < len(separadores); i++ {
		idx := strings.Index(operacion, separadores[i])
		if idx != -1 && separador == "" {
			separador = separadores[i]
		} else if idx != -1 && separador != "" {
			return "", errors.New("La operacion tiene mas de un operador, ingrese solo uno")
		}
	}
	if separador == "" {
		return "", errors.New("Ingrese un operador valido +, -, *, /")
	}
	return separador, nil
}

Murray Walker Greer Cifuentes

student•

este profesor tiene una forma peculiar de hablar y en ocasiones no lo entiendo.

David Ramos

student•

Mi calculadora, bastante simplificado, con un pequeño menú

Seria interesante saber como puedo pasar el scanner como parámetro para no volver a declararlo

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	for {
		fmt.Println()
		fmt.Println()
		fmt.Println("Ingrese el símbolo de la operación : ")
		fmt.Println("+ Sumar")
		fmt.Println("- Restar")
		fmt.Println("* Multiplicar")
		fmt.Println("/ Dividir")
		fmt.Println("x Salir")
		fmt.Println()
		fmt.Print(": ")

		scanner.Scan()
		operador := scanner.Text()

		switch strings.ToLower(operador) {
		case "+":
			Sumar()
		case "-":
			Restar()
		case "*":
			Multiplicar()
		case "/":
			Dividir()
		case "x":
			return
		default:
			fmt.Println("La operación no es válida")
		}
	}
}

func Parametros(funcion string) (int, int) {

	scanner := bufio.NewScanner(os.Stdin)

	fmt.Println("Programa : ", funcion)
	fmt.Println()

	fmt.Println("Ingrese el primer valor")
	scanner.Scan()
	val1 := scanner.Text()
	// fmt.Println("El primer valor ingresado es : ", val1)

	num1, error1 := strconv.Atoi(val1)

	if error1 != nil {
		fmt.Println("No se pudo convertir el primer valor : ", error1)
		return 0, 0
	}

	fmt.Println("Ingrese el segundo valor")
	scanner.Scan()
	val2 := scanner.Text()
	// fmt.Println("El segundo valor ingresado es : ", val2)

	num2, error2 := strconv.Atoi(val2)

	if error2 != nil {
		fmt.Println("No se pudo convertir el segundo valor : ", error2)
		return 0, 0
	}

	return num1, num2
}

func Sumar() {

	operator1, operator2 := Parametros("Suma")

	resultado := operator1 + operator2

	fmt.Println("La suma es : ", resultado)
}

func Restar() {

	operator1, operator2 := Parametros("Resta")

	resultado := operator1 - operator2

	fmt.Println("La resta es : ", resultado)
}

func Multiplicar() {

	operator1, operator2 := Parametros("Miltiplicación")

	resultado := operator1 * operator2

	fmt.Println("La multiplicación es : ", resultado)
}

func Dividir() {

	operator1, operator2 := Parametros("División")

	if operator2 == 0 {
		fmt.Println("No se puede dividr entre cero (0)")
		return
	}

	resultado := operator1 / operator2

	fmt.Println("La multiplicación es : ", resultado)
}

Alejandro Gaspar Flores

student•

Les dejo mi Calculadora. Ya permite utilizar todos los tipos de Operadores sin cambiar el codigo y Limpia la pantalla =)

package main

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

func main() {
	// Limpiamos pantalla
	fmt.Println("\033[H\033[2J")

	// Imprimimos Menu
	fmt.Println("Ingrese el Simbolo de la operacion a realizar:")
	fmt.Println("1) + Suma")
	fmt.Println("2) - Resta")
	fmt.Println("3) * Multiplicación")
	fmt.Println("4) / División")
	fmt.Printf(": ")

	// Instancia que nos permite escanar el Standar Input
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operador := ""

	// Identificando operador
	switch scanner.Text() {
	case "+":
		operador = "+"
	case "-":
		operador = "-"
	case "*":
		operador = "*"
	case "/":
		operador = "/"
	default:
		fmt.Println("Invalid operator: ", operador)
		os.Exit(1)
	}

	// Pedimos La operacion a Realizar
	fmt.Println("\033[H\033[2J")
	fmt.Println("Ingrese la Operación:")
	fmt.Printf(": ")
	scanner.Scan()

	// Asiganamos a una variable el Texto que obtuvimos
	operacion := scanner.Text()
	fmt.Println(operacion)

	// Identificamos los valores que el usuario manda
	valores := strings.Split(operacion, operador)
	fmt.Println(valores)

	// Convertimos el texto en un número
	operador1, err1 := strconv.Atoi(valores[0])
	operador2, err2 := strconv.Atoi(valores[1])

	if err1 != nil || err2 != nil {
		fmt.Println(err1)
	} else {
		// Identificamos la operacion a Realizar
		switch operador {
		case "+":
			fmt.Println(operador1 + operador2)
		case "-":
			fmt.Println(operador1 - operador2)
		case "*":
			fmt.Println(operador1 * operador2)
		case "/":
			fmt.Println(operador1 / operador2)
		default:
			fmt.Println("Invalid operator: ", operador)
		}
	}
}

Cristian Alejandro Velasco Cernas

student•

Hice una calculadora más simple...

package main

import(
	"fmt"
)

func operates(response int) int {
	
	switch response{
		
	case 1:
		operador1, operador2 := leerEntradas()
		fmt.Print("Resultado: ")
		fmt.Println(operador1 + operador2)
		return operador1 + operador2
	case 2:
		operador1, operador2 := leerEntradas()
		fmt.Print("Resultado: ")
		fmt.Println(operador1 - operador2)
		return operador1 - operador2
	case 3:
		operador1, operador2 := leerEntradas()
		fmt.Print("Resultado: ")
		fmt.Println(operador1 * operador2)	
		return operador1 * operador2
	case 4:
		operador1, operador2 := leerEntradas()
		fmt.Print("Resultado: ")
		fmt.Println(operador1 / operador2)
		return operador1 / operador2
	default:
		fmt.Println("No esta soportado")
		return 0
	}
	 
}

func leerEntradas() (int, int) {
	operador1 := 0
	operador2 := 0
	fmt.Println("primer numero:") 
	fmt.Scanln(&operador1)
	fmt.Println("segundo numero:")
	fmt.Scanln(&operador2)
	return operador1, operador2
}

func main(){

	response := 0

	fmt.Println("menu") 
	fmt.Println("1.-suma") 
	fmt.Println("2.-resta") 
	fmt.Println("3.-multiplicacion") 
	fmt.Println("4.-division") 
	fmt.Scanln(&response)

	operates(response)
}

rusbel bermúdez rivera

student•

Yo hice el switch incorporando un array con los valid operators

package main

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

func main() {
	// scanner para leer datos de la terminal
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	// extreaer el exto
	operation := scanner.Text()
	fmt.Println(operation)

	valid_operators := [4]string{"+", "-", "*", "/"}

	operator := ""
	for _, value := range valid_operators {
		if strings.Contains(operation, value) {
			operator = value
			break
		}
	}

	fmt.Println("this", operator)
	values := strings.Split(operation, operator)
	fmt.Println(values)
	// sumando los dos valores sin el operador
	// ambos son strings
	fmt.Println(values[0] + values[1])

	//casteando los strings a enteros
	operator1, err1 := strconv.Atoi(values[0])
	if err1 != nil {
		fmt.Println(err1)
	} else {
		fmt.Println(operator1)
	}
	operator2, _ := strconv.Atoi(values[1])

	switch operator {

	case "+":
		fmt.Println(operator1 + operator2)
	case "-":
		fmt.Println(operator1 - operator2)
	case "*":
		fmt.Println(operator1 * operator2)
	case "/":
		fmt.Println(operator1 / operator2)
	}
}

Luis Andrés Villegas Sanchez

student•

Aquí le dejo mi solución, implemente expresiones regulares para saber si ingreso bien el símbolo (+, -, *, /) y funciones:

package main

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

func main() {

	symbol, err := getSymbol()

	if err != nil {
		fmt.Println(err)
		return
	}

	numberOne, numberTwo, err2 := splitOperation(symbol)

	if err2 != nil {
		fmt.Println(err)
		return
	}

	total := setOperation(numberOne, numberTwo, symbol)

	if total == -1 {
		fmt.Println("An error Ocurred in te operaion")
		return
	}

	fmt.Println(total)
}

func setOperation(numberOne int, numberTwo int, symbol string) int {
	switch symbol {
	case "+":
		return numberOne + numberTwo
	case "-":
		return numberOne - numberTwo
	case "*":
		return numberOne * numberTwo
	case "/":
		return numberTwo / numberOne
	default:
		return -1
	}
}

func splitOperation(symbol string) (n1 int, n2 int, err error) {
	fmt.Println("Ingrese la operacion matematica")
	/*
		1. Vamos a crear un scanner que nos permite leer los input del usuario.
	*/
	scanner := bufio.NewScanner(os.Stdin) // Instanciamos el scan
	scanner.Scan()                        // Iniciamos el scan
	data := scanner.Text()                // .Text no va a devolver un los datos ingresados en un "string"
	values := strings.Split(data, symbol) // Nos devuelve un arreglo.

	numberOne, err1 := strconv.Atoi(values[0]) //.Atoi, toma un string y lo convierte a un entero
	numberTwo, err2 := strconv.Atoi(values[1])

	if err1 != nil {
		return 0, 0, err1
	}

	if err2 != nil {
		return 0, 0, err2
	}

	return numberOne, numberTwo, nil
}

func getSymbol() (symbol string, err error) {
	fmt.Println("Ingrese el simbolo. Ej: +, - , *, /")
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	data := scanner.Text()
	pattern := `^(\-|\+|\*|\/)$`

	/*
		"_" blank identifier
		Sirve como placeholder anónimo. Por ejemplo,
		si tengo una funcion que devuelve 3 valores pero nada más
		me interesa uno de ellos, haría algo así:
		_, y, _ := getXYZ()
		fmt.Println(y) -> 3
		func getXYZ() (int, int, int){
			return 2, 3, 1
		}
	*/
	matched, _ := regexp.MatchString(pattern, data)

	if matched {
		return data, nil
	}

	return "", errors.New("Lexical: input is not a operation")
}

Juan David Rueda Quiroga

student•

No logré sacar los decimales

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	fmt.Println("Ingrese una suma con 2 operadores")
	scanner.Scan()
	operation := scanner.Text()

	operator := "/"

	values := strings.Split(operation, operator)

	factor1, e1 := strconv.Atoi(values[0])
	if e1 != nil {
		log.Fatal("El primer parámetro falló\n", e1)
	}
	factor2, e2 := strconv.Atoi(values[1])
	if e2 != nil {
		log.Fatal("El segundo parámetro falló\n", e2)
	}

	var result float64
	switch operator {
	case "+":
		result = float64(factor1 + factor2)
		break

	case "-":
		result = float64(factor1 - factor2)
		break

	case "*":
		result = float64(factor1 * factor2)
		break

	case "/":
		result = float64(factor1 / factor2)
		break

	default:
		log.Fatal("No se detectó un operador válido")
	}

	fmt.Println("El resultado es", result)
}

Juan José González Ramírez

student•

Humilde aporte

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operacion := scanner.Text()
	resultado := 0
	operador := ""
	var valores []string
	switch {
	case strings.Contains(operacion, "+"):
		valores = strings.Split(operacion, "+")
		operador = "+"
		operador1, operador2, estado := parseValores(valores[0], valores[1])
		if estado {
			resultado = operador1 + operador2
		}
	case strings.Contains(operacion, "-"):
		valores = strings.Split(operacion, "-")
		operador = "-"
		operador1, operador2, estado := parseValores(valores[0], valores[1])
		if estado {
			resultado = operador1 - operador2
		}
	case strings.Contains(operacion, "*"):
		valores = strings.Split(operacion, "*")
		operador = "*"
		operador1, operador2, estado := parseValores(valores[0], valores[1])
		if estado {
			resultado = operador1 * operador2
		}
	default:
		fmt.Println("Ningún caso aplicado")
	}
	fmt.Printf("La operación es %v, el resultado es %d\n", operador, resultado)
} 

// parseValores formats two string parameters to string :)
func parseValores(num1, num2 string) (int, int, bool) {
	isValid := true
	operador1, err1 := strconv.Atoi(num1)
	if err1 != nil {
		fmt.Println("Error en operador1", err1)
		isValid = false
	}
	operador2, err2 := strconv.Atoi(num2)
	if err2 != nil {
		fmt.Println("Error en operador2", err2)
		isValid = false
	}
	return operador1, operador2, isValid
}

Cristian Córdova

student•

Les dejo el código con comentarios y mensajes para detallar algo más cada parte del código:

package main

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

func main() {
	// Lee la entrada de un usaurio
	fmt.Println("Introduzca datos separados por el símbolo '+':")
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	// Asigna la entrada de un usuario a la variable operation
	operation := scanner.Text()
	fmt.Println("Valores introducidos:")
	fmt.Println(operation) // Muestra lo que ha introducido el usuario

	// Trasnforma los datos introducidos en una lista, separa cada elemento por un signo "+". Ejm: Si introduczo 2+2 lo convertirá en [2 2]
	fmt.Println("Lista de valores introducidos:")
	operator := "+"
	values := strings.Split(operation, operator)
	fmt.Println(values) // Muestra la lista
	fmt.Println("Concadenacion de strings de la lista:")
	fmt.Println(values[0] + values[1]) // Muestra la concadenación de los valores de la lista (Son strings)

	// Transformamos los strings en valores de tipo int
	operator1, err1 := strconv.Atoi(values[0])
	if err1 != nil { // Manejando el error al parsear los datos de string a int
		fmt.Println(err1)
	}

	operator2, err2 := strconv.Atoi(values[1])
	if err1 != nil { // Manejando el error al parsear los datos de string a int
		fmt.Println(err2)
	}

	switch operator {
	case "+":
		fmt.Println("Suma de valores:")
		fmt.Println(operator1 + operator2) // Muestra la suma de los valores
	case "-":
		fmt.Println("Resta de valores:")
		fmt.Println(operator1 - operator2) // Muestra la resta de los valores
	case "*":
		fmt.Println("Multiplicación de valores:")
		fmt.Println(operator1 * operator2) // Muestra la multiplicación de los valores
	case "/":
		fmt.Println("División de valores:")
		fmt.Println(operator1 / operator2) // Muestra la división de los valores
	default:
		fmt.Println("El operador indicado no es correcto") // Muestra el mensaje por defecto
	}
}

Mayra Montalván

student•

package main

import "fmt"
func main ()  {
	var operacion int 
	var operadorA float64
	var operadorB float64
	
	fmt.Println("Seleccione el número de la operación que desea realizar: ")
	fmt.Println("1 - Suma")
	fmt.Println("2 - Resta")
	fmt.Println("3 - Multiplicación")
	fmt.Println("4 - División")
	fmt.Scan(&operacion)
	
	if operacion > 0 && operacion < 5 {
		fmt.Print("Ingrese A: ")
		fmt.Scan(&operadorA)
		fmt.Print("Ingrese B: ")
		fmt.Scan(&operadorB)
	}
	
	switch operacion {
	case 1:
		fmt.Printf("\nA + B = %v \n", (operadorA + operadorB)) 
	case 2:
		fmt.Printf("\nA - B = %v \n", (operadorA - operadorB)) 
	case 3:
		fmt.Printf("\nA * B = %v \n", (operadorA * operadorB)) 
	case 4:
		fmt.Printf("\nA / B = %v \n", (operadorA / operadorB)) 
	default:
		fmt.Println("Operación no permitida")
	}
}

Switch

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos