No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

15D
23H
1M
46S

Switch

9/42
Recursos

Aportes 34

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 "a":
	fmt.Println("Case A")
case "b":
	fmt.Println("Case B")
case "c":
	fmt.Println("Case C")
default:
	fmt.Println("Invalid input")
}

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贸.

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)
}

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

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(" a tiene un valor de 5 o 6")
default:
	fmt.Println("a es un valor distinto a 5 o 6")
}

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.

Algunos controles que agregaria yo son los siguientes:

  1. Chequeo de correcto spliteo de operadores
if len(valores) > 1 {
	// logica normal
} else {
	// manejo de error
}
  1. Chequeo de division por cero
if operador2 != 0 {
	resultado = operador1 / operador2
} else {
	fmt.Println("No se puede dividir por cero")
}

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

Tiene una sintaxis curiosa pero agradable este lenguaje.

el switch se ve mas sencillo que en otros lenguajes.

Excelente 馃槂

Para los interesados :

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

package main

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

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

Como aporte les dejo el code de una calculadora que recibe valores infinitos en go:

  • El resultado:
package main

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

func main() {
	loopCount := 0
	result := 0.0
	fmt.Println("Hello, Welcome!")
	function := ""
	for {
		if loopCount == 0 {
			number, _ := getNumber(loopCount)
			result = number
		} else if loopCount%2 == 0 {
			number, _ := getNumber(loopCount)
			switch function {
			case "+":
				result = add(result, number)
			case "-":
				result = substract(result, number)
			case "*":
				result = multiply(result, number)
			case "/":
				result = divide(result, number)
			default:
				break
			}
		} else {
			fmt.Println("Write your function please(add = +, substract = -, multiply = *, divide = / or done = 0)")
			scannerFunction := bufio.NewScanner(os.Stdin)
			scannerFunction.Scan()
			function = scannerFunction.Text()
			if function == "0" {
				break
			}
		}
		loopCount++
	}
	fmt.Println("[done]: GoodBye, see you soon!")
	fmt.Println("[result]:", result)
}

func getNumber(loopCount int) (float64, error) {
	fmt.Println("Write your NUMBER", loopCount+1, "please")
	scannerNumber := bufio.NewScanner(os.Stdin)
	scannerNumber.Scan()
	return strconv.ParseFloat(scannerNumber.Text(), 64)
}

func add(x float64, y float64) float64 {
	return x + y
}

func substract(x float64, y float64) float64 {
	return x - y
}

func multiply(x float64, y float64) float64 {
	return x * y
}

func divide(x float64, y float64) float64 {
	return x / y
}

Lo que yo realice fueron funciones para reutilizar un poco mas el codigo.

Les comparto mi c贸digo, calculadora que acepta comandos y valida las entradas del usuario,

Dejo mi soluci贸n: repositorio

Tengo esta otra alternativa
Usar un map en lugar de usar el switch
Creo que podr铆a ser m谩s 贸ptimo porque no recorre las opciones sino que entra en la que tiene su operador
Tambi茅n hice una optimizaci贸n con expresiones regulares porque me gusta aprovecharlas cuando puedo

package main

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

var format = regexp.MustCompile(`[\+\*\/\-\=]`)

func main() {
	operations := map[string]func(x, y int) int{
		"+": add,
		"-": substract,
		"*": product,
		"/": division,
	}

	scanner := bufio.NewScanner(os.Stdin)

	ok := scanner.Scan()
	if !ok {
		log.Fatal("it is not scanning")
	}

	s := scanner.Text()

	operator := format.FindString(s)
	if operator == "" {
		log.Fatal("invalid operation")
	}

	values := format.Split(s, -1)
	if len(values) != 2 {
		log.Fatal("invalid operation")
	}

	a, err := strconv.Atoi(values[0])
	if err != nil {
		log.Fatal("error parsing first number: ", err)
	}

	b, err := strconv.Atoi(values[1])
	if err != nil {
		log.Fatal("error parsing second number: ", err)
	}

	op, ok := operations[operator]
	if !ok {
		log.Fatal("unsupported operation")
	}

	res := op(a, b)

	fmt.Println(res)
}

func add(x, y int) int {
	return x + y
}

func substract(x, y int) int {
	return x - y
}

func product(x, y int) int {
	return x * y
}

func division(x, y int) int {
	return x / y
}

Est谩 interesante la forma en que usaste el scanner, yo en mi proyecto de crud utilic茅 readers, puedes verlo en el c贸digo del paquete que ves en la imagen

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	fmt.Println("BIENVENIDOS A NUESTRA CALCULADORA")
	fmt.Print("Por favor introduzca la operacion a realizar:  ")
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	operador := "*"
	valores := strings.Split(operacion, operador)

	operador1, error1 := strconv.Atoi(valores[0])
	operador2, _ := strconv.Atoi(valores[1])

	if error1 != nil {
		fmt.Println(error1)
	} else {
		fmt.Println(operador1)
	}
	switch operador {
	case "+":
		fmt.Println(operador1 + operador2)
	case "-":
		fmt.Println(operador1 - operador2)
	case "*":
		fmt.Println(operador1 * operador2)
	case "/":
		fmt.Println(operador1 / operador2)
	}
}

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")
	}
}

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)
	}
}

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
	}
}

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
}

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

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)
}

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
}

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")
}

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)
}

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)
		}
	}
}

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
}

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)
}

Como dato adicional, en go podemos hacer uso del Switch sin una expresion a evaluar como tal, y podemos evaluar posibles situaciones en cada caso, seria algo similar a esto:

a := 10
b :=  11

switch {
	case a < b:
		fmt.Println("a is minor than b")
	case a > b:
		fmt.Println("a is greater than b")
	case a == b:
		fmt.Println("a is equal to b)"
	default:
		fmt.Println("I guess something weird happen")
}

Pueden ver un poco mas de switch en Go by Example: https://gobyexample.com/switch

No se existe el else if?

Mi solucion:

package main

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

func main()  {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	operador := "p"
	valores := strings.Split(operacion, operador)
	fmt.Println(valores)
	fmt.Println(valores[0] + valores[1])

	operador1, err1 := strconv.Atoi(valores[0])
	if err1 != nil {
		fmt.Println(err1)
	} else {
		fmt.Println(operador1)
	}

	operador2, err2 := strconv.Atoi(valores[1])
	if err2 != nil {
		fmt.Println(err2)
	} else {
		fmt.Println(operador2)
	}

	if err1 == nil && err2 == nil {
		switch operador {
		case "+":
			fmt.Println(operador1 + operador2)
		case "-":
			fmt.Println(operador1 - operador2)
		case "*":
			fmt.Println(operador1 * operador2)
		case "/":
			if operador2 == 0 {
				fmt.Println("no se puede dividir por 0")
			} else {
				fmt.Println(operador1 / operador2)
			}
		default:
			fmt.Println("el operador->", operador, "no esta soportado")
		}
	} else {
		fmt.Println("no se pudo hacer la operacion")
	}
}
No es necesario agregar "break" en cada caso como en otros lenguajes?

Con entradas de los argumentos de la consola

package main

import (
	"fmt"
	"os"
	"strconv"
)

func main() {
	fmt.Printf("Your arguments: %v\n", os.Args[1:])
	opt := os.Args[2]

	switch opt {
	case "+":
		numA, errA := strconv.Atoi(os.Args[1])
		numB, errB := strconv.Atoi(os.Args[3])

		if errA != nil || errB != nil {
			fmt.Println("Atoi could not pass integers")
		} else {
			fmt.Printf("%v + %v = %v\n", numA, numB, numA+numB)
		}
		break

	case "-":
		numA, errA := strconv.Atoi(os.Args[1])
		numB, errB := strconv.Atoi(os.Args[3])

		if errA != nil || errB != nil {
			fmt.Println("Atoi could not pass integers")
		} else {
			fmt.Printf("%v - %v = %v\n", numA, numB, numA-numB)
		}
		break

	case "/":
		numA, errA := strconv.Atoi(os.Args[1])
		numB, errB := strconv.Atoi(os.Args[3])

		if errA != nil || errB != nil {
			fmt.Println("Atoi could not pass integers")
		} else {
			fmt.Printf("%v / %v = %v\n", numA, numB, numA/numB)
		}
		break

	case "x", "*":
		numA, errA := strconv.Atoi(os.Args[1])
		numB, errB := strconv.Atoi(os.Args[3])

		if errA != nil || errB != nil {
			fmt.Println("Atoi could not pass integers")
		} else {
			fmt.Printf("%v * %v = %v\n", numA, numB, numA*numB)
		}
		break

	default:
		fmt.Println("invalid operation")

	}
}

Mi aporte permitiendo que es usuario escoja el operador durante la ejeuci贸n