Leer inputs desde la consola

7/42
Recursos
Transcripci贸n

Aportes 41

Preguntas 5

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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 鈥渟eparador鈥.

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?

_ = 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.
    var a string
fmt.Scanf("%d", &a)
fmt.Println("Hola mundo", a)

de esta forma me parece mejor y mas facil de entender

驴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

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

<h3>Scanner</h3>
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

<h3>Split</h3>
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.

<h3>Atoi</h3>
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)
}```