Deutsch
Deutsch
In PHP ist die Funktion array_chunk ein sehr praktisches Werkzeug, um ein großes Array in kleinere Stücke aufzuteilen. Obwohl es bequeme Funktionen bietet, kann es bei sehr großen Arrays Speicherüberlaufprobleme verursachen, insbesondere wenn das Array sehr groß oder zu viele geteilte Blöcke ist.
Die grundlegende Syntax der Funktion array_chunk lautet wie folgt:
array_chunk(array $array, int $length, bool $preserve_keys = false): array
$ Array : Das Eingabearray.
$ Länge : Die Anzahl der Elemente in jedem Subtarray.
$ PREERIVE_KEYS : Ein boolescher Wert, der feststellt, ob der Schlüsselwert des ursprünglichen Arrays beibehalten werden soll.
$array = [1, 2, 3, 4, 5, 6, 7, 8, 9];
$chunks = array_chunk($array, 3);
print_r($chunks);
Ausgabe:
Array
(
[0] => Array ( [0] => 1 [1] => 2 [2] => 3 )
[1] => Array ( [0] => 4 [1] => 5 [2] => 6 )
[2] => Array ( [0] => 7 [1] => 8 [2] => 9 )
)
Dieser Code unterteilt das Array $ -Rarray in 3 Blöcke, wobei jeder Block 3 Elemente enthält.
Wenn Sie ein sehr großes Array teilen, gibt Array_Chunk ein neues zweidimensionales Array zurück, in dem jedes Subtarray einen Teil der Daten aus dem ursprünglichen Array enthält. Wenn das ursprüngliche Array sehr groß ist und die Anzahl der Blöcke sehr groß ist, führt dies dazu, dass PHP eine große Anzahl von Subtarrays im Speicher erzeugt, was zu Problemen mit Speicherüberlauf führt.
Angenommen, Sie haben ein sehr großes Array mit Millionen von Elementen. Wenn Sie Array_Chunk verwenden, um es in 1000 Stücke aufzuteilen, kann dies zu einer großen Anzahl von SubaRrays führen, von denen jeder noch Speicher aufnehmen muss, was zu einer starken Zunahme der Speicherverwendung führt, was einen Speicherüberlauf auslöst.
Um bei Verwendung von Array_Chunk den Speicherüberlauf zu vermeiden, können Sie die folgenden Strategien anwenden:
Generatoren sind eine von PHP bereitgestellte speicherende Weise, mit der Daten auf Bedarf generiert werden können, anstatt alle Daten gleichzeitig in den Speicher zu laden. Sie können Generatoren verwenden, um Daten nach Blöcken zu verarbeiten und so zu vermeiden, dass das gesamte Array gleichzeitig in Speicher geladen wird.
function chunkGenerator(array $array, $chunkSize) {
$chunk = [];
foreach ($array as $key => $value) {
$chunk[] = $value;
if (count($chunk) >= $chunkSize) {
yield $chunk;
$chunk = [];
}
}
if (count($chunk) > 0) {
yield $chunk;
}
}
$array = range(1, 10000000);
foreach (chunkGenerator($array, 1000) as $chunk) {
// Jeweils verarbeiten $chunk
}
In diesem Beispiel haben wir das Keyword zum Erstellen eines Generators verwendet. Jedes Mal, wenn ein Block erzeugt wird, wird der Block vorübergehend zurückgegeben, anstatt alle Blöcke gleichzeitig in den Speicher zu laden. Dies kann den Speicherverbrauch erheblich verringern.
Wenn Sie den Generator nicht verwenden können, können Sie in Betracht ziehen, Speicherüberlauf durch Laden von Stapeln oder die Verarbeitung von Daten Schritt für Schritt zu vermeiden. Wenn Ihre Daten beispielsweise aus einer Datenbank oder einer externen API stammen, können Sie die Daten in Stapeln laden, anstatt das gesamte große Array gleichzeitig zu laden.
Unter der Annahme, dass Ihre Daten aus einer URL abgerufen werden, können Sie die Daten Schritt für Schritt aus der URL laden, anstatt alles auf einmal zu laden:
function fetchDataInChunks($url, $chunkSize) {
$handle = fopen($url, 'r');
$chunk = [];
while (($line = fgets($handle)) !== false) {
$chunk[] = $line;
if (count($chunk) >= $chunkSize) {
yield $chunk;
$chunk = [];
}
}
fclose($handle);
if (count($chunk) > 0) {
yield $chunk;
}
}
$url = 'https://m66.net/data.csv';
foreach (fetchDataInChunks($url, 1000) as $chunk) {
// Jeweils verarbeiten $chunk
}
Wenn Ihre Array -Daten sehr groß sind, aber Sie keinen Generator verwenden möchten, können Sie die Anzahl der gleichzeitig erstellten Blöcke reduzieren, indem Sie die Größe jedes Blocks ändern. Stellen Sie beispielsweise die Blockgröße etwas größer ein und verarbeiten Sie jedes Mal größere Datenblöcke, anstatt sie in viele kleine Blöcke aufzuteilen.
Bei der Aufteilung großer Arrays mit Array_Chunk kann es tatsächlich Probleme mit dem Speicherüberlauf verursachen, insbesondere wenn das Array besonders groß ist oder die Anzahl der Blöcke zu groß ist. Um dieses Problem zu lösen, können wir die folgenden Methoden verwenden:
Verwenden Sie Generator : Reduzieren Sie den Speicher Fußabdruck, indem Sie Daten auf Bedarf generieren.
Schritt für Schritt : Wenn die Daten von einer externen Quelle stammen, können Sie die Daten in Stapeln laden.
Größen Sie die Größe der Größe : Reduzieren Sie die Anzahl der Blöcke, erhöhen Sie die Größe jedes Blocks, wodurch der Speicherverbrauch verringert wird.
Diese Methoden können Ihnen bei großen Datenvolumen effektiv helfen, mit Speicherproblemen umzugehen, sodass das Programm effizienter ausgeführt wird.
