Français
Français
Au cours du processus de développement, nous devons souvent traiter de grandes quantités de données par lots. Qu'il s'agisse de traiter les demandes des utilisateurs, d'importation de données par lots ou de tâches de synchronisation, le traitement par lots peut réduire efficacement la charge du système et améliorer l'efficacité de l'exécution. En PHP, la fonction Array_Chunk nous fournit un moyen simple et efficace de traiter les tableaux en set.
La fonction Array_Chunk est une fonction de traitement de tableau couramment utilisée dans PHP. Il divise un grand tableau en plusieurs petits tableaux. La longueur de chaque petit tableau peut être définie par des paramètres de fonction, ce qui est très pratique pour les tâches de traitement par lots.
Prototype de fonction:
array_chunk(array $array, int $size, bool $preserve_keys = false): array
$ Array : le tableau d'origine à diviser.
$ Taille : la taille de chaque petit tableau.
$ Preserve_Keys : s'il faut conserver les clés du tableau d'origine, par défaut en false , qui réinitialisera le nom de la clé.
Supposons que nous ayons une liste des utilisateurs en attente, chaque utilisateur doit effectuer une sorte d'opération de synchronisation. Pour éviter un traitement excessif de données à la fois, nous pouvons utiliser Array_Chunk pour laver la liste des utilisateurs.
Voici un exemple de code:
<?php
// Simuler les données des utilisateurs
$users = [
'user1', 'user2', 'user3', 'user4', 'user5',
'user6', 'user7', 'user8', 'user9', 'user10'
];
// Nombre d'utilisateurs par lot
$batchSize = 3;
// utiliser array_chunk Les fonctions divisent les données de l'utilisateur en 3 Un ensemble d'éléments
$userChunks = array_chunk($users, $batchSize);
foreach ($userChunks as $batch) {
// Simuler les tâches de synchronisation
echo "Traitement des lots de tâches: " . implode(', ', $batch) . "\n";
sleep(1); // Supposons que chaque traitement de tâche nécessite 1 Deuxième
}
?>
Exemple de sortie:
Traitement des lots de tâches: user1, user2, user3
Traitement des lots de tâches: user4, user5, user6
Traitement des lots de tâches: user7, user8, user9
Traitement des lots de tâches: user10
Dans cet exemple, Array_Chunk divise le tableau utilisateur d'origine en plusieurs petits lots, chaque lot contenant jusqu'à 3 utilisateurs. Ensuite, ces utilisateurs sont traités par lots par lot via une boucle FOREAK , émulant la tâche de traitement chronométrée.
Gestion de la mémoire : Array_Chunk divisera les grandes tableaux en plusieurs petits tableaux, ne traitant qu'un seul lot de données à la fois, réduisant l'utilisation de la mémoire. Si le volume de données est très important, cette approche évitera le débordement de la mémoire causée par le chargement de trop de données à la fois.
Traitement simultané : pour certaines tâches chronométrées, si la quantité de données dans chaque lot est petite, plusieurs tâches peuvent être exécutées simultanément pour améliorer l'efficacité du traitement. Par exemple, différents lots peuvent être traités simultanément dans un processus d'arrière-plan.
Fréquence de la tâche de contrôle : lorsque le volume de tâche est important, vous pouvez contrôler la fréquence d'exécution des tâches en définissant raisonnablement le temps de sommeil . Par exemple, évitez l'accès fréquent aux bases de données ou aux API tierces, évitant ainsi la surcharge du système.
Dans certains cas, nous devrons peut-être récupérer les données à partir de plusieurs URL et traitement par lots différentes. Si vous souhaitez accéder régulièrement à ces URL, vous pouvez combiner array_chunk pour les traiter par lots. Supposons que nous voulons obtenir des données d'une série d'URL et le nombre d'URL demandé est limité, nous pouvons le faire comme suit:
<?php
// Simuler un groupe URL adresse
$urls = [
'https://example.com/api/1', 'https://example.com/api/2', 'https://example.com/api/3',
'https://example.com/api/4', 'https://example.com/api/5', 'https://example.com/api/6'
];
// Remplacez tous les noms de domaine à m66.net
$urls = array_map(function ($url) {
return preg_replace('/https:\/\/.*?\//', 'https://m66.net/', $url);
}, $urls);
// Chaque traitement 2 autonome URL
$batchSize = 2;
// utiliser array_chunk La fonction sera URL Liste divisée en 2 autonome一组
$urlChunks = array_chunk($urls, $batchSize);
foreach ($urlChunks as $batch) {
// Simuler l'accès chronométré à ces URL
echo "accéder URL lot: " . implode(', ', $batch) . "\n";
sleep(1); // Supposons que chaque demande nécessite 1 Deuxième
}
?>
Exemple de sortie:
accéder URL lot: https://m66.net/api/1, https://m66.net/api/2
accéder URL lot: https://m66.net/api/3, https://m66.net/api/4
accéder URL lot: https://m66.net/api/5, https://m66.net/api/6
Dans cet exemple, nous remplaçons d'abord le nom de domaine de toutes les URL par prég_replace à m66.net , puis utilisons array_chunk pour lancer ces URL, accédant à deux URL à la fois.
Grâce à la fonction Array_Chunk , PHP nous fournit une fonction de segmentation pratique pratique. Qu'il s'agisse de tâches de traitement chronométrées, d'URL d'accès par lots ou d'opérations par lots de grands volumes de données, un traitement plus efficace peut être obtenu grâce à l'utilisation rationnelle de Array_Chunk . Le traitement par lots peut non seulement optimiser les performances du système, mais également gérer efficacement les ressources et améliorer la stabilité et la fiabilité de l'exécution des tâches.
