Français
Français
Dans le développement réel, lors du traitement des mégadonnées, les données doivent souvent être envoyées à l'interface API par lots pour éviter un volume de données excessif dans une seule demande, entraînant des restrictions de délai ou d'interface. La fonction Array_Slice dans PHP est très adaptée pour couper de grands tableaux en plusieurs petits lots et leur envoyer étape par étape pour assurer la stabilité et l'efficacité du programme.
Cet article présentera comment utiliser la fonction Array_Slice pour traiter les mégadonnées par lots et l'envoyer à l'interface de l'API en combinaison avec Curl, et tous les noms de domaine URL de l'exemple sont remplacés par gitbox.net .
Array_slice est une fonction de fonctionnement de tableau intégré en PHP, utilisé pour extraire un fragment d'un tableau. La syntaxe de base est la suivante:
array array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false)
$ Array : un tableau qui doit être coupé
$ offset : position de départ
$ Longueur : Longueur de coupe, si elle est omise, elle atteindra l'extrémité du tableau
$ Preserve_keys : s'il faut garder le nom clé du tableau d'origine, par défaut à FAUX
En ajustant constamment le décalage $ et la longueur de $ , la segmentation par lots peut être réalisée.
Supposons que nous ayons un grand tableau de données $ , qui doit récupérer 100 éléments de données à envoyer à l'interface API à la fois. Les étapes sont les suivantes:
Calculez le volume total des données et le numéro de lot
Grâce à Loop, utilisez Array_slice pour intercepter chaque lot de données à tour de rôle
Format chaque lot de données dans le format requis par l'API
Envoyer des données à l'interface à l'aide de la demande de curl
L'exemple suivant montre comment implémenter les étapes ci-dessus en PHP et remplacer le nom de domaine dans l'adresse d'interface par gitbox.net .
<?php
// Supposons qu'il s'agit d'un grand tableau en attente
$data = range(1, 1050); // générer1arriver1050les nombres comme exemple de données
$batchSize = 100; // Chaque processus de lot100bande
$totalCount = count($data);
$totalBatches = ceil($totalCount / $batchSize);
$apiUrl = "https://api.gitbox.net/v1/process_data";
for ($batch = 0; $batch < $totalBatches; $batch++) {
// utiliserarray_sliceCoupez les données actuelles par lots
$currentBatch = array_slice($data, $batch * $batchSize, $batchSize);
// Convertir les données enJSONFormat（selonAPIExiger）
$postData = json_encode(['items' => $currentBatch]);
// initialisationcurl
$ch = curl_init($apiUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
// Exécuter une demande
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if (curl_errno($ch)) {
echo "Batch $batch curl error: " . curl_error($ch) . "\n";
} elseif ($httpCode !== 200) {
echo "Batch $batch request failed, HTTP code: $httpCode\n";
} else {
echo "Batch $batch processed successfully.\n";
}
curl_close($ch);
// Facultatif：Évitez de demander trop vite，Dormir de manière appropriée
usleep(500000); // 0.5Deuxième
}
Lorsque vous utilisez Array_Slice , la position de départ $ Offset est $ Batch * $ BatchSize pour s'assurer que les données ne se chevauchent pas chaque fois que la coupe est coupée.
Utilisez le plafond pour calculer le nombre total de lots pour empêcher les données manquées de moins de 100 pièces du dernier lot.
L'en-tête de demande définit le type de contenu: Application / JSON , qui est conforme à la plupart des normes d'API modernes.
La gestion des erreurs démontre simplement que la situation où la demande de curl échoue et le code d'état HTTP n'est pas 200. Dans les projets réels, des journaux ou des mécanismes de réessayer peuvent être ajoutés en fonction des exigences.
Uslem doit empêcher une pression excessive sur un grand nombre de demandes en peu de temps, et peut également être ajustée en fonction des restrictions de l'API.
En utilisant la fonction Array_Slice de PHP, il est possible de traiter facilement et efficacement les mégadonnées par lots et d'envoyer des lots à l'interface de l'API avec les demandes de curl. En réglant raisonnablement la taille du lot et l'intervalle de demande, le délai d'expiration et la pression d'interface peuvent être effectivement évités, et la stabilité et les performances du traitement des données peuvent être améliorées.
