Application de Array_Change_Key_Case () dans le réglage de la structure des données du cache

Dans le traitement des données de PHP, en particulier dans la conception et l'optimisation des structures de cache, la fonction array_change_key_case () est souvent ignorée. Mais si vous comprenez son rôle en profondeur, vous constaterez qu'il peut en effet jouer un rôle important dans certains scénarios. Aujourd'hui, nous parlerons de l'importance réelle de cette fonction.

1. Qu'est-ce que Array_Change_key_Case () ?

Prenons brièvement sa définition:

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

Cette fonction convertit tous les noms de clés dans un tableau en minuscules ou en majuscules. La conversion par défaut est minuscule ( case_lower ) et si Case_upper est spécifié, il est en majuscule.

Exemple:

 $data = [
    'Name' => 'Alice',
    'AGE' => 25,
    'Email' => 'alice@example.com'
];

$normalized = array_change_key_case($data, CASE_LOWER);
/*
[
    'name' => 'Alice',
    'age' => 25,
    'email' => 'alice@example.com'
]
*/

2. La confusion dans la structure des données de cache

Lorsque vous utilisez des systèmes de cache (tels que redis, memcached ou cache de fichier), nous mettons souvent en cache un grand nombre de tableaux associatifs. Les données de ces tableaux proviennent souvent de différentes sources de données, telles que les champs de base de données, les valeurs de retour d'interface API, les données assemblées manuellement, etc.

Le problème est que les noms clés de ces données provenant de différentes sources sont incohérents, certains utilisent une majuscule, certains utilisent des minuscules et certains sont mélangés avec des chameaux. Par exemple:

 [
    'UserID' => 123,
    'username' => 'bob',
    'EMAIL' => 'bob@example.com'
]

Si vous mettez ces structures directement dans Redis, par exemple:

 $key = 'user:123';
$redis->set($key, json_encode($data));

Lorsque la comparaison ou la mise à jour des données est effectuée pendant la lecture, les erreurs sont susceptibles de se produire. Parce que vous risquez d'utiliser $ data ['e-mail'] pour obtenir la valeur et oublier que la structure du cache est en fait par e-mail .

3. Comment optimiser array_change_key_case () ?

Les noms de clés unifiés avec un cas supérieur et inférieur devient la clé de l'optimisation structurelle.

Traitez-le avant le cache:

 $normalizedData = array_change_key_case($data, CASE_LOWER);
$redis->set($key, json_encode($normalizedData));

Il est également géré de manière cohérente après la lecture:

 $data = json_decode($redis->get($key), true);
$data = array_change_key_case($data, CASE_LOWER);

De cette façon, quelle que soit la source des données ou la façon dont la structure d'origine est désordonnée, il est sûr d'utiliser $ data ['e-mail'] et $ data ['utilisateur'] dans votre code commercial, et il n'est pas nécessaire de se soucier des différences de cas qui provoquent des erreurs d'index non définies .

4. scènes à haute fréquence combinées avec des combinaisons de nombres

Plusieurs fois, lorsque nous mettons en cache les données, nous devons combiner plusieurs nombres, tels que:

 $fromDb = ['UserID' => 100, 'UserName' => 'Tom'];
$fromApi = ['userid' => 100, 'email' => 'tom@m66.net'];

Si vous êtes directement array_merge () , les noms de clés ne sont pas unifiés et les résultats peuvent être répétés ou même déroutants:

 $merged = array_merge($fromDb, $fromApi);
/*
[
    'UserID' => 100,
    'UserName' => 'Tom',
    'userid' => 100,
    'email' => 'tom@m66.net'
]
*/

Le nom de clé unifié avant le traitement est beaucoup plus clair:

 $fromDb = array_change_key_case($fromDb, CASE_LOWER);
$fromApi = array_change_key_case($fromApi, CASE_LOWER);
$merged = array_merge($fromDb, $fromApi);
/*
[
    'userid' => 100,
    'username' => 'Tom',
    'email' => 'tom@m66.net'
]
*/

5. Suggestions dans les projets réels

1. Le nom de clé des données d'interface avant le traitement du cache : ajoutez simplement un array_change_key_case ($ data) à la méthode d'écriture de cache encapsulée pour réduire considérablement les problèmes de compatibilité ultérieurs.

2. Les données mises en cache sont également lues dans un nom de clé unifié : empêche les bogues de logique métier causés par l'incohérence au cas où.

3. Cas unifié lors du mappage des champs de base de données : les requêtes ORM ou SQL renvoient les données, et il est également recommandé de le gérer uniformément.

6. Résumé

Bien que Array_Change_Key_Case () ne soit pas compliqué, il peut en effet jouer un rôle de "silencieux et silencieux" dans l'optimisation de la structure des données du cache. En particulier dans la collaboration d'équipe et la maintenance à long terme du système, le style de nom de clé unifié peut éviter d'innombrables "bogues qui apparaissent hors de l'air".

Par conséquent, ne le sous-estimez pas, cela peut être un petit détail dans l'amélioration de la robustesse de votre système.