Visualize Go slices and arrays

Expore the connection between slices and arrays by generating diagrams from Go code.

1

Play with the code in the editor below.
2

Pass arrays and slices to the Visualize function.

The signature of this function looks like Visualize(vals ...any). The values must be slices or pointers to arrays.
3

Click the visualize button to update the diagram.

Check out some examples

1: Arrays

2: Array and slice

3: Array with multiple slices

4: Slice (make)

5: Slice (literal)

6: Custom labels

7: Append (reuse array)

8: Append (new array)

This article on arrays and slices shows how to interpret these diagrams.

editor

Options

Treat unknown offsets as zero

When no pointer to a backing array is provided, it's not possible to determine the exact offset of a slice. Enabling this option treats unknown offsets as 0.

Show argument labels

Label each diagram with the argument it represents. Output diagrams are not always in the order of the arguments.

output

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"reflect"
	"strings"
)

// Slice contains everything we need to know to display a slice.
type Slice struct {
	Label  string
	Type   string
	Offset int
	Len    int
	Cap    int
}

// Group contains everything we need to know to display a group of:
// - Backing array.
// - Accompanying slices.
type Group struct {
	ArrayLabel string
	ArrayType  string
	ArrayRows  []string
	// UnknownArray indicates that we don't know the entire array.
	UnknownArray bool
	Slices       []Slice
}

type array struct {
	v            reflect.Value
	len          int
	elementT     reflect.Type
	zeroSlicePtr uintptr
	index        int
}

func (a array) createRows() []string {
	rows := make([]string, 0, a.len)
	for i := 0; i < a.len; i++ {
		v := a.v.Index(i)
		var s string

switch a.elementT.Kind() {
		case reflect.String:
			s = fmt.Sprintf(`"%s"`, v.String())
		case reflect.Bool:
			s = fmt.Sprintf("%v", v.Bool())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			s = fmt.Sprintf("%d", v.Int())
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			s = fmt.Sprintf("%d", v.Uint())
		case reflect.Float32, reflect.Float64:
			s = fmt.Sprintf("%f", v.Float())
		case reflect.Complex64, reflect.Complex128:
			s = fmt.Sprintf("%f", v.Complex())
		case reflect.Array, reflect.Struct:
			s = fmt.Sprintf("%#v", v.Interface())
			// remove prefix from collections.
			s = strings.Replace(s, a.elementT.String(), "", 1)
		case reflect.Map, reflect.Slice:
			if v.IsNil() {
				s = "<nil>"
			} else {
				s = fmt.Sprintf("%#v", v.Interface())
				// remove prefix from collections.
				s = strings.Replace(s, a.elementT.String(), "", 1)
			}
		case reflect.Chan, reflect.Func, reflect.Pointer:
			if v.IsNil() {
				s = "<nil>"
			} else {
				s = fmt.Sprintf("0x%x", v.Pointer())
			}
		case reflect.Interface:
			s = fmt.Sprintf("%#v", v.Interface())
		}

rows = append(rows, s)
	}

return rows
}

type Var struct {
	Label string
	Val   any
}

// visualize tries to visualize the given arrays and slices.
// it returns slices grouped by their backing array.
func visualize(vars ...Var) ([]Group, error) {
	groups := []Group{}
	arrays := []array{}

// First we create groups for explicitly provided array variables.
	for i, v := range vars {
		vv := reflect.ValueOf(v.Val)
		kind := vv.Kind()

switch kind {
		case reflect.Slice:
			// we will handle slices in the next loop.
			continue
		case reflect.Pointer:
			arr, err := newArray(vv, len(groups))
			if err != nil {
				return nil, fmt.Errorf("argument %d error: %w", i, err)
			}

// check if array already has a group.
			if _, ok := findArray(arrays, arr); ok {
				continue
			}

arrays = append(arrays, arr)
			groups = append(groups, Group{
				ArrayLabel:   v.Label,
				ArrayType:    normalizedTypeString(arr.v),
				ArrayRows:    []string{},
				UnknownArray: false,
				Slices:       []Slice{},
			})
		default:
			return nil, fmt.Errorf("unsupported kind of variable: %s", kind)
		}
	}

// Then we create groups for backing arrays that don't have a group yet.
	for i, v := range vars {
		vv := reflect.ValueOf(v.Val)
		kind := vv.Kind()

if kind != reflect.Slice {
			continue
		}

arrayT := reflect.ArrayOf(vv.Cap(), vv.Type().Elem())
		arrayPtrT := reflect.PointerTo(arrayT)

// if v contains a []string, this is equivalent to doing:
		// vFull := v[:cap(v)]
		// arrayPtrV := *[<cap>]string(vFull)
		vFull := vv.Slice(0, vv.Cap())
		arrayPtrV := vFull.Convert(arrayPtrT)

arr, err := newArray(arrayPtrV, len(groups))
		if err != nil {
			return nil, fmt.Errorf("argument %d error: %w", i, err)
		}

index, ok := findArray(arrays, arr)
		if !ok {
			// this slice does not use any of the existing arrays.
			arrays = append(arrays, arr)
			groups = append(groups, Group{
				ArrayLabel:   "backing array",
				ArrayType:    normalizedTypeString(arr.v),
				ArrayRows:    []string{},
				UnknownArray: true, // we don't know if this is the start of the array.
				Slices:       []Slice{},
			})
		} else {
			// this slice uses an existing array.
			// it can be that the backing array of this slice is larger than the existing array.
			existing := arrays[index]
			if arr.len > existing.len {
				arr.index = index
				arrays[index] = arr
				groups[index].ArrayType = arr.v.Type().String()
			} else {
				arr = existing
			}
		}
	}

// And then, we add slices to the right groups.
	for i, v := range vars {
		vv := reflect.ValueOf(v.Val)
		kind := vv.Kind()

if kind != reflect.Slice {
			continue
		}

arrayT := reflect.ArrayOf(vv.Cap(), vv.Type().Elem())
		arrayPtrT := reflect.PointerTo(arrayT)

// if v contains a []string, this is equivalent to doing:
		// vFull := v[:cap(v)]
		// arrayPtrV := *[<cap>]string(vFull)
		vFull := vv.Slice(0, vv.Cap())
		arrayPtrV := vFull.Convert(arrayPtrT)

arr, err := newArray(arrayPtrV, len(groups))
		if err != nil {
			return nil, fmt.Errorf("argument %d error: %w", i, err)
		}

index, ok := findArray(arrays, arr)
		if !ok {
			return nil, fmt.Errorf("unknown array for: %s", v.Label)
		}

arr = arrays[index]

groups[index].Slices = append(groups[index].Slices, Slice{
			Label:  v.Label,
			Type:   normalizedTypeString(vv),
			Offset: findOffset(arr, vv),
			Len:    vv.Len(),
			Cap:    vv.Cap(),
		})
	}

for _, a := range arrays {
		groups[a.index].ArrayRows = a.createRows()
	}

return groups, nil
}

func findArray(arrays []array, x array) (int, bool) {
	for i, a := range arrays {
		if a.elementT != x.elementT {
			continue
		}

for j := 0; j <= a.len; j++ {
			zeroSlicePtr := a.v.Slice(j, j).Pointer()
			if zeroSlicePtr == x.zeroSlicePtr {
				return i, true
			}
		}

for j := 0; j <= x.len; j++ {
			zeroSlicePtr := x.v.Slice(j, j).Pointer()
			if zeroSlicePtr == a.zeroSlicePtr {
				return i, true
			}
		}
	}

return 0, false
}

func findOffset(a array, s reflect.Value) int {
	zeroPtr := s.Slice(0, 0).Pointer()
	for i := 0; i <= a.len; i++ {
		// if this is a zero cap slice, we skip the first address
		// because we might want to match the last pointer.
		if s.Cap() == 0 && i == 0 {
			continue
		}

zeroSlicePtr := a.v.Slice(i, i).Pointer()
		if zeroSlicePtr == zeroPtr {
			return i
		}
	}

return 0
}

func newArray(v reflect.Value, groupIndex int) (array, error) {
	if v.IsNil() {
		return array{}, fmt.Errorf("nil pointer")
	}

v = v.Elem()
	if v.Kind() != reflect.Array {
		return array{}, fmt.Errorf("kind must be an array, is: %s", v.Kind())
	}

a := array{
		v:        v,
		len:      v.Len(),
		elementT: v.Type().Elem(),
		index:    groupIndex,
	}

// We slice into a zero len/cap slice that we can compare against.
	a.zeroSlicePtr = v.Slice(0, 0).Pointer()

return a, nil
}

func Visualize(vals ...any) {
	vars := make([]Var, len(vals))
	for i, val := range vals {
		vars[i] = Var{
			Label: fmt.Sprintf("arg %d", i),
			Val:   val,
		}
	}

VisualizeWithLabels(vars...)
}

func VisualizeWithLabels(vars ...Var) {
	groups, err := visualize(vars...)
	if err != nil {
		log.Fatalf("failed to visualize values: %v", err)
	}

out, err := json.Marshal(groups)
	if err != nil {
		log.Fatalf("failed to marshal json: %v", err)
	}

fmt.Println(base64.StdEncoding.EncodeToString(out))
}

func normalizedTypeString(v reflect.Value) string {
	return strings.Replace(v.Type().String(), "main.", "", 1)
}

🧠 Boost your Go skills

Get your hands dirty with project files, unit tests, excercises and more by subscribing to my newsletter. It's completely free.

I send emails every 1-2 weeks and I promise to keep your data safe. You can unsubscribe at any time.