# How to Clear a Slice or Map in Go Using the `clear` Built-In Function

> Learn how to clear a slice or map in Go with the new clear built-in function introduced in Go 1.21. This guide shows efficient map and slice manipulation.

- Repository: [JetBrains/go-modern-guidelines](https://github.com/jetbrains/go-modern-guidelines)
- Tags: how-to-guide
- Published: 2026-08-29

---

**Go 1.21 introduced the `clear` built-in function as the idiomatic way to delete all entries from a map or zero-out slice elements while preserving length and capacity.**

The `clear` built-in provides a concise, readable alternative to manual iteration when you need to reset collections. According to the JetBrains/go-modern-guidelines repository, this function represents current Go best practices for collection management.

## Understanding the `clear` Built-In in Go

Go 1.21 added `clear` to the language specification as a universal cleanup mechanism for maps and slices. The implementation handles each type differently while maintaining consistent syntax.

### Clearing Maps with `clear()`

For maps, `clear(m)` iterates internally and deletes every key-value pair. This produces the same result as manually looping with `delete()`, but expresses intent more clearly and requires no boilerplate code.

```go
// Clearing a map completely
m := map[string]int{
    "a": 1,
    "b": 2,
    "c": 3,
}
clear(m) // m is now empty (len == 0)

```

The guideline definition in [`internal/guidelines/guidelines.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/internal/guidelines/guidelines.json) explicitly recommends: *"Use clear(m) to delete all map entries or clear(s) to zero slice elements"* (see lines 721-735).

### Zeroing Slices with `clear()`

For slices, `clear(s)` sets every element to the zero value of the element type. Unlike re-slicing to zero length (`s = s[:0]`), this operation preserves the original length and capacity while clearing the data.

```go
// Zero-ing a slice (preserves length & capacity)
s := []int{5, 6, 7}
clear(s) // s == []int{0, 0, 0}, len(s) == 3, cap(s) unchanged

```

This distinction matters when you need to reuse the underlying array without reallocating memory, but want to ensure no stale data remains accessible through the slice header.

## Implementation in the Go Modern Guidelines Repository

The JetBrains/go-modern-guidelines project documents this pattern in its structured guideline definitions. The JSON specification resides in [`internal/guidelines/guidelines.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/internal/guidelines/guidelines.json), which contains the formal definition including usage examples and rationale.

The CLI tool that presents these guidelines loads this data at runtime through [`internal/guidelines/guidelines.go`](https://github.com/JetBrains/go-modern-guidelines/blob/main/internal/guidelines/guidelines.go) (lines 21-27). This architecture separates the static rule definitions from the presentation layer, allowing the repository to serve both as documentation and as a functional command-line reference tool.

## Summary

- **Go 1.21 requirement**: The `clear` built-in requires Go version 1.21 or later.
- **Map behavior**: `clear(m)` deletes all keys, equivalent to `for k := range m { delete(m, k) }` but more concise.
- **Slice behavior**: `clear(s)` zeroes elements while preserving length and capacity, unlike `s = s[:0]` which truncates length.
- **Source reference**: The official guideline lives in [`internal/guidelines/guidelines.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/internal/guidelines/guidelines.json) within the JetBrains repository.

## Frequently Asked Questions

### What is the difference between `clear(s)` and `s = s[:0]` for slices?

`clear(s)` sets every element to its zero value while keeping the slice length intact, whereas `s = s[:0]` creates a zero-length slice that still references the same underlying array. Use `clear()` when you need to zero-out data for security or reuse, and use re-slicing when you simply want to reset the length for appending new elements.

### Does `clear()` free memory for maps or slices?

No, `clear()` does not release backing memory. For maps, it removes all entries but keeps the bucket structure allocated for future use. For slices, it only zeroes values in place. To actually release memory, you must set the variable to `nil` or allow it to go out of scope.

### Can I use `clear()` on nil maps or slices?

Yes, `clear()` handles nil collections safely. Calling `clear(nil)` or `clear(nilMap)` is a valid no-op that does not panic, making it safe to use defensively without nil checks.