Como ler da entrada padrão no console?

Gostaria de ler a entrada padrão na linha de comando, mas minhas tentativas foram encerradas com a saída do programa antes de ser solicitada a entrada. Estou procurando o equivalente de Console.ReadLine () em c #.

Isto é o que eu tenho atualmente:

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

Não tenho certeza do que há de errado com o bloco

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

Como funciona na minha máquina. No entanto, para o próximo bloco, você precisa de um ponteiro para as variáveis ​​às quais está atribuindo a entrada. Tente substituir fmt.Scanln(text2)por fmt.Scanln(&text2). Não use Sscanln, porque analisa uma string já na memória, em vez de no stdin. Se você quiser fazer algo parecido com o que estava tentando fazer, substitua-o porfmt.Scanf("%s", &ln)

Se isso ainda não funcionar, seu culpado pode ser algumas configurações estranhas do sistema ou um IDE com bugs.

você também pode tentar:

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

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

Eu acho que uma maneira mais padrão de fazer isso seria:

package main

import "fmt"

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

Dê uma olhada no scangodoc: http://godoc.org/fmt#Scan

A digitalização digitaliza o texto lido da entrada padrão, armazenando sucessivos valores separados por espaço em argumentos sucessivos. As novas linhas contam como espaço.

Scanln é semelhante ao Scan, mas para a digitalização em uma nova linha e após o item final deve haver uma nova linha ou EOF.

Sempre tente usar o bufio.NewScanner para coletar entradas do console. Como já mencionado, existem várias maneiras de executar o trabalho, mas o Scanner foi originalmente projetado para executar o trabalho. Dave Cheney explica por que você deve usar o Scanner em vez do ReadLine do bufio.Reader.

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

Aqui está a resposta do trecho de código para sua pergunta

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

Se você não deseja coletar programaticamente as entradas, basta adicionar essas linhas

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

A saída do programa acima será:

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

O programa acima coleta as entradas do usuário e as salva em uma matriz. Também podemos interromper esse fluxo com um caractere especial. O scanner fornece API para uso avançado, como divisão usando uma função personalizada, etc., varredura de diferentes tipos de fluxos de E / S (Stdin, String) etc.

Outra maneira de ler várias entradas em um loop que pode manipular uma entrada com espaços:

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

Resultado:

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

Estou atrasado para a festa. Mas que tal um forro:

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

e pressione ctrl + d (EOT) quando a entrada for inserida na linha de comando.

Experimente este código: -

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

Também pode ser feito assim: -

package main
import "fmt"     

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

Leia corretamente alguns valores solicitados:

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

Aqui está uma corrida:

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

Você precisa fornecer um ponteiro para a var que deseja digitalizar, da seguinte forma:

fmt.scan(&text2)

No meu caso, o programa não estava esperando porque eu estava usando o watchercomando para executar automaticamente o programa. A execução manual do programa go run main.goresultou em "Inserir texto" e, eventualmente, na impressão no console.

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