Wie lese ich von der Standardeingabe in der Konsole?

Ich möchte die Standardeingabe über die Befehlszeile lesen, aber meine Versuche wurden mit dem Beenden des Programms beendet, bevor ich zur Eingabe aufgefordert werde. Ich suche das Äquivalent von Console.ReadLine () in C #.

Folgendes habe ich derzeit:

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

Ich bin mir nicht sicher, was mit dem Block los ist

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

Wie es auf meiner Maschine funktioniert. Für den nächsten Block benötigen Sie jedoch einen Zeiger auf die Variablen, denen Sie die Eingabe zuweisen. Versuchen Sie es fmt.Scanln(text2)durch fmt.Scanln(&text2). Nicht verwenden Sscanln, da eine Zeichenfolge analysiert wird, die sich bereits im Speicher befindet, anstatt von stdin. Wenn Sie so etwas wie das tun möchten, was Sie versucht haben, ersetzen Sie es durchfmt.Scanf("%s", &ln)

Wenn dies immer noch nicht funktioniert, liegt Ihr Schuldiger möglicherweise an seltsamen Systemeinstellungen oder einer fehlerhaften IDE.

Sie können auch versuchen:

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

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

Ich denke, ein normaler Weg, dies zu tun, wäre:

package main

import "fmt"

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

Schauen Sie sich den scanGodoc an: http://godoc.org/fmt#Scan

Scan scannt den von der Standardeingabe gelesenen Text und speichert aufeinanderfolgende durch Leerzeichen getrennte Werte in aufeinanderfolgenden Argumenten. Zeilenumbrüche gelten als Leerzeichen.

Scanln ähnelt Scan, stoppt jedoch das Scannen an einer neuen Zeile und nach dem letzten Element muss eine neue Zeile oder EOF vorhanden sein.

Versuchen Sie immer, den bufio.NewScanner zum Sammeln von Eingaben von der Konsole zu verwenden. Wie bereits erwähnt, gibt es mehrere Möglichkeiten, die Aufgabe zu erledigen, aber Scanner ist ursprünglich für die Ausführung der Aufgabe vorgesehen. Dave Cheney erklärt, warum Sie Scanner anstelle von bufio.Reader's ReadLine verwenden sollten.

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

Hier ist die Code-Snippet-Antwort für Ihre Frage

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

Wenn Sie die Eingaben nicht programmgesteuert erfassen möchten, fügen Sie einfach diese Zeilen hinzu

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

Die Ausgabe des obigen Programms lautet:

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

Das obige Programm sammelt die Benutzereingaben und speichert sie in einem Array. Wir können diesen Fluss auch mit einem besonderen Charakter unterbrechen. Der Scanner bietet eine API für die erweiterte Verwendung wie das Aufteilen mithilfe einer benutzerdefinierten Funktion usw., das Scannen verschiedener Arten von E / A-Streams (Stdin, String) usw.

Eine andere Möglichkeit, mehrere Eingaben innerhalb einer Schleife zu lesen, die eine Eingabe mit Leerzeichen verarbeiten kann:

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

Ausgabe:

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

Ich bin zu spät zur Party. Aber wie wäre es mit einem Liner:

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

und drücken Sie Strg + d (EOT), sobald die Eingabe in die Befehlszeile eingegeben wurde.

Versuchen Sie diesen Code: -

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

Kann auch so gemacht werden: -

package main
import "fmt"     

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

Lesen Sie einige angeforderte Werte sauber ein:

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

Hier ist ein Lauf:

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

Sie müssen einen Zeiger auf die Variable bereitstellen, die Sie scannen möchten, wie folgt:

fmt.scan(&text2)

In meinem Fall wartete das Programm nicht, da ich den watcherBefehl zum automatischen Ausführen des Programms verwendete. Das manuelle Ausführen des Programms go run main.goführte zu "Text eingeben" und schließlich zum Drucken auf der Konsole.

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