Пакет strconv

• import "strconv"
• Обзор
• Индекс
• Примеры

Обзор

Пакет strconv реализует преобразования к строковым представлениям и из них основных типов данных.

Преобразования чисел

Наиболее распространённые преобразования чисел — Atoi (строка в целое число) и Itoa (целое число в строку).

i, err := strconv.Atoi("-42")
s := strconv.Itoa(-42)

Они предполагают десятичную систему счисления и тип целых чисел Go.

ParseBool, ParseFloat, ParseInt и ParseUint преобразуют строки в значения:

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

Функции преобразования возвращают самый широкий тип (float64, int64 и uint64), но если аргумент size указывает более узкую ширину, результат может быть преобразован к этому более узкому типу без потери данных:

s := "2147483647" // biggest int32
i64, err := strconv.ParseInt(s, 10, 32)
...
i := int32(i64)

FormatBool, FormatFloat, FormatInt и FormatUint преобразуют значения в строки:

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)

AppendBool, AppendFloat, AppendInt и AppendUint аналогичны, но добавляют отформатированное значение к срезу назначения.

Преобразования строк

Quote и QuoteToASCII преобразуют строки в двойные кавычки (Go string literals). Последний гарантирует, что результат является строкой ASCII, экранируя все не-ASCII Unicode символы с помощью \u:

q := strconv.Quote("Hello, 世界")
q := strconv.QuoteToASCII("Hello, 世界")

QuoteRune и QuoteRuneToASCII аналогичны, но принимают руны и возвращают строковые литералы рун Go.

Unquote и UnquoteChar снимают двойные кавычки с Go строковых и руновых литералов.

Индекс

• Константы
• Переменные
• func AppendBool(dst []byte, b bool) []byte
• func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte
• func AppendInt(dst []byte, i int64, base int) []byte
• func AppendQuote(dst []byte, s string) []byte
• func AppendQuoteRune(dst []byte, r rune) []byte
• func AppendQuoteRuneToASCII(dst []byte, r rune) []byte
• func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte
• func AppendQuoteToASCII(dst []byte, s string) []byte
• func AppendQuoteToGraphic(dst []byte, s string) []byte
• func AppendUint(dst []byte, i uint64, base int) []byte
• func Atoi(s string) (int, error)
• func CanBackquote(s string) bool
• func FormatBool(b bool) string
• func FormatComplex(c complex128, fmt byte, prec, bitSize int) string
• func FormatFloat(f float64, fmt byte, prec, bitSize int) string
• func FormatInt(i int64, base int) string
• func FormatUint(i uint64, base int) string
• func IsGraphic(r rune) bool
• func IsPrint(r rune) bool
• func Itoa(i int) string
• func ParseBool(str string) (bool, error)
• func ParseComplex(s string, bitSize int) (complex128, error)
• func ParseFloat(s string, bitSize int) (float64, error)
• func ParseInt(s string, base int, bitSize int) (i int64, err error)
• func ParseUint(s string, base int, bitSize int) (uint64, error)
• func Quote(s string) string
• func QuoteRune(r rune) string
• func QuoteRuneToASCII(r rune) string
• func QuoteRuneToGraphic(r rune) string
• func QuoteToASCII(s string) string
• func QuoteToGraphic(s string) string
• func QuotedPrefix(s string) (string, error)
• func Unquote(s string) (string, error)
• func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)
• тип NumError
• func (e *NumError) Error() string
• func (e *NumError) Unwrap() error

Файлы пакета

atob.go atoc.go atof.go atoi.go bytealg.go ctoa.go decimal.go doc.go eisel_lemire.go ftoa.go ftoaryu.go isprint.go itoa.go quote.go

Константы

IntSize — размер в битах значения int или uint.

const IntSize = intSize

Переменные

ErrRange указывает, что значение выходит за пределы диапазона для целевого типа.

var ErrRange = errors.New("value out of range")

ErrSyntax указывает, что значение не имеет правильного синтаксиса для целевого типа.

var ErrSyntax = errors.New("invalid syntax")

func AppendBool

func AppendBool(dst []byte, b bool) []byte

AppendBool добавляет "true" или "false", в соответствии со значением b, в dst и возвращает расширенный буфер.

Пример

Код:

b := []byte("bool:")
b = strconv.AppendBool(b, true)
fmt.Println(string(b))

Вывод:

bool:true

func AppendFloat

func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte

AppendFloat добавляет строковое представление числа с плавающей запятой f, сгенерированное функцией FormatFloat, в dst и возвращает расширенный буфер.

Пример

Код:

b32 := []byte("float32:")
b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
fmt.Println(string(b32))

b64 := []byte("float64:")
b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
fmt.Println(string(b64))

Вывод:

float32:3.1415927E+00
float64:3.1415926535E+00

func AppendInt

func AppendInt(dst []byte, i int64, base int) []byte

AppendInt добавляет строковое представление целого числа i, сгенерированное функцией FormatInt, в dst и возвращает расширенный буфер.

Пример

Код:

b10 := []byte("int (base 10):")
b10 = strconv.AppendInt(b10, -42, 10)
fmt.Println(string(b10))

b16 := []byte("int (base 16):")
b16 = strconv.AppendInt(b16, -42, 16)
fmt.Println(string(b16))

Вывод:

int (base 10):-42
int (base 16):-2a

func AppendQuote

func AppendQuote(dst []byte, s string) []byte

AppendQuote добавляет строковый литерал Go в двойных кавычках, представляющий s, сгенерированный функцией Quote, в dst и возвращает расширенный буфер.

Пример

Код:

b := []byte("quote:")
b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
fmt.Println(string(b))

Вывод:

quote:"\"Fran & Freddie's Diner\""

func AppendQuoteRune

func AppendQuoteRune(dst []byte, r rune) []byte

AppendQuoteRune добавляет строковый литерал Go для символа в одинарных кавычках, представляющий руну, сгенерированный функцией QuoteRune, в dst и возвращает расширенный буфер.

Пример

Код:

b := []byte("rune:")
b = strconv.AppendQuoteRune(b, '☺')
fmt.Println(string(b))

Вывод:

rune:'☺'

func AppendQuoteRuneToASCII

func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

AppendQuoteRuneToASCII добавляет строковый литерал Go для символа в одинарных кавычках, представляющий руну, сгенерированный функцией QuoteRuneToASCII, в dst и возвращает расширенный буфер.

Пример

Код:

b := []byte("rune (ascii):")
b = strconv.AppendQuoteRuneToASCII(b, '☺')
fmt.Println(string(b))

Вывод:

rune (ascii):'\u263a'

func AppendQuoteRuneToGraphic 1.6

func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte

AppendQuoteRuneToGraphic добавляет строковый литерал Go для символа в одинарных кавычках, представляющий руну, сгенерированный функцией QuoteRuneToGraphic, в dst и возвращает расширенный буфер.

func AppendQuoteToASCII

func AppendQuoteToASCII(dst []byte, s string) []byte

AppendQuoteToASCII добавляет строковый литерал Go в двойных кавычках, представляющий s, сгенерированный функцией QuoteToASCII, в dst и возвращает расширенный буфер.

Пример

Код:

b := []byte("quote (ascii):")
b = strconv.AppendQuoteToASCII(b, `"Fran & Freddie's Diner"`)
fmt.Println(string(b))

Вывод:

quote (ascii):"\"Fran & Freddie's Diner\""

func AppendQuoteToGraphic 1.6

func AppendQuoteToGraphic(dst []byte, s string) []byte

AppendQuoteToGraphic добавляет строковый литерал Go в двойных кавычках, представляющий s, сгенерированный функцией QuoteToGraphic, в dst и возвращает расширенный буфер.

func AppendUint

func AppendUint(dst []byte, i uint64, base int) []byte

AppendUint добавляет строковое представление беззнакового целого числа i, сгенерированное функцией FormatUint, в dst и возвращает расширенный буфер.

Пример

Код:

b10 := []byte("uint (base 10):")
b10 = strconv.AppendUint(b10, 42, 10)
fmt.Println(string(b10))

b16 := []byte("uint (base 16):")
b16 = strconv.AppendUint(b16, 42, 16)
fmt.Println(string(b16))

Вывод:

uint (base 10):42
uint (base 16):2a

func Atoi

func Atoi(s string) (int, error)

Atoi эквивалентен ParseInt(s, 10, 0), преобразованному к типу int.

Пример

Код:

v := "10"
if s, err := strconv.Atoi(v); err == nil {
    fmt.Printf("%T, %v", s, s)
}

Вывод:

int, 10

func CanBackquote

func CanBackquote(s string) bool

CanBackquote сообщает, можно ли представить строку s без изменений как строку в обратных кавычках на одной строке без управляющих символов, кроме табуляции.

Пример

Код:

fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
fmt.Println(strconv.CanBackquote("`can't backquote this`"))

Вывод:

true
false

func FormatBool

func FormatBool(b bool) string

FormatBool возвращает "true" или "false" в зависимости от значения b.

Пример

Код:

v := true
s := strconv.FormatBool(v)
fmt.Printf("%T, %v\n", s, s)

Вывод:

string, true

func FormatComplex 1.15

func FormatComplex(c complex128, fmt byte, prec, bitSize int) string

FormatComplex преобразует комплексное число c в строку вида (a+bi), где a и b — вещественная и мнимая части, отформатированные в соответствии с форматом fmt и точностью prec.

Формат fmt и точность prec имеют то же значение, что и в FormatFloat. Результат округляется, предполагая, что исходное значение получено из комплексного значения с размером в битах bitSize, которое должно быть 64 для complex64 и 128 для complex128.

func FormatFloat

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

FormatFloat преобразует число с плавающей точкой f в строку в соответствии с форматом fmt и точностью prec. Результат округляется, предполагая, что исходное значение получено из числа с плавающей точкой размером в битах bitSize (32 для float32, 64 для float64).

Формат fmt — это один из 'b' (-ddddp±ddd, двоичный экспоненциальный формат), 'e' (-d.dddde±dd, десятичный экспоненциальный формат), 'E' (-d.ddddE±dd, десятичный экспоненциальный формат), 'f' (-ddd.dddd, без экспоненты), 'g' ('e' для больших экспонент, 'f' в противном случае), 'G' ('E' для больших экспонент, 'f' в противном случае), 'x' (-0xd.ddddp±ddd, шестнадцатеричная дробь и двоичный экспоненциальный формат) или 'X' (-0Xd.ddddP±ddd, шестнадцатеричная дробь и двоичный экспоненциальный формат).

Точность prec управляет количеством цифр (исключая экспоненту), выводимых в форматах 'e', 'E', 'f', 'g', 'G', 'x' и 'X'. Для 'e', 'E', 'f', 'x' и 'X' это количество цифр после десятичной точки. Для 'g' и 'G' это максимальное количество значащих цифр (завершающие нули удаляются). Специальная точность -1 использует наименьшее количество цифр, необходимое для того, чтобы ParseFloat возвращала f точно.

Пример

Код:

v := 3.1415926535

s32 := strconv.FormatFloat(v, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)

s64 := strconv.FormatFloat(v, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)

// fmt.Println uses these arguments to print floats
fmt64 := strconv.FormatFloat(v, 'g', -1, 64)
fmt.Printf("%T, %v\n", fmt64, fmt64)

Вывод:

string, 3.1415927E+00
string, 3.1415926535E+00
string, 3.1415926535

func FormatInt

func FormatInt(i int64, base int) string

FormatInt возвращает строковое представление i в заданной системе счисления, для 2 ≤ base ≤ 36. Результат использует строчные буквы 'a' до 'z' для значений цифр ≥ 10.

Пример

Код:

v := int64(-42)

s10 := strconv.FormatInt(v, 10)
fmt.Printf("%T, %v\n", s10, s10)

s16 := strconv.FormatInt(v, 16)
fmt.Printf("%T, %v\n", s16, s16)

Вывод:

string, -42
string, -2a

func FormatUint

func FormatUint(i uint64, base int) string

FormatUint возвращает строковое представление i в заданной системе счисления, для 2 ≤ base ≤ 36. Результат использует строчные буквы 'a' до 'z' для значений цифр ≥ 10.

Пример

Код:

v := uint64(42)

s10 := strconv.FormatUint(v, 10)
fmt.Printf("%T, %v\n", s10, s10)

s16 := strconv.FormatUint(v, 16)
fmt.Printf("%T, %v\n", s16, s16)

Вывод:

string, 42
string, 2a

func IsGraphic 1.6

func IsGraphic(r rune) bool

IsGraphic сообщает, является ли символ графическим согласно Unicode. Такие символы включают буквы, знаки, цифры, пунктуацию, символы и пробелы, из категорий L, M, N, P, S и Zs.

Пример

Код:

shamrock := strconv.IsGraphic('☘')
fmt.Println(shamrock)

a := strconv.IsGraphic('a')
fmt.Println(a)

bel := strconv.IsGraphic('\007')
fmt.Println(bel)

Вывод:

true
true
false

func IsPrint

func IsPrint(r rune) bool

IsPrint сообщает, является ли символ печатным в Go, с тем же определением, что и unicode.IsPrint: буквы, цифры, пунктуация, символы и ASCII-пробел.

Пример

Код:

c := strconv.IsPrint('\u263a')
fmt.Println(c)

bel := strconv.IsPrint('\007')
fmt.Println(bel)

Вывод:

true
false

func Itoa

func Itoa(i int) string

Itoa эквивалентен FormatInt(int64(i), 10).

Пример

Код:

i := 10
s := strconv.Itoa(i)
fmt.Printf("%T, %v\n", s, s)

Вывод:

string, 10

func ParseBool

func ParseBool(str string) (bool, error)

ParseBool возвращает булево значение, представленное строкой. Принимает 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False. Любое другое значение возвращает ошибку.

Пример

Код:

v := "true"
if s, err := strconv.ParseBool(v); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}

Вывод:

bool, true

func ParseComplex 1.15

func ParseComplex(s string, bitSize int) (complex128, error)

ParseComplex преобразует строку s в комплексное число с точностью, указанной bitSize: 64 для complex64 или 128 для complex128. Когда bitSize=64, результат всё ещё имеет тип complex128, но он может быть преобразован в complex64 без изменения значения.

Число, представленное s, должно быть в форме N, Ni или N±Ni, где N — число с плавающей точкой, распознаваемое ParseFloat, а i — мнимая часть. Если второе N без знака, перед ним требуется знак +, как указано символом ±. Если второе N — NaN, принимается только знак +. Формат может быть заключён в скобки и не может содержать пробелы. Результирующее комплексное число состоит из двух компонентов, преобразованных функцией ParseFloat.

Ошибки, возвращаемые ParseComplex, имеют конкретный тип *NumError и включают err.Num = s.

Если s не имеет правильного синтаксиса, ParseComplex возвращает err.Err = ErrSyntax.

Если s имеет правильный синтаксис, но любой компонент отличается более чем на 1/2 ULP от наибольшего числа с плавающей точкой заданного размера компонента, ParseComplex возвращает err.Err = ErrRange и c = ±Inf для соответствующего компонента.

func ParseFloat

func ParseFloat(s string, bitSize int) (float64, error)

ParseFloat преобразует строку s в число с плавающей точкой с точностью, заданной bitSize: 32 для float32 или 64 для float64. Когда bitSize=32, результат всё ещё имеет тип float64, но он может быть преобразован в float32 без изменения значения.

ParseFloat принимает десятичные и шестнадцатеричные числа с плавающей точкой, как определено синтаксисом Go для чисел с плавающей точкой. Если s имеет правильный синтаксис и близка к допустимому числу с плавающей точкой, ParseFloat возвращает ближайшее число с плавающей точкой, округлённое с использованием смещённого округления IEEE754. (При разборе шестнадцатеричного числа с плавающей точкой округление выполняется только тогда, когда в шестнадцатеричном представлении больше битов, чем помещается в мантиссу.)

Ошибки, возвращаемые ParseFloat, имеют конкретный тип *NumError и включают err.Num = s.

Если s не имеет правильного синтаксиса, ParseFloat возвращает err.Err = ErrSyntax.

Если s имеет правильный синтаксис, но отличается более чем на 1/2 ULP от наибольшего числа с плавающей точкой заданного размера, ParseFloat возвращает f = ±Inf, err.Err = ErrRange.

ParseFloat распознаёт строку "NaN", а также (возможно, со знаком) строки "Inf" и "Infinity" как соответствующие специальные значения чисел с плавающей точкой. Разбирает их без учёта регистра.

Пример

Код:

v := "3.1415926535"
if s, err := strconv.ParseFloat(v, 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat(v, 64); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("NaN", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
// ParseFloat is case insensitive
if s, err := strconv.ParseFloat("nan", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("inf", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-0", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+0", 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}

Вывод:

float64, 3.1415927410125732
float64, 3.1415926535
float64, NaN
float64, NaN
float64, +Inf
float64, +Inf
float64, -Inf
float64, -0
float64, 0

func ParseInt

func ParseInt(s string, base int, bitSize int) (i int64, err error)

ParseInt интерпретирует строку s в заданной системе счисления (0, 2 до 36) и размере в битах (0 до 64) и возвращает соответствующее значение i.

Строка может начинаться со знака: "+" или "-".

Если аргумент base равен 0, истинное основание подразумевается префиксом строки после знака (если он есть): 2 для "0b", 8 для "0" или "0o", 16 для "0x" и 10 в противном случае. Также, только для аргумента base 0, символы подчеркивания разрешены, как определено синтаксисом Go для целых литералов.

Аргумент bitSize указывает целочисленный тип, в который должен поместиться результат. Размеры в битах 0, 8, 16, 32 и 64 соответствуют типам int, int8, int16, int32 и int64. Если bitSize меньше 0 или больше 64, возвращается ошибка.

Ошибки, возвращаемые ParseInt, имеют конкретный тип *NumError и включают err.Num = s. Если s пуста или содержит недопустимые цифры, err.Err = ErrSyntax и возвращаемое значение равно 0; если значение, соответствующее s, не может быть представлено целым числом со знаком заданного размера, err.Err = ErrRange и возвращаемое значение — максимальное целое число соответствующего bitSize и знака.

Пример

Код:

v32 := "-354634382"
if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}

v64 := "-3546343826724305832"
if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}

Вывод:

int64, -354634382
int64, -3546343826724305832

func ParseUint

func ParseUint(s string, base int, bitSize int) (uint64, error)

ParseUint подобен ParseInt, но для беззнаковых чисел.

Префикс знака недопустим.

Пример

Код:

v := "42"
if s, err := strconv.ParseUint(v, 10, 32); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseUint(v, 10, 64); err == nil {
    fmt.Printf("%T, %v\n", s, s)
}

Вывод:

uint64, 42
uint64, 42

func Quote

func Quote(s string) string

Quote возвращает строковый литерал Go в двойных кавычках, представляющий s. Возвращаемая строка использует последовательности эскейпов Go (\t, \n, \xFF, \u0100) для управляющих символов и непечатаемых символов, как определено функцией IsPrint.

Пример

Код:

// This string literal contains a tab character.
s := strconv.Quote(`"Fran & Freddie's Diner	☺"`)
fmt.Println(s)

Вывод:

"\"Fran & Freddie's Diner\t☺\""

func QuoteRune

func QuoteRune(r rune) string

QuoteRune возвращает строковый литерал Go в одинарных кавычках, представляющий символ. Возвращаемая строка использует последовательности эскейпов Go (\t, \n, \xFF, \u0100) для управляющих символов и непечатаемых символов, как определено функцией IsPrint. Если r — некорректный код Unicode, он интерпретируется как символ замены Unicode U+FFFD.

Пример

Код:

s := strconv.QuoteRune('☺')
fmt.Println(s)

Вывод:

'☺'

func QuoteRuneToASCII

func QuoteRuneToASCII(r rune) string

QuoteRuneToASCII возвращает строковый литерал Go в одинарных кавычках, представляющий символ. Возвращаемая строка использует последовательности эскейпов Go (\t, \n, \xFF, \u0100) для символов, не являющихся ASCII, и непечатаемых символов, как определено функцией IsPrint. Если r — некорректный код Unicode, он интерпретируется как символ замены Unicode U+FFFD.

Пример

Код:

s := strconv.QuoteRuneToASCII('☺')
fmt.Println(s)

Вывод:

'\u263a'

func QuoteRuneToGraphic 1.6

func QuoteRuneToGraphic(r rune) string

QuoteRuneToGraphic возвращает одиночную строку с символом Go, представляющую буквенный символ rune. Если rune не является графическим символом Unicode, как определено в IsGraphic, возвращаемая строка будет использовать последовательность экранирования Go (\t, \n, \xFF, \u0100). Если r не является допустимым кодовым значением Unicode, он интерпретируется как символ замены Unicode U+FFFD.

Пример

Код:

s := strconv.QuoteRuneToGraphic('☺')
fmt.Println(s)

s = strconv.QuoteRuneToGraphic('\u263a')
fmt.Println(s)

s = strconv.QuoteRuneToGraphic('\u000a')
fmt.Println(s)

s = strconv.QuoteRuneToGraphic('	') // tab character
fmt.Println(s)

Вывод:

'☺'
'☺'
'\n'
'\t'

func QuoteToASCII

func QuoteToASCII(s string) string

QuoteToASCII возвращает двойную строку Go, представляющую s. Возвращаемая строка использует последовательности экранирования Go (\t, \n, \xFF, \u0100) для символов, не являющихся ASCII, и непечатаемых символов, как определено в IsPrint.

Пример

Код:

// This string literal contains a tab character.
s := strconv.QuoteToASCII(`"Fran & Freddie's Diner	☺"`)
fmt.Println(s)

Вывод:

"\"Fran & Freddie's Diner\t\u263a\""

func QuoteToGraphic 1.6

func QuoteToGraphic(s string) string

QuoteToGraphic возвращает двойную строку Go, представляющую s. Возвращаемая строка оставляет графические символы Unicode, как определено в IsGraphic, неизменными и использует последовательности экранирования Go (\t, \n, \xFF, \u0100) для символов, не являющихся графическими.

Пример

Код:

s := strconv.QuoteToGraphic("☺")
fmt.Println(s)

// This string literal contains a tab character.
s = strconv.QuoteToGraphic("This is a \u263a	\u000a")
fmt.Println(s)

s = strconv.QuoteToGraphic(`" This is a ☺ \n "`)
fmt.Println(s)

Вывод:

"☺"
"This is a ☺\t\n"
"\" This is a ☺ \\n \""

func QuotedPrefix 1.17

func QuotedPrefix(s string) (string, error)

QuotedPrefix возвращает цитируемую строку (как понимается Unquote) в префиксе s. Если s не начинается с допустимой цитируемой строки, QuotedPrefix возвращает ошибку.

Пример

Код:

s, err := strconv.QuotedPrefix("not a quoted string")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.QuotedPrefix("\"double-quoted string\" with trailing text")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.QuotedPrefix("`or backquoted` with more trailing text")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.QuotedPrefix("'\u263a' is also okay")
fmt.Printf("%q, %v\n", s, err)

Вывод:

"", invalid syntax
"\"double-quoted string\"", <nil>
"`or backquoted`", <nil>
"'☺'", <nil>

func Unquote

func Unquote(s string) (string, error)

Unquote интерпретирует s как одиночную, двойную или обратную цитируемую строку Go, возвращая значение строки, которую цитирует s. (Если s одиночная, это будет литерал символа Go; Unquote возвращает соответствующую строку из одного символа.)

Пример

Код:

s, err := strconv.Unquote("You can't unquote a string without quotes")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("\"The string must be either double-quoted\"")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("`or backquoted.`")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("'\u263a'") // single character only allowed in single quotes
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("'\u2639\u2639'")
fmt.Printf("%q, %v\n", s, err)

Вывод:

"", invalid syntax
"The string must be either double-quoted", <nil>
"or backquoted.", <nil>
"☺", <nil>
"", invalid syntax

func UnquoteChar

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

UnquoteChar декодирует первый символ или байт в строке с экранированием или литерале символа, представленном строкой s. Он возвращает четыре значения:

1. значение, декодированное кодовое значение Unicode или байтовое значение;
2. multibyte, логическое значение, указывающее, требует ли декодированный символ многобайтовое представление UTF-8;
3. остаток, оставшаяся часть строки после символа; и
4. ошибка, которая будет равна nil, если символ синтаксически допустим.

Второй аргумент, quote, определяет тип литерала, который анализируется, и, следовательно, какой экранированный символ кавычек допускается. Если он установлен в одинарную кавычку, он разрешает последовательность \' и запрещает неэкранированную '. Если он установлен в двойную кавычку, он разрешает \" и запрещает неэкранированную ". Если он установлен в ноль, он не разрешает ни один из этих символов, и оба символа кавычек могут появляться без экранирования.

Пример

Код:

v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
if err != nil {
    log.Fatal(err)
}

fmt.Println("value:", string(v))
fmt.Println("multibyte:", mb)
fmt.Println("tail:", t)

Вывод:

value: "
multibyte: false
tail: Fran & Freddie's Diner\"

тип NumError

NumError записывает неудачное преобразование.

type NumError struct {
    Func string // the failing function (ParseBool, ParseInt, ParseUint, ParseFloat, ParseComplex)
    Num  string // the input
    Err  error  // the reason the conversion failed (e.g. ErrRange, ErrSyntax, etc.)
}

Пример

Код:

str := "Not a number"
if _, err := strconv.ParseFloat(str, 64); err != nil {
    e := err.(*strconv.NumError)
    fmt.Println("Func:", e.Func)
    fmt.Println("Num:", e.Num)
    fmt.Println("Err:", e.Err)
    fmt.Println(err)
}

Вывод:

Func: ParseFloat
Num: Not a number
Err: invalid syntax
strconv.ParseFloat: parsing "Not a number": invalid syntax

func (*NumError) Error

func (e *NumError) Error() string

func (*NumError) Unwrap 1.14

func (e *NumError) Unwrap() error