strconv.Unquote în Go

func Unquote(s string) (string, error)
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)
func QuotedPrefix(s string) (string, error)

Ce face strconv.Unquote

strconv.Unquote(s) face invers față de Quote: primește un text scris ca în codul Go, între ghilimele duble ("…"), apostrofuri ('…', un singur caracter) sau backticks (`…`), scoate delimitatorii și transformă secvențele \n, \t, \u0219 în caracterele reale. Dacă textul nu este scris corect, returnează invalid syntax.

strconv.UnquoteChar(s, quote) decodează doar primul caracter (sau prima secvență) din s și returnează caracterul, dacă are mai mulți octeți în UTF-8, restul textului și eroarea. quote este delimitatorul în care se află textul; dacă dai '"', o ghilimea fără \ în față este eroare.

strconv.QuotedPrefix(s) caută un text citat corect chiar la începutul lui s și îl returnează cu tot cu ghilimele, ignorând restul. Util la citirea manuală a unor formate simple.

Parametri

Parametru	Descriere
s	Textul de decodat.
quote	La UnquoteChar: delimitatorul ('"', '\'' sau 0).

Ce returnează

Unquote: textul decodat și eroarea. UnquoteChar: caracterul, multibyte, restul și eroarea. QuotedPrefix: prefixul citat și eroarea.

Exemple

Exemplul 1: Unquote pe trei feluri de texte

Între backticks secvențele nu sunt interpretate: \n rămâne două caractere (backslash și n), pe care %q le afișează ca \\n.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	for _, s := range []string{`"Ia\u0219i\tRomânia"`, "`fără \\n escape`", `'ș'`, `"neterminat`} {
		t, err := strconv.Unquote(s)
		fmt.Printf("%-24s -> %q, eroare: %v\n", s, t, err)
	}
}

Rezultat

"Ia\u0219i\tRomânia"     -> "Iași\tRomânia", eroare: <nil>
`fără \n escape`         -> "fără \\n escape", eroare: <nil>
'ș'                      -> "ș", eroare: <nil>
"neterminat              -> "", eroare: invalid syntax

Exemplul 2: UnquoteChar caracter cu caracter

Textul conține secvențele scrise cu backslash, nu caracterele reale. Fiecare apel decodează o secvență: \u0219 devine ș (2 octeți în UTF-8, deci multibyte=true).

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s := `\u0219a\n`
	for len(s) > 0 {
		r, multi, rest, err := strconv.UnquoteChar(s, '"')
		if err != nil {
			fmt.Println("eroare:", err)
			return
		}
		fmt.Printf("%q multibyte=%t rest=%q\n", r, multi, rest)
		s = rest
	}
}

Rezultat

'ș' multibyte=true rest="a\\n"
'a' multibyte=false rest="\\n"
'\n' multibyte=false rest=""

Exemplul 3: QuotedPrefix: textul citat de la început

package main

import (
	"fmt"
	"strconv"
)

func main() {
	linie := `"Ana Pop" are nota 10`
	citat, err := strconv.QuotedPrefix(linie)
	fmt.Println(citat, err)
	nume, _ := strconv.Unquote(citat)
	fmt.Println("nume:", nume, "| rest:", linie[len(citat):])

	_, err = strconv.QuotedPrefix("Ana Pop")
	fmt.Println(err)
}

Rezultat

"Ana Pop" <nil>
nume: Ana Pop | rest:  are nota 10
invalid syntax

Greșeli frecvente

• Dai lui Unquote un text fără ghilimele (Ia\u0219i): returnează invalid syntax. Textul trebuie să înceapă și să se termine cu delimitatorul.
• Folosești Unquote pentru texte JSON. JSON are reguli puțin diferite (de exemplu nu acceptă \x sau apostrofuri); folosește encoding/json.

Comenzi înrudite

• strconv.Quote: Pune textul între ghilimele, ca în codul Go, și scrie caracterele speciale ca secvențe \n, \t, \u…
• strconv.QuoteRune: Scrie un caracter (rune) între apostrofuri, ca în codul Go: ‘ș’, ‘\n’, ‘\u0219’.