Switch

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!

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

Tiene una sintaxis curiosa pero agradable este lenguaje.

el switch se ve mas sencillo que en otros lenguajes.

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
}

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
}

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

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

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

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

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

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

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
}

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

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

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

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

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.

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

	}
}

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