Come leggere dall'input standard nella console?

Vorrei leggere l'input standard dalla riga di comando, ma i miei tentativi sono terminati con l'uscita del programma prima che mi venga richiesto di immettere. Sto cercando l'equivalente di Console.ReadLine () in C #.

Questo è quello che ho attualmente:

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

Non sono sicuro di cosa c'è che non va nel blocco

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

Come funziona sulla mia macchina. Tuttavia, per il blocco successivo è necessario un puntatore alle variabili a cui si sta assegnando l'input. Prova a sostituirlo fmt.Scanln(text2)con fmt.Scanln(&text2). Non usare Sscanln, perché analizza una stringa già in memoria anziché da stdin. Se vuoi fare qualcosa di simile a quello che stavi cercando di fare, sostituiscilo confmt.Scanf("%s", &ln)

Se il problema persiste, il tuo colpevole potrebbe essere una strana impostazione del sistema o un IDE errato.

puoi anche provare:

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

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

Penso che un modo più standard per farlo sarebbe:

package main

import "fmt"

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

Dai un'occhiata al scangodoc: http://godoc.org/fmt#Scan

La scansione esegue la scansione del testo letto dallo standard input, memorizzando i valori successivi separati da spazi in argomenti successivi. Newline conta come spazio.

Scanln è simile a Scan, ma interrompe la scansione su una nuova riga e dopo l'elemento finale deve esserci una nuova riga o EOF.

Cerca sempre di utilizzare bufio.NewScanner per raccogliere input dalla console. Come altri hanno già detto, esistono diversi modi per eseguire il lavoro, ma lo scanner è originariamente destinato a fare il lavoro. Dave Cheney spiega perché dovresti usare Scanner invece di bufio.Reader ReadLine.

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

Ecco la risposta dello snippet di codice per la tua domanda

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

Se non si desidera raccogliere programmaticamente gli input, è sufficiente aggiungere queste righe

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

L'output del programma sopra sarà:

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

Il programma sopra raccoglie l'input dell'utente e li salva in un array. Possiamo anche interrompere quel flusso con un personaggio speciale. Scanner fornisce API per un uso avanzato come la divisione mediante una funzione personalizzata ecc., La scansione di diversi tipi di flussi I / O (Stdin, String) ecc.

Un altro modo per leggere più input all'interno di un loop in grado di gestire un input con spazi:

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

Produzione:

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

Sono in ritardo alla festa. Ma che ne dici di un liner:

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

e premere ctrl + d (EOT) una volta immesso l'ingresso nella riga di comando.

Prova questo codice: -

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

Può anche essere fatto in questo modo: -

package main
import "fmt"     

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

Leggi in modo chiaro in un paio di valori richiesti:

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

Ecco una corsa:

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

Devi fornire un puntatore al var che vuoi scansionare, in questo modo:

fmt.scan(&text2)

Nel mio caso, il programma non era in attesa perché stavo usando il watchercomando per eseguire automaticamente il programma. L'esecuzione manuale del programma ha go run main.gocomportato "Immettere testo" e infine stampare sulla console.

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