What is input handling? And why does it matter in backend development?

Input handling in backend development refers to receiving, validating, and processing data sent by users to a server. Hence, user input is central to backend development. From form submissions and API requests to file uploads and command-line tools, poor input handling can lead to issues like broken features, injection attacks, or even system crashes.

Overview of the bufio package in Go

The bufio package in Go helps with buffered I/O.

I know some of these terms might not make sense, but I’ll try to always break down complex terms using very simple words throughout this article.

buffered I/O is the technique of temporarily storing the results of an I/O (input/output) operation before transmitting it to the kernel (when it’s writing) or before providing it to your process (when it’s reading).

The kernel is the core part of an operating system. It’s like a manager that handles the communication between your program and your computer hardware.

A quick example on how to use the bufio package in your Go program

package main

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

func main() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter text: ")
    input, _ := reader.ReadString('\n')
    fmt.Println("You entered:", input)
}

In this code, we’re using bufio.NewReader to create a buffered reader that reads from standard input.
Here, os.Stdin just refers to your keyboard input. You don’t need to worry too much about the os package for now, it’s only helping us capture input from the user.

Using bufio.NewScanner

The bufio.NewScanner function in Go is used to read input line-by-line or word-by-word, depending on how you configure it. It’s perfect for cases where you want to process input in small chunks, like reading lines from a user or parsing a file line by line.

Here’s how to read user input from the terminal using bufio.NewScanner:

package main

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

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    fmt.Println("Enter some text:")
// this line creates a new scanner that read input from your keyboard and also prints a message to the terminal asking the user to write something


    for scanner.Scan() {
        line := scanner.Text()
        fmt.Println("You typed:", line)
    }
// this is a loop that runs each time the user enters a new line and scanner.Text() gets the current line of text the user just typed
// fmt.Println() returns the result of the user input back to the terminal

    if err := scanner.Err(); err != nil {
        fmt.Println("Error reading input:", err)
    }
// this line of code checks if there is an error while reading the user input and then prints it out
}

Here’s how you can use the bufio.NewScanner to read a file line by line:

package main

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

func main() {
    file, err := os.Open("example.txt") // this line opens the file named "example.txt" if it already exists
    if err != nil {                    
        fmt.Println("Error opening file:", err)
        return                          
    }
    // this block tells the program to stop runing if there is an error

    defer file.Close() // this makes sure the opened file is closed when the function ends

    scanner := bufio.NewScanner(file) // this line creates a scanner to read the file line by line
    for scanner.Scan() {              
        fmt.Println(scanner.Text())
    }
    // this block of code loops through the opened file line by line and prints each line to the terminal


    if err := scanner.Err(); err != nil {           
        fmt.Println("Error reading file:", err)   
    }
    // this block of code checks if there was an error while reading the file and prints it to the terminal

}

Using bufio.NewReader

Although using bufio.NewScanner is efficient for reading input line by line, bufio.NewReader can be utilized when you need full control of the input, like reading until it gets to a specific character or reading raw bytes.

Reading raw bytes simply means reading data exactly the way it is — in its binary or byte level form — without trying to interpret it as characters, strings or lines. This can be useful when dealing with binary files, custom formats or any data that isn’t plain text.

Use NewReader when:

• You want to read input until a specific character, like a comma or a hash symbol, instead of just stopping at a new line.

• You want more control — like checking the next part of the input without reading it yet, or reading a fixed number of characters or bytes.

Here’s an example of how to use NewReader to read input until a newline:

package main

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

func main() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Type something and press Enter: ")
    input, _ := reader.ReadString('\n')
    fmt.Println("You typed:", input)
}

//reader.ReadString('\n') reads input from the user until they press Enter (\n is the newline character).

Incase you didn’t already know, the _ is just saying “I know the ReadString() function returns a value there (an error in this case) but I’m just choosing to ignore it”

Here’s another example on how to use NewReader to read input until it gets to a specific character. In this case, we’ll go with the ‘&’ character:

package main

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

func main() {
    input := "Go is awesome&But this part won’t show"
    reader := bufio.NewReader(strings.NewReader(input))

    result, _ := reader.ReadString('&') // remember what I told you about the _
    fmt.Println("Read until &: ", result)
}

I hope these code blocks will be able to guide you through on getting started with the bufio package in Go.

Key differences between bufio.NewScanner and bufio.NewReader

Here’s a quick comparison table to help you decide the right one for your Go projects:

Edge case: NewScanner’s 64KB limit

By default, bufio.NewScanner can only read one line if it’s 64KB or smaller. If your line is longer (like a big chunk of text or a long JSON string), it will fail and give an error.

You can fix this by telling the scanner to use a bigger buffer with the scanner.Buffer() function, but if your input is often that large, it’s easier to just use bufio.NewReader instead.

Here are common pitfalls you might come across when using the bufio package in your Go projects:

• Scanner not reading the last line

  If the last line of your input doesn't end with a newline (\n), Scanner might skip it. Always make sure your input ends with a newline, especially when reading from files.

• Reader hanging due to heavy delimiter

  If you're using reader.ReadString(delimiter) and the delimiter (like ‘\n’ or ‘&’) never shows up, the program will wait forever. Always be sure that the input contains the character you're waiting for.

• Best practices when handling error from the bufio package

  Both Scanner and Reader can fail quietly. Always check for errors using by checking the err returned from ReadString(). It helps catch problems like missing files or bad input.

Conclusion

To wrap it up, use bufio.NewScanner when you just want to read things line by line — like simple user input or text files. It’s easy to use but can’t handle very big lines. Use bufio.NewReader when you need more control, like reading until a special character or working with large or complex input. It takes more code, but it’s more flexible. Just pick the one that fits what you're trying to do, and always check for errors so your program doesn’t crash or behave in strange ways.