Dans le développement de PHP, Array_Slice est une fonction de fonctionnement de tableau très courante utilisée pour intercepter les fragments d'une longueur spécifiée à partir d'un tableau. Son utilisation de base est simple et claire, mais face à des tableaux super grands, les développeurs se soucient souvent de son utilisation de la mémoire, en particulier si cela entraînera une forte augmentation de l'utilisation de la mémoire, ce qui affectera les performances du programme et la stabilité.
Cet article analysera le mécanisme d'utilisation de la mémoire de la fonction Array_Slice en profondeur et le combinera avec des exemples de code pour aider tout le monde à comprendre les performances de la fonction lors du traitement des tableaux super grands et donne des suggestions d'optimisation.
array_slice (array $ array, int $ offset ,? int $ length = null, bool $ preserve_keys = false): array
$ Array : Entrez le tableau
$ offset : position de départ
$ Longueur : Intercepter la longueur (facultative)
$ Preserve_keys : s'il faut conserver le nom de la clé du tableau d'origine, il n'est pas conservé par défaut (les noms de clés seront réindexés)
Array_slice renverra un fragment du tableau d'entrée, et la fonction elle-même copiera cette partie des données dans un nouveau tableau à retourner.
Lorsque la taille du tableau est petite, l'empreinte mémoire de l'array_slice n'attire généralement pas l'attention. Cependant, face à une énorme gamme de millions, voire des dizaines de millions d'éléments, la surcharge de mémoire de Array_Slice est digne de vigilance.
Array_slice ne fait pas référence ou intercepte le tableau d'origine en place, mais copiera la pièce de tableau correspondante pour générer un tout nouveau tableau. Cela signifie:
Si le tableau d'origine prend la mémoire comme x,
Extractions de longueur y,
Le nouveau tableau renvoyé consommera également environ la même mémoire que la taille Y.
Donc, si le fragment intercepté est important, l'utilisation de la mémoire doublera ou même plus (plus le tableau d'origine).
<?php
// Simuler des tableaux super grands
$largeArray = range(1, 10_000_000);
// Retirer un million de données au milieu du tableau
$startTime = microtime(true);
$slice = array_slice($largeArray, 4_000_000, 1_000_000);
$endTime = microtime(true);
echo "Interception longue:" . ($endTime - $startTime) . "Deuxième\n";
echo "Mémoire de tableau d'origine:" . (memory_get_usage() / 1024 / 1024) . " MB\n";
// Accéder aux résultats d'interception partiel
echo "Trancher le premier élément:" . $slice[0] . "\n";
?>
Lorsque vous exécutez ce code, vous verrez:
La mémoire occupée par le script augmente considérablement (tableau d'origine + tableau de tranche)
Le temps d'exécution du programme a augmenté de manière significative par rapport aux opérations de petites réseaux ordinaires.
Array_slice entraîne une augmentation significative de l'utilisation de la mémoire lorsqu'il s'agit de tableaux super grands car il copie les données de tableau correspondantes.
Si les données du tableau proviennent d'un fichier ou d'une base de données, envisagez de les lire étape par étape ou à l'aide d'un générateur pour traiter les données selon les besoins pour éviter de charger toutes les données à la fois.
Si seule une petite partie des données est nécessaire, les petits fragments interceptés par Array_Slice prennent moins de mémoire et ont un impact limité.
L'interface itératrice de PHP (comme Limiterator ) peut obtenir des effets de type interception similaires sans copier le tableau.
Exemple:
<?php
$array = new ArrayIterator(range(1, 10_000_000));
$iterator = new LimitIterator($array, 4_000_000, 1_000_000);
foreach ($iterator as $value) {
// traiter avec$value
}
?>
Cela évite de copier des tableaux et enregistre la mémoire.
Si vous devez utiliser Array_Slice pour gérer les grandes tableaux, assurez-vous que la mémoire de la limite de mémoire de PHP est suffisamment grande pour éviter la terminaison anormale du programme.
La fonction Array_Slice copie des fragments de tableau lors du traitement des tableaux super grands, ce qui entraînera une augmentation significative de l'utilisation de la mémoire. Si vous faites face à des baisses de dizaines de millions, il est recommandé d'envisager d'utiliser des itérateurs ou de lire la lecture pour éviter les goulots d'étranglement de la mémoire et améliorer les performances et la stabilité du programme.
Pour plus de compétences PHP, veuillez visiter https://gitbox.net/php-tips pour les derniers tutoriels et expérience pratique.
Étiquettes associées:
array_slice