nums := []int{5, 3, 1, 4, 2}
sort.Slice(nums, func(i, j int) bool {
    return nums[i] < nums[j]
})
// [1, 2, 3, 4, 5]

// Сортировка структур
type User struct {
    Name string
    Age  int
}

users := []User{
    {"Bob", 30}, {"Alice", 25}, {"Carol", 35},
}

sort.Slice(users, func(i, j int) bool {
    return users[i].Age < users[j].Age
})

sort.Slice использует reflection один раз для получения swap-функции, поэтому немного медленнее sort.Sort с sort.Interface. На горячем пути это может быть заметно.

<?php
declare(strict_types=1);

$nums = [5, 3, 1, 4, 2];
sort($nums); // [1, 2, 3, 4, 5] - in-place, переиндексирует

// Сортировка структур через usort + spaceship operator <=>
final readonly class User
{
    public function __construct(public string $name, public int $age) {}
}

$users = [
    new User('Bob', 30),
    new User('Alice', 25),
    new User('Carol', 35),
];

usort($users, static fn (User $a, User $b): int => $a->age <=> $b->age);
// [Alice 25, Bob 30, Carol 35]

В PHP - sort() (числа/строки in-place), usort() (с компаратором), asort() (сохраняя ключи), ksort() (по ключам).

type ByName []User

func (a ByName) Len() int           { return len(a) }
func (a ByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
func (a ByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

sort.Sort(ByName(users))

Когда один и тот же тип сортируется в разных местах - выноси sort.Interface в reusable тип.

<?php
declare(strict_types=1);

final class UserComparator
{
    public static function byName(User $a, User $b): int
    {
        return $a->name <=> $b->name;
    }

    public static function byAge(User $a, User $b): int
    {
        return $a->age <=> $b->age;
    }

    /** Multi-key: сначала по департаменту, потом по имени */
    public static function byDeptThenName(User $a, User $b): int
    {
        return $a->department <=> $b->department
            ?: $a->name <=> $b->name;
    }
}

usort($users, UserComparator::byName(...)); // PHP 8.1+ first-class callable syntax

В PHP компараторы вытаскивают в final class со статическими методами или в invokable-объекты - удобно тестировать.

// Через sort.Search (возвращает индекс первого элемента, где f(i) == true)
nums := []int{1, 3, 5, 7, 9, 11}
target := 7

idx := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= target
})

if idx < len(nums) && nums[idx] == target {
    fmt.Printf("Найден на позиции %d\n", idx)
}

// С Go 1.21: slices.BinarySearch
import "slices"

idx, found := slices.BinarySearch(nums, target)

slices.BinarySearch короче и не требует замыкания. Работает только с упорядоченными типами (cmp.Ordered).

<?php
declare(strict_types=1);

/**
 * Бинарный поиск на отсортированном массиве.
 * @return int Индекс или -1, если не найдено.
 */
function binarySearch(array $nums, int $target): int
{
    $lo = 0;
    $hi = count($nums) - 1;

    while ($lo <= $hi) {
        $mid = intdiv($lo + $hi, 2);
        if ($nums[$mid] === $target) {
            return $mid;
        }
        if ($nums[$mid] < $target) {
            $lo = $mid + 1;
        } else {
            $hi = $mid - 1;
        }
    }

    return -1;
}

$nums = [1, 3, 5, 7, 9, 11];
$idx = binarySearch($nums, 7); // 3

В PHP native бинарного поиска нет - array_search() это O(n) линейный обход. Если данные отсортированы и поиск горячий - реализуй вручную.

// sort.Slice - НЕ стабильная (равные элементы могут поменять порядок)
// sort.SliceStable - стабильная (на ~10-20% медленнее)
sort.SliceStable(users, func(i, j int) bool {
    return users[i].Age < users[j].Age
})

Не платишь за стабильность, когда она не нужна - Slice быстрее.

В PHP 8.0+ usort стабилен по умолчанию (Timsort) - отдельного «stable»-варианта не нужно. На PHP 7.x для стабильной сортировки добавляли индекс в компаратор как tiebreaker. Если код должен работать на legacy-версиях - см. ниже.

<?php
declare(strict_types=1);

// PHP 8.0+ - просто usort, оно уже stable
usort($users, static fn (User $a, User $b): int => $a->age <=> $b->age);

// Legacy-trick для PHP < 8.0: добавить индекс как tiebreaker
$indexed = array_map(
    static fn (int $i, User $u): array => ['idx' => $i, 'user' => $u],
    array_keys($users),
    $users,
);
usort($indexed, static fn (array $a, array $b): int =>
    $a['user']->age <=> $b['user']->age
        ?: $a['idx'] <=> $b['idx']
);
$users = array_column($indexed, 'user');

func countingSort(nums []int, maxVal int) []int {
    count := make([]int, maxVal+1)
    for _, v := range nums {
        count[v]++
    }
    out := make([]int, 0, len(nums))
    for v, c := range count {
        for ; c > 0; c-- {
            out = append(out, v)
        }
    }
    return out
}

<?php
declare(strict_types=1);

/**
 * @param array<int> $nums
 * @return array<int>
 */
function countingSort(array $nums, int $maxVal): array
{
    $count = array_fill(0, $maxVal + 1, 0);
    foreach ($nums as $v) {
        $count[$v]++;
    }

    $out = [];
    foreach ($count as $value => $cnt) {
        for ($i = 0; $i < $cnt; $i++) {
            $out[] = $value;
        }
    }
    return $out;
}

import "slices"

nums := []int{3, 1, 4, 1, 5}
slices.Sort(nums)                  // сортировка
slices.SortStableFunc(nums, cmp.Compare) // стабильная с компаратором
slices.SortFunc(nums, cmp.Compare) // нестабильная с компаратором
slices.Contains(nums, 4)           // O(n) поиск
slices.Index(nums, 4)              // индекс или -1
slices.Min(nums)                   // минимум
slices.Max(nums)                   // максимум
slices.BinarySearch(nums, 4)       // O(log n) на отсортированном

Новый API быстрее старого sort за счёт generics - нет reflection. Используй slices в новом коде, sort - только для совместимости с sort.Interface библиотек.

В PHP набор аналогичных функций давно встроен в ядро:

<?php
declare(strict_types=1);

$nums = [3, 1, 4, 1, 5];

sort($nums);                                  // [1, 1, 3, 4, 5] - in-place
$copy = $nums; sort($copy);                   // сортировка копии

usort($nums, fn($a, $b) => $a <=> $b);        // с компаратором (stable с PHP 8.0)

in_array(4, $nums, strict: true);             // O(n) поиск
$idx = array_search(4, $nums, strict: true);  // O(n), индекс или false
min($nums);                                    // минимум
max($nums);                                    // максимум

// asort/ksort/uasort/uksort - вариации с сохранением ключей
asort($users);   // сортирует значения, сохраняет ключи
ksort($users);   // сортирует по ключам

// БАГ: возвращает по убыванию, хотя задумано по возрастанию
sort.Slice(nums, func(i, j int) bool {
    return nums[i] > nums[j] // > вместо <
})

<?php
declare(strict_types=1);

// PHP-аналог: путаница в знаке spaceship-оператора
// БАГ: $b - $a сортирует по убыванию вместо возрастания
usort($nums, static fn (int $a, int $b): int => $b <=> $a); // DESC, не ASC

// Правильно - $a <=> $b для возрастания:
usort($nums, static fn (int $a, int $b): int => $a <=> $b);

nums := []float64{1.0, math.NaN(), 2.0}
sort.Float64s(nums) // NaN портит порядок

<?php
declare(strict_types=1);

// PHP - то же поведение: NAN не сравнивается ни с чем.
$nums = [1.0, NAN, 2.0];
sort($nums); // порядок NAN не определён, нарушает сортировку

// Фильтрация NAN до сортировки:
$nums = array_values(array_filter($nums, static fn (float $v): bool => !is_nan($v)));
sort($nums);

// Или кастомный компаратор - NAN в конец:
usort($nums, static function (float $a, float $b): int {
    if (is_nan($a)) return 1;
    if (is_nan($b)) return -1;
    return $a <=> $b;
});

idx, found := slices.BinarySearch([]int{3, 1, 4, 1, 5}, 4)
// found может быть false, даже если 4 есть в слайсе

<?php
declare(strict_types=1);

// PHP-эквивалент: ручной binarySearch без проверки сортировки в рантайме
$nums = [3, 1, 4, 1, 5]; // НЕ отсортирован
$idx = binarySearch($nums, 4); // вернёт -1 или неверный индекс

// Защитный паттерн: assertion в DEBUG, sort в production:
assert($nums === array_values(array_unique($nums)) && $nums === [...$nums]);

// Или forsorted-обёртка, гарантирующая контракт:
final class SortedIntArray
{
    public function __construct(private readonly array $items)
    {
        $copy = $items;
        sort($copy);
        if ($items !== $copy) {
            throw new \InvalidArgumentException('Input must be sorted');
        }
    }
}