Leer inputs desde la consola

Hola, solamente con el afan de dejar las salidas un poco mas explicadas (asi aprovecho y practico), si tienen tips para hacerlo mas pro les agradezco las sugerencias! 😃

package main

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

func main() {

	scanner := bufio.NewScanner(os.Stdin)
	fmt.Println("Ingrese la operacion (suma, de la forma numero + numero, ej: 2+2): ")
	scanner.Scan()

	operacion := scanner.Text()

	fmt.Println("La operacion ingresada es: ", operacion)

	valores := strings.Split(operacion, "+")

	fmt.Println("Estos son los valores ingresados: ", valores)
	fmt.Println("Primer y segundo valor sumados como texto: ", valores[0]+valores[1])

	// Cast valores from text to number
	operador1, _ := strconv.Atoi(valores[0])
	operador2, _ := strconv.Atoi(valores[1])

	fmt.Println("Suma de los dos operadores matematicamente: ", operador1+operador2)

}

Lo primero que se va hacer es un escáner para recibir los inputs del usuario. Para esto usaremos una librería llamada bufio y su método NewScanner() que genera una nueva instancia de escaneo. Este escaneo puede ser desde diferentes inputs de entrada, en este caso le pasaremos como parámetro os.Stdin para que funcione con los inputs de la terminal.

Para que la terminal funcione necesitamos un par más de funciones:
scanner.Scan() recibe y guarda en la instancia del escáner el texto escrito en la terminal hasta un Enter.
scanner.Text() extrae el texto del escáner y lo podemos asignar a alguna variable.

El siguiente paso es extraer los valores y la operación que se está realizando. Para esto usamos la función split perteneciente al paquete strings. Lo que hace es partir un string por medio de un caracter definido como el “separador”.

La función strings.Split() regresa un array, por lo que una vez en nuestras variables podemos acceder a sus valores por medio de sus índices. De igual forma, la función únicamente hace la partición del string original, mas no su valor numérico. Hay que hacer un casting o transformación utilizando la función Atoi perteneciente al paquete strconv que convierte un valor string a entero.

Otra peculiaridad de Go es que las funciones pueden regresar más de un solo valor, como es el caso de strconv.Atoi(). Esta función a su vez regresa un error si algo sale mal, sin embargo, podemos utilizar guión bajo _ para omitir el uso de la variable.

¿Que es os.Stdin?

    var a string
fmt.Scanf("%d", &a)
fmt.Println("Hola mundo", a)

de esta forma me parece mejor y mas facil de entender

_ = blank identifier

• Sirve como placeholder anónimo.

Por ejemplo, si tengo una function que devuelve 3 valores pero nadamas me interesa uno de ellos, haria algo asi:

_, y, _ := getxyz()```
para obtener el valor de y.

¿Que es os?

Yo lo hice usando simplemente el paquete fmt:

package main

import "fmt"

func main() {
	var operator string
	var number1, number2 int

	fmt.Print("Please enter First number: ")
	fmt.Scanln(&number1)

	fmt.Print("Please enter Second number: ")
	fmt.Scanln(&number2)

	fmt.Print("Please enter Operator (+,-,/,%,*):")
	fmt.Scanln(&operator)

	output := 0

	switch operator {
	case "+":
		output = number1 + number2
	case "-":
		output = number1 - number2
	case "*":
		output = number1 * number2
	case "/":
		output = number1 / number2
	case "%":
		output = number1 % number2
	default:
		fmt.Println("Invalid Operation.")
	}

	fmt.Printf("%d %s %d = %d\n", number1, operator, number2, output)
}

Me parece que le metieron un nivel de complejida inecesaria a este proyecto.

Instale una extención llamada Kite para python pero tambien esta funcionando para Go, muy recomendable, tiene autocompletado con inteligencia artificial por si desean instalarla.

Dejo esta documentación que esta en español para los que estan comenzando y se apoyen con algo mas de material

https://apuntes.de/golang/#gsc.tab=0

¿Que es ftm?

A mi no me coloca los import de manera automática cuando guardo 😕

Aquí se pone complejo, pero eso es la idea.

el famoso split y Atoio.

• Si les da error en el import va entre ( ) el listado.

Según la documentación oficial de Go

El paquete bufio envuelve un objeto io.Reader o io.Writer, creando otro objeto (Reader o Writer) que también implementa la interfaz pero proporciona almacenamiento en búfer.

Link: Explicación de bufio donde habla de Scanner:
https://medium.com/golangspec/introduction-to-bufio-package-in-golang-ad7d1877f762

si les aparecen mensajes como:
assignment mismatch: 1 variable but strconv.Atoi returns 2 values
puedes poner por ejemplo:

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

en vez de

operador1 := strconv.Atoi(valores[0])

Dejo mi intento de calculadora que desarrolle antes de ver la clase

package main

import "fmt"

func main() {
	var firstNumber, secondNumber int
	var operator string

	fmt.Printf("Operation: + - / *\n")
	fmt.Scan(&operator)

	fmt.Printf("Primer valor\n")
	fmt.Scan(&firstNumber)

	fmt.Printf("Segundo valor\n")
	fmt.Scan(&secondNumber)

	switch operator {
	case "+":
		fmt.Printf("Result of %d %s %d = %d\n", firstNumber, operator, secondNumber, (firstNumber + secondNumber))

	case "-":
		fmt.Printf("Result of %d %s %d = %d\n", firstNumber, operator, secondNumber, (firstNumber - secondNumber))

	case "/":
		fmt.Printf("Result of %d %s %d = %d\n", firstNumber, operator, secondNumber, (firstNumber / secondNumber))

	case "*":
		fmt.Printf("Result of %d %s %d = %d\n", firstNumber, operator, secondNumber, (firstNumber * secondNumber))

	default:
		fmt.Println("Really nigga?", firstNumber, operator, secondNumber)
	}
}

package main

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

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

	operacion := scanner.Text()
	fmt.Println("Esto fue lo ingresado:  " + operacion)

	valores := strings.Split(operacion, "+")

	fmt.Println(valores)

	fmt.Println(valores[0] + valores[1])

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

	fmt.Println(operador1 + operador2)

}

gente volvi a este curo despues del basico y se me da mejor asimilar cada funciion que usa 😄 ahora si podre terminar este curso

Se puede utilizar strings.Replace() después de capturar la operación para eliminar espacios en blanco y que no se rompa en caso el usuario introduzca 2 + 2 en lugar de 2+2

	
operation := scanner.Text(os.Stdin)
operation = strings.Replace(operation, " ", "", -1)

package main

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

func main()  {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	valores := strings.Split(operacion, "+")
	fmt.Println(valores)
	fmt.Println(valores[0] + valores[1])
	operador1, _ := strconv.Atoi(valores[0])
	operador2, _ := strconv.Atoi(valores[1])
	fmt.Println( operador1 +  operador2 )
}

😄 Código de la clase con comentarios de lo que hace cada parte del código + un poco más de código para describir mejor el programa:

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:")
	values := strings.Split(operation, "+")
	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
	fmt.Println("Suma de valores:")
	operator1, _ := strconv.Atoi(values[0])
	operator2, _ := strconv.Atoi(values[1])
	fmt.Println(operator1 + operator2) // Muestra la suma de los valores
}

Pequeña mejora: Poder trabajar con imputs tipo "2 + 2 ", con espacios de por medio.

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	operacion = strings.ReplaceAll(operacion, " ", "")
	valores := strings.Split(operacion, "+")
	fmt.Println(valores)
	operandoOne, _ := strconv.Atoi(valores[0])
	operandoTwo, _ := strconv.Atoi(valores[1])
	fmt.Println(operandoOne + operandoTwo)
}

También podemos hacer el scan con fmt

// Including the main package
package main
 
// Importing fmt
import (
    "fmt"
)
 
// Calling main
func main() {
 
    // Declaring some variables
    var name string
    var alphabet_count int
 
    // Calling Scanf() function for
    // scanning and reading the input
    // texts given in standard input
    fmt.Scanf("%s", &name)
    fmt.Scanf("%d", &alphabet_count)
 
    // Printing the given texts
    fmt.Printf("The word %s containing %d number of alphabets.",
               name, alphabet_count)
 

Excelente

Excelente!

Code:

package main

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

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

	fmt.Printf("Type operation: "); scanner.Scan()
	operation := scanner.Text()

	values := strings.Split(operation, "+")

	v1, _ := strconv.Atoi(values[0])
	v2, _ := strconv.Atoi(values[1])

	fmt.Println(v1 + v2)
}

Me hubiera gustado saber que explicara por qué Atoi devuelve 2 valores ¿cuáles son esos 2 valores?

imagen

valor, error := strconv.Atoi(i) // resultado del valor int y el mensaje de error (en caso de que falle el proceso de conversión)

scan nos permite todo el input del usuario

scanner := bufio.NewScanner(os.Stdin) scanner.Scan() operacion := scanner.Text() fmt.Println(operacion)

split retorna un array

split es una funcion que nos permite tomar un string y separarlo

Super 😃 anda bien

Lo puse más interactivo con mensajes al usuario

package main

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

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

	operator1, _ := strconv.Atoi(values[0])
	operator2, _ := strconv.Atoi(values[1])

	result := operator1 + operator2
	fmt.Println("El resultado es", result)
}```

strconv.Atoi para que es o que hace ???

strings.Split(operacion, "+") NO retorna un array; retorna un slice. Función Split

Les dejo como va quedando el codigó 👇

package main

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

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

	operation := scanner.Text()

	valores := strings.Split(operation, "+")
	operation_int, _ := strconv.Atoi(valores[0])
	operation_int_2, _ := strconv.Atoi(valores[1])
	fmt.Println(operation_int + operation_int_2)
}

Tambien lo hice en Python solo para compararlos un poco 🤣

def main():
    operation = str(input("")).split("+")
    print(int(operation[0])+int(operation[1]))

if __name__ == "__main__":
    main()

Cuando era muy pequeño un profesor me dijo: "Deja que el código hable…"
Siempre lo tome muy literal… 8P

package main

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

func main() {

	// Separador elegante 8)
	fmt.Println("----------------------------")
	fmt.Println("Comienzo del programa")
	fmt.Println("----------------------------")
	fmt.Println("Por favor, ingrese la operación que desea realizar")
	fmt.Println("Solo suma por ahora (Pleaaaasseeeeee)")

	// bufio : buffered input and output
	// Referencia : https://golang.org/pkg/bufio/
	// Se crea una variable scanner para asignarle
	// un objeto scanner que capturara la entrada de datos del usuario.
	// La entrada o salida de datos en un buffer permite optimizar la memoria que usa
	// un dispositivo infomático para sus operaciones.

	// os: operative system
	// Referencia : https://golang.org/pkg/os/
	// Este paquete proporciona interfaces para llamar funcionalidades
	// del sistema operativo (independiente de plataforma).
	// En este caso se utiliza para capturar la entrada estandar de datos (El teclado).
	// Es importante aclarar, el tipo de datos que contiene un objeto scanner es bytes.
	scanner := bufio.NewScanner(os.Stdin)

	// Deja el scanner a la espera de un input
	scanner.Scan()

	// Se crea la variable operacion que almacena el contenido de scanner
	// en formato de String con la función Text()
	operacion := scanner.Text()

	// fmt: format
	// Referencia: https://golang.org/pkg/fmt/
	// Este paquete provee funciones para dar formato a los datos.
	// Su función Println() imprime la información en la salida estandar
	// agregando un salto de linea al final.
	fmt.Println(operacion)
	fmt.Println("----------------------------")

	// strings: cadenas de texto
	// Referencia: https://golang.org/pkg/strings/
	// Implementa funciones sencillas para manipular cadenas de texto.
	// Tipo de codificación: UTF-8
	// Mediante la función Split() podemos separar el contenido en una cadena de texto
	// para eso se le entregaran dos parametros.
	// El primero la cadena de texto que queremos dividir.
	// El segundo el caracter que queremos usar para dividir los datos.
	valores := strings.Split(operacion, "+")

	// La variable valores es un arreglo (Array) de strings
	// un conjunto de datos (en este caso cadenas de texto) ordenados por un indice.
	fmt.Println("Contenido del Array: ")
	fmt.Println(valores)

	// Podemos invocarlos individualmente llamandolos por su indice
	// dentro del Array.
	// Recordatorio!!!! Todos los Arreglos comienzan en indice 0

	fmt.Println("Primer valor del Array: " + valores[0])
	fmt.Println("Segundo valor del Array: " + valores[1])

	// Recordamos que con la función Text() traemos el contenido
	// almacenado dentro de la variable scanner como un texto (Tipo de dato String).
	// Luego se separo la cadena de texto en un arreglo que sigue conteniendo datos
	// de tipo String.
	// Si quisieramos "Sumar" estos valores, la computadora interpreta
	// que en lugar de realizar la operación aritmetica queremos "Pegar entre si"
	// este proceso se llama concatenación.
	// los contenidos de ambas cadenas como puede verse a continuación...
	fmt.Println("----------------------------")
	fmt.Println(valores[0] + "--- Estoy concatenando dos strings ---" + valores[1])
	fmt.Println(valores[0] + valores[1])
	fmt.Println("----------------------------")

	// Pero evidentemente lo que queremos es realizar la operación aritmética (¿o no?)
	// Para esto sera necesario convertir los datos para que el dispositivo infomático
	// en el que ejecutamos el programa logre interpretar correctamente nuestra intención.
	// Razón por la cual utilizamos la siguiente libreria:
	// strconv : string converter
	// Referencia: https://golang.org/pkg/strconv/
	// Provee funciones para convertir los strings a otros tipos de datos.
	// Mediante la función Atoi(string) recibira un string y regresara el dato en formato int
	// o numero entero. Tambien existe la función ParseInt(), Atoi es la version simplificada.
	// El proceso de convertir un dato de un tipo a otro se llama "Casting"
	//
	// Atoi regresa dos valores.
	// El primer valor contiene el string convertido al nuevo tipo de dato.
	// El segundo es un codigo de error (por si las cosas salen mal)
	// Como este caso no se utiliza el código de error Golang provee una forma de almacenarlo
	// dentro de una variable anonima mediante el operador "_" (guion bajo)
	// Lo que nos adelanta que Golang como en otros lenguajes de programación permite la inicialización
	// de varias variables en una linea, a saber:
	// nombre, apellido := "Ezequiel", "Pettinari"
	// fmt.Println("Nombre: " + nombre)
	// fmt.Println("Apellido: " + apellido)

	primer_operador, _ := strconv.Atoi(valores[0])
	segundo_operador, _ := strconv.Atoi(valores[1])

	fmt.Println("----------------------------")
	fmt.Println("Resultado de la operación aritmética:")
	fmt.Println(primer_operador + segundo_operador)

	fmt.Println("----------------------------")
	fmt.Println("Fin del programa")
	fmt.Println("----------------------------")

}

Entrada de Datos

import (
	"bufio"
	"os"
)

scanner := bufio.NewScanner(os.Stdin)

El paquete bufio maneja el bufer de entrada y salida.
En conjunto con la función NewScanner permite tomar un dato.

A esto se le suma el paquete os que proporciona una interface para la funcionalidad del sistema Operativo
En conjunto con la función Stdin que maneja en este caso el Standar Inpud

scanner.Scan()

la función Scan() como su nombre lo indica lo que hace es Scanear

operacion := scanner.Text()

La función Text() Extrae el texto y lo asigna a un variable

import (
	"strings"
) 
func main(){
	operacion := "2+2"
	valores := strings.Split(operacion, "+")
	fmt.Println(valores)
	fmt.Println(valores[0] + valores[1])
}

El paquete strings posee una función Split(<STRING>,<SEPARADOR>) que recibe dos parametros, la cadena de texto y el separador.
esto arroja un arreglo con los valores, en esta caso de 2 posiciones.

import (
	"strconv"
) 
func main(){
	cadena := "55"
	numero, _ := strconv.Atoi(cadena)
}

El paquete strconv implementa conversiones hacia y desde representaciones de cadenas de tipos de datos básicos.
en conjunto con la función Atoi(<STRING>) La función Atoi convierte un valor string a enter.

Esta función regresar más de un solo valor, a su vez regresa un error si algo sale mal,
sin embargo, podemos utilizar guión bajo _ para omitir el uso de la variable.

func main() {
	var operator string = ""
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	fmt.Println("Qué operación desea realizar?")
	fmt.Println("Introduzca: \n+ para sumar \n- para restar \n* para multiplicar \n/ para dividir")

	operator = scanner.Text()

	fmt.Println("Introduzca el primer numero")
	scanner.Scan()
	n1, _ := strconv.Atoi(scanner.Text())

	fmt.Println("Introduzca el segundo numero")
	scanner.Scan()
	n2, _ := strconv.Atoi(scanner.Text())

	switch operator {
	case "+":
		fmt.Println(n1, " + ", n2, " = ", n1+n2)
	case "-":
		fmt.Println(n1, " - ", n2, " = ", n1-n2)
	case "*":
		fmt.Println(n1, " * ", n2, " = ", n1*n2)
	case "/":
		fmt.Println(n1, " / ", n2, " = ", n1/n2)
	default:
		fmt.Println("Operador invalido")
	}
}

Código de la clase

package main

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

func main()  {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operation := scanner.Text()
	fmt.Println(operation)
	values := strings.Split(operation, "+")
	fmt.Println(values)
	fmt.Println(values[0] + values[1])
	operator1, _ := strconv.Atoi(values[0])
	operator2, _ := strconv.Atoi(values[1])

	fmt.Println(operator1 + operator2)
}

Usen fresh para que el server se reinicie cada vez que hagan un cambio.

ayudita

package main

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

func main()  {
	scanner := bufio.NewScanner(os.Stdin) //se defina la vairable, con la biblioteca bufio se define un nuevo escaner, con la biblioteca os se define que es una input

	scanner.Scan() //recibe y guarda la instancia del scaner del texto

	operacion := scanner.Text() //extrae el texto de "scanner"

	fmt.Println(operacion)

	variable := strings.Split(operacion, "+") //con la biblioteca strings y la función Split creamos un array en la cual estan nuestras dos variables menos el "+" y esta es asignada a "variables"

	fmt.Println(variable)

	fmt.Println(variable[0] + variable[1]) //para entrar a una variable de un array se utiliza [numero de la variable], se ordenan del 0 en adelante

	operacion1,_ := strconv.Atoi(variable[0]) //con la biblioteca strconv y la función Atoi convertimos nuestas variables de string a entero (cabe decir que Atoi regresa 2 valores, la primera es la converción y la segunda el error, por lo tanto si no vamos a utilizar esta variable ponemos "_" para indicarle a go que esuna variable que no se va a utilizar "una variable basura")

	operacion2,_ := strconv.Atoi(variable[1])
	
	fmt.Println(operacion1 + operacion2)
}```