Golang Byte Array to String Conversion

If you're working with raw data or binary streams in Go, you’ll eventually need to convert a byte array to string. In this article, we'll explore different ways to perform this operation in Go using the string() conversion, fmt.Sprintf(), and byte slicing techniques.

Whether you're searching for “golang byte array to string” or “golang bytes to string”, this tutorial has got you covered with easy-to-follow code examples and best practices.

What Is a Byte Array in Go?

In Golang, a byte array is simply a slice of bytes ([]byte). It often represents binary data or UTF-8 encoded text. Converting byte slices to strings is a common requirement when processing network responses, files, or encoded data.

Method 1: Convert Byte Array to String Using string()

The most straightforward way to convert a byte array to a string in Go is by using the built-in string() function.

Hexadecimal Byte Values

package main

import "fmt"

func main() {
    byteArray := []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f}
    str := string(byteArray)
    fmt.Println(str) // Output: hello
}

This method directly interprets the byte slice as a UTF-8 encoded string.

Character Literals in Byte Array

package main

import "fmt"

func main() {
    byteArray := []byte{'h', 'e', 'l', 'l', 'o'}
    str := string(byteArray[:])
    fmt.Println(str) // Output: hello
}

This is functionally equivalent to the previous example and is commonly used when initializing byte slices manually.

Method 2: Convert Byte Array to String Using fmt.Sprintf()

While less direct, you can also use fmt.Sprintf() to convert bytes to a string:

package main

import "fmt"

func main() {
    byteArray := []byte{104, 101, 108, 108, 111}
    str := fmt.Sprintf("%s", byteArray)
    fmt.Println(str) // Output: hello
}

Why use fmt.Sprintf()?

• Useful when formatting additional text.
• Slight overhead compared to string().

Method 3: Convert Partial Byte Array Using Slicing

Sometimes you only want to convert part of a byte array. You can slice it before converting.

package main

import "fmt"

func main() {
    byteArray := []byte{'h', 'e', 'l', 'l', 'o', ' ', 'G', 'o'}
    str := string(byteArray[6:]) // Slice from 6th index onward
    fmt.Println(str) // Output: Go
}

Slicing gives you fine-grained control over the data you want to convert.

Common Pitfalls to Avoid

• Invalid UTF-8 sequences: If your byte array contains invalid UTF-8, converting to string may produce garbage characters.
• Performance: string() is faster than fmt.Sprintf() — avoid fmt.Sprintf() in performance-critical code.
• Memory usage: Converting large byte arrays copies data — use slicing carefully to avoid memory bloat.

When Should You Use []byte vs string?

Use Case	Use []byte	Use string
Binary data	+	–
File/network I/O	+	–
Text processing	–	+
JSON marshalling	–	+

For network and file operations, stick with []byte. For human-readable data, use string.

Benchmark: string() vs fmt.Sprintf()

Here’s a quick benchmark comparing both methods:

package main

import (
    "fmt"
    "testing"
)

func BenchmarkStringConversion(b *testing.B) {
    data := []byte("hello world")
    for i := 0; i < b.N; i++ {
        _ = string(data)
    }
}

func BenchmarkSprintfConversion(b *testing.B) {
    data := []byte("hello world")
    for i := 0; i < b.N; i++ {
        _ = fmt.Sprintf("%s", data)
    }
}

Result (on most systems):

• string() is significantly faster than fmt.Sprintf().

Best Practice Summary

Method	Use Case	Performance
string([]byte)	General conversion	Fastest
fmt.Sprintf("%s", []byte)	With formatting	Slower
string([]byte[start:end])	Partial data	Efficient