How to Read Standard Input in Go

By the end of this page, you will understand how to read input from standard input in Go, when to use bufio.Reader versus fmt.Scanln, and why some input attempts fail. You will also learn beginner-friendly patterns for reading full lines, single values, and handling common input mistakes.

In Go, reading from standard input means reading data from os.Stdin, which represents what the user types in the terminal.

There are two common approaches:

• bufio.Reader for reading full lines or larger chunks of text
• fmt.Scan, fmt.Scanln, or fmt.Scanf for scanning space-separated values into variables

If you want behavior similar to C#'s Console.ReadLine(), the closest match is usually reading from os.Stdin with bufio.Reader.

Why this matters

Console input is useful in many kinds of programs:

• small command-line tools
• coding challenge programs
• interactive scripts
• configuration prompts
• debugging utilities

A key detail in Go is that some input functions expect pointers to variables. If you pass a normal value instead of a pointer, the function cannot store the result in your variable.

For example, this is wrong:

text2 := ""
fmt.Scanln(text2)

This passes the value of text2, not its address. Go needs the address so it can write the input into that variable.

Correct version:

Think of standard input as a stream of characters flowing from the keyboard into your program.

• os.Stdin is the pipe connected to the keyboard input
• bufio.Reader is a helper that lets you collect characters until a stopping point, such as a newline
• fmt.Scanln is more like a form parser: it reads typed values and places them into variables you provide

A simple analogy:

• bufio.Reader = reading an entire sentence from a notebook line
• fmt.Scanln = filling labeled boxes with typed values

If you want the whole line exactly as the user typed it, use a reader. If you want individual values like a name, age, or number, scanning functions can be simpler.

Read a full line with bufio.Reader

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)

    fmt.Print("Enter text: ")
    text, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    text = strings.TrimSpace(text)
    fmt.Println("You entered:", text)
}

Explanation

• bufio.NewReader(os.Stdin) creates a reader connected to keyboard input.
• ReadString('\n') keeps reading until the user presses Enter.
• The returned text usually includes the newline, so strings.TrimSpace() is often used to remove it.

Read a single word with fmt.Scanln

package main

import "fmt"

func  {
     name 

    fmt.Print()
    _, err := fmt.Scanln(&name)
     err !=  {
        fmt.Println(, err)
        
    }

    fmt.Println(, name)
}

Consider this example:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)

    fmt.Print("Enter text: ")
    input, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    input = strings.TrimSpace(input)
    fmt.Println("Final value:", input)
}

What happens step by step

1. reader := bufio.NewReader(os.Stdin)

   • A reader is created that listens to terminal input.

2. fmt.Print("Enter text: ")

   • The prompt is shown without adding a newline.

3. input, err := reader.ReadString('\n')

   • The program pauses and waits.
   • The user types something like hello world and presses Enter.
   • The value returned is usually "hello world\n".

Reading from standard input is common in practical Go programs.

Command-line utilities

A script may ask for a filename, search term, or confirmation:

fmt.Print("Enter filename: ")

Coding challenge platforms

Many competitive programming tasks read data from standard input instead of from files or prompts.

Setup scripts

A tool might ask for environment values:

• database host
• port number
• API key label

Interactive admin tools

Terminal apps often request commands like:

• create
• delete
• list

Data entry programs

You may ask the user to enter names, quantities, or notes, then process those values inside the program.

In real Go codebases, developers usually choose the input tool based on the shape of the data.

Common patterns

Full-line input for free-form text

Used for:

• search queries
• comments
• prompts with spaces
• file paths

Typical choice:

reader := bufio.NewReader(os.Stdin)
line, err := reader.ReadString('\n')

Token-based input for structured values

Used for:

• menu choices
• numbers
• short identifiers

Typical choice:

var choice int
fmt.Scanln(&choice)

Validation after input

Developers rarely trust raw input directly.

if strings.TrimSpace(name) == "" {
    fmt.Println("Name cannot be empty")
    return
}

Early returns on input errors

A very common Go style is:

input, err := reader.ReadString('\n')
if err != nil {
    
}

1. Passing a value instead of a pointer

Broken code:

var name string
fmt.Scanln(name)

Problem:

• Scanln cannot write into name because it needs a pointer.

Correct code:

var name string
fmt.Scanln(&name)

2. Using fmt.Sscanln for terminal input

Broken code:

var name string
fmt.Sscanln("%v", name)

Problem:

• Sscanln scans from a string, not from standard input.
• It is the wrong function for keyboard input.

Correct approach:

fmt.Scanln(&name)

or

reader := bufio.NewReader(os.Stdin)
text, _ := reader.ReadString('\n')

3. Ignoring errors

Full line input

reader := bufio.NewReader(os.Stdin)
text, err := reader.ReadString('\n')

Remove newline:

text = strings.TrimSpace(text)

Single value input

var name string
_, err := fmt.Scanln(&name)

Important rule

Scanning functions need pointers:

fmt.Scanln(&value) // correct
fmt.Scanln(value)  // wrong

Useful imports

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

Best tool by situation

• Full sentence or line: bufio.Reader or bufio.Scanner
• Single word or number: fmt.Scanln
• Parse from an existing string: fmt.Sscanln

Common edge cases

What is the Go equivalent of Console.ReadLine()?

The closest equivalent is usually reading from os.Stdin using bufio.Reader or bufio.Scanner.

Why does fmt.Scanln(text2) not work?

Because Scanln needs a pointer. Use fmt.Scanln(&text2) instead.

Should I use bufio.Reader or bufio.Scanner?

Use bufio.Scanner for simple line-by-line input. Use bufio.Reader when you want more control.

Does fmt.Sscanln read from the keyboard?

No. It reads from a string already in memory, not from standard input.

Why does my input contain a newline character?

Functions like ReadString('\n') include the newline in the returned string. Use strings.TrimSpace() to remove it.

Can fmt.Scanln read text with spaces?

• os.Stdin — the standard input stream your program reads from.
• bufio.Reader — useful for buffered reading and full-line input.
• bufio.Scanner — a simpler way to read input line by line.
• fmt.Scan — reads space-separated values into variables.
• fmt.Scanln — reads values until a newline.
• pointers in Go — important because scan functions need addresses to store data.
• error handling in Go — input operations can fail and should be checked.
• strings.TrimSpace — commonly used to clean newline characters from input.