Múltiple condiciones anidadas con Switch

aquí les dejo un pequeño ejemplo con lo que hemos visto hasta ahora, básicamente es un contador de vocales 🤠

package main

import "fmt"

func contadorVocales(palabra string)(int, int, int, int, int,){
	conta := 0
	conte := 0
	conti := 0
	conto := 0
	contu := 0
	for _ , valor := range palabra{ 
		variable := string(valor)
		switch variable {
		case "a" :
			conta++
		case "e" :
			conte++
		case "i" :
			conti++
		case "o" :
			conto++
		case "u" :
			contu++
		}
	}
	return conta, conte , conti, conto, contu
}

func main() {

	palabra := "en platzi nunca paramos de aprender"	
	a,e,i,o,u := contadorVocales(palabra)
	fmt.Printf("la frase '%s' tiene: \n",palabra)
	fmt.Printf("%d vocales a \n",a)
	fmt.Printf("%d vocales e \n",e)
	fmt.Printf("%d vocales i \n",i)
	fmt.Printf("%d vocales o \n",o)
	fmt.Printf("%d vocales u \n",u)	
}

aqui los resultados 😃

Comparto un ejemplo.

package main

import "fmt"

func main() {
	// Estructura condicional - Switch
	var dia int8 = 4

	switch dia {
	case 1:
		fmt.Println("Lunes")
	case 2:
		fmt.Println("Martes")
	case 3:
		fmt.Println("Miercoles")
	case 4:
		fmt.Println("Jueves")
	case 5:
		fmt.Println("Viernes")
	case 6:
		fmt.Println("Sabado")
	case 7:
		fmt.Println("Domingo")
	default:
		fmt.Println("Ese no es un día valido de la semana!")
	}
}

Que raro se ve un switch con los cases al mismo nivel que la palabra switch

Este bloque de código ilustra el uso de switch sin expresión

	// Estructura condicional - Switch
	var mes int8 = 10
	switch {
	case mes <= 3:
		fmt.Println("Primer Trimestre")
	case mes > 3 && mes <= 6:
		fmt.Println("Segundo Trimestre")
	case mes > 6 && mes <= 9:
		fmt.Println("Tercer Trimestre")
	case mes > 9 && mes <= 12:
		fmt.Println("Cuarto Trimestre")
	default:
		fmt.Println("Este no es un mes valido")
	}

Mis apuntes 😄

package main

import "fmt"

func main() {
	//SWITCH

	//structure of switch
	auxiliar := 10
	switch auxiliar {
	case 5:
		fmt.Println("Value is 5")
	case 10:
		fmt.Println("Value is 10")
	default:
		fmt.Println("Unknown value")
	}

	//If using a variable is recommended to do this

	switch auxiliar2 := 10; auxiliar2 {
	case 5:
		fmt.Println("Value is 5")
	case 10:
		fmt.Println("Value is 10")
	default:
		fmt.Println("Unknown value")
	}

	//Switch without a condition
	value := 50
	switch {
	case value < 0:
		fmt.Println("Value is smaller than zero")
	case value > 100:
		fmt.Println("Value is greater than 100")
	default:
		fmt.Println("Value is between 0 and 100")
	}

}

switch con fallthrough statement, como en C++:

package main

import "fmt"

func main() {
	num := 300

	switch num {
	case 100:
		fmt.Println("El valor es 100")
	case 200:
		fmt.Println("El valor es 200")
	case 300:
		fmt.Println("Continua al siguiente :)")
		fallthrough
	default:
		fmt.Println("Soy el caso por defecto :D")
	}
}

Con Condición:

package main

import "fmt"

func main() {
	var modulo int = 6 % 2
	switch modulo {
	case 0:
		fmt.Println("Es un número par.")
	default:
		fmt.Println("Es un número impar.")
	}
}

Sin condición:

package main

import "fmt"

func main() {
	var value int = -98
	switch {
	case value > 100:
		fmt.Println("Es un número mayor a 100.")
	case value < 0:
		fmt.Println("Es un número menor a 0.")
	default:
		fmt.Println("No cumple ninguna condición.")
	}
}

Cuando estas ejecutando múltiples condiciones If se vuelve redundante y dificil de leer
para eso utilizamos switch.

Algo que me parecio raro fue que en este lenguaje no lleva la sentencia break. O al menos no lo vimos en esta clase.

El switch sin condición es lo mejor, no lo conocía en mi basta experiencia programando en Go (2 meses jeje)

¿Qué tipo de variable es (…)? Esa es la premisa de este ejercicio usando switch case:

package main

import ("fmt")

// What kind of value is it?

func whaType(value interface{}){

  switch v := value.(type) {
  case float64:
    fmt.Printf("%g is float. \n", v)
  case int:
    fmt.Printf("%d is integer. \n", v)
  default:
    fmt.Printf("%v is %T. \n", v, v)
 }
}

func main(){
  whaType(3.14)
  whaType(4134)
  whaType("Go")
}

Consulte para más información aquí

Genial

<
package main

import "fmt"

func main() {

	switch modulo := 5 % 2; modulo {
	case 0:
		fmt.Println("un número par")
	default:
		fmt.Println("un número impar")
	}

	// Sin condicionales
	value := 200

	switch {
	case value < 100:
		fmt.Println("value es menor que 100")
	case value > 100 && value < 200:
		fmt.Println("value es entre 100 y 200")
	default:
		fmt.Println("value es mayor que 200")
	}

}
> 

Otra visión de la clase:

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("=========================================")
	fmt.Println("Switch - Múltiples condiciones ¿anidadas?")
	fmt.Println("=========================================")
	fmt.Println()

	fmt.Println("Sirve para simplificar múltiples condiciones en secuencia que implementadas con IF hace un código extenso.")
	fmt.Println()

	fmt.Println("A continuación en el código se declara de la forma mas parecida a C/Java/Kotlin donde de nuevo la condición" +
		" se colocas sin paréntesis conteniéndola.")
	fmt.Println("Interesante también ver que cada opción CASE no termina en un 'break' como en los otros lenguajes.")
	fmt.Println()

	fmt.Println("el resultado de la evaluación de si es par o no < modulo := 5 % 2 > es:")
	fmt.Println()

	const moduloInicial int8 = 5 % 2

	switch moduloInicial {
	case 0:
		fmt.Println("> Es par")
	default:
		fmt.Println("> Es impar")
	}

	fmt.Println()
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println("Se intenta una variación, donde se pone diréctamente la condición en el switch => switch 7 & 2 {....")
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println()

	switch 7 & 2 {
	case 0:
		fmt.Println("> Es par")
	default:
		fmt.Println("> Es impar")
	}

	fmt.Println()
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println("Forma directa de la instrucción donde se asigna el resultado en la variable.\nPor ahora le veo poca utilidad" +
		" a esta forma.")
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println()

	switch moduloVariableContextoInterno := 4 % 2; moduloVariableContextoInterno {
	case 0:
		fmt.Println("Aquí entró la evaluación de la condición, que dió", moduloVariableContextoInterno)
	default:
		fmt.Println("2> Es impar")
	}

	fmt.Println()
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println("SWITCH sin condición, abierto - Anidas múltiples condiciones")
	fmt.Println("____________________________________________________________________________________________________")
	fmt.Println()

	moduloVariableExterno := 200

	switch {
	case moduloVariableExterno < 100 && moduloInicial == 1:
		fmt.Println("Es mayor a 100")
	case moduloVariableExterno > 150 || moduloInicial == 1:
		fmt.Println("Es mayor a 150")
	default:
		fmt.Println("Este es si no se cumple alguno otro")
	}

	fmt.Println()
}

package main

import (
	"fmt"
)

// funcion que determine si un numero que recibe esa funcion es par o impar.
func parImpar(a int) {
	if a%2 == 0 {
		fmt.Println("Es par")
	} else {
		fmt.Println("Es impar")
	}
}

// funcion que reciba un usuario y un password las compare y diga si ese usuario tiene acceso. return TRUE
func acceso(user, password string) {
	var rUser string = "kevin"
	var rPassword string = "gutierrez"

	if user == rUser && password == rPassword {
		fmt.Println(user == rUser && password == rPassword)
		println("Acceso permitido")
	} else {
		fmt.Println(user == rUser && password == rPassword)
		println("Acceso denegado")
	}


func main() {
	parImpar(4)
	acceso("kevin", "gutierrez")
}

package main

import "fmt"

func parOImpar(num int) string{
	switch modulo := num % 2; modulo {
	case 0:
		return "Es par"
	default:
		return "Es impar"
	}
}

func main() {
	valor1 := 1

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

	queEs := parOImpar(24)
	fmt.Println(queEs)

	value := 50
	switch {
	case value > 100:
		fmt.Println("Es mayor que 100")
	case value < 0:
		fmt.Println("Es menor a 0")
	default:
		fmt.Println("No condicion")
	}
}