Go Walkthrough: strconv

Ben Johnson
Sep 8, 2016 · 9 min read

Formatting & parsing primitive values in Go is a common task. You probably first dipped your toes into the package when you started Go, however, there’s a less commonly used package for basic formatting that’s more efficient and preserves compiler type checking.

The package is built for speed. It’s great for when you need to handle primitive value formatting while minimizing allocations and CPU cycles. Understanding the package also gives you a better understanding of how the package itself works.

This post is part of a series of walkthroughs to help you understand the standard library better. While generated documentation provides a wealth of information, it can be difficult to understand packages in a real world context. This series aims to provide context of how standard library packages are used in every day applications. If you have questions or comments you can reach me at on Twitter.

The primitive types

There are 4 different types of primitives that strconv works with — booleans, integers, floating-point numbers, & strings. Each type has functions for formatting & parsing.

Some of these have variations for reducing allocations and some have helper functions for common options. Let’s take a look at them one by one.

Integer operations

Computers use a binary representation of numeric values so we have to convert them if we want to work with them in decimal (or other numeral systems).

Go has two kinds of integer types, int & uint, for signed and unsigned representations. The package has different functions for each kind.

Parsing integers

If you have a string and want to convert it to one of Go’s integer types, you can use the () or () functions:

func ParseInt(s , base , bitSize ) (, )
func ParseUint(s , base , bitSize ) (, )

These functions read s and convert it to a numeral system based on the base argument. You can specify any base between 2 and 36 but you can also use zero to determine the base from the string. If the string contains a “0x” prefix then it’s parsed as base-16, if it contains just a “0” prefix then it’s parsed as base-8, otherwise it’s parsed as decimal.

The bitSize argument restricts the size of the integer parsed. This is important if you need to ensure that your value can fit into a smaller type such as int8, int16, or int32. You can also specify a bitSize of zero to indicate that you want it to fit into the system’s int size (i.e. 32-bit or 64-bit).

When parsing fails

There are a couple ways that parsing can fail. The most obvious is if your string contains characters outside of the range the numeral system. For example, a “9” is not a valid number when parsing base-8. This will return a with an Err field of .

Parsing can also fail if the number is too large for the bitSize. For example, parsing the number “300” with a bitSize of 8 is invalid because an int8 has a maximum value of 127. This will return a with an Err field of .

Convenient int parsing

Finally, there’s a convenience function called ():

func Atoi(s ) (, )

Internally this is just a call to () with a base of 10 and a bitSize of 0. Also, note that it returns an int type instead of ()’s int64 return type.

I typically use the int type for all my integers in my application unless there’s a specific need to use sized integer types (such as efficiency or to ensure 64-bit range on 32-bit systems). It reduces the clutter of having to type convert between the various sizes. Because I mainly use the int type, I primarily use the () function.

Formatting integers

For encoding your Go integer types into a string, you can use () and ():

func FormatInt(i , base ) 
func FormatUint(i , base )

These functions convert i into the given base and return the string representation. The base supports anything between 2 and 36.

Formatting integers seems simple from the outside but there are a lot of optimizations internally for base-10 as well as any base which is a power of 2.

Formatting integers (with fewer allocations)

One often overlooked part of the package is its Append functions. The Format functions generally require that the returned variable is allocated each time. Allocations are the enemy of performance.

To remove these allocations for each call, we can reuse a single buffer by using the Append functions. Integer formatting provides the () and the () functions:

func AppendInt(dst [], i , base ) []
func AppendUint(dst [], i , base ) []

Reusing a buffer is simple. In fact, you can create one on the stack if it’s small by using a fixed size array and then converting to a byte slice:

In this example, we have a list of int16 values called a. We can determine the buffer size by taking the number of digits of the (which is 32,767) plus 1 extra byte for a possible negative sign. That’s 5 bytes + 1 byte which makes our buffer 6 bytes. That’s the maximum size an int16 can encode into in base-10.

Now we can loop over our list of values and append into our local buffer. We need to convert our buffer’s byte array to a byte slice so we reslice it using the [:0] notation. This just means that we want to start from the beginning of the slice but make the length zero. The capacity of our slice will be 6 so we can append into it without an allocation.

The returned b variable has a new slice header with the appropriate length set for the formatted integer but it’s data still points to the underlying buf byte array.

Floating-point operations

There are two floating-point types in Go — float32 & float64. They provide a way to express numbers which are not whole numbers. They provide a much larger range of available values compared to the integer types but they do so by trading off precision. They also allow you to represent and ±.

Go implements the IEEE-754 specification for floating-point numbers and there are a lot of technical considerations when using it. I’m not going to get into those details here. Wikipedia has a good page on if you want to read more.

Parsing floats

Unlike integers, floating-point numbers can take on a couple different forms:

  • Integers such as “123”.
  • Numbers with a fractional part such as “123.45678”.
  • Numbers with an exponent such as “1.234E+56".

You can parse these using the () function:

func ParseFloat(s , bitSize ) (, )

This parses s and returns a value that fits within bitSize (which can be 32 or 64). If you try to parse a number that is too large or small then you’ll receive a with Err set to and the value will be +Infinity or -Infinity.

Parsing float-point in Go involves tons of optimization and bit twiddling so if you’re interested in the low level mechanics I suggest diving into the file to explore further.

Formatting floats

Encoding floats to strings is a little more complicated than parsing them. For this task we use the () function:

func FormatFloat(f , fmt , prec, bitSize ) 

This function encodes f as a string. The fmt provides a couple options for how you want to display that float:

  • ‘f’ — This encodes your float without any exponent. So 123.45 will print as “123.45”. Easy enough so far.
  • ‘e’, ‘E’ — These encode your float by always using an exponent. In this case, 123.45 will encode as “1.2345E+02”. The case of the fmt character determines whether an “e” or “E” is used in your encoded string.
  • ‘g’, ‘G’ — These encode your float without an exponent for small values and with an exponent for large values. What qualifies as a small value vs large value depends on your prec argument.
  • ‘b’— This one is the most confusing. The other formats use a decimal exponent (e.g. 10ⁿ), however, this format uses a binary exponent (e.g. 2ⁿ). For example, 64.0 is formatted with a bitSize of 32 is “8388608p-17". You can convert this back to 64 by doing 8388608 × (2^-17). There is probably some fancy math stuff you use this for but I‘ve never had to use it.

Next is the prec argument to specify precision. For example, formatting 3.14159 with a precision of 2 will give you “3.14”. If you pass in a -1 then it’ll determine the precision based on the bitSize.

Finally, the bitSize specifies whether the formatting should treat f like a float32 or float64. As mentioned before, precision is affected by this.

Boolean operations

Parsing booleans

To parse boolean values, we can use the () function:

func ParseBool(str ) (, )

This function has a set list of true and false values for str. True values consist of “1”, “t”, “T”, “true”, “True”, & “TRUE”. False values consist of “0”, “f”, “F”, “false”, “False”, & “FALSE”. Anything else will return an error.

I don’t typically use () simply because I like my inputs to be specific (e.g. either “true” or “false”).

Formatting booleans

We can perform the reverse operation and format a boolean using ():

func FormatBool(b ) 

This returns “true” or “false” depending on the value of b. Easy peasy so far.

There’s also another option for formatting booleans when you’re using byte slices called ():

func AppendBool(dst [], b ) []

This will append “true” or “false” to the end of dst and return the new byte slice.

Despite this function only being 3 lines, I do find myself using it. No reason to rewrite 3 lines of code that’s already in the standard library.

String operations

Oddly enough there is also string encoding for strings. This is used for quoting strings so that control characters and non-printable characters can be displayed. It uses Go’s character escapes so it’s very specific to the Go language itself.

Quoting strings

You can quote strings by use the () function:

func Quote(s ) 

This will convert your tabs and newlines and unprintable characters using escape sequences such as \t, \n, and \uXXXX. This can be useful when displaying error messages with data since your data may include weird characters like the (\u0008) which is invisible.

If you need to limit your string to ASCII characters only, you can use the () function:

func QuoteToASCII(s ) 

This will ensure that fancy Unicode characters will be escaped (e.g. ☃ will be displayed as “\u2603”).

There is also another function called () for printing characters instead of escaping them. For example, one Graphic character that gets escaped by () is the (whatever that is). Honestly, I had a really hard time figuring out when you would care about the difference. The () function isn’t even used within the standard library.

Efficiently quoting strings

As with other strconv functions, there’s also Append functions for appending to a byte slice to reduce allocations:

func AppendQuote(dst [], s ) []
func AppendQuoteToASCII(dst [], s ) []
func AppendQuoteToGraphic(dst [], s ) []

Quoting individual runes

You can also quote runes by using (), (), and ():

func QuoteRune(r ) 
func QuoteRuneToASCII(r )
func QuoteRuneToGraphic(r )

One difference with these is that individual runes are quoted with single quotes instead of double quotes.

Efficiently quoting runes

Again, there’s a set of Append functions for each of these:

func AppendQuoteRune(dst [], r ) []
func AppendQuoteRuneToASCII(dst [], r ) []
func AppendQuoteRuneToGraphic(dst [], r ) []

Unquoting strings

If you already have a quoted string value, you can parse it into a Go string by using ():

func Unquote(s ) (, )

This will parse not only double-quoted strings but also single-quoted and backtick-quoted strings.

Unquoting strings the hard way

If you are a masochist then you can also unquote strings one character at a time using ():

func UnquoteChar(s , quote ) (value , multibyte , tail , err )

This unquotes the first character of s and returns the rune value along with whether the rune is multi-byte. It also returns tail which is the remainder of the string.

Conclusion

Converting Go’s boolean, numeric, and string types into human readable strings is a core component of most software. We need to see our data! While is the go-to package for formatting, it can be slow and inefficient.

The package gives us a way to format our primitives quickly and efficiently while providing some basic formatting options. It also preserves strong type checking for its arguments whereas frequently uses interface{}.

If you liked this, click the💚 below so other people will see this here on Medium.

Go Walkthrough

A series of walkthroughs to help you understand the Go standard library better.

Ben Johnson

Written by

Writing databases and distributed systems in Go.

Go Walkthrough

A series of walkthroughs to help you understand the Go standard library better.