How to remove an element from a slice in Go

1slices.Delete (Go 1.21+)Recommended

slices.Delete(s, i, j) removes the half-open range [i, j) and returns the shortened slice, so a single element at index i is Delete(s, i, i+1). The half-open range trips people up once and then never again — it is the same convention as s[i:j], and it means you can drop a whole run in one call. It is generic, so it works on a slice of any element type.

package main

import (
	"fmt"
	"slices"
)

func main() {
	fruits := []string{"apple", "banana", "cherry", "date"}

	// Delete takes a half-open range [i, j) -- one element is i, i+1
	fruits = slices.Delete(fruits, 1, 2)
	fmt.Println(fruits)

	// A whole run goes in one call: indexes 1 and 2
	nums := []int{10, 20, 30, 40, 50}
	nums = slices.Delete(nums, 1, 3)
	fmt.Println(nums)

	// The length shrinks; the capacity does not
	fmt.Println(len(fruits), cap(fruits))
}

Prints [apple cherry date], [10 40 50], then 3 4 — the length dropped to 3 while the capacity stayed at 4, because nothing was reallocated. Two things to hold on to: Delete panics if s[i:j] isn't a valid range of s, so bounds-check an index that came from user input, and the return value is not optional — drop the fruits = and your slice keeps its old length over a rewritten array.

2The classic append idiom

Before Go 1.21, append(s[:i], s[i+1:]...) was the answer, and you will still meet it everywhere. Read it right to left: take the tail after i, spread it with ..., and append it onto the head that stops before i. Both halves point into the same backing array — that's fine, append copies left-to-right — so this is exactly the copy-down slices.Delete performs, written out.

package main

import "fmt"

// remove deletes index i and keeps the order of everything else.
func remove(s []string, i int) []string {
	return append(s[:i], s[i+1:]...)
}

func main() {
	fruits := []string{"apple", "banana", "cherry", "date"}
	fruits = remove(fruits, 1)
	fmt.Println(fruits)

	// The two ends need no append at all -- just reslice
	fmt.Println(fruits[1:])             // drop the first
	fmt.Println(fruits[:len(fruits)-1]) // drop the last
}

Prints [apple cherry date], [cherry date], then [apple cherry] — identical to section 1 for the middle element, and the two ends don't need append at all: dropping the first or last element is a pure reslice, O(1) and allocation-free. The one behavioural difference from slices.Delete is invisible here and matters in section 7: this form leaves a stale copy of the removed element in the tail of the backing array.

3Removing by value, not index

Every removal API in Go is index-based, so "delete this value" is two steps: find the index, then delete it. slices.Index returns the position of the first match or -1, and that -1 is the whole reason for the guard — passing it straight to Delete panics. If you only need to know whether the value is there at all, see check if a slice contains an element.

package main

import (
	"fmt"
	"slices"
)

func main() {
	fruits := []string{"apple", "banana", "cherry"}

	// Find it, then delete that one index
	if i := slices.Index(fruits, "banana"); i >= 0 {
		fruits = slices.Delete(fruits, i, i+1)
	}
	fmt.Println(fruits)

	// Missing values return -1, so the guard is not optional
	if i := slices.Index(fruits, "mango"); i >= 0 {
		fruits = slices.Delete(fruits, i, i+1)
	} else {
		fmt.Println("mango was not in the slice")
	}
	fmt.Println(fruits)
}

Prints [apple cherry], mango was not in the slice, then [apple cherry] unchanged. This removes the first match only — for duplicates you would have to loop, which is O(n²) and a classic source of skipped elements. Remove every match in one pass with slices.DeleteFunc instead (section 5). For a custom notion of equality, slices.IndexFunc takes a predicate the same way.

4O(1) removal when order does not matter

Both idioms above shift every later element left, which is O(n). If the slice is really an unordered bag — a worker pool, a free list, a set of active connections — you can move the last element into the hole and cut the length by one. That's two assignments regardless of size, and it scrambles the order, which is exactly the trade you are making.

package main

import "fmt"

// removeFast deletes index i in O(1) by moving the last element into the hole.
// The slice order is not preserved.
func removeFast(s []string, i int) []string {
	s[i] = s[len(s)-1]
	return s[:len(s)-1]
}

func main() {
	tasks := []string{"a", "b", "c", "d", "e"}

	tasks = removeFast(tasks, 1) // "e" lands where "b" was
	fmt.Println(tasks)

	tasks = removeFast(tasks, 0)
	fmt.Println(tasks)
}

Prints [a e c d] then [d e c] — e jumped into slot 1, then d jumped into slot 0. Note it still works when i is the last index: the element is copied onto itself and then sliced away. Like the append idiom this leaves the old value in the tail slot, so for a slice of pointers add s[len(s)-1] = nil before the reslice.

5Removing many elements at once

Deleting inside a loop is the bug factory: every removal shifts the indexes under you, so the straightforward version silently skips elements and runs in O(n²). Do it in one pass instead. slices.DeleteFunc(s, f) (Go 1.21+) removes every element the predicate returns true for; the pre-generics equivalent is the s[:0] filter, which writes the survivors back over the front of the same backing array.

package main

import (
	"fmt"
	"slices"
)

func main() {
	// One pass, one call: keep everything the predicate says false for
	nums := []int{1, 2, 3, 4, 5, 6}
	nums = slices.DeleteFunc(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println(nums)

	// The pre-1.21 equivalent: filter in place, reusing the backing array
	words := []string{"go", "", "rust", "", "zig"}
	keep := words[:0] // same array, length 0
	for _, w := range words {
		if w != "" {
			keep = append(keep, w)
		}
	}
	fmt.Println(keep)
	fmt.Println(len(keep), cap(keep))
}

Prints [1 3 5], [go rust zig], then 3 5 — the filtered slice has three elements and the original capacity of five, proof that it reused the array rather than allocating. Mind the direction of the predicate: DeleteFunc takes a should-remove test, while the loop keeps what you append, so the two conditions are inverses of each other. And the s[:0] trick destroys the input as it goes — if you still need the original order, filter into a fresh make([]T, 0, len(s)).

6Which should you use?

7The trap: aliasing and the elements left behind

A slice is a header — pointer, length, capacity — over an array it doesn't own exclusively. Removing an element rewrites that array, so every other slice sharing it sees the new contents, including the caller's. And the vacated slot at the end still holds whatever was there: for a []*User or [][]byte that's a live reference the garbage collector cannot free. Since Go 1.22 slices.Delete zeroes the vacated slots for you; the hand-rolled idioms do not, and clear is the fix.

package main

import (
	"fmt"
	"slices"
)

func main() {
	// 1. Removal rewrites the caller's backing array in place
	nums := []int{1, 2, 3, 4}
	_ = slices.Delete(nums, 1, 2) // result ignored on purpose
	fmt.Println(nums, len(nums))

	// 2. The hand-rolled append idiom leaves a stale copy in the tail
	names := []string{"ann", "bob", "cy"}
	kept := append(names[:1], names[2:]...)
	fmt.Printf("%q %q\n", kept, names[:cap(names)])

	// 3. clear() zeroes the vacated slots so the GC can reclaim what they held
	clear(names[len(kept):cap(names)])
	fmt.Printf("%q\n", names[:cap(names)])
}

The first line prints [1 3 4 0] 4: nums was never reassigned, so it still has length 4, but its contents were shifted left and the freed slot zeroed — the caller's data changed even though the return value was thrown away. Line two prints ["ann" "cy"] ["ann" "cy" "cy"]: the visible slice is right, but the full backing array still holds a second "cy" past the end. After clear it reads ["ann" "cy" ""]. For value types the leftovers are harmless; for pointers, interfaces, or anything holding a big buffer they pin memory for as long as the slice lives. When the caller must not see the change at all, remove from slices.Clone(s) — the same in-place hazard as sorting a slice.