Introduction to Go’s Quote Functions

When working with strings in Go, you’ll often need to create properly escaped string literals or handle special characters safely. Go’s strconv package provides a comprehensive set of quote functions that transform your strings into valid Go string literals, complete with proper escaping and formatting.

These functions become essential when you’re generating code, working with user input that contains special characters, or need to safely represent strings in logs and debug output. Instead of manually handling escape sequences like \n, \", or \\, Go’s quote functions do the heavy lifting for you.

The quote functions in strconv fall into two main categories: those that work with entire strings (Quote, QuoteToASCII, QuoteToGraphic) and those that handle individual runes (QuoteRune, QuoteRuneToASCII, QuoteRuneToGraphic). Each serves specific use cases depending on your character encoding needs and output requirements.

Understanding Quote(s string) string

The Quote function is your go-to tool for converting any string into a valid Go string literal. It wraps your string in double quotes and escapes any characters that need special treatment.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Basic string quoting
    simple := "Hello, World!"
    quoted := strconv.Quote(simple)
    fmt.Println(quoted) // "Hello, World!"
    
    // Strings with special characters
    withNewline := "Line 1\nLine 2"
    quotedNewline := strconv.Quote(withNewline)
    fmt.Println(quotedNewline) // "Line 1\nLine 2"
    
    // Strings with quotes
    withQuotes := `He said "Hello"`
    quotedQuotes := strconv.Quote(withQuotes)
    fmt.Println(quotedQuotes) // "He said \"Hello\""
    
    // Unicode characters
    unicode := "café 🚀"
    quotedUnicode := strconv.Quote(unicode)
    fmt.Println(quotedUnicode) // "café 🚀"
}

The Quote function handles all the common escape sequences you’d expect: \n for newlines, \t for tabs, \" for double quotes, \\ for backslashes, and many others. It preserves Unicode characters as-is, making it suitable for international text.

This function proves particularly useful when generating Go code programmatically or when you need to safely embed user-provided strings into larger text structures. The output is always a valid Go string literal that you could paste directly into Go source code.

Working with QuoteToASCII(s string) string

The QuoteToASCII function takes string quoting a step further by ensuring that all non-ASCII characters are escaped using their Unicode code points. This becomes crucial when you need to generate strings that will work reliably across different systems, terminals, or environments that might not handle Unicode properly.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // ASCII characters remain unchanged
    ascii := "Hello, World!"
    quotedASCII := strconv.QuoteToASCII(ascii)
    fmt.Println(quotedASCII) // "Hello, World!"
    
    // Non-ASCII characters get escaped
    unicode := "café"
    quotedUnicodeASCII := strconv.QuoteToASCII(unicode)
    fmt.Println(quotedUnicodeASCII) // "caf\u00e9"
    
    // Emojis and complex Unicode
    emoji := "Hello 🌍 World"
    quotedEmoji := strconv.QuoteToASCII(emoji)
    fmt.Println(quotedEmoji) // "Hello \U0001f30d World"
    
    // Mixed content with special characters
    mixed := "Line 1\nHello 世界"
    quotedMixed := strconv.QuoteToASCII(mixed)
    fmt.Println(quotedMixed) // "Line 1\nHello \u4e16\u754c"
}

The key difference between Quote and QuoteToASCII lies in how they handle non-ASCII characters. While Quote preserves Unicode characters in their original form, QuoteToASCII converts them to escape sequences like \u00e9 for é or \U0001f30d for 🌍.

This ASCII-safe approach becomes invaluable when you’re working with legacy systems, generating configuration files that need to work across different character encodings, or creating output that must remain readable in ASCII-only environments. It’s also useful for debugging Unicode-related issues since you can see the exact code points being used.

The function automatically chooses between \u (4-digit hex) and \U (8-digit hex) escape sequences based on the Unicode code point value, ensuring the most compact representation while maintaining clarity.

Understanding QuoteToGraphic(s string) string

The QuoteToGraphic function provides a middle ground between Quote and QuoteToASCII. It escapes non-printable characters while preserving printable Unicode characters, making the output more human-readable than ASCII-only quoting while still handling problematic characters safely.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Printable characters stay readable
    printable := "Hello, café! 世界"
    quotedGraphic := strconv.QuoteToGraphic(printable)
    fmt.Println(quotedGraphic) // "Hello, café! 世界"
    
    // Control characters get escaped
    withControl := "Hello\x00World\x1f"
    quotedControl := strconv.QuoteToGraphic(withControl)
    fmt.Println(quotedControl) // "Hello\x00World\x1f"
    
    // Mixed printable and non-printable
    mixed := "Text\nMore text\x07End"
    quotedMixed := strconv.QuoteToGraphic(mixed)
    fmt.Println(quotedMixed) // "Text\nMore text\x07End"
    
    // Comparing with other quote functions
    input := "café\x00🌍\x1f"
    fmt.Printf("Quote:         %s\n", strconv.Quote(input))
    fmt.Printf("QuoteToASCII:  %s\n", strconv.QuoteToASCII(input))
    fmt.Printf("QuoteToGraphic: %s\n", strconv.QuoteToGraphic(input))
}

The QuoteToGraphic function uses Go’s definition of graphic characters - essentially characters that are printable and visible. This includes most Unicode letters, numbers, punctuation, and symbols, but excludes control characters, zero-width characters, and other non-visible Unicode code points.

This approach strikes an excellent balance for logging and debugging scenarios where you want to maintain readability of international text while ensuring that problematic invisible characters are clearly visible as escape sequences. It’s particularly useful when processing user input that might contain hidden control characters or when working with text that combines multiple languages and scripts.

Single Character Quoting with QuoteRune(r rune) string

When you need to quote individual characters rather than entire strings, Go provides QuoteRune for handling single rune values. This function works similarly to Quote but operates on individual Unicode code points, making it perfect for character-by-character processing or when building strings programmatically.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Basic ASCII characters
    char := 'A'
    quotedChar := strconv.QuoteRune(char)
    fmt.Println(quotedChar) // 'A'
    
    // Special characters that need escaping
    newline := '\n'
    quotedNewline := strconv.QuoteRune(newline)
    fmt.Println(quotedNewline) // '\n'
    
    // Single quote character
    quote := '\''
    quotedQuote := strconv.QuoteRune(quote)
    fmt.Println(quotedQuote) // '\''
    
    // Unicode characters
    unicodeChar := 'é'
    quotedUnicode := strconv.QuoteRune(unicodeChar)
    fmt.Println(quotedUnicode) // 'é'
    
    // Emoji as a single rune
    emoji := '🚀'
    quotedEmoji := strconv.QuoteRune(emoji)
    fmt.Println(quotedEmoji) // '🚀'
    
    // Processing characters in a loop
    text := "Hi\n世界"
    for _, r := range text {
        fmt.Printf("Character: %s\n", strconv.QuoteRune(r))
    }
}

Notice that QuoteRune uses single quotes around the character, following Go’s rune literal syntax, while the string quote functions use double quotes. This maintains consistency with how you’d write these literals in actual Go code.

The function becomes particularly useful when you’re iterating through strings character by character and need to examine or log individual runes safely. It handles all the same escape sequences as Quote but formats them as character literals rather than string literals.

Rune Variants: QuoteRuneToASCII and QuoteRuneToGraphic

Just like the string quote functions, rune quoting has ASCII-safe and graphic-safe variants that give you control over how non-ASCII characters are represented.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Comparing rune quote variants
    unicodeRune := 'é'
    emojiRune := '🌍'
    controlRune := '\x07' // Bell character
    
    fmt.Printf("Character: %c\n", unicodeRune)
    fmt.Printf("QuoteRune:         %s\n", strconv.QuoteRune(unicodeRune))
    fmt.Printf("QuoteRuneToASCII:  %s\n", strconv.QuoteRuneToASCII(unicodeRune))
    fmt.Printf("QuoteRuneToGraphic: %s\n", strconv.QuoteRuneToGraphic(unicodeRune))
    
    fmt.Printf("\nEmoji: %c\n", emojiRune)
    fmt.Printf("QuoteRune:         %s\n", strconv.QuoteRune(emojiRune))
    fmt.Printf("QuoteRuneToASCII:  %s\n", strconv.QuoteRuneToASCII(emojiRune))
    fmt.Printf("QuoteRuneToGraphic: %s\n", strconv.QuoteRuneToGraphic(emojiRune))
    
    fmt.Printf("\nControl character:\n")
    fmt.Printf("QuoteRune:         %s\n", strconv.QuoteRune(controlRune))
    fmt.Printf("QuoteRuneToASCII:  %s\n", strconv.QuoteRuneToASCII(controlRune))
    fmt.Printf("QuoteRuneToGraphic: %s\n", strconv.QuoteRuneToGraphic(controlRune))
    
    // Processing mixed content
    mixed := "A\né🌍\x00"
    fmt.Println("\nProcessing mixed content:")
    for i, r := range mixed {
        fmt.Printf("Position %d: %s (ASCII: %s)\n", 
            i, 
            strconv.QuoteRune(r), 
            strconv.QuoteRuneToASCII(r))
    }
}

QuoteRuneToASCII converts any non-ASCII character to its Unicode escape sequence, making it ideal for generating portable character representations. This becomes essential when you’re working with character data that needs to work across different systems or when debugging character encoding issues.

QuoteRuneToGraphic preserves readable Unicode characters while escaping control characters and other non-printable runes. This gives you the best of both worlds: international character support with safe handling of problematic characters.

These rune variants are particularly powerful when combined with range loops over strings, allowing you to process and examine each character individually while maintaining safe, readable output regardless of the character’s origin or encoding.