Golang strconv.UnquoteChar
last modified April 20, 2025
This tutorial explains how to use the strconv.UnquoteChar function
in Go. We'll cover character unquoting basics with practical examples.
The strconv.UnquoteChar function decodes the first character or escape sequence in a quoted string. It's useful for parsing escaped strings.
UnquoteChar returns four values: the decoded rune, a multibyte flag, the tail string, and an error. This provides detailed control over string parsing.
Basic strconv.UnquoteChar Example
This example demonstrates basic usage of UnquoteChar to decode a
simple escaped character. We show how to handle the return values.
package main
import (
"fmt"
"strconv"
)
func main() {
s := `\"Hello\"`
r, mb, tail, err := strconv.UnquoteChar(s, '"')
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Printf("Decoded: %c\n", r)
fmt.Println("Multibyte:", mb)
fmt.Println("Remaining:", tail)
}
We decode the first escaped quote character from the string. The function returns the decoded rune, a multibyte flag, remaining string, and error.
Handling Different Escape Sequences
UnquoteChar supports various escape sequences. This example shows
how it handles common escape sequences in Go strings.
package main
import (
"fmt"
"strconv"
)
func main() {
testCases := []string{`\n`, `\t`, `\\`, `\x41`, `\u263a`}
for _, tc := range testCases {
r, _, _, err := strconv.UnquoteChar(tc, 0)
if err != nil {
fmt.Printf("Error unquoting '%s': %v\n", tc, err)
continue
}
fmt.Printf("'%s' → %c (U+%04x)\n", tc, r, r)
}
}
We test newline, tab, backslash, hex, and Unicode escape sequences. Each is properly decoded to its corresponding rune value with Unicode code point.
Processing String Literals
This example shows how to process an entire quoted string character by
character using UnquoteChar in a loop.
package main
import (
"fmt"
"strconv"
)
func main() {
s := `"Go\t\u263a"`
// Skip the opening quote
content := s[1:]
for len(content) > 0 {
r, mb, tail, err := strconv.UnquoteChar(content, '"')
if err != nil {
fmt.Println("Error:", err)
break
}
fmt.Printf("%c", r)
content = tail
}
fmt.Println()
}
We process each character in the string, handling escape sequences as we encounter them. The loop continues until we've processed all characters.
Handling Invalid Escape Sequences
This example demonstrates how UnquoteChar handles invalid or
unsupported escape sequences with proper error reporting.
package main
import (
"fmt"
"strconv"
)
func main() {
testCases := []string{`\z`, `\xzz`, `\u123`, `\`, `\U12345678`}
for _, tc := range testCases {
_, _, _, err := strconv.UnquoteChar(tc, 0)
if err != nil {
fmt.Printf("'%s': %v\n", tc, err)
}
}
}
Each test case shows a different type of invalid escape sequence. The function returns descriptive errors for each invalid input case.
Working with Different Quote Characters
UnquoteChar can handle different quote characters. This example
shows how the quote parameter affects the parsing behavior.
package main
import (
"fmt"
"strconv"
)
func main() {
s1 := `\'Single quoted\'`
s2 := `\"Double quoted\"`
// Process with single quote as delimiter
r1, _, _, _ := strconv.UnquoteChar(s1, '\'')
fmt.Printf("Single quoted: %c\n", r1)
// Process with double quote as delimiter
r2, _, _, _ := strconv.UnquoteChar(s2, '"')
fmt.Printf("Double quoted: %c\n", r2)
}
The quote parameter determines which quote character needs escaping. This allows proper handling of strings quoted with different characters.
Comparing with strconv.Unquote
This example compares UnquoteChar with Unquote,
showing when each is more appropriate for different use cases.
package main
import (
"fmt"
"strconv"
)
func main() {
s := `"Hello\nWorld"`
// Using Unquote (whole string)
unquoted, err := strconv.Unquote(s)
if err != nil {
fmt.Println("Unquote error:", err)
} else {
fmt.Println("Unquote result:", unquoted)
}
// Using UnquoteChar (character by character)
content := s[1:len(s)-1] // Remove surrounding quotes
fmt.Print("UnquoteChar result: ")
for len(content) > 0 {
r, _, tail, err := strconv.UnquoteChar(content, '"')
if err != nil {
fmt.Println("\nError:", err)
break
}
fmt.Printf("%c", r)
content = tail
}
fmt.Println()
}
Unquote is simpler for whole strings, while UnquoteChar
provides more control for custom parsing needs or partial string processing.
Practical Example: Custom String Parser
This practical example demonstrates building a custom string parser using
UnquoteChar to handle complex string parsing scenarios.
package main
import (
"fmt"
"strconv"
)
func parseCustomString(s string) (string, error) {
if len(s) == 0 || s[0] != '"' {
return "", fmt.Errorf("string must be quoted")
}
content := s[1:]
var result []rune
for len(content) > 0 {
if content[0] == '"' {
content = content[1:]
break
}
r, _, tail, err := strconv.UnquoteChar(content, '"')
if err != nil {
return "", err
}
result = append(result, r)
content = tail
}
return string(result), nil
}
func main() {
testStr := `"Complex \tstring \u263a with\n escapes"`
parsed, err := parseCustomString(testStr)
if err != nil {
fmt.Println("Parse error:", err)
return
}
fmt.Println("Parsed string:", parsed)
}
We build a custom parser that handles quoted strings with escape sequences.
The parser uses UnquoteChar to properly decode each character.
Source
Go strconv package documentation
This tutorial covered the strconv.UnquoteChar function in Go with
practical examples of character unquoting in various scenarios.
Author
List all Go tutorials.