Comment lire à partir d'une entrée standard dans la console?

Je voudrais lire l'entrée standard à partir de la ligne de commande, mais mes tentatives se sont terminées avec la fermeture du programme avant que je ne sois invité à entrer. Je cherche l'équivalent de Console.ReadLine () en C #.

Voici ce que j'ai actuellement:

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

Je ne sais pas ce qui ne va pas avec le bloc

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

Comme cela fonctionne sur ma machine. Cependant, pour le bloc suivant, vous avez besoin d'un pointeur sur les variables auxquelles vous affectez l'entrée. Essayez de remplacer fmt.Scanln(text2)par fmt.Scanln(&text2). N'utilisez pas Sscanln, car il analyse une chaîne déjà en mémoire au lieu de stdin. Si vous voulez faire quelque chose comme ce que vous essayez de faire, remplacez-le parfmt.Scanf("%s", &ln)

Si cela ne fonctionne toujours pas, votre coupable pourrait être des paramètres système étranges ou un IDE buggy.

vous pouvez aussi essayer:

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

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

Je pense qu'une façon plus standard de procéder serait:

package main

import "fmt"

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

Jetez un œil au scangodoc: http://godoc.org/fmt#Scan

Scan analyse le texte lu à partir de l'entrée standard, stockant les valeurs séparées par des espaces successifs dans des arguments successifs. Les sauts de ligne comptent comme de l'espace.

Scanln est similaire à Scan, mais arrête de numériser sur une nouvelle ligne et après le dernier élément, il doit y avoir une nouvelle ligne ou EOF.

Essayez toujours d'utiliser bufio.NewScanner pour collecter les entrées de la console. Comme d'autres l'ont mentionné, il existe plusieurs façons de faire le travail, mais le scanner est initialement destiné à le faire. Dave Cheney explique pourquoi vous devriez utiliser Scanner au lieu de bufio.Reader ReadLine.

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

Voici la réponse d'extrait de code pour votre question

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 vous ne voulez pas collecter par programmation les entrées, ajoutez simplement ces lignes

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

Le résultat du programme ci-dessus sera:

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

Le programme ci-dessus recueille les entrées utilisateur et les enregistre dans un tableau. Nous pouvons également briser ce flux avec un caractère spécial. Le scanner fournit une API pour une utilisation avancée comme le fractionnement à l'aide d'une fonction personnalisée, etc., l'analyse de différents types de flux d'E / S (Stdin, String), etc.

Une autre façon de lire plusieurs entrées dans une boucle qui peut gérer une entrée avec des espaces:

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

Production:

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

Je suis en retard à la fête. Mais que diriez-vous d'une doublure:

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

et appuyez sur ctrl + d (EOT) une fois l'entrée entrée sur la ligne de commande.

Essayez ce code: -

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

Peut aussi se faire comme ceci: -

package main
import "fmt"     

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

Lisez proprement dans quelques valeurs invitées:

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

Voici une course:

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

Vous devez fournir un pointeur sur la var que vous souhaitez numériser, comme ceci:

fmt.scan(&text2)

Dans mon cas, le programme n'attendait pas car j'utilisais la watchercommande pour exécuter automatiquement le programme. L'exécution manuelle du programme a go run main.goentraîné la «saisie de texte» et finalement l'impression sur la console.

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