Golang leggi da stdin

Nella maggior parte dei linguaggi di programmazione, hai la possibilità di leggere l'input dalla console e archiviarlo in una variabile. La programmazione di Go non è lasciata alle spalle a questo proposito. In questo articolo, impareremo come leggere input dalla console in Go Programming.

Importazioni richieste

Per leggere l'input dalla console, dobbiamo importare alcuni pacchetti. Il primo è il pacchetto Bufio, il pacchetto FMT e il pacchetto del sistema operativo.

Il pacchetto Bufio ti consente di leggere i caratteri dalla stdin contemporaneamente. Il pacchetto FMT viene utilizzato per gestire le operazioni I/O e il sistema operativo fornisce funzionalità di sistema di basso livello.

Il seguente snippet importa tutti i pacchetti richiesti:

importazione (
"Bufio"
"FMT"
"OS"
)

Golang leggi il personaggio

Vediamo come puoi leggere un singolo carattere Unicode da Stdin nel linguaggio Go. Considera il seguente codice fornito:

Pacchetto principale
importazione (
"Bufio"
"FMT"
"tronco d'albero"
"OS"
)
func main ()
fmt.Println ("Digita un carattere>")
lettore: = bufio.NewReader (sistema operativo.Stdin)
char, _, err: = lettore.Readrune ()
Se err != nil
tronco d'albero.Fatale (err)

fmt.Printf ("Unicode char: %u \ n", char)

Nell'esempio precedente, creiamo un nuovo lettore dal pacchetto Bufio e passiamo il sistema operativo.Stdin come parametro.

Abbiamo quindi letto il carattere e l'errore del lettore. Si noti che utilizziamo il metodo readrune () per restituire un carattere Unicode.

Il codice precedente dovrebbe restituire un output come mostrato:

Digita un carattere>
UN
Unicode Char: U+0041

L'output sopra mostra il punto di codice Unicode per il carattere "a."

Golang leggi Multi-Line

Se si desidera leggere più righe dalla console, è possibile utilizzare il metodo ReadString () anziché ReadRune, come mostrato sopra.

Di seguito viene fornito un esempio di codice:

Pacchetto principale
importazione (
"Bufio"
"FMT"
"tronco d'albero"
"OS"
)
func main ()
fmt.Println ("immettere una stringa")
lettore: = bufio.NewReader (sistema operativo.Stdin)
str, err: = lettore.Readstring ('\ n')
Se err != nil
tronco d'albero.Fatale (err)

fmt.Printf ("%s", str)

In questo esempio, il lettore leggerà continuamente l'input dell'utente fino a quando non incontra il delimitatore specificato. Nel nostro esempio, se il lettore incontra un personaggio di nuova linea, smette di leggere.

Se eseguiamo il codice, dovremmo ottenere un output come:

Immettere una stringa
..
ciao mondo da stdin

Scanner Golang

Un altro metodo che possiamo usare per accettare l'input da stdin è il metodo scanner. Il metodo NewsCanner () è molto utile quando si legge un file. Tuttavia, possiamo usarlo per leggere da stdin.

Un esempio di codice è mostrato di seguito:

Pacchetto principale
importazione (
"Bufio"
"FMT"
"OS"
)
func main ()
scanner: = bufio.NewsCanner ((sistema operativo.Stdin))
Input: = make ([] string, 0)
per
fmt.Println ("digita qui:")
scanner.Scansione()
txt: = scanner.Testo()
input = append (input, txt)
rottura

fmt.Println (input)

Il codice precedente legge l'input dall'utente e lo aggiunge alla fetta di input. È possibile espandere il codice precedente per leggere continuamente l'input e terminare una volta che non viene fornito alcun valore.

Conclusione

Come visto da questa guida, GO Programming ci fornisce diversi modi per leggere input da Stdin. Puoi scegliere qualsiasi metodo adatto alle tue esigenze. Speriamo che tu abbia trovato questo articolo utile. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.