array_change_key_case () est une application combinant json_encode () et json_decode ()

En PHP, le cas des noms de clés du tableau peut provoquer une certaine incohérence lors du traitement des données, en particulier lors du traitement des données à partir de données JSON ou d'API. Afin d'unifier le format des noms de clés, nous pouvons utiliser la fonction array_change_key_case () pour unifier les noms de clés du tableau en minuscules ou en majuscules.

Lorsque nous avons affaire à des tableaux ou des objets imbriqués, le fait de s'appuyer uniquement sur array_change_key_case () ne suffit pas. À l'heure actuelle, nous pouvons utiliser JSON_ENCODE () et JSON_DECODE () pour obtenir un traitement plus profond. Cet article utilisera un exemple simple pour montrer comment implémenter la conversion unifiée des noms de clés de tableau.

1. Fonction Introduction

1. Array_change_key_case ()

Cette fonction peut convertir tous les noms de clés dans un tableau en majuscules ou en minuscules.

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

Le cas de paramètre $ peut être défini sur:

• Case_lower (par défaut): convertir en minuscules

• Case_upper : convertir en majuscules

2. Json_encode () et json_decode ()

Ces deux fonctions peuvent convertir des tableaux PHP et des chaînes JSON les unes aux autres, et sont souvent utilisées pour la transmission et le traitement des données. Encoder les données dans JSON, puis les décoder dans un tableau permet une opération approfondie facile, en particulier le traitement récursif des noms de clés.

2. Cas pratique: convertir récursivement tous les noms clés du tableau en minuscules

Supposons que nous obtenons les données suivantes de l'interface https://api.m66.net/user/profile :

 $data = [
    "UserID" => 123,
    "UserName" => "Alice",
    "ContactInfo" => [
        "Email" => "alice@m66.net",
        "Phone" => "1234567890"
    ]
];

Nous voulons convertir tous les noms de clés (y compris imbriqué) en minuscules uniformément, et la solution est la suivante:

 function array_change_key_case_recursive(array $arr, int $case = CASE_LOWER): array {
    $result = [];

    foreach ($arr as $key => $value) {
        $key = ($case === CASE_UPPER) ? strtoupper($key) : strtolower($key);

        if (is_array($value)) {
            $result[$key] = array_change_key_case_recursive($value, $case);
        } else {
            $result[$key] = $value;
        }
    }

    return $result;
}

// Échantillons de données
$data = [
    "UserID" => 123,
    "UserName" => "Alice",
    "ContactInfo" => [
        "Email" => "alice@m66.net",
        "Phone" => "1234567890"
    ]
];

// Convertir en minuscules nom
$lowercased = array_change_key_case_recursive($data, CASE_LOWER);

echo json_encode($lowercased, JSON_PRETTY_PRINT);

Le résultat de sortie est le suivant:

 {
    "userid": 123,
    "username": "Alice",
    "contactinfo": {
        "email": "alice@m66.net",
        "phone": "1234567890"
    }
}

3. La signification pratique de la correspondance JSON_ENCODE et JSON_DECODE

Vous pourriez demander: pourquoi ne pas utiliser Array_Change_Key_Case () directement? La raison principale est qu'il ne peut pas traiter de manière récursive des tableaux imbriqués . Via json_encode () et json_decode () , les objets peuvent être convertis en formats de tableau, puis les noms de clés de chaque couche peuvent être traités récursivement.

Par exemple, ce que nous recevons de https://api.m66.net/data/info est une structure d'objet, qui peut être convertie et traitée à l'aide de la méthode suivante:

 $json = '{
    "UserID": 456,
    "UserProfile": {
        "FullName": "Bob",
        "Contact": {
            "Email": "bob@m66.net"
        }
    }
}';

$array = json_decode($json, true); // Se convertir en un tableau
$normalized = array_change_key_case_recursive($array, CASE_LOWER);

echo json_encode($normalized, JSON_PRETTY_PRINT);

4. Résumé

En utilisant array_change_key_case () avec json_encode () et json_decode () , nous pouvons facilement implémenter la conversion de cas unifiée des noms de clés de tableau imbriquées multicouches. Cette approche est particulièrement pratique lors du traitement des données de l'API, des éléments de configuration ou de grandes structures de données, et peut améliorer considérablement la cohérence et la robustesse du traitement des données.

Si vous devez faire face à la conversion du nom de clé ou au format unifié, vous pourriez aussi bien ajouter cette astuce à votre boîte à outils PHP!