go1.20.5
GoThrough

strconv.IntSize

// IntSize is the size in bits of an int or uint value. const IntSize = intSize

strconv.ErrRange

// ErrRange indicates that a value is out of range for the target type. var ErrRange = errors.New("value out of range")

strconv.ErrSyntax

// ErrSyntax indicates that a value does not have the right syntax for the target type. var ErrSyntax = errors.New("invalid syntax")

strconv.AppendBool

// AppendBool appends "true" or "false", according to the value of b, // to dst and returns the extended buffer. func AppendBool(dst []byte, b bool) []byte

strconv.AppendFloat

// AppendFloat appends the string form of the floating-point number f, // as generated by FormatFloat, to dst and returns the extended buffer. func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte

strconv.AppendInt

// AppendInt appends the string form of the integer i, // as generated by FormatInt, to dst and returns the extended buffer. func AppendInt(dst []byte, i int64, base int) []byte

strconv.AppendQuote

// AppendQuote appends a double-quoted Go string literal representing s, // as generated by Quote, to dst and returns the extended buffer. func AppendQuote(dst []byte, s string) []byte

strconv.AppendQuoteRune

// AppendQuoteRune appends a single-quoted Go character literal representing the rune, // as generated by QuoteRune, to dst and returns the extended buffer. func AppendQuoteRune(dst []byte, r rune) []byte

strconv.AppendQuoteRuneToASCII

// AppendQuoteRuneToASCII appends a single-quoted Go character literal representing the rune, // as generated by QuoteRuneToASCII, to dst and returns the extended buffer. func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

strconv.AppendQuoteRuneToGraphic

// AppendQuoteRuneToGraphic appends a single-quoted Go character literal representing the rune, // as generated by QuoteRuneToGraphic, to dst and returns the extended buffer. func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte

strconv.AppendQuoteToASCII

// AppendQuoteToASCII appends a double-quoted Go string literal representing s, // as generated by QuoteToASCII, to dst and returns the extended buffer. func AppendQuoteToASCII(dst []byte, s string) []byte

strconv.AppendQuoteToGraphic

// AppendQuoteToGraphic appends a double-quoted Go string literal representing s, // as generated by QuoteToGraphic, to dst and returns the extended buffer. func AppendQuoteToGraphic(dst []byte, s string) []byte

strconv.AppendUint

// AppendUint appends the string form of the unsigned integer i, // as generated by FormatUint, to dst and returns the extended buffer. func AppendUint(dst []byte, i uint64, base int) []byte

strconv.Atoi

// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int. func Atoi(s string) (int, error)

strconv.CanBackquote

// CanBackquote reports whether the string s can be represented // unchanged as a single-line backquoted string without control // characters other than tab. func CanBackquote(s string) bool

strconv.FormatBool

// FormatBool returns "true" or "false" according to the value of b. func FormatBool(b bool) string

strconv.FormatComplex

// FormatComplex converts the complex number c to a string of the // form (a+bi) where a and b are the real and imaginary parts, // formatted according to the format fmt and precision prec. // // The format fmt and precision prec have the same meaning as in FormatFloat. // It rounds the result assuming that the original was obtained from a complex // value of bitSize bits, which must be 64 for complex64 and 128 for complex128. func FormatComplex(c complex128, fmt byte, prec int, bitSize int) string

strconv.FormatFloat

// FormatFloat converts the floating-point number f to a string, // according to the format fmt and precision prec. It rounds the // result assuming that the original was obtained from a floating-point // value of bitSize bits (32 for float32, 64 for float64). // // The format fmt is one of // 'b' (-ddddp±ddd, a binary exponent), // 'e' (-d.dddde±dd, a decimal exponent), // 'E' (-d.ddddE±dd, a decimal exponent), // 'f' (-ddd.dddd, no exponent), // 'g' ('e' for large exponents, 'f' otherwise), // 'G' ('E' for large exponents, 'f' otherwise), // 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or // 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent). // // The precision prec controls the number of digits (excluding the exponent) // printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats. // For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point. // For 'g' and 'G' it is the maximum number of significant digits (trailing // zeros are removed). // The special precision -1 uses the smallest number of digits // necessary such that ParseFloat will return f exactly. func FormatFloat(f float64, fmt byte, prec int, bitSize int) string

strconv.FormatInt

// FormatInt returns the string representation of i in the given base, // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' // for digit values >= 10. func FormatInt(i int64, base int) string

strconv.FormatUint

// FormatUint returns the string representation of i in the given base, // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' // for digit values >= 10. func FormatUint(i uint64, base int) string

strconv.IsGraphic

// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such // characters include letters, marks, numbers, punctuation, symbols, and // spaces, from categories L, M, N, P, S, and Zs. func IsGraphic(r rune) bool

strconv.IsPrint

// IsPrint reports whether the rune is defined as printable by Go, with // the same definition as unicode.IsPrint: letters, numbers, punctuation, // symbols and ASCII space. func IsPrint(r rune) bool

strconv.Itoa

// Itoa is equivalent to FormatInt(int64(i), 10). func Itoa(i int) string

strconv.ParseBool

// ParseBool returns the boolean value represented by the string. // It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False. // Any other value returns an error. func ParseBool(str string) (bool, error)

strconv.ParseComplex

// ParseComplex converts the string s to a complex number // with the precision specified by bitSize: 64 for complex64, or 128 for complex128. // When bitSize=64, the result still has type complex128, but it will be // convertible to complex64 without changing its value. // // The number represented by s must be of the form N, Ni, or N±Ni, where N stands // for a floating-point number as recognized by ParseFloat, and i is the imaginary // component. If the second N is unsigned, a + sign is required between the two components // as indicated by the ±. If the second N is NaN, only a + sign is accepted. // The form may be parenthesized and cannot contain any spaces. // The resulting complex number consists of the two components converted by ParseFloat. // // The errors that ParseComplex returns have concrete type *NumError // and include err.Num = s. // // If s is not syntactically well-formed, ParseComplex returns err.Err = ErrSyntax. // // If s is syntactically well-formed but either component is more than 1/2 ULP // away from the largest floating point number of the given component's size, // ParseComplex returns err.Err = ErrRange and c = ±Inf for the respective component. func ParseComplex(s string, bitSize int) (complex128, error)

strconv.ParseFloat

// ParseFloat converts the string s to a floating-point number // with the precision specified by bitSize: 32 for float32, or 64 for float64. // When bitSize=32, the result still has type float64, but it will be // convertible to float32 without changing its value. // // ParseFloat accepts decimal and hexadecimal floating-point numbers // as defined by the Go syntax for [floating-point literals]. // If s is well-formed and near a valid floating-point number, // ParseFloat returns the nearest floating-point number rounded // using IEEE754 unbiased rounding. // (Parsing a hexadecimal floating-point value only rounds when // there are more bits in the hexadecimal representation than // will fit in the mantissa.) // // The errors that ParseFloat returns have concrete type *NumError // and include err.Num = s. // // If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax. // // If s is syntactically well-formed but is more than 1/2 ULP // away from the largest floating point number of the given size, // ParseFloat returns f = ±Inf, err.Err = ErrRange. // // ParseFloat recognizes the string "NaN", and the (possibly signed) strings "Inf" and "Infinity" // as their respective special floating point values. It ignores case when matching. // // [floating-point literals]: https://go.dev/ref/spec#Floating-point_literals func ParseFloat(s string, bitSize int) (float64, error)

strconv.ParseInt

// ParseInt interprets a string s in the given base (0, 2 to 36) and // bit size (0 to 64) and returns the corresponding value i. // // The string may begin with a leading sign: "+" or "-". // // If the base argument is 0, the true base is implied by the string's // prefix following the sign (if present): 2 for "0b", 8 for "0" or "0o", // 16 for "0x", and 10 otherwise. Also, for argument base 0 only, // underscore characters are permitted as defined by the Go syntax for // [integer literals]. // // The bitSize argument specifies the integer type // that the result must fit into. Bit sizes 0, 8, 16, 32, and 64 // correspond to int, int8, int16, int32, and int64. // If bitSize is below 0 or above 64, an error is returned. // // The errors that ParseInt returns have concrete type *NumError // and include err.Num = s. If s is empty or contains invalid // digits, err.Err = ErrSyntax and the returned value is 0; // if the value corresponding to s cannot be represented by a // signed integer of the given size, err.Err = ErrRange and the // returned value is the maximum magnitude integer of the // appropriate bitSize and sign. // // [integer literals]: https://go.dev/ref/spec#Integer_literals func ParseInt(s string, base int, bitSize int) (i int64, err error)

strconv.ParseUint

// ParseUint is like ParseInt but for unsigned numbers. // // A sign prefix is not permitted. func ParseUint(s string, base int, bitSize int) (uint64, error)

strconv.Quote

// Quote returns a double-quoted Go string literal representing s. The // returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for // control characters and non-printable characters as defined by // IsPrint. func Quote(s string) string

strconv.QuoteRune

// QuoteRune returns a single-quoted Go character literal representing the // rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) // for control characters and non-printable characters as defined by IsPrint. // If r is not a valid Unicode code point, it is interpreted as the Unicode // replacement character U+FFFD. func QuoteRune(r rune) string

strconv.QuoteRuneToASCII

// QuoteRuneToASCII returns a single-quoted Go character literal representing // the rune. The returned string uses Go escape sequences (\t, \n, \xFF, // \u0100) for non-ASCII characters and non-printable characters as defined // by IsPrint. // If r is not a valid Unicode code point, it is interpreted as the Unicode // replacement character U+FFFD. func QuoteRuneToASCII(r rune) string

strconv.QuoteRuneToGraphic

// QuoteRuneToGraphic returns a single-quoted Go character literal representing // the rune. If the rune is not a Unicode graphic character, // as defined by IsGraphic, the returned string will use a Go escape sequence // (\t, \n, \xFF, \u0100). // If r is not a valid Unicode code point, it is interpreted as the Unicode // replacement character U+FFFD. func QuoteRuneToGraphic(r rune) string