strconv

Finds the integer value of the given rune

Inputs

• r: The input rune to find the integer value of

Returns The integer value of the given rune

Converts a decimal number to its floating-point representation with the given format and returns the resulting bits

Inputs

• d: Pointer to the decimal number to convert
• info: Pointer to the Float_Info structure containing information about the floating-point format

Returns

• b: The bits representing the floating-point number
• overflow: A boolean indicating whether an overflow occurred during conversion

Accepts '0'..='9', otherwise returns ok = false

Converts a decimal floating-point number into a byte buffer with the given format

Inputs

• buf: The byte buffer to store the formatted number
• shortest: If true, generates the shortest representation of the number
• neg: If true, the number is negative
• digs: The decimal number to be formatted
• precision: The number of digits after the decimal point
• fmt: The format specifier (accepted values: 'f', 'F', 'e', 'E', 'g', 'G')

Returns

• A byte slice containing the formatted decimal floating-point number

Converts a floating-point number to a string with the specified format and precision.

Inputs

buf: A byte slice to store the resulting string val: The floating-point value to be converted fmt: The formatting byte, accepted values are 'e', 'E', 'f', 'F', 'g', 'G' precision: The number of decimal places to round to bit_size: The size of the floating-point number in bits, valid values are 16, 32, 64

Example:

buf: [32]byte
val := 3.141592
fmt := 'f'
precision := 2
bit_size := 64
result := strconv.generic_ftoa(buf[:], val, fmt, precision, bit_size) -> "3.14"

Returns

• A byte slice containing the formatted string

Determines whether the given unsigned 64-bit integer is a negative value by interpreting it as a signed integer with the specified bit size.

Inputs

• x: The unsigned 64-bit integer to check for negativity
• is_signed: A boolean indicating if the input should be treated as a signed integer
• bit_size: The bit size of the signed integer representation (8, 16, 32, or 64)

Returns

• u: The absolute value of the input integer
• neg: A boolean indicating whether the input integer is negative

Determines whether the given unsigned 128-bit integer is a negative value by interpreting it as a signed integer with the specified bit size.

Inputs

• x: The unsigned 128-bit integer to check for negativity
• is_signed: A boolean indicating if the input should be treated as a signed integer
• bit_size: The bit size of the signed integer representation (8, 16, 32, 64, or 128)

Returns

• u: The absolute value of the input integer
• neg: A boolean indicating whether the input integer is negative

2025-10-03 Deprecated C short names and implementations

Parses a boolean value from the input string

Inputs

• s: The input string
• true: "1", "t", "T", "true", "TRUE", "True"
• false: "0", "f", "F", "false", "FALSE", "False"
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Returns

• result: The parsed boolean value (default: false)
• ok: A boolean indicating whether the parsing was successful

Parses a 128-bit complex number from a string

Inputs

• str: The input string containing a 128-bit complex number.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_complex128_example :: proc() {
	n: int
	c, ok := strconv.parse_complex128("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex128("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

Output:

3+1i 4 true
5+7i 4 false

Returns

• value: The parsed 128-bit complex number.
• ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 32-bit complex number from a string

Inputs

• str: The input string containing a 32-bit complex number.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_complex32_example :: proc() {
	n: int
	c, ok := strconv.parse_complex32("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex32("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

Output:

3+1i 4 true
5+7i 4 false

Returns

• value: The parsed 32-bit complex number.
• ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 64-bit complex number from a string

Inputs

• str: The input string containing a 64-bit complex number.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_complex64_example :: proc() {
	n: int
	c, ok := strconv.parse_complex64("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex64("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

Output:

3+1i 4 true
5+7i 4 false

Returns

• value: The parsed 64-bit complex number.
• ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 32-bit floating point number from a string

Inputs

• s: The input string containing a 32-bit floating point number.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_f32_example :: proc() {
	n, ok := strconv.parse_f32("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, ok = strconv.parse_f32("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

Output:

0.000 false
567800.000 true

Returns

• value: The parsed 32-bit floating point number.
• ok: false if a base 10 float could not be found, or if the input string contained more than just the number.

Parses a 32-bit floating point number from a string and returns the parsed number, the length of the parsed substring, and a boolean indicating whether the parsing was successful

Inputs

• str: The input string containing a 32-bit floating point number.

Example:

import "core:fmt"
import "core:strconv"
parse_f32_prefix_example :: proc() {
	n, _, ok := strconv.parse_f32_prefix("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f32_prefix("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

Output:

0.000 false
567800.000 true

Returns

• value: The parsed 32-bit floating point number.
• nr: The length of the parsed substring.
• ok: A boolean indicating whether the parsing was successful.

Parses a 64-bit floating point number from a string

Inputs

• str: The input string containing a 64-bit floating point number.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_f64_example :: proc() {
	n, ok := strconv.parse_f64("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, ok = strconv.parse_f64("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

Output:

0.000 false
567800.000 true

Returns

• value: The parsed 64-bit floating point number.
• ok: false if a base 10 float could not be found, or if the input string contained more than just the number.

Parses a 64-bit floating point number from a string and returns the parsed number, the length of the parsed substring, and a boolean indicating whether the parsing was successful

Inputs

• str: The input string containing a 64-bit floating point number.

Example:

import "core:fmt"
import "core:strconv"
parse_f64_prefix_example :: proc() {
	n, _, ok := strconv.parse_f64_prefix("12.34eee")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f64_prefix("12.34e2")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f64_prefix("13.37 hellope")
	fmt.printfln("%.3f %v", n, ok)
}

Output:

0.000 false
1234.000 true
13.370 true

Returns

• value: The parsed 64-bit floating point number.
• nr: The length of the parsed substring.
• ok: false if a base 10 float could not be found

Parses an integer value from a string in base 10, unless there's a prefix

Inputs

• str: The input string containing the integer value
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_i128_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_i128_maybe_prefixed("1234")
	fmt.println(n, ok)

	n, ok = strconv.parse_i128_maybe_prefixed("0xeeee")
	fmt.println(n, ok)
}

Output:

1234 true
61166 true

Returns

• value: The parsed i128 value
• ok: false if a valid integer could not be found, or if the input string contained more than just the number.

Parses an integer value from a string in the given base, without any prefix

Inputs

• str: The input string containing the integer value
• base: The base (radix) to use for parsing the integer (1-16)
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_i128_of_base_example :: proc() {
	n, ok := strconv.parse_i128_of_base("-1234eeee", 10)
	fmt.println(n,ok)
}

Output:

-1234 false

Returns

• value: The parsed i128 value
• ok: false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses an integer value from the input string in base 10, unless there's a prefix

Inputs

• str: The input string to parse the integer value from
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_i64_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_i64_maybe_prefixed("1234")
	fmt.println(n,ok)

	n, ok = strconv.parse_i64_maybe_prefixed("0xeeee")
	fmt.println(n,ok)
}

Output:

1234 true
61166 true

Returns

• value: The parsed integer value
• ok: ok=false if a valid integer could not be found, or if the input string contained more than just the number.

Parses an integer value from the input string in the given base, without a prefix

Inputs

• str: The input string to parse the integer value from
• base: The base of the integer value to be parsed (must be between 1 and 16)
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_i64_of_base_example :: proc() {
	n, ok := strconv.parse_i64_of_base("-1234e3", 10)
	fmt.println(n, ok)
}

Output:

-1234 false

Returns

• value: Parses an integer value from a string, in the given base, without a prefix.
• ok: ok=false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses a signed integer value from the input string, using the specified base or inferring the base from a prefix

Inputs

• s: The input string to parse
• base: The base of the number system to use for parsing (default: 0)
• If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
• If base is not 0, it will be used for parsing regardless of any prefix in the input string
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_int_example :: proc() {
	n, ok := strconv.parse_int("1234") // without prefix, inferred base 10
	fmt.println(n,ok)

	n, ok = strconv.parse_int("ffff", 16) // without prefix, explicit base
	fmt.println(n,ok)

	n, ok = strconv.parse_int("0xffff") // with prefix and inferred base
	fmt.println(n,ok)
}

Output:

1234 true
65535 true
65535 true

Returns

• value: The parsed int value
• ok: false if no appropriate value could be found, or if the input string contained more than just the number.

Parses a 128-bit quaternion from a string

Inputs

• str: The input string containing a 128-bit quaternion.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_quaternion128_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion128("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion128("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

Output:

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns

• value: The parsed 128-bit quaternion.
• ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses a 256-bit quaternion from a string

Inputs

• str: The input string containing a 256-bit quaternion.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_quaternion256_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion256("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion256("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

Output:

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns

• value: The parsed 256-bit quaternion.
• ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses a 64-bit quaternion from a string

Inputs

• str: The input string containing a 64-bit quaternion.
• n: An optional pointer to an int to store the length of the parsed substring (default: nil).

Example:

import "core:fmt"
import "core:strconv"
parse_quaternion64_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion64("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion64("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

Output:

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns

• value: The parsed 64-bit quaternion.
• ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses an unsigned integer value from a string in base 10, unless there's a prefix

Inputs

• str: The input string containing the integer value
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_u128_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_u128_maybe_prefixed("1234")
	fmt.println(n, ok)

	n, ok = strconv.parse_u128_maybe_prefixed("5678eeee")
	fmt.println(n, ok)
}

Output:

1234 true
5678 false

Returns

• value: The parsed u128 value
• ok: false if a valid integer could not be found, if the value was negative, or if the input string contained more than just the number.

Parses an unsigned integer value from a string in the given base, without any prefix

Inputs

• str: The input string containing the integer value
• base: The base (radix) to use for parsing the integer (1-16)
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_u128_of_base_example :: proc() {
	n, ok := strconv.parse_u128_of_base("1234eeee", 10)
	fmt.println(n, ok)

	n, ok = strconv.parse_u128_of_base("5678eeee", 16)
	fmt.println(n, ok)
}

Output:

1234 false
1450766062 true

Returns

• value: The parsed u128 value
• ok: false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses an unsigned 64-bit integer value from the input string, using the specified base or inferring the base from a prefix

Inputs

• str: The input string to parse
• base: The base of the number system to use for parsing (default: 0)
• If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
• If base is not 0, it will be used for parsing regardless of any prefix in the input string
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_u64_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_u64_maybe_prefixed("1234")
	fmt.println(n,ok)

	n, ok = strconv.parse_u64_maybe_prefixed("0xee")
	fmt.println(n,ok)
}

Output:

1234 true
238 true

Returns

• value: The parsed uint64 value
• ok: ok=false if a valid integer could not be found, if the value was negative, or if the input string contained more than just the number.

Parses an unsigned 64-bit integer value from the input string without a prefix, using the specified base

Inputs

• str: The input string to parse
• base: The base of the number system to use for parsing
• Must be between 1 and 16 (inclusive)
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_u64_of_base_example :: proc() {
	n, ok := strconv.parse_u64_of_base("1234e3", 10)
	fmt.println(n,ok)

	n, ok = strconv.parse_u64_of_base("5678eee",16)
	fmt.println(n,ok)
}

Output:

1234 false
90672878 true

Returns

• value: The parsed uint64 value
• ok: A boolean indicating whether the parsing was successful

Parses an unsigned integer value from the input string, using the specified base or inferring the base from a prefix

Inputs

• s: The input string to parse
• base: The base of the number system to use for parsing (default: 0, inferred)
• If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
• If base is not 0, it will be used for parsing regardless of any prefix in the input string
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Example:

import "core:fmt"
import "core:strconv"
parse_uint_example :: proc() {
	n, ok := strconv.parse_uint("1234") // without prefix, inferred base 10
	fmt.println(n,ok)

	n, ok = strconv.parse_uint("ffff", 16) // without prefix, explicit base
	fmt.println(n,ok)

	n, ok = strconv.parse_uint("0xffff") // with prefix and inferred base
	fmt.println(n,ok)
}

Output:

1234 true
65535 true
65535 true

Returns

value: The parsed uint value ok: false if no appropriate value could be found; the value was negative; he input string contained more than just the number

Writes a quoted string representation of the input string to a given byte slice and returns the result as a string

Inputs

• buf: The byte slice to which the quoted string will be written
• str: The input string to be quoted

!! ISSUE !! NOT EXPECTED -- "\"hello\"" was expected

Example:

import "core:fmt"
import "core:strconv"
quote_example :: proc() {
	buf: [20]byte
	result := strconv.quote(buf[:], "hello")
	fmt.println(result, buf)
}

Output:

"'h''e''l''l''o'" [34, 39, 104, 39, 39, 101, 39, 39, 108, 39, 39, 108, 39, 39, 111, 39, 34, 0, 0, 0]

Returns

• The resulting string after writing the quoted string representation

Writes a quoted rune representation of the input rune to a given byte slice and returns the result as a string

Inputs

• buf: The byte slice to which the quoted rune will be written
• r: The input rune to be quoted

Example:

import "core:fmt"
import "core:strconv"
quote_rune_example :: proc() {
	buf: [4]byte
	result := strconv.quote_rune(buf[:], 'A')
	fmt.println(result, buf)
}

Output:

'A' [39, 65, 39, 0]

Returns

• The resulting string after writing the quoted rune representation

Rounds the given decimal number to its shortest representation, considering the provided floating-point format

Inputs

• d: The decimal number to round
• mant: The mantissa of the floating-point number
• exp: The exponent of the floating-point number
• flt: Pointer to the Float_Info structure containing information about the floating-point format

Unquotes a single character from the input string, considering the given quote character

Inputs

• str: The input string containing the character to unquote
• quote: The quote character to consider (e.g., '"')

Example:

import "core:fmt"
import "core:strconv"
unquote_char_example :: proc() {
	src:="\'The\' raven"
	r, multiple_bytes, tail_string, success  := strconv.unquote_char(src,'\'')
	fmt.println("Source:", src)
	fmt.printf("r: <%v>, multiple_bytes:%v, tail_string:<%s>, success:%v\n",r, multiple_bytes, tail_string, success)
}

Output:

Source: 'The' raven
r: <'>, multiple_bytes:false, tail_string:<The' raven>, success:true

Returns

• r: The unquoted rune
• multiple_bytes: A boolean indicating if the rune has multiple bytes
• tail_string: The remaining portion of the input string after unquoting the character
• success: A boolean indicating whether the unquoting was successful

Unquotes the input string considering any type of quote character and returns the unquoted string

Inputs

• lit: The input string to unquote
• allocator: (default: context.allocator)

WARNING: This procedure gives unexpected results if the quotes are not the first and last characters.

Example:

import "core:fmt"
import "core:strconv"
unquote_string_example :: proc() {
	src:="\"The raven Huginn is black.\""
	s, allocated, ok := strconv.unquote_string(src)
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n\n", s, allocated, ok)

	src="\'The raven Huginn\' is black."
	s, allocated, ok = strconv.unquote_string(src)
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n\n", s, allocated, ok)

	src="The raven \'Huginn\' is black."
	s, allocated, ok = strconv.unquote_string(src) // Will produce undesireable results
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n", s, allocated, ok)
}

Output:

"The raven Huginn is black."
Unquoted: <The raven Huginn is black.>, alloc:false, ok:true

'The raven Huginn' is black.
Unquoted: <The raven Huginn' is black>, alloc:false, ok:true

The raven 'Huginn' is black.
Unquoted: <he raven 'Huginn' is black>, alloc:false, ok:true

Returns

• res: The resulting unquoted string
• allocated: A boolean indicating if the resulting string was allocated using the provided allocator
• success: A boolean indicating whether the unquoting was successful

NOTE: If unquoting is unsuccessful, the allocated memory for the result will be freed.

Writes the string representation of an integer to a buffer with specified base, flags, and digit set.

Inputs

• buf: The buffer to append the integer representation to
• x: The integer value to convert
• base: The base for the integer representation (2 <= base <= MAX_BASE)
• is_signed: A boolean indicating if the input should be treated as a signed integer
• bit_size: The bit size of the signed integer representation (8, 16, 32, or 64)
• digits: The digit set used for the integer representation
• flags: The Int_Flags bit set to control integer formatting

Returns

• The string containing the integer representation appended to the buffer

Writes the string representation of a 128-bit integer to a buffer with specified base, flags, and digit set.

Inputs

• buf: The buffer to append the integer representation to
• x: The 128-bit integer value to convert
• base: The base for the integer representation (2 <= base <= MAX_BASE)
• is_signed: A boolean indicating if the input should be treated as a signed integer
• bit_size: The bit size of the signed integer representation (8, 16, 32, 64, or 128)
• digits: The digit set used for the integer representation
• flags: The Int_Flags bit set to control integer formatting

Returns

• The string containing the integer representation written to the buffer

Writes a boolean value as a string to the given buffer

Inputs

• buf: The buffer to write the boolean value to
• b: The boolean value to be written

Example:

import "core:fmt"
import "core:strconv"
write_bool_example :: proc() {
	buf: [6]byte
	result := strconv.write_bool(buf[:], true)
	fmt.println(result, buf)
}

Output:

true [116, 114, 117, 101, 0, 0]

Returns

• The resulting string after writing the boolean value

ftoa C name deprecated, use write_float instead (same procedure)

Writes a float64 value as a string to the given buffer with the specified format and precision

Inputs

• buf: The buffer to write the float64 value to
• f: The float64 value to be written
• fmt: The byte specifying the format to use for the conversion
• prec: The precision to use for the conversion
• bit_size: The size of the float in bits (32 or 64)

Example:

import "core:fmt"
import "core:strconv"
write_float_example :: proc() {
	buf: [8]byte
	result := strconv.write_float(buf[:], 3.14159, 'f', 2, 64)
	fmt.println(result, buf)
}

Output:

+3.14 [43, 51, 46, 49, 52, 0, 0, 0]

Returns

• The resulting string after writing the float

Writes a signed integer value as a string to the given buffer with the specified base

Inputs

• buf: The buffer to write the signed integer value to
• i: The signed integer value to be written
• base: The base to use for converting the integer value

Example:

import "core:fmt"
import "core:strconv"
write_int_example :: proc() {
	buf: [4]byte
	result := strconv.write_int(buf[:], -42, 10)
	fmt.println(result, buf)
}

Output:

-42 [45, 52, 50, 0]

Returns

• The resulting string after writing the signed integer value

Writes an unsigned integer value as a string to the given buffer with the specified base

Inputs

• buf: The buffer to write the unsigned integer value to
• u: The unsigned integer value to be written
• base: The base to use for converting the integer value

Example:

import "core:fmt"
import "core:strconv"
write_uint_example :: proc() {
	buf: [4]byte
	result := strconv.write_uint(buf[:], 42, 16)
	fmt.println(result, buf)
}

Output:

2a [50, 97, 0, 0]

Returns

• The resulting string after writing the unsigned integer value