Trim Newlines From Strings in Go: ReadString and Substrings

You will learn how Go strings and string slices work, why no null terminator is needed, and how to remove \n or Windows-style \r\n line endings safely with the strings package.

(*bufio.Reader).ReadString('\n') reads bytes until it finds the specified delimiter and includes that delimiter in the returned string. Therefore, when a user presses Enter, the result commonly ends in a newline ("\n").

In Go, the usual solution is to use a function from the standard strings package rather than manually slicing by a fixed number of bytes:

line = strings.TrimSuffix(line, "\n")

Go strings are not null-terminated like C strings. A Go string has a length stored separately from its contents. Slicing a string creates a new string value representing the selected bytes; it does not require "\0", "", or any other ending character.

This matters because manual slicing such as input[:len(input)-2] is fragile:

• A Unix newline is normally one byte: \n.
• A Windows line ending is two bytes: \r\n.
• The final line of input may not end in a newline at all, especially when input ends at EOF.
• Subtracting too much can remove actual user data or cause a runtime panic for short input.

Think of a Go string as a label attached to a measured piece of text. Go already knows exactly how many bytes belong to the text, so it does not need a special null character to mark the end.

String slicing is like cutting a measured strip of paper from position 0 up to a chosen position. The resulting strip already has a known length. You do not need to glue an extra marker onto its end.

strings.TrimSuffix is like asking: “If this strip ends with this exact sticker, remove one sticker.” If the sticker is not there, the text remains unchanged.

Import the strings package and remove an expected suffix with strings.TrimSuffix:

package main

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

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

	fmt.Print("Enter a message: ")
	line, err := reader.ReadString('\n')
	if err != nil {
		// EOF can be normal if input ends without a newline.
		fmt.Println("read error:", err)
	}

	line = strings.TrimSuffix(line, "\n")
	fmt.Printf("You entered: %q\n", line)
}

If the program can receive Windows-style line endings, remove \r\n first, then \n:

line = strings.TrimSuffix(line, "\r\n")
line = strings.TrimSuffix(line, "\n")

If the goal is to remove all trailing carriage returns and newlines, use strings.TrimRight:

line = strings.TrimRight(line, "\r\n")

TrimRight treats its second argument as a set of characters, not as one exact sequence. Use TrimSuffix when you specifically mean “remove one line ending.”

Consider this input typed on a Unix-like system:

hello world↵

Code:

input := "hello world\n"
clean := strings.TrimSuffix(input, "\n")
fmt.Printf("%q\n", clean)

Execution:

1. input contains "hello world\n". The newline is part of the string.
2. strings.TrimSuffix(input, "\n") checks whether input ends with exactly "\n".
3. It does, so the suffix is removed.
4. clean becomes "hello world".
5. %q prints quotes and escape sequences, making invisible characters visible:

"hello world"

Now consider input without a final newline:

input := "hello world"
clean := strings.TrimSuffix(input, "\n")

The function does not find the suffix and safely returns "hello world" unchanged. This is why it is safer than subtracting from len(input).

• Command-line programs: Read a name, path, search query, or menu choice while preserving spaces inside the input.
• Configuration files: Remove a line ending after reading a key-value line, while keeping meaningful spaces in a value.
• Network protocols: Normalize a received line after reading through a buffered connection. Protocol-specific rules may require handling \r\n.
• Log processing: Read log lines and remove only their terminators before parsing timestamps or fields.
• Text imports: Process user-uploaded text that may use Unix (\n) or Windows (\r\n) line endings.

In real Go programs, developers usually separate reading, normalization, and validation.

A typical pattern is:

line, err := reader.ReadString('\n')
if err != nil && len(line) == 0 {
	return err
}

line = strings.TrimSuffix(line, "\r\n")
line = strings.TrimSuffix(line, "\n")

if line == "" {
	return fmt.Errorf("input cannot be empty")
}

Important patterns:

• Check read errors: ReadString may return both data and an error. At EOF, it can return the final unterminated text together with io.EOF.
• Use exact normalization: Prefer TrimSuffix when removing a delimiter added by a reader or protocol.
• Preserve intentional spaces: Do not use strings.TrimSpace unless leading and trailing whitespace is truly irrelevant.
• Validate after normalizing: First remove the line ending, then check whether the value is empty or otherwise valid.
• Avoid manual indexes: Named standard-library functions communicate intent and handle absent suffixes safely.

Removing two bytes unconditionally

// Broken: Unix input usually ends in only one byte: \n.
clean := input[:len(input)-2]

This removes one real character from input such as "cat\n", producing "ca". It can also panic when the input is too short.

Use:

clean := strings.TrimSuffix(input, "\n")

Assuming Go strings need a null terminator

// Unnecessary and changes the data.
clean := input[:len(input)-1] + "\x00"

Go strings are length-aware. Adding \x00 inserts an actual byte into the string; it is not required to finish a string.

Using TrimSpace when spaces matter

clean := strings.TrimSpace(input)

This removes newlines, but it also removes leading and trailing spaces, tabs, and other whitespace. That can change a password, a formatted message, or a meaningful value.

Use TrimSuffix for only the newline:

clean := strings.TrimSuffix(input, "\n")

Forgetting Windows line endings

clean := strings.TrimSuffix(input, "\n")

For "hello\r\n", this leaves "hello\r". If input may come from Windows, remove \r\n first:

clean := strings.TrimSuffix(input, "\r\n")
clean = strings.TrimSuffix(clean, "\n")

Ignoring errors from ReadString

line, _ := reader.ReadString('\n')

Ignoring errors can hide real I/O failures. In particular, handle io.EOF carefully because it may arrive with useful final text.

For line ending removal, TrimSuffix is generally the clearest choice because its name states exactly what the code intends to do.

import "strings"

// Remove one Unix line feed, if present.
line = strings.TrimSuffix(line, "\n")

// Support either CRLF or LF.
line = strings.TrimSuffix(line, "\r\n")
line = strings.TrimSuffix(line, "\n")

// Remove every trailing CR or LF character.
line = strings.TrimRight(line, "\r\n")

// Remove all outer whitespace; use only when desired.
line = strings.TrimSpace(line)

Rules:

• Go strings do not need a null terminator.
• String slices use byte indexes: s[start:end], where end is excluded.
• Avoid fixed len(s)-1 or len(s)-2 unless the format is guaranteed and you have checked the length.
• TrimSuffix leaves the string unchanged when the suffix is absent.
• A final ReadString result can contain data even when it also returns io.EOF.

Does bufio.Reader.ReadString include the delimiter?

Yes. ReadString('\n') returns text through and including the newline when it finds one.

Do Go strings end with \0?

No. Go strings store their length separately, so no terminating null byte is needed.

Why does input[:len(input)-2] remove the wrong text?

A typical Unix newline is only \n, which is one byte. Removing two bytes removes the newline and the last actual character.

How do I remove a newline but keep spaces typed by the user?

Use strings.TrimSuffix(line, "\n"). Unlike strings.TrimSpace, it does not remove ordinary spaces.

How do I handle both Windows and Unix line endings in Go?

Remove "\r\n" first and then "\n" using strings.TrimSuffix, or use strings.TrimRight(line, "\r\n") when removing all trailing line-ending characters is appropriate.

Is strings.TrimRight(line, "\r\n") the same as removing the exact string "\r\n"?

No. TrimRight removes any run of trailing \r or \n characters. TrimSuffix(line, "\r\n") removes only one exact CRLF suffix.

What happens if the last input line has no newline?

TrimSuffix safely returns it unchanged. ReadString may return that text along with io.EOF, so check both the returned text and the error.

• Go strings — Understand immutable, byte-oriented string values and slicing.
• bufio.Reader — Learn buffered input methods such as ReadString and ReadBytes.
• bufio.Scanner — A convenient alternative for reading tokenized or line-based input.
• Error handling in Go — Important because readers can return data and an error together.
• String trimming functions — Compare TrimSuffix, TrimPrefix, TrimRight, and TrimSpace.
• UTF-8 and runes — Relevant when slicing user text that may contain multi-byte characters.