array_change_key_case() è una funzione PHP che cambia il “case” (maiuscole/minuscole) delle chiavi di un array. È utilissima quando ricevi array con chiavi incoerenti da DB, API o form (es. ProductId, PRODUCTID, productid).

Cos’è e cosa fa

• Converte tutte le chiavi stringa in:
  • minuscolo (CASE_LOWER, default)
  • maiuscolo (CASE_UPPER)
• Le chiavi numeriche restano invariate.
• Restituisce un nuovo array (non modifica l’originale).

Firma

array_change_key_case(array $array, int $case = CASE_LOWER): array

Esempio base

$input = [
  'Nome'    => 'Renato',
  'COGNOME' => 'Cantarella',
  'eMail'   => 'test@example.com',
  10        => 'dieci',
];

$lower = array_change_key_case($input, CASE_LOWER);
$upper = array_change_key_case($input, CASE_UPPER);

print_r($lower);
print_r($upper);

Nota: dopo la conversione, le chiavi stringa saranno tutte coerenti (tutte lower o tutte upper), mentre 10 rimane 10.

Attenzione: collisioni di chiavi (caso più importante)

Se dopo la conversione due chiavi diventano uguali, una sovrascrive l’altra (in pratica: l’ultima vince).

$a = [
  'ID' => 1,
  'id' => 2,
];

$out = array_change_key_case($a, CASE_LOWER);
// Risultato: ['id' => 2]

Versione “safe” per intercettare collisioni

Se vuoi accorgerti delle collisioni (utile in debug), usa una funzione che avvisa quando succede:

function array_change_key_case_safe(array $a, int $case = CASE_LOWER): array {
  $out  = [];
  $seen = [];

  foreach ($a as $k => $v) {
    // chiavi numeriche: invariate
    if (!is_string($k)) {
      $out[$k] = $v;
      continue;
    }

    $nk = ($case === CASE_UPPER) ? strtoupper($k) : strtolower($k);

    // se c'è già, segnalo collisione
    if (isset($seen[$nk])) {
      trigger_error("Collisione chiave: '$k' collide con '{$seen[$nk]}' -> '$nk'", E_USER_WARNING);
    } else {
      $seen[$nk] = $k;
    }

    $out[$nk] = $v;
  }

  return $out;
}

Quando usarla davvero (casi reali)

1) Normalizzare input da DB/API con chiavi “miste”

Scenario tipico: un array arriva con chiavi inconsistenti e tu vuoi leggere sempre le stesse chiavi senza impazzire.

$row = [
  'ProductId' => 123,
  'NAME'      => 'Guanti',
  'price'     => 19.99,
];

$row = array_change_key_case($row, CASE_LOWER);

$id    = $row['productid'] ?? null;
$name  = $row['name'] ?? '';
$price = $row['price'] ?? 0;

2) Header HTTP (case-insensitive)

Gli header HTTP non sono case-sensitive: convertirli tutti in lower rende più semplice recuperarli.

$headers = [
  'Content-Type'  => 'application/json',
  'Authorization' => 'Bearer xxx',
];

$h = array_change_key_case($headers, CASE_LOWER);

$auth = $h['authorization'] ?? null;

3) Uniformare dati prima di cache / JSON

Se salvi in cache o serializzi in JSON, uniformare le chiavi evita differenze inutili tra payload “equivalenti”.

Limiti e note

• Non è ricorsiva: converte solo le chiavi del primo livello.
• Converte solo le chiavi stringa, non quelle numeriche.
• Attenzione alle collisioni (es. ID e id).
• Con caratteri accentati/multibyte (es. À), il comportamento dipende dal contesto: in casi internazionali può servire una gestione custom.

Versione ricorsiva (anche nei sotto-array)

Se hai array annidati e vuoi normalizzare tutte le chiavi, puoi usare una versione ricorsiva:

function array_change_key_case_recursive(array $a, int $case = CASE_LOWER): array {
  $a = array_change_key_case($a, $case);

  foreach ($a as $k => $v) {
    if (is_array($v)) {
      $a[$k] = array_change_key_case_recursive($v, $case);
    }
  }

  return $a;
}

Cheat-sheet veloce

• Normalizza in minuscolo e usa sempre ??:
  
  $data = array_change_key_case($data, CASE_LOWER);

$val = $data['chiave'] ?? null;
• Occhio alle collisioni (ID vs id) → usa la safe in debug.
• Se hai array annidati → usa la ricorsiva.