Как итерироваться по срезу (slice) в обратном порядке в Go?

Стандартный способ: цикл с декрементом индекса

В Go действительно нет встроенной функции для обратной итерации по срезу, но это не проблема — цикл с декрементом индекса решает задачу элегантно и эффективно. Главное — правильно указать начальное и конечное значения счётчика.

Вот правильный код для обхода среза в обратном порядке:

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // Обратная итерация: от последнего элемента к первому
    for i := len(numbers) - 1; i >= 0; i-- {
        fmt.Println(numbers[i])
    }
    // Вывод: 5, 4, 3, 2, 1
}

Разберём ключевые моменты:

• Начальное значение: len(numbers) - 1 — индекс последнего элемента (для среза длины 5 это индекс 4).
• Условие продолжения: i >= 0 — пока индекс не станет меньше нуля (включая нулевой элемент).
• Шаг: i-- — уменьшаем индекс на 1 на каждой итерации.

Ошибка, которую вы допустили (пропуск нулевого элемента), возникает, если использовать условие i > 0 вместо i >= 0. В этом случае цикл останавливается на индексе 1, не доходя до нулевого.

Идиоматичный подход: функция-обёртка (опционально)

Если вам нужно часто выполнять обратную итерацию, можно создать небольшую вспомогательную функцию. Это не улучшит производительность, но сделает код более читаемым:

package main

import "fmt"

// reverseIterate вызывает функцию f для каждого элемента среза в обратном порядке
func reverseIterate[T any](s []T, f func(int, T)) {
    for i := len(s) - 1; i >= 0; i-- {
        f(i, s[i])
    }
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    reverseIterate(numbers, func(i, v int) {
        fmt.Printf("index=%d, value=%d\n", i, v)
    })
}

Преимущество такого подхода — использование дженериков (Go 1.18+), что позволяет работать с любым типом элементов.

Важно: избегайте создания копии среза

Некоторые новички пытаются сначала развернуть срез, а потом итерироваться:

// ПЛОХОЙ ПОДХОД — создаёт лишнюю копию
for _, v := range reverseCopy(numbers) {
    fmt.Println(v)
}

Такой код неэффективен по памяти и времени, особенно для больших срезов. Цикл с декрементом индекса работает за O(n) без дополнительных аллокаций.

Когда нужен range?

Если вы хотите использовать синтаксис for range (например, для работы с каналами или мапами), то для срезов это невозможно — range всегда идёт от начала к концу. Однако вы можете схитрить с отрицательным шагом в другом цикле, как показано выше.

В итоге: самый простой и производительный способ — это ручной цикл for i := len(s) - 1; i >= 0; i--. Это идиоматично для Go и понятно любому разработчику.

package main

import (
    "fmt"
    "sort"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // Сортировка в обратном порядке (изменяет исходный срез!)
    sort.Slice(numbers, func(i, j int) bool {
        return numbers[i] > numbers[j]
    })
    
    for _, v := range numbers {
        fmt.Println(v) // 5, 4, 3, 2, 1
    }
}

reversed := make([]int, len(numbers))
copy(reversed, numbers)
sort.Slice(reversed, func(i, j int) bool {
    return reversed[i] > reversed[j]
})