¿Cómo leer desde la entrada estándar en la consola?

Me gustaría leer la entrada estándar desde la línea de comando, pero mis intentos han terminado con la salida del programa 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)
}

No estoy seguro de qué le pasa al bloque

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

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

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

también puedes probar:

scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

if scanner.Err() != nil {
    // handle error.
}

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 al scangodoc: http://godoc.org/fmt#Scan

El escaneo escanea el texto leído desde la entrada estándar, almacenando valores sucesivos separados por espacios en argumentos sucesivos. Las nuevas líneas 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.

Siempre trate de usar el bufio.NewScanner para recopilar información de la consola. Como otros mencionaron, hay varias formas de hacer el trabajo, pero Scanner originalmente está destinado a hacer el trabajo. Dave Cheney explica por qué debería usar Scanner en lugar de bufio. ReadLine de Read.

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 la entrada del usuario y la guarda en una matriz. También podemos romper ese flujo con un carácter especial. Scanner proporciona API para uso avanzado como dividir usando una función personalizada, etc., escaneando diferentes tipos de flujos de E / S (Stdin, String), etc.

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

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

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

y presione ctrl + d (EOT) una vez que se ingresa la entrada en la línea de comando.

Prueba este código: -

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

También se puede hacer así:

package main
import "fmt"     

func main(){
    var myname string
fmt.Scanf("%s", &myname)           
fmt.Println("Hello", myname)       
}

Lea claramente 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"

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

fmt.scan(&text2)

En mi caso, el programa no estaba esperando porque estaba usando el watchercomando para ejecutar automáticamente el programa. La ejecución manual del programa go run main.godio como resultado "Introducir texto" y, finalmente, imprimir en la consola.

fmt.Print("Enter text: ")
var input string
fmt.Scanln(&input)
fmt.Print(input)