Deutsch
Deutsch
Während des Entwicklungsprozesses ist es häufig erforderlich, ein großes Array in mehrere kleine Arrays zu unterteilen, wenn große Datenmengen verarbeitet werden. PHP bietet eine sehr nützliche Funktion array_chunk () für die Array -Segmentierung. Diese Funktion kann ein großes Array in mehrere kleine Arrays aufteilen, was für verschiedene Szenarien geeignet ist, wie Paginierung, Stapelverarbeitung usw. Obwohl Array_Chunk () bei der Behandlung großer Arrays sehr bequem ist, kann sie zu Leistungsengpassungen führen. In diesem Artikel wird effizient verwendet, wie Sie Array_Chunk () verwenden und nach Möglichkeiten untersuchen, um Leistungsprobleme zu vermeiden.
Die Funktion array_chunk () wird verwendet, um ein Array in mehrere kleine Arrays aufzuteilen und ein zweidimensionales Array mit kleinen Arrays zurückzugeben.
Grundlegende Syntax:
array_chunk(array $array, int $size, bool $preserve_keys = false): array
$ Array : Das Array, das geteilt werden muss.
$ Größe : Die Größe jedes kleinen Arrays.
$ PREISERVE_KEYS : Wenn auf True gesetzt, wird der Schlüsselname des ursprünglichen Arrays beibehalten. Wenn falsch , wird der Schlüsselname neu integriert.
Beispielcode:
<?php
$array = range(1, 20); // Erstellen eine enthalten 1 ankommen 20 Array von
$chunked = array_chunk($array, 5);
print_r($chunked);
?>
Ausgangsergebnis:
Array
(
[0] => Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
[1] => Array ( [0] => 6 [1] => 7 [2] => 8 [3] => 9 [4] => 10 )
[2] => Array ( [0] => 11 [1] => 12 [2] => 13 [3] => 14 [4] => 15 )
[3] => Array ( [0] => 16 [1] => 17 [2] => 18 [3] => 19 [4] => 20 )
)
Diese Methode ist für kleine Arrays sehr effektiv. Wenn Sie jedoch mit einem sehr großen Array zu tun haben, treten allmählich Leistungsprobleme auf.
Wenn das Array sehr groß ist, kann die Verwendung von Array_Chunk () direkt zu übermäßiger Speicherverwendung führen, was die Leistung beeinflusst. Die Hauptgründe sind wie folgt:
Memory Footprint : Array_Chunk () erstellt mehrere Neuarray -Kopien, die zu einer starken Zunahme der Speicherverwendung führen können.
Unnöter Schlüsselname Rekonstruktion : Wenn der Parameter $ Preserve_Keys falsch ist, wird jedes kleine Array den Schlüsselnamen wieder in den Griff bekommen und zusätzlichen Rechenaufwand hinzugefügt.
Bei großen Arrays können Leistungs Engpässe ohne Optimierung besonders auffällig sein und sogar Programmabstürze oder eine langsame Reaktion verursachen.
Wenn wir mit großen Arrays zu tun haben, können wir die folgenden Optimierungsmaßnahmen ergreifen, um Leistungs Engpässe zu vermeiden:
Die Funktion Array_Slice () kann Subarrays aus einem Array extrahieren, ohne das gesamte Array zu kopieren. Im Vergleich zu Array_Chunk () ermöglicht es uns mit Array_Slice () , einen Teil der Daten im Array nach Bedarf zu verarbeiten und die Speicherverwendung der Verarbeitung des gesamten großen Array gleichzeitig zu vermeiden.
Optimierungsbeispiel:
<?php
$array = range(1, 1000000); // Angenommen, wir haben eine große Auswahl an Millionen Elementen
$chunk_size = 10000; // Jede Verarbeitung 10000 Elemente
// verwenden array_slice Durch große Arrays wiederholen
for ($i = 0; $i < count($array); $i += $chunk_size) {
$chunk = array_slice($array, $i, $chunk_size);
// bewältigen $chunk Daten，Zum Beispiel senden HTTP Anfrage usw.
// Annahme Anfrage URL für https://m66.net/api/data
file_get_contents("https://m66.net/api/data?data=" . urlencode(json_encode($chunk)));
}
?>
Bei der Verwendung von Array_Slice () , um große Arrays zu durchqueren, wird jeweils nur ein Teil der Daten einer festen Größe verarbeitet, wodurch der Speicherverbrauch effektiv reduziert und Leistungsprobleme vermieden werden können, die durch das Laden zu viel Daten gleichzeitig verursacht werden.
Wie bereits erwähnt, wirkt sich der Parameter von Array_Chunk () auf den Speicherverbrauch aus. Wenn wir den Schlüsselnamen nicht bewahren müssen, ist es besser, diesen Parameter auf False festzulegen, um die Speicherverwendung zu reduzieren.
<?php
$array = range(1, 1000000);
$chunked = array_chunk($array, 10000, false); // Kein ursprünglicher Schlüsselname beibehalten
?>
Dies führt dazu, dass die Schlüsselnamen jedes kleinen Arrays wieder integriert werden, was den unnötigen Speicheraufwand verringert.
Für super große Arrays besteht der beste Weg, sie in Segmenten zu verarbeiten. Durch die Verarbeitung von Daten in Stapeln in Zyklen können große Arrays in mehrere kleine Stücke unterteilt werden, um einzeln zu verarbeiten, wodurch der Speicherdruck verringert wird.
Beispiel für die Batch -Verarbeitung:
<?php
$array = range(1, 1000000); // Großes Array
$chunk_size = 50000; // 每批次bewältigen 50000 个Daten
foreach (array_chunk($array, $chunk_size) as $chunk) {
// 逐批bewältigenDaten，Zum Beispiel initiieren API fragen
file_get_contents("https://m66.net/api/data?data=" . urlencode(json_encode($chunk)));
}
?>
Diese Methode kann verhindern, dass übermäßige Daten gleichzeitig in den Speicher geladen und die Programmstabilität und -leistung verbessern.
Bei der Verwendung von Array_Chunk () sollten wir die Verarbeitung großer Arrays besondere Aufmerksamkeit schenken, um Leistungs Engpässe zu vermeiden. Die Leistung kann auf folgende Weise optimiert werden:
Verwenden Sie Array_Slice () , um die Array -Segmente bei Bedarf zu verarbeiten.
Stellen Sie den Parameter rensed_keys vernünftig ein, um unnötige Speicheraufwand zu vermeiden.
Die Verarbeitungsdaten in Stapeln reduzieren die Speicherverwendung und verbessert die Programmeffizienz.
Diese Optimierungsmethoden ermöglichen es, große Arrays effizienter verarbeitet zu werden und Leistungsprobleme in Umgebungen mit hoher Belastung zu vermeiden.
