pedir - leer datos en go

¿Cómo leer la entrada de la línea de consola?

Question

Me gustaría leer la entrada desde la línea de comandos, pero mis intentos han terminado con el programa saliendo antes de que se me solicite la entrada. Estoy buscando el equivalente de Console.ReadLine() en C #.

Esto es lo que tengo actualmente:

package main
import (
"bufio"
"fmt"
"os"
)
func main() {
reader := bufio.NewReader(os.Stdin)
fmt.Print("Enter text: ")
text, _ := reader.ReadString(''/n'')
fmt.Println(text)
fmt.Println("Enter text: ")
text2 := ""
fmt.Scanln(text2)
fmt.Println(text2)
ln := ""
fmt.Sscanln("%v", ln)
fmt.Println(ln)
}

Answer 1

Creo que una forma más estándar de hacer esto sería:

package main
import "fmt"
func main() {
fmt.Print("Enter text: ")
var input string
fmt.Scanln(&input)
fmt.Print(input)
}

Eche un vistazo a la scan godoc: http://godoc.org/fmt#Scan

Escanear escanea el texto leído de la entrada estándar, almacenando sucesivos valores separados por espacios en argumentos sucesivos. Las líneas nuevas cuentan como espacio.

Scanln es similar a Scan, pero detiene el escaneo en una nueva línea y después del elemento final debe haber una nueva línea o EOF.

Answer 2

Debe proporcionar un puntero a la var que desea escanear, así:

fmt.scan(&text2)

Answer 3

Intente este código: -

var input string
func main() {
fmt.Print("Enter Your Name=")
fmt.Scanf("%s",&input)
fmt.Println("Hello "+input)
}

Answer 4

Leer de forma limpia en un par de valores solicitados:

// Create a single reader which can be called multiple times
reader := bufio.NewReader(os.Stdin)
// Prompt and read
fmt.Print("Enter text: ")
text, _ := reader.ReadString(''/n'')
fmt.Print("Enter More text: ")
text2, _ := reader.ReadString(''/n'')
// Trim whitespace and print
fmt.Printf("Text1: /"%s/", Text2: /"%s/"/n",
strings.TrimSpace(text), strings.TrimSpace(text2))

Aquí hay una carrera:

Enter text: Jim
Enter More text: Susie
Text1: "Jim", Text2: "Susie"

Answer 5

Llego tarde a la fiesta. Pero ¿qué tal un trazador de líneas:

data, err := ioutil.ReadAll(os.Stdin)

Answer 6

No estoy seguro de lo que está mal con el bloque.

reader := bufio.NewReader(os.Stdin)
fmt.Print("Enter text: ")
text, _ := reader.ReadString(''/n'')
fmt.Println(text)

Como funciona en mi maquina. Sin embargo, para el siguiente bloque necesita un puntero a las variables a las que está asignando la entrada. Intente reemplazar fmt.Scanln(text2) con fmt.Scanln(&text2) . No use Sscanln , porque analiza una cadena que ya está en la memoria en lugar de desde stdin. Si desea hacer algo como lo que estaba tratando de hacer, reemplácelo con fmt.Scanf("%s", &ln)

Si esto todavía no funciona, su culpable podría ser alguna configuración del sistema extraña o un IDE con errores.

Answer 7

Otra forma de leer múltiples entradas dentro de un bucle que puede manejar una entrada con espacios:

package main
import (
"fmt"
"bufio"
"os"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
var text string
for text != "q" { // break the loop if text == "q"
fmt.Print("Enter your text: ")
scanner.Scan()
text = scanner.Text()
if text != "q" {
fmt.Println("Your text was: ", text)
}
}
}

Salida:

Enter your text: Hello world!
Your text was: Hello world!
Enter your text: Go is awesome!
Your text was: Go is awesome!
Enter your text: q

Answer 8

Siempre intente usar el bufio.NewScanner para recopilar información desde la consola. Como han mencionado otros, hay varias formas de hacer el trabajo, pero el escáner está originalmente destinado a hacer el trabajo. Dave Cheney explica por qué debes usar Scanner en lugar de bufio. ReadLine del lector.

https://twitter.com/davecheney/status/604837853344989184?lang=en

Aquí está la respuesta del fragmento de código para su pregunta

package main
import (
"bufio"
"fmt"
"os"
)
/*
Three ways of taking input
1. fmt.Scanln(&input)
2. reader.ReadString()
3. scanner.Scan()
Here we recommend using bufio.NewScanner
*/
func main() {
// To create dynamic array
arr := make([]string, 0)
scanner := bufio.NewScanner(os.Stdin)
for {
fmt.Print("Enter Text: ")
// Scans a line from Stdin(Console)
scanner.Scan()
// Holds the string that scanned
text := scanner.Text()
if len(text) != 0 {
fmt.Println(text)
arr = append(arr, text)
} else {
break
}
}
// Use collected inputs
fmt.Println(arr)
}

Si no desea recopilar las entradas mediante programación, simplemente agregue estas líneas

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

La salida del programa anterior será:

Enter Text: Bob
Bob
Enter Text: Alice
Alice
Enter Text:
[Bob Alice]

El programa anterior recopila las entradas del usuario y las guarda en una matriz. También podemos romper ese flujo con un carácter especial. El escáner proporciona API para uso avanzado, como dividir usando una función personalizada, etc., escaneando diferentes tipos de flujos de E / S (Stdin, String), etc.

Answer 9

También puedes intentar:

scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
if scanner.Err() != nil {
// handle error.
}