Convert a Zero-Terminated Byte Array to String in Go

By the end of this page, you will understand why Go strings do not automatically stop at a null byte, how zero-terminated byte arrays differ from C strings, and how to safely convert fixed-size byte arrays like [100]byte into clean Go strings.

In Go, a string is a sequence of bytes. It can contain any byte value, including 0 (the null byte). That means Go does not treat 0 as a special end-of-string marker.

This is different from C, where strings are commonly stored as null-terminated character arrays. In C, the first \0 marks the end of the string.

So when you do this in Go:

s := string(byteArray[:])

Go converts all 100 bytes into the string, including any trailing 0 bytes.

If your data format uses a fixed-size byte array with zero padding, you need to manually find where the meaningful content ends.

A common approach is:

1. Find the first 0 byte
2. Slice up to that position
3. Convert that slice to a string

This matters in real programs because many binary formats, network protocols, and C interop APIs store text in fixed-length buffers rather than true Go strings.

Think of the [100]byte array as a 100-slot storage tray.

• The real text is placed in the first few slots
• The remaining unused slots are filled with 0
• Go reads the entire tray unless you tell it where to stop

C behaves more like: "stop reading when you hit the first empty marker."

Go behaves more like: "read exactly what you gave me."

So in Go, you must decide where the useful data ends before converting it to a string.

The core idea is to cut the byte slice at the first null byte.

Option 1: Use bytes.IndexByte

package main

import (
	"bytes"
	"fmt"
)

func main() {
	data := [100]byte{'H', 'e', 'l', 'l', 'o', 0, 0, 0}

	n := bytes.IndexByte(data[:], 0)
	if n == -1 {
		n = len(data)
	}

	s := string(data[:n])
	fmt.Println(s)
}

This finds the first 0 byte and converts only the bytes before it.

Option 2: Use bytes.TrimRight

If your array is padded with trailing zeros and you want to remove only zeros at the end:

package main

import (
	"bytes"
	"fmt"
)

func main {
	data := []{, , , , , , , }

	s := (bytes.TrimRight(data[:], ))
	fmt.Println(s)
}

Consider this example:

package main

import (
	"bytes"
	"fmt"
)

func main() {
	data := [10]byte{'G', 'o', 0, 0, 0, 0, 0, 0, 0, 0}

	n := bytes.IndexByte(data[:], 0)
	if n == -1 {
		n = len(data)
	}

	s := string(data[:n])
	fmt.Println(s)
}

Step by step

1. data is a fixed-size array of 10 bytes.
2. The first two bytes are 'G' and 'o'.
3. The third byte is 0, which marks the end of meaningful text.
4. data[:] converts the array into a slice so functions like bytes.IndexByte can inspect it.
5. bytes.IndexByte(data[:], 0) returns because the first null byte is at index .

This pattern appears often when Go works with older or lower-level systems.

Common situations

• Binary file formats: fixed-size name fields padded with zeros
• Network protocols: packet headers containing fixed-width text fields
• C library interop: reading char[100] values from C structs
• Database drivers or legacy systems: fixed-length text records
• Embedded systems: device messages stored in byte buffers

Example scenarios

• Reading a username from a binary record
• Extracting a device label from firmware data
• Parsing a file header that stores a 32-byte application name
• Converting a C struct field into a normal Go string

In real projects, developers usually wrap this logic in a helper function so they do not repeat it everywhere.

Helper function pattern

func cString(b []byte) string {
	n := bytes.IndexByte(b, 0)
	if n == -1 {
		n = len(b)
	}
	return string(b[:n])
}

This is common when parsing many fields from structs or binary data.

Guard clause pattern

Developers often handle the -1 case early:

func cString(b []byte) string {
	n := bytes.IndexByte(b, 0)
	if n < 0 {
		return string(b)
	}
	return string(b[:n])
}

Validation pattern

If the data must be valid UTF-8, some codebases validate after conversion:

import "unicode/utf8"

  {
	n := bytes.IndexByte(b, )
	 n ==  {
		n = (b)
	}
	s := (b[:n])
	 !utf8.ValidString(s) {
		 
	}
	 s
}

1. Converting the full array directly

Broken example:

s := string(data[:])

This includes all bytes, including 0 padding.

Fix: stop at the first null byte.

n := bytes.IndexByte(data[:], 0)
if n == -1 {
	n = len(data)
}
s := string(data[:n])

2. Forgetting to handle -1

Broken example:

n := bytes.IndexByte(data[:], 0)
s := string(data[:n])

If no 0 exists, n is -1, and the slice will panic.

Fix: always check for -1.

3. Using TrimRight when the string may contain internal null bytes

s := string(bytes.TrimRight(data[:], ))

IndexByte vs

// Convert a null-terminated byte slice to string
n := bytes.IndexByte(b, 0)
if n == -1 {
    n = len(b)
}
s := string(b[:n])

Quick rules

• Go strings can contain 0 bytes
• string(b) converts every byte in b
• Go does not automatically stop at 0
• Use bytes.IndexByte(b, 0) for C-style strings
• Use bytes.TrimRight(b, "\x00") for trailing zero padding only
• Convert arrays to slices with array[:]

Common helper

func cString(b []byte) string {
    n := bytes.IndexByte(b, 0)
    if n == -1 {
        n = len(b)
    }
    return string(b[:n])
}

Edge cases

Why does Go not stop at \x00 like C?

Go strings are length-based, not null-terminated. A Go string can contain any bytes, including 0.

What is the best function for C-style strings in Go?

bytes.IndexByte(b, 0) is a clear and common choice because it finds the first null byte.

Can I use bytes.TrimRight instead?

Yes, if the data is zero-padded at the end. But it is not the same as stopping at the first null byte.

What happens if there is no 0 byte in the array?

Then the whole array is meaningful data, so you should convert the full slice.

Do I need to convert [100]byte to []byte first?

You do not need a copy, but you usually need a slice view: data[:].

Can a Go string contain null bytes safely?

Yes. Go strings can store null bytes without any problem.

Is there a standard library helper exactly for C strings?

For general byte handling, bytes.IndexByte is the usual tool. In some C interop cases, other packages may be relevant, but for plain byte arrays this is the standard approach.

• Arrays in Go — fixed-size collections like [100]byte are arrays, not slices.
• Slices in Go — most byte-processing functions work with []byte.
• Strings in Go — Go strings are immutable byte sequences and can contain null bytes.
• Byte slices — useful for file parsing, protocol handling, and binary data.
• The bytes package — provides helpers like IndexByte and TrimRight.
• UTF-8 in Go — important when converting bytes to text and validating string content.
• C interop with Go — relevant when reading null-terminated strings from C APIs.