m := make(map[string]int)
// внутри: hmap.B = 0 → 1 бакет
// при добавлении ~8 элементов B становится 1 → 2 бакета
// и так далее

<?php
declare(strict_types=1);

// PHP не даёт API для подсказки начальной capacity у обычного array.
// На больших данных снижение реаллокаций даёт \SplFixedArray или \Ds\Map:
$m = new \Ds\Map();
$m->allocate(10000); // зарезервировать capacity заранее
for ($i = 0; $i < 10000; $i++) {
    $m->put('user:' . $i, $i);
}
// Без allocate() Zend ресайзил бы HashTable несколько раз (степенями двойки).

m := make(map[string]int)

// fatal error: concurrent map writes
go func() { m["a"] = 1 }()
go func() { m["b"] = 2 }()

Это не panic, а fatal error: программа падает целиком, без шанса восстановиться через recover. Runtime специально включает детектор гонок на map в release-сборках.

<?php
declare(strict_types=1);

// Внутри одного запроса PHP однопоточен - конкуренции нет
$m = [];
$m['a'] = 1;
$m['b'] = 2;

// Кросс-запросное хранилище - APCu (local) или Redis (shared)
apcu_store('users:count', 42);
$count = apcu_fetch('users:count');
// Или через Symfony Cache:
// $cache->get('users:count', fn () => loadFromDb());

В классическом PHP-FPM этой проблемы нет: каждый запрос - изолированный процесс, shared memory отсутствует. Если нужно «общее» хранилище между запросами - используют APCu (in-memory, per-машина) или Redis (распределённое).

keys := make([]string, 0, len(m))
for k := range m {
    keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
    fmt.Println(k, m[k])
}

<?php
declare(strict_types=1);

// PHP-эквивалент: array_keys + сортировка ключей
$keys = array_keys($m);
sort($keys);
foreach ($keys as $k) {
    echo $k . ' => ' . $m[$k] . "\n";
}

// Или короче - ksort напрямую сортирует array по ключам in-place:
ksort($m);
foreach ($m as $k => $v) {
    echo $k . ' => ' . $v . "\n";
}

type SafeMap struct {
    mu sync.RWMutex
    m  map[string]int
}

func (s *SafeMap) Get(k string) (int, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.m[k]
    return v, ok
}

func (s *SafeMap) Set(k string, v int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[k] = v
}

Простой, предсказуемый, работает на любых типах. Но при write-heavy нагрузке писатели блокируют всех читателей.

В PHP-FPM аналог sync.RWMutex не нужен внутри одного запроса (нет конкуренции). Для shared state между процессами/инстансами используют symfony/lock:

<?php
declare(strict_types=1);

use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Lock\Store\RedisStore;

final class SafeCounter
{
    public function __construct(
        private readonly \Redis $redis,
        private readonly LockFactory $lockFactory,
    ) {}

    public function increment(string $key): int
    {
        $lock = $this->lockFactory->createLock($key, ttl: 5.0);
        $lock->acquire(blocking: true);
        try {
            $current = (int) $this->redis->get($key);
            $this->redis->set($key, $current + 1);
            return $current + 1;
        } finally {
            $lock->release();
        }
    }
}

type Set map[string]struct{}

func NewSet() Set {
    return make(Set)
}

func (s Set) Add(key string) {
    s[key] = struct{}{}
}

func (s Set) Has(key string) bool {
    _, ok := s[key]
    return ok
}

func (s Set) Remove(key string) {
    delete(s, key)
}

struct{} занимает 0 байт - идеально для множеств. Альтернатива map[string]bool тратит лишний байт на значение.

<?php
declare(strict_types=1);

// Set через массив с null-значениями: ключ - элемент, значение игнорируем
$set = [];
$set['alice'] = true;
$set['bob'] = true;
isset($set['alice']); // true - O(1)
unset($set['alice']);

// SplObjectStorage - set для объектов (по identity, не по equals)
$users = new \SplObjectStorage();
$users->attach($userA);
$users->contains($userA); // true

// ext-ds: \Ds\Set - быстрый value-set
$tags = new \Ds\Set(['php', 'go', 'algorithms']);
$tags->add('php'); // no-op, уже есть
$tags->contains('go'); // true

// ПЛОХО: начинаем с маленького map, постоянные эвакуации
m := make(map[string]int, 0)

// ХОРОШО: знаем примерный размер
m := make(map[string]int, 10000)

<?php
declare(strict_types=1);

// У обычного array нет hint'а размера - Zend ресайзит HashTable сам.
// Для критичных по производительности мест используют \Ds\Map с allocate():
$m = new \Ds\Map();
$m->allocate(10000); // capacity заранее, без промежуточных удвоений
for ($i = 0; $i < 10000; $i++) {
    $m->put('user:' . $i, $i);
}

// Для пар «int-ключ → int-значение» с known max size - SplFixedArray:
$counters = new \SplFixedArray(10000); // C-array, индексация 0..N-1
$counters[42] = 1;

type Point struct {
    X, Y int
}

visited := make(map[Point]bool)
visited[Point{1, 2}] = true

НЕ могут быть ключами: слайсы, map, функции, структуры с такими полями. Это compile-time ошибка.

<?php
declare(strict_types=1);

final readonly class Point
{
    public function __construct(public int $x, public int $y) {}
}

// В обычном массиве - сериализуем в строку:
$visited = [];
$key = $point->x . ',' . $point->y;
$visited[$key] = true;

// Или \Ds\Map с объектным ключом:
$visited = new \Ds\Map();
$visited->put(new Point(1, 2), true);
$visited->get(new Point(1, 2)); // работает, если есть __equals (или identity)

В PHP-массиве ключ - только int или string (всё остальное приводится). Объект или массив как ключ - ошибка. Если нужны произвольные ключи (объекты, массивы) - есть \Ds\Map или \SplObjectStorage.

var m = map[any]int{}
m[int32(1)] = 1
m[int64(1)] = 2
fmt.Println(m[int(1)]) // 0 - другой тип, другой ключ!

<?php
declare(strict_types=1);

// PHP-противоположность: ключ всегда приводится к int или string.
// int 1, float 1.0, string '1', bool true - все становятся ключом 1
$m = [];
$m[1] = 'int';
$m[1.0] = 'float';   // перезапишет $m[1]
$m['1'] = 'string';  // перезапишет $m[1]
$m[true] = 'bool';   // перезапишет $m[1]
// в итоге $m === [1 => 'bool']

// \Ds\Map уважает тип:
$ds = new \Ds\Map();
$ds->put(1, 'int');
$ds->put('1', 'string');
$ds->count(); // 2 - разные ключи

var m map[string]int
_ = m["x"]   // OK, вернёт нулевое значение
m["x"] = 1   // panic: assignment to entry in nil map

Всегда make перед записью.

<?php
declare(strict_types=1);

// В PHP нет «nil map» - неинициализированная переменная просто становится array
$m = null;
$m['x'] = 1; // TypeError в strict_types - попытка array-write по null

// Идиоматично - инициализировать пустым array:
$m = [];
$m['x'] = 1; // OK

// Чтение несуществующего ключа без isset() - E_WARNING и null:
$v = $m['nope']; // Undefined array key

// Безопасный паттерн:
$v = $m['nope'] ?? 0; // 0, без warning

for k := range m {
    if cond(k) {
        m[newKey()] = 0 // поведение не определено
    }
}

<?php
declare(strict_types=1);

// В PHP foreach работает над КОПИЕЙ массива (copy-on-write) - можно модифицировать,
// но изменения не видны в текущем цикле:
$m = ['a' => 1, 'b' => 2, 'c' => 3];
foreach ($m as $k => $v) {
    if ($v > 1) {
        $m['new_' . $k] = 0; // добавится в оригинал, но НЕ войдёт в текущий обход
    }
}

// Идиома - собрать изменения и применить после:
$additions = [];
foreach ($m as $k => $v) {
    if (cond($k)) {
        $additions['new_' . $k] = 0;
    }
}
$m = [...$m, ...$additions];

m := map[string]LargeStruct{}
v := m["x"]
v.Field = 1    // изменяет КОПИЮ, не значение в map!

// FIX: хранить указатели
m2 := map[string]*LargeStruct{}
m2["x"].Field = 1 // работает

<?php
declare(strict_types=1);

// В PHP объекты ВСЕГДА передаются по handle (что-то вроде указателя):
final class LargeData
{
    public int $field = 0;
}

$m = ['x' => new LargeData()];
$v = $m['x'];
$v->field = 1; // изменит тот же объект, что и в $m['x']

// А вот массивы в значении - copy-on-write, как и в Go-примере:
$m2 = ['x' => ['field' => 0]];
$v2 = $m2['x'];
$v2['field'] = 1;       // изменит копию
$m2['x']['field']; // 0

// Идиоматично - либо обернуть в class, либо модифицировать через ключ:
$m2['x']['field'] = 1; // работает напрямую