How do I reverse a slice in go?

How do I reverse an arbitrary slice ([]interface{}) in Go? I'd rather not have to write Less and Swap to use sort.Reverse. Is there a simple, builtin way to do this?

Use slices.Reverse in Go 1.21 or later:

slices.Reverse(s)

Answers for Go version 1.20 and earlier:

The standard library does not have a built-in function for reversing a slice. Use a for loop to reverse a slice:

for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
	s[i], s[j] = s[j], s[i]
}

Use type parameters to write a generic reverse function in Go 1.18 or later:

func reverse[S ~[]E, E any](s S)  {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
}

Use reflect.Swapper to write a function that works with arbitrary slice types in Go version 1.8 or later:

func reverse(s interface{}) {
	n := reflect.ValueOf(s).Len()
	swap := reflect.Swapper(s)
	for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
		swap(i, j)
	}
}

The functions in this answer reverse the slice inplace. If you do not want to modify the original slice, copy the slice before reversing the slice.

Here's another possible way to reverse generic slice (go 1.18)

// You can edit this code!
// Click here and start typing.
package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int64{10, 5, 15, 20, 1, 100, -1}
	ReverseSlice(nums)
	fmt.Println(nums)

	strs := []string{"hello", "world"}
	ReverseSlice(strs)
	fmt.Println(strs)

	runes := []rune{'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'}
	ReverseSlice(runes)
	for _, r := range runes {
		fmt.Print(string(r), " ")
	}
}

func ReverseSlice[T comparable](s []T) {
	sort.SliceStable(s, func(i, j int) bool {
		return i > j
	})
}

Running the program above should output:

[-1 100 1 20 15 5 10]
[world hello]
d l r o w o l l e h 
Program exited.

<kbd>go playground</kbd>

This will return a reversed slice without modifying the original slice.

Algorithm used from official wiki page: https://github.com/golang/go/wiki/SliceTricks#reversing

func reverse(s []interface{}) []interface{} {
a := make([]interface{}, len(s))
copy(a, s)
for i := len(a)/2 - 1; i >= 0; i-- {
opp := len(a) - 1 - i
a[i], a[opp] = a[opp], a[i]
}
return a
}

There are my code example, you can run it in playground

package main

import (
	"fmt"
	"reflect"
	"errors"
)

func ReverseSlice(data interface{}) {
	value := reflect.ValueOf(data)
	if value.Kind() != reflect.Slice {
		panic(errors.New("data must be a slice type"))
	}
	valueLen := value.Len()
	for i := 0; i <= int((valueLen-1)/2); i++ {
		reverseIndex := valueLen - 1 - i
		tmp := value.Index(reverseIndex).Interface()
		value.Index(reverseIndex).Set(value.Index(i))
		value.Index(i).Set(reflect.ValueOf(tmp))
	}
}


func main() {
	names := []string{"bob", "mary", "sally", "michael"}
	ReverseSlice(names)
	fmt.Println(names)
}

Here is the function I'm using with generics (go 1.18+). You can use it to reverse any kind of slice or even a string (using the split/join trick). It doesn't change the original slice.

package main

import (
	"fmt"
	"strings"
)

func Reverse[T any](original []T) (reversed []T) {
	reversed = make([]T, len(original))
	copy(reversed, original)

	for i := len(reversed)/2 - 1; i >= 0; i-- {
		tmp := len(reversed) - 1 - i
		reversed[i], reversed[tmp] = reversed[tmp], reversed[i]
	}

	return
}

func main() {
	a := []string{"a", "b", "c"}
	fmt.Println(a, Reverse(a))

	b := []uint{0, 1, 2}
	fmt.Println(b, Reverse(b))

	c := "abc"
	fmt.Println(c, strings.Join(Reverse(strings.Split(c, "")), ""))
}

Better Go Playground

This generic slice reversal function should do it for you:

func ReverseSlice[T comparable](s []T) []T {
var r []T
for i := len(s) - 1; i >= 0; i-- {
r = append(r, s[i])
}
return r
}

func Reverse[T any](array []T) []T {
	length := len(array)
	result := make([]T, length)
	for i, elem := range array {
		result[length-1-i] = elem
	}
	return result
}

func ReverseInPlace[T any](array []T) []T {
	length := len(array)
	swap := reflect.Swapper(array)
	for i := 0; i < length/2; i++ {
		swap(i, length-1-i)
	}
	return array
}

Enhanced the accepted answer.

And tests:

func TestReverse(t *testing.T) {
	t.Run("Empty array", func(t *testing.T) {
		input := []int{}
		assert.Equal(t, []int{}, Reverse(input))
		assert.Equal(t, []int{}, input)
	})

	t.Run("Reverse integers", func(t *testing.T) {
		input := []int{1, 2, 3}
		assert.Equal(t, []int{3, 2, 1}, Reverse(input))
		assert.Equal(t, []int{1, 2, 3}, input)
	})

	t.Run("Reverse strings", func(t *testing.T) {
		input := []string{"a", "b", "c"}
		assert.Equal(t, []string{"c", "b", "a"}, Reverse(input))
		assert.Equal(t, []string{"a", "b", "c"}, input)
	})
}

func TestReverseInPlace(t *testing.T) {
	t.Run("Empty array", func(t *testing.T) {
		input := []int{}
		assert.Equal(t, []int{}, ReverseInPlace(input))
		assert.Equal(t, []int{}, input)
	})

	t.Run("Reverse integers", func(t *testing.T) {
		input := []int{1, 2, 3}
		assert.Equal(t, []int{3, 2, 1}, ReverseInPlace(input))
		assert.Equal(t, []int{3, 2, 1}, input)
	})

	t.Run("Reverse strings", func(t *testing.T) {
		input := []string{"a", "b", "c"}
		assert.Equal(t, []string{"c", "b", "a"}, ReverseInPlace(input))
		assert.Equal(t, []string{"c", "b", "a"}, input)
	})
}