Пакет strconv

• import "strconv"
• Обзор
• Указатель
• Примеры

Обзор

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

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

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

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

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

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. Последняя функция гарантирует, что результат будет строкой 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)
• type NumError
• func (e *NumError) Error() string
• func (e *NumError) Unwrap() error

Файлы пакета

bytealg.go doc.go isprint.go number.go quote.go

Константы

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

const IntSize = strconv.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 добавляет в dst строку "true" или "false" в зависимости от значения b и возвращает расширенный буфер.

Пример

Код:

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 добавляет в dst строковое представление числа с плавающей точкой f, сформированное функцией FormatFloat, и возвращает расширенный буфер.

Пример

Код:

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 добавляет в dst строковое представление целого числа i, сформированное функцией FormatInt, и возвращает расширенный буфер.

Пример

Код:

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 добавляет в dst строковый литерал Go в двойных кавычках, представляющий s и сформированный функцией Quote, и возвращает расширенный буфер.

Пример

Код:

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 добавляет в dst символьный литерал Go в одинарных кавычках, представляющий руну и сформированный функцией QuoteRune, и возвращает расширенный буфер.

Пример

Код:

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

Вывод:

rune:'☺'

func AppendQuoteRuneToASCII

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

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

Пример

Код:

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 добавляет в dst символьный литерал Go в одинарных кавычках, представляющий руну и сформированный функцией QuoteRuneToGraphic, и возвращает расширенный буфер.

func AppendQuoteToASCII

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

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

Пример

Код:

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 добавляет в dst строковый литерал Go в двойных кавычках, представляющий s и сформированный функцией QuoteToGraphic, и возвращает расширенный буфер.

func AppendUint

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

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

Пример

Код:

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 бит, где для complex64 это значение должно быть равно 64, а для complex128 — 128.

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 без изменений. Показатель степени записывается как десятичное целое число; для всех форматов, кроме 'b', он содержит не менее двух цифр.

Пример

Код:

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. Для значений цифр >= 10 в результате используются строчные буквы от 'a' до 'z'.

Пример

Код:

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. Для значений цифр >= 10 в результате используются строчные буквы от 'a' до 'z'.

Пример

Код:

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. В возвращаемой строке для управляющих и непечатаемых символов используются escape-последовательности 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 в одинарных кавычках, представляющий руну. В возвращаемой строке для управляющих и непечатаемых символов используются escape-последовательности 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 в одинарных кавычках, представляющий руну. В возвращаемой строке для символов, отличных от ASCII, и непечатаемых символов используются escape-последовательности Go (\t, \n, \xFF, \u0100), как определено функцией IsPrint. Если r не является допустимой кодовой точкой Unicode, она интерпретируется как символ замены Unicode U+FFFD.

Пример

Код:

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

Вывод:

'\u263a'

func QuoteRuneToGraphic 1.6

func QuoteRuneToGraphic(r rune) string

QuoteRuneToGraphic возвращает символьный литерал Go в одинарных кавычках, представляющий руну. Если руна не является графическим символом Unicode, согласно определению IsGraphic, возвращаемая строка будет использовать escape-последовательность 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. В возвращаемой строке используются escape-последовательности 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, в возвращаемой строке остаются без изменений, а для неграфических символов используются escape-последовательности 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 возвращает соответствующую строку из одного символа. Для пустого символьного литерала 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. value — декодированную кодовую точку Unicode или значение байта;
2. multibyte — логическое значение, указывающее, требуется ли декодированному символу многобайтовое представление UTF-8;
3. tail — остаток строки после символа; и
4. ошибку, которая будет равна nil, если символ синтаксически допустим.

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

Пример

Код:

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\"

type 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