Jak czytać ze standardowego wejścia w konsoli?

Chciałbym odczytać standardowe dane wejściowe z wiersza poleceń, ale moje próby zakończyły się wyjściem programu przed wyświetleniem monitu o wprowadzenie danych. Szukam odpowiednika Console.ReadLine () w C #.

Oto, co obecnie mam:

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

Nie jestem pewien, co jest nie tak z blokiem

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

Jak to działa na moim komputerze. Jednak do następnego bloku potrzebujesz wskaźnika do zmiennych, do których przypisujesz dane wejściowe. Spróbuj wymienić fmt.Scanln(text2)z fmt.Scanln(&text2). Nie używaj Sscanln, ponieważ analizuje ciąg znaków już w pamięci zamiast ze standardowego wejścia. Jeśli chcesz zrobić coś takiego, co próbujesz zrobić, zastąp tofmt.Scanf("%s", &ln)

Jeśli to nadal nie działa, twoim winowajcą mogą być jakieś dziwne ustawienia systemowe lub błędne IDE.

możesz również spróbować:

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

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

Myślę, że bardziej standardowym sposobem na to byłoby:

package main

import "fmt"

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

Spójrz na scangodoc: http://godoc.org/fmt#Scan

Skanuje skanuje tekst odczytany ze standardowego wejścia, przechowując kolejne wartości oddzielone spacją w kolejnych argumentach. Nowe linie liczą się jako spacja.

Scanln jest podobny do skanowania, ale zatrzymuje skanowanie w nowej linii, a po ostatnim elemencie musi znajdować się nowa linia lub EOF.

Zawsze staraj się używać bufio.NewScanner do zbierania danych wejściowych z konsoli. Jak wspomniano inni, istnieje wiele sposobów wykonania zadania, ale skaner pierwotnie miał na celu wykonanie zadania. Dave Cheney wyjaśnia, dlaczego warto używać skanera zamiast bufio.Reader's ReadLine.

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

Oto odpowiedź na fragment kodu dla twojego pytania

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

Jeśli nie chcesz programowo zbierać danych wejściowych, po prostu dodaj te wiersze

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

Wyjście powyższego programu będzie:

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

Powyższy program zbiera dane wejściowe użytkownika i zapisuje je w tablicy. Możemy również przerwać ten przepływ specjalnym charakterem. Skaner zapewnia interfejs API do zaawansowanych zastosowań, takich jak dzielenie przy użyciu funkcji niestandardowej itp., Skanowanie różnych typów strumieni we / wy (Stdin, String) itp.

Innym sposobem odczytu wielu danych wejściowych w pętli, które mogą obsłużyć dane wejściowe ze spacjami:

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

Wynik:

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

Jestem spóźniony na przyjęcie. Ale co powiesz na jedną wkładkę:

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

i naciśnij ctrl + d (EOT) po wprowadzeniu danych w wierszu poleceń.

Wypróbuj ten kod: -

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

Można to również zrobić w następujący sposób:

package main
import "fmt"     

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

Wyczyść kilka podpowiedzi:

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

Oto przebieg:

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

Musisz podać wskaźnik do zmiennej, którą chcesz skanować, na przykład:

fmt.scan(&text2)

W moim przypadku program nie czekał, ponieważ użyłem watcherpolecenia do automatycznego uruchomienia programu. Ręczne uruchomienie programu go run main.gospowodowało „Wprowadź tekst” i ostatecznie drukowanie na konsoli.

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