String Literals

A string literal is a fixed sequence of characters you write directly in Go source code to represent a string value. Go has two distinct forms: interpreted literals enclosed in double quotes, and raw literals enclosed in backticks. Understanding the differences between them is essential for writing correct, readable code.

Interpreted String Literals

Double-quoted strings are the default form you will see most often. They are called interpreted because the Go compiler processes escape sequences inside them.

greeting := "Hello, Gophers!"

This literal can contain any Unicode character except a newline or an unescaped double quote. To include a double quote, a backslash, or control characters, you use an escape sequence—a backslash followed by a specific character.

quote := "She said \"Go is fantastic!\""
path  := "C:\\Users\\gopher\\docs"

Every \ in an interpreted literal has special meaning. If you need a literal backslash, you must write \\. For a newline, you write \n; for a tab, \t. The table later in this section covers all recognized sequences.

Escape sequences are resolved at compile time. The string stored at runtime already contains the actual bytes for the newline, tab, or quote you specified. This means there is no performance penalty for using them—they are no different from writing the corresponding raw bytes.

Raw String Literals

A raw string literal is a sequence of characters between backticks (`). No escape processing takes place: what you see is exactly what you get.

raw := `Line one
Line two
    Indented line
Literal backslash \ and quote " are ordinary here`

Because there is no escape processing, you can safely write backslashes, double quotes, and newlines without any extra syntax. This makes raw strings the natural choice for regular expressions, file paths on Windows, JSON snippets embedded in code, and multi-line text blocks.

The one character you cannot include in a raw string literal is a backtick itself—it would end the literal. If you must embed a backtick, you will need to use an interpreted literal and escape it, or concatenate with a backtick-bearing interpreted string.

// Correct: using concatenation to include a backtick in output
output := "This is a backtick: `" + "`" + ` is included`

Escape Sequences in Interpreted Strings

The following escape sequences are recognized inside double-quoted string literals. Any backslash not followed by one of these characters is illegal.

For Unicode escapes, the four- and eight-digit forms denote the same code point; the eight-digit form is useful for supplementary characters beyond U+FFFF.

heart := "I \u2665 Go"       // I ♥ Go
smile := "\U0001F600"        // 😀

Each escape represents a single character in the string, even though it spans several source characters.

// Interpreted: painful double escaping
re := regexp.MustCompile("\\d{3}-\\d{2}-\\d{4}")
// Raw: write the pattern as you would in a regex tester
re := regexp.MustCompile(`\d{3}-\d{2}-\d{4}`)

Interpreted vs Raw: Choosing the Right Form

Neither form is a “smarter” default—each solves a different readability problem. Use interpreted strings when escape sequences are part of the value. Use raw strings when backslashes and newlines are part of the content and escaping them would harm readability.

String Literals Are Constants

A string literal is a constant expression. Its value is known at compile time, and the compiler can use it anywhere a constant string is required—for example, in const declarations or in switch case labels.

const welcome = "Hello"
const rawBlock = `
=====================
=   WELCOME TO GO   =
=====================
`

Because the literal is a constant, it cannot be assigned to at runtime. The underlying bytes are immutable. This leads directly to the next point.

Taking the Address of a String Literal

You cannot write &"hello" in Go. This is not an oversight—it follows from the fact that a string literal is a constant, not an addressable variable.

s := "hello"
p := &s   // allowed

The restriction protects the immutability contract. If &"hello" were allowed, a function that modifies the string through the pointer could change what is conceptually a fixed value. Other constants like 42 or 3.14 likewise cannot have their addresses taken. Composite literals like &MyStruct{...} work because they are not constants—they allocate a new value at runtime.

This design choice is consistent with Go’s systems-language philosophy: constants are truly constant, and addressability implies mutability. If you need a pointer to a string, create a variable first.

Common Mistakes and How to Avoid Them

Forgetting to escape a backslash in interpreted strings.
If you mean a literal backslash inside a double-quoted string, write \\. A single \ followed by an unrecognised character is a compile error.

// Wrong: path := "C:\new\folder"
path := "C:\\new\\folder" // correct

Trying to put a backtick inside a raw string.
The backtick is the delimiter; you cannot escape it. Use concatenation if you need a backtick in the value.

Indenting a raw string’s closing backtick.
Every space before the closing backtick is part of the string. If you want clean multi-line output, do not indent the closing backtick.

// Surprise: leading spaces and tabs are embedded
msg := `
    This starts with a newline and four spaces
    `
// Cleaner: start and end at column 1
msg := `This starts right away
and the next line is flush.`

Confusing \x escapes with UTF-8 multibyte sequences.
\x specifies a single byte, not a Unicode code point. For characters beyond ASCII, use \u or \U escapes to avoid breaking multi-byte UTF-8 sequences.

s := "\xE2\x82\xAC"   // UTF-8 bytes for € – works but fragile
s := "\u20AC"          // clear and self-documenting

Expecting raw strings to trim indentation.
Raw strings include exactly the characters between the backticks. If you want automatically trimmed multi-line strings, you must handle that yourself or use a helper function. The standard library does not strip indentation from raw literals.

Summary

Interpreted and raw string literals are two tools for expressing string constants in Go. Interpreted literals give you fine-grained control over special characters through escape sequences; raw literals let you write text exactly as it should appear, free from backslash noise. The choice hinges on whether the value contains more characters that need escaping (like backslashes and newlines) or characters that must not be escaped (like the backtick).

The most important structural fact to remember is that string literals are constants: they are immutable, known at compile time, and not addressable. This keeps programs safe and predictable, even though it sometimes means you must assign a literal to a variable before taking its address.