Comment éviter la traversée répétée des tableaux lors de l'utilisation de Array_Column via la stratégie de cache?

M66 2025-05-11

Dans PHP, la fonction Array_Column est souvent utilisée pour extraire les données d'une colonne d'un tableau multidimensionnel. Cependant, dans certains cas, l'utilisation de Array_Column peut provoquer des problèmes de performances, en particulier lorsque des opérations fréquentes sur de grandes tableaux sont nécessaires. La clé de ce problème est que Array_Column traversera le tableau d'origine plusieurs fois. Si nous ne mettons pas en cache les résultats, cela peut entraîner des traversées répétées et une consommation de performances inutile. Cet article explorera comment éviter la traversée répétée des tableaux lors de l'utilisation de Array_Column via des politiques de cache, améliorant ainsi les performances.

La racine du problème: traversée répétée

Considérez l'exemple de code suivant:

 $array = [
    ['id' => 1, 'name' => 'Alice', 'age' => 25],
    ['id' => 2, 'name' => 'Bob', 'age' => 30],
    ['id' => 3, 'name' => 'Charlie', 'age' => 35]
];

$names = array_column($array, 'name');

Dans cet exemple, Array_Column iratera le tableau $ array une fois et extraire la colonne de nom dans chaque sous-réseau. Bien que cette opération elle-même ne soit pas particulièrement coûteuse, si vous avez besoin d'extraire différentes colonnes plusieurs fois ou d'utiliser Array_Column à plusieurs reprises dans un grand tableau, il provoquera des traversées répétées inutiles, ce qui affectera les performances.

Solution: utilisez du cache pour éviter les traversées répétées

Pour éviter la traversée répétée du tableau, nous pouvons stocker le résultat dans le cache lorsqu'une colonne est extraite la première fois. La prochaine fois que la même colonne sera nécessaire, elle est lue directement à partir du cache sans appeler Array_Column .

En utilisant des tableaux de cache simples

Le moyen le plus simple de cache est d'utiliser un tableau pour enregistrer les colonnes déjà extraites. Par exemple:

 // Initialiser le tableau de cache
$cache = [];

function getColumnFromCache($array, $column, &$cache) {
    // Vérifiez si la colonne est déjà dans le cache
    if (!isset($cache[$column])) {
        // Si la colonne n&#39;est pas dans le cache，utiliser array_column Obtenir des données，Et mettre en cache les résultats
        $cache[$column] = array_column($array, $column);
    }
    return $cache[$column];
}

$array = [
    ['id' => 1, 'name' => 'Alice', 'age' => 25],
    ['id' => 2, 'name' => 'Bob', 'age' => 30],
    ['id' => 3, 'name' => 'Charlie', 'age' => 35]
];

// Get de cache 'name' Liste
$names = getColumnFromCache($array, 'name', $cache);
print_r($names);

// 再次Get de cache 'name' Liste，Évitez les traversées répétées
$namesAgain = getColumnFromCache($array, 'name', $cache);
print_r($namesAgain);

Dans cet exemple, la fonction GetColumnFromCache vérifie d'abord si les données d'une certaine colonne ont été stockées dans le tableau de cache $ . Si les données ont été mises en cache, le résultat mis en cache sera retourné directement; Sinon, le Array_Column est appelé pour obtenir les données de la colonne et les stocker dans le cache.

Utilisez des schémas de mise en cache plus complexes (comme Redis ou Memcached)

Si votre application est grande et doit extraire fréquemment les mêmes colonnes de données à partir de plusieurs demandes, envisagez d'utiliser des schémas de mise en cache plus efficaces tels que redis ou memcached.

Par exemple, le code qui utilise Redis pour mettre en cache les données de la colonne peut être comme ceci:

 $redis = new Redis();
$redis->connect('127.0.0.1', 6379);

function getColumnFromRedis($array, $column, $redis) {
    // examiner Redis 中是否已缓存该Liste
    $cachedColumn = $redis->get($column);
    if ($cachedColumn === false) {
        // si Redis 中没有缓存该Liste，utiliser array_column Obtenir des données
        $cachedColumn = json_encode(array_column($array, $column));
        // Enregistrer le résultat Redis
        $redis->set($column, $cachedColumn);
    }
    return json_decode($cachedColumn, true);
}

// Échantillons de données
$array = [
    ['id' => 1, 'name' => 'Alice', 'age' => 25],
    ['id' => 2, 'name' => 'Bob', 'age' => 30],
    ['id' => 3, 'name' => 'Charlie', 'age' => 35]
];

// Obtenir 'name' Liste
$names = getColumnFromRedis($array, 'name', $redis);
print_r($names);

Cette façon de mettre en cache les données de colonne via Redis peut réduire considérablement les opérations répétées sur les mêmes données, en particulier pour les scénarios d'accès fréquents.

en conclusion

En utilisant une politique de mise en cache, plusieurs traversées des mêmes données lors de l'utilisation de Array_Column peuvent être évitées efficacement, améliorant ainsi les performances. Pour les petites applications, il suffit d'utiliser un cache de mémoire simple (tel que des tableaux); Pour les grandes applications, des systèmes de cache tels que Redis ou Memcached peuvent être utilisés pour améliorer davantage les performances et l'évolutivité. Le choix du bon schéma de mise en cache peut optimiser considérablement l'efficacité du programme, en particulier lors du traitement de grandes quantités de données.

array_column

Connexe