web-dev-qa-db-fra.com

Comment lire les entrées de la ligne de console?

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

C'est 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)
}
go
203
Dante

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 essayiez de faire, remplacez-le par fmt.Scanf("%s", &ln)

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

220
LinearZoetrope

vous pouvez aussi bien essayer:

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

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

Je pense qu'un moyen plus standard de faire cela serait:

package main

import "fmt"

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

Jetez un coup d’œil à la scan godoc: http://godoc.org/fmt#Scan

Balayer analyse le texte lu à partir de l'entrée standard, en stockant des valeurs successives séparées par des espaces dans des arguments successifs. Les nouvelles lignes comptent comme un espace.

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

73
Pith

Une autre façon de lire plusieurs entrées dans une boucle pouvant 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)
        }
    }
}

Sortie:

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
9
Chiheb Nexus

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

https://Twitter.com/davecheney/status/604837853344989184?lang=fr

Voici l'extrait de code qui répond à 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 les entrées par programme, 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 collecte les entrées utilisateur et les enregistre dans un tableau. Nous pouvons également briser ce flux avec un caractère spécial. Scanner fournit une API pour une utilisation avancée, telle que le fractionnement à l'aide d'une fonction personnalisée, l'analyse de différents types de flux d'E/S (Stdin, String), etc.

8
Naren Yellavula

Essayez ce code: -

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

Je suis en retard à la fête. Mais qu'en est-il d'un paquebot:

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

Lire proprement dans un couple 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"
2
Rohanthewiz

Peut aussi être fait comme ça: -

package main
import "fmt"     

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

Vous devez fournir un pointeur sur la variable à analyser, comme suit:

fmt.scan(&text2)
0
Liam Mertens