Français
Français
En PHP, les opérations de réseau sont des tâches de programmation très courantes. Qu'il s'agisse de traiter des données ou d'effectuer des calculs complexes, les tableaux sont l'une des structures de données de base. Le remplissage des tableaux est une exigence commune, et PHP fournit plusieurs façons de remplir les tableaux, les deux méthodes les plus courantes utilisent la fonction Array_Fill () et le remplissage manuel des tableaux via une boucle pour une boucle.
Ces deux méthodes présentent leurs propres avantages et inconvénients. Cet article comparera ces deux façons de remplir les tableaux du point de vue des performances pour aider les développeurs à mieux choisir la méthode appropriée.
Array_Fill () est une fonction intégrée en PHP pour remplir les éléments du tableau dans une plage spécifiée. Sa signature de fonction est la suivante:
<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 : l'indice de départ du tableau.
$ num : le nombre d'éléments à remplir.
$ Value : la valeur du rembourrage.
Array_Fill () commencera à partir de la position d'index spécifiée et remplira le nombre d'éléments spécifié, et les valeurs de tous les éléments sont la valeur $ fournie.
Par exemple, utilisez array_fill () pour remplir un tableau avec 10 éléments, chacun avec une valeur de 0 :
<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>Dans cet exemple, le 0ème élément du tableau $ ARR commence par 10 éléments remplis de chaque élément, et la valeur de chaque élément est 0 .
Une autre façon courante de remplir les tableaux est d'attribuer manuellement des valeurs en utilisant A pour la boucle. En spécifiant manuellement la valeur de chaque index, les développeurs peuvent contrôler le processus de remplissage de manière plus flexible. Les exemples de code communs sont les suivants:
<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>Ici, utilisez une boucle pour commencer par l'index 0 , remplissant chaque position dans le tableau avec 0 . Contrairement à Array_Fill () , pour les boucles, offrez une plus grande flexibilité, permettant aux développeurs d'effectuer des opérations plus complexes pendant le processus de remplissage.
Lorsque vous comparez les performances de Array_Fill () et pour les boucles, nous devons considérer plusieurs aspects, notamment l'efficacité de l'exécution, la consommation de mémoire et la maintenabilité du code. Analyons-le un par un ci-dessous.
En termes de performances, array_fill () exécute généralement plus rapidement que pour les boucles. La raison est très simple: array_fill () est une fonction sous-jacente intégrée dans PHP. Il a été hautement optimisé et fonctionne directement sur la mémoire sous-jacente. Chaque itération de la boucle FOR nécessite des opérations supplémentaires, telles que l'accès à des index de tableau, des affectations, etc., qui sont relativement lents.
Nous pouvons le vérifier avec un test de performance simple:
<span><span><span class="hljs-comment">// utiliserarray_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_fillprend du temps："</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">"Deuxième\n"</span></span><span>;
</span><span><span class="hljs-comment">// utiliserforfaire du vélo</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">"forfaire du véloprend du temps："</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">"Deuxième\n"</span></span><span>;
</span></span>Lorsqu'une grande quantité de données est remplie, le temps d'exécution de Array_Fill () est généralement plus court que celui de la boucle FOR , car l'optimisation sous-jacente de Array_Fill () , tandis que la boucle FOR nécessite des opérations de recherche et d'affectation d'index supplémentaires.
En termes de consommation de mémoire, les deux ne sont généralement pas très différents. Qu'il s'agisse d' un array_fill () ou d'une boucle, de la mémoire est nécessaire pour stocker des éléments de tableau remplis. Étant donné que Array_Fill () est une fonction intégrée, il peut y avoir des optimisations dans la gestion de la mémoire, mais cette optimisation a un impact relativement faible sur la consommation de mémoire, en particulier lorsque le tableau est relativement important.
Cependant, si vous effectuez des opérations plus complexes dans une boucle pour une boucle (comme le calcul de la valeur de chaque élément), il peut ajouter une consommation de mémoire supplémentaire. Par conséquent, Array_Fill () convient plus aux tâches de remplissage simples, tandis que pour les boucles peuvent gérer des scénarios plus complexes.
array_fill () est évidemment meilleur en termes de lisibilité et de maintenance. Sa syntaxe est concise et claire, et il exprime directement l'intention de remplir le tableau, et il ne s'appuie pas sur les instructions de boucle. Par conséquent, pour les tâches de remplissage de tableaux simples, l'utilisation de Array_Fill () peut améliorer la lisibilité du code.
Bien que la boucle FOR soit flexible, elle est relativement longue et nécessite explicitement l'indice du tableau et son processus d'attribution. Pour les tâches de remplissage complexes de tableau, la flexibilité de pour les boucles peut être nécessaire, mais si vous ne faites qu'un simple remplissage, l'utilisation pour les boucles semblera un peu lourde.
Scénarios utilisant array_fill () :
Un tableau de gammes continues doit être rempli et la valeur de chaque élément est la même.
Il n'est pas nécessaire d'effectuer des calculs complexes sur chaque élément, remplissez simplement un nombre spécifié d'éléments.
Vous voulez écrire du code concis et facile à comprendre.
Scénarios utilisant pour les boucles :
Il est nécessaire d'effectuer des calculs complexes ou des jugements conditionnels sur chaque élément du tableau.
Le tableau rempli est irrégulier (par exemple, remplissez un tableau avec un indice irrégulier).
Plus de flexibilité est nécessaire pour contrôler le processus de remplissage.
En effectuant une comparaison, Array_Fill () est généralement meilleur que pour les boucles de performances, en particulier lors du traitement de grandes quantités de données, Array_Fill () peut remplir plus efficacement les tableaux. Cependant, pour les boucles, offrez une plus grande flexibilité pour les scénarios où des opérations complexes sont nécessaires.
Par conséquent, le choix de la méthode pour remplir le tableau doit être déterminé en fonction du scénario d'application spécifique. Si vous remplissez simplement un tableau, array_fill () est un choix plus approprié; Si vous devez effectuer plus d'opérations pendant le processus de remplissage, car Loop est plus approprié.
