Français
Français
En PHP, la conversion de cas des noms de clés est une exigence commune. Surtout lors du traitement de l'entrée des utilisateurs ou des données externes, le cas peut être incohérent et un format unifié est requis. Les pratiques communes incluent l'utilisation de la fonction array_change_key_case () , ou traverser manuellement le tableau et modifier le cas des noms de clés un par un. Cet article comparera les performances de ces deux méthodes pour aider les développeurs à faire des choix plus appropriés.
La fonction intégrée Array_Change_Key_Case () est utilisée pour modifier le cas de tous les noms de clés dans un tableau. Cette fonction accepte deux paramètres:
Le premier paramètre est le tableau sur lequel fonctionner.
Le deuxième paramètre est un indicateur facultatif qui spécifie de convertir le nom de la clé en majuscules ou en minuscules. Par défaut, les noms de clés sont convertis en minuscules.
Le prototype de fonction est le suivant:
array array_change_key_case ( array $array , int $case = CASE_LOWER )
Si le paramètre de cas $ est défini sur case_upper , le nom de la clé sera converti en majuscule. Sinon, la valeur par défaut est convertie en minuscules.
$array = ['FirstName' => 'John', 'LastName' => 'Doe'];
$lowercaseArray = array_change_key_case($array, CASE_LOWER);
print_r($lowercaseArray);
Sortir:
Array
(
[firstname] => John
[lastname] => Doe
)
Une autre façon d'implémenter la conversion de cas de nom de clé consiste à traverser manuellement le tableau et à modifier le cas des noms de clés un par un. Cette méthode nécessite d'utiliser des structures telles que array_map () ou foreach pour parcourir chaque élément de tableau et ajuster manuellement son nom de clé.
$array = ['FirstName' => 'John', 'LastName' => 'Doe'];
foreach ($array as $key => $value) {
$newKey = strtolower($key); // ou strtoupper($key) Convertir la capitalisation
$newArray[$newKey] = $value;
}
print_r($newArray);
Sortir:
Array
(
[firstname] => John
[lastname] => Doe
)
Pour comparer l'efficacité de ces deux méthodes, nous pouvons utiliser la fonction MicroTime () de PHP pour enregistrer le temps d'exécution de chaque méthode. Voici le code de test de performances simples:
// Préparer un plus grand tableau
$array = [];
for ($i = 0; $i < 100000; $i++) {
$array['Key' . $i] = 'Value' . $i;
}
// test array_change_key_case()
$startTime = microtime(true);
array_change_key_case($array, CASE_LOWER);
$endTime = microtime(true);
echo "array_change_key_case() Temps d'exécution: " . ($endTime - $startTime) . " Deuxième\n";
// testTraversée manuelle
$startTime = microtime(true);
$newArray = [];
foreach ($array as $key => $value) {
$newKey = strtolower($key); // Tourner en minuscules
$newArray[$newKey] = $value;
}
$endTime = microtime(true);
echo "Traversée manuelle Temps d'exécution: " . ($endTime - $startTime) . " Deuxième\n";
Avantages de array_change_key_case () :
Le code est concis et facile à comprendre.
Pour les réseaux plus petits, il y a peu ou pas de problème avec les performances.
L'efficacité d'exécution des fonctions intégrées est généralement meilleure que la traversée manuelle, en particulier lorsque le tableau est grand.
Avantages de la traversée manuelle :
Dans certains cas particuliers, une plus grande flexibilité peut être fournie. Par exemple, vous devrez peut-être effectuer d'autres opérations complexes sur les noms de clés lors de la conversion de cas.
Vous pouvez contrôler avec précision la méthode de conversion des noms de clés (comme la conversion partielle des noms de clés en fonction de certaines règles).
Pour la plupart des scénarios normaux, array_change_key_case () est un choix plus simple et plus efficace. Son implémentation interne est optimisée et s'exécute généralement plus rapidement que la traversée manuelle, en particulier lorsqu'il s'agit de grands tableaux. Cependant, dans des scénarios spéciaux où les noms de clés doivent être gérés de manière plus flexible, la traversée manuelle est également un bon choix.
Si nous le considérons uniquement du point de vue des performances, array_change_key_case () est sans aucun doute une solution plus rapide, en particulier en ce qui concerne les opérations de données à grande échelle. Pour certaines tâches simples, éviter les opérations de traversée inutiles, l'utilisation de fonctions intégrées est généralement plus efficace.
