Deutsch
Deutsch
In PHP sind Array -Operationen sehr häufige Programmieraufgaben. Unabhängig davon, ob es sich um Daten handelt oder komplexe Berechnungen durchführt, sind Arrays eine der grundlegenden Datenstrukturen. Das Füllen von Arrays ist eine häufige Anforderung, und PHP bietet mehrere Möglichkeiten zum Füllen von Arrays. Die beiden häufigsten Methoden verwenden die Funktion array_fill () und füllen Arrays manuell über eine für die Schleife.
Diese beiden Methoden haben ihre eigenen Vor- und Nachteile. In diesem Artikel wird diese beiden Möglichkeiten zum Ausfüllen von Arrays aus Perspektive verglichen, um den Entwicklern dabei zu helfen, die entsprechende Methode besser auszuwählen.
Array_Fill () ist eine integrierte Funktion in PHP, um Array-Elemente in einem bestimmten Bereich zu füllen. Die Funktionssignatur ist wie folgt:
<span><span><span class="hljs-keyword">array</span></span><span> </span><span><span class="hljs-title function_ invoke__">array_fill</span></span><span>(</span><span><span class="hljs-keyword">int</span></span><span> </span><span><span class="hljs-variable">$start_index</span></span><span>, </span><span><span class="hljs-keyword">int</span></span><span> </span><span><span class="hljs-variable">$num</span></span><span>, </span><span><span class="hljs-keyword">mixed</span></span><span> </span><span><span class="hljs-variable">$value</span></span><span>)
</span></span>$ start_index : Der Startindex des Arrays.
$ num : Die Anzahl der zu füllenden Elemente.
$ Wert : Der Wert der Polsterung.
Array_Fill () startet mit der angegebenen Indexposition und füllt die angegebene Anzahl von Elementen ein, und die Werte aller Elemente sind der bereitgestellte $ -Werte .
Verwenden Sie beispielsweise Array_Fill () , um ein Array mit jeweils 10 Elementen mit einem Wert von 0 zu füllen:
<span><span><span class="hljs-variable">$arr</span></span><span> = </span><span><span class="hljs-title function_ invoke__">array_fill</span></span><span>(</span><span><span class="hljs-number">0</span></span><span>, </span><span><span class="hljs-number">10</span></span><span>, </span><span><span class="hljs-number">0</span></span><span>);
</span></span>In diesem Beispiel beginnt das 0. Element des Array $ arr mit 10 mit jedem Element gefüllten Elementen, und der Wert jedes Elements beträgt 0 .
Eine weitere häufige Möglichkeit, Arrays zu füllen, besteht darin, Werte manuell mit einer für die Schleife zuzuweisen. Durch die manuelle Angabe des Werts jedes Index können Entwickler den Füllprozess flexibler steuern. Häufige Codebeispiele sind wie folgt:
<span><span><span class="hljs-variable">$arr</span></span><span> = [];
</span><span><span class="hljs-keyword">for</span></span><span> (</span><span><span class="hljs-variable">$i</span></span><span> = </span><span><span class="hljs-number">0</span></span><span>; </span><span><span class="hljs-variable">$i</span></span><span> < </span><span><span class="hljs-number">10</span></span><span>; </span><span><span class="hljs-variable">$i</span></span><span>++) {
</span><span><span class="hljs-variable">$arr</span></span><span>[</span><span><span class="hljs-variable">$i</span></span><span>] = </span><span><span class="hljs-number">0</span></span><span>;
}
</span></span>Verwenden Sie hier eine für die Schleife, um mit Index 0 zu beginnen und jede Position im Array mit 0 zu füllen. Im Gegensatz zu Array_Fill () bieten für Schleifen eine größere Flexibilität, sodass Entwickler komplexere Vorgänge während des Füllprozesses ausführen können.
Beim Vergleich der Leistung von Array_Fill () und für Schleifen müssen wir mehrere Aspekte berücksichtigen, einschließlich Ausführungseffizienz, Speicherverbrauch und Code -Wartbarkeit. Lassen Sie es uns nacheinander unten analysieren.
In Bezug auf die Leistung wird Array_Fill () normalerweise schneller ausgeführt als bei Schleifen. Der Grund ist sehr einfach: Array_Fill () ist eine integrierte zugrunde liegende Funktion in PHP. Es wurde hoch optimiert und arbeitet direkt im zugrunde liegenden Speicher. Jede Iteration der für die für die Schleife erforderlichen zusätzlichen Vorgänge, wie z. B. Zugriff auf Array -Indizes, Zuordnungen usw., die relativ langsam sind.
Wir können dies mit einem einfachen Leistungstest überprüfen:
<span><span><span class="hljs-comment">// verwendenarray_fill</span></span><span>
</span><span><span class="hljs-variable">$start</span></span><span> = </span><span><span class="hljs-title function_ invoke__">microtime</span></span><span>(</span><span><span class="hljs-literal">true</span></span><span>);
</span><span><span class="hljs-variable">$arr1</span></span><span> = </span><span><span class="hljs-title function_ invoke__">array_fill</span></span><span>(</span><span><span class="hljs-number">0</span></span><span>, </span><span><span class="hljs-number">1000000</span></span><span>, </span><span><span class="hljs-number">0</span></span><span>);
</span><span><span class="hljs-variable">$end</span></span><span> = </span><span><span class="hljs-title function_ invoke__">microtime</span></span><span>(</span><span><span class="hljs-literal">true</span></span><span>);
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"array_fillzeitaufwendig："</span></span><span> . (</span><span><span class="hljs-variable">$end</span></span><span> - </span><span><span class="hljs-variable">$start</span></span><span>) . </span><span><span class="hljs-string">"Zweite\n"</span></span><span>;
</span><span><span class="hljs-comment">// verwendenforZyklus</span></span><span>
</span><span><span class="hljs-variable">$start</span></span><span> = </span><span><span class="hljs-title function_ invoke__">microtime</span></span><span>(</span><span><span class="hljs-literal">true</span></span><span>);
</span><span><span class="hljs-variable">$arr2</span></span><span> = [];
</span><span><span class="hljs-keyword">for</span></span><span> (</span><span><span class="hljs-variable">$i</span></span><span> = </span><span><span class="hljs-number">0</span></span><span>; </span><span><span class="hljs-variable">$i</span></span><span> < </span><span><span class="hljs-number">1000000</span></span><span>; </span><span><span class="hljs-variable">$i</span></span><span>++) {
</span><span><span class="hljs-variable">$arr2</span></span><span>[</span><span><span class="hljs-variable">$i</span></span><span>] = </span><span><span class="hljs-number">0</span></span><span>;
}
</span><span><span class="hljs-variable">$end</span></span><span> = </span><span><span class="hljs-title function_ invoke__">microtime</span></span><span>(</span><span><span class="hljs-literal">true</span></span><span>);
</span><span><span class="hljs-keyword">echo</span></span><span> </span><span><span class="hljs-string">"forZykluszeitaufwendig："</span></span><span> . (</span><span><span class="hljs-variable">$end</span></span><span> - </span><span><span class="hljs-variable">$start</span></span><span>) . </span><span><span class="hljs-string">"Zweite\n"</span></span><span>;
</span></span>Wenn eine große Datenmenge gefüllt wird, ist die Ausführungszeit von Array_Fill () im Allgemeinen kürzer als die der für die für die Schleife, da die zugrunde liegende Optimierung von Array_Fill () , während für die Loop zusätzliche Index -Lookup- und Zuordnungsvorgänge erforderlich sind.
In Bezug auf den Gedächtnisverbrauch sind die beiden normalerweise nicht sehr unterschiedlich. Unabhängig davon, ob es sich um einen Array_Fill () oder eine für die Schleife handelt, wird Speicher benötigt, um gefüllte Array -Elemente zu speichern. Da Array_Fill () eine integrierte Funktion ist, kann es einige Optimierungen in der Speicherverwaltung geben, diese Optimierung hat jedoch einen relativ geringen Einfluss auf den Speicherverbrauch, insbesondere wenn das Array relativ groß ist.
Wenn Sie jedoch komplexere Operationen in einer für die Schleife ausführen (z. B. Berechnung des Werts jedes Elements), kann dies einen zusätzlichen Speicherverbrauch hinzufügen. Daher ist Array_Fill () besser für einfache Füllaufgaben geeignet, während für Schleifen komplexere Szenarien verarbeiten können.
Array_Fill () ist offensichtlich besser in Bezug auf Lesbarkeit und Wartung. Seine Syntax ist prägnant und klar und drückt direkt die Absicht aus, das Array zu füllen, und es stützt sich nicht auf Schleifenanweisungen. Daher kann bei einfachen Array -Füllaufgaben mit Array_Fill () die Lesbarkeit des Codes verbessern.
Obwohl die für die Schleife flexibel ist, ist sie relativ lang und erfordert explizit den Array -Index und seinen Zuordnungsprozess. Bei komplexen Array -Füllaufgaben kann die Flexibilität für Schleifen erforderlich sein. Wenn Sie jedoch nur eine einfache Füllung ausführen, scheint es für Schleifen etwas umständlich zu sein.
Szenarien mit Array_Fill () :
Eine Reihe von kontinuierlichen Bereichen muss gefüllt werden, und der Wert jedes Elements ist gleich.
Es besteht keine Notwendigkeit, komplexe Berechnungen für jedes Element durchzuführen, sondern nur eine bestimmte Anzahl von Elementen ausfüllen.
Möchten Sie präzise und leicht verständliche Code schreiben.
Szenarien für Schleifen verwenden :
Es ist notwendig, komplexe Berechnungen oder bedingte Urteile in jedem Element des Arrays durchzuführen.
Das gefüllte Array ist unregelmäßig (z. B. füllen Sie ein Array mit unregelmäßigem Index).
Für die Steuerung des Füllprozesses ist mehr Flexibilität erforderlich.
Durch den Vergleich ist Array_Fill () in der Regel besser als bei Leistungsschleifen, insbesondere wenn große Datenmengen verarbeitet werden. Array_Fill () kann Arrays effizienter füllen. Für Schleifen bieten jedoch eine größere Flexibilität für Szenarien, in denen komplexe Vorgänge erforderlich sind.
Daher sollte die Auswahl der Methode zum Ausfüllen des Arrays basierend auf dem spezifischen Anwendungsszenario ermittelt werden. Wenn Sie einfach ein Array füllen, ist Array_Fill () eine bessere Wahl. Wenn Sie während des Füllvorgangs mehr Operationen durchführen müssen, ist für die Schleife besser geeignet.
