Trouver le dernier élément d'un tableau en utilisant une boucle foreach dans PHP
J'écris un créateur de requête SQL en utilisant certains paramètres. En Java, il est très facile de détecter le dernier élément d'un tableau de l'intérieur de la boucle for en vérifiant simplement la position actuelle du tableau avec la longueur du tableau.
for(int i=0; i< arr.length;i++){
boolean isLastElem = i== (arr.length -1) ? true : false;
}
Dans PHP, ils ont des index non entiers pour accéder aux tableaux. Vous devez donc parcourir un tableau en utilisant une boucle foreach. Cela devient problématique lorsque vous devez prendre une décision (dans mon cas, ajouter ou/et paramétrer lors de la création d'une requête).
Je suis sûr qu'il doit y avoir un moyen standard de le faire.
Comment résolvez-vous cela en PHP?
On dirait que vous voulez quelque chose comme ça:
$numItems = count($arr);
$i = 0;
foreach($arr as $key=>$value) {
if(++$i === $numItems) {
echo "last index!";
}
}
Cela étant dit, vous n'avez pas à parcourir un "tableau" en utilisant foreach dans php.
Vous pouvez obtenir la valeur de la dernière clé du tableau en utilisant end(array_keys($array)) et la comparer à la clé actuelle:
$last_key = end(array_keys($array));
foreach ($array as $key => $value) {
if ($key == $last_key) {
// last element
} else {
// not last element
}
}
pourquoi si compliqué?
foreach($input as $key => $value) {
$ret .= "$value";
if (next($input)==true) $ret .= ",";
}
Cela ajoutera un, derrière chaque valeur sauf la dernière!
Quand ToEnd atteint 0, cela signifie qu'il en est à la dernière itération de la boucle.
$toEnd = count($arr);
foreach($arr as $key=>$value) {
if (0 === --$toEnd) {
echo "last index! $value";
}
}
La dernière valeur est toujours disponible après la boucle, donc si vous voulez simplement l'utiliser pour plus de choses après la boucle, c'est encore mieux:
foreach($arr as $key=>$value) {
//something
}
echo "last index! $key => $value";
Si vous ne souhaitez pas traiter la dernière valeur comme une boucle interne spéciale. Cela devrait être plus rapide si vous avez de grands tableaux. (Si vous réutilisez le tableau après la boucle dans la même portée, vous devez d'abord "copier" le tableau).
//If you use this in a large global code without namespaces or functions then you can copy the array like this:
//$array = $originalArrayName; //uncomment to copy an array you may use after this loop
//end($array); $lastKey = key($array); //uncomment if you use the keys
$lastValue = array_pop($array);
//do something special with the last value here before you process all the others?
echo "Last is $lastValue", "\n";
foreach ($array as $key => $value) {
//do something with all values before the last value
echo "All except last value: $value", "\n";
}
//do something special with the last value here after you process all the others?
echo "Last is $lastValue", "\n";
Et pour répondre à votre question initiale "dans mon cas, ajouter ou/et paramètre lors de la création de la requête"; cela va boucler sur toutes les valeurs, puis les joindre à une chaîne avec "et" entre elles mais pas avant la première valeur ou après la dernière valeur:
$params = [];
foreach ($array as $value) {
$params[] = doSomething($value);
}
$parameters = implode(" and ", $params);
Il y a déjà beaucoup de réponses, mais cela vaut également la peine de chercher dans les itérateurs, surtout parce qu'on lui a demandé de manière standard
$arr = range(1, 3);
$it = new CachingIterator(new ArrayIterator($arr));
foreach($it as $key => $value)
{
if (!$it->hasNext()) echo 'Last:';
echo $value, "\n";
}
Vous trouverez peut-être aussi quelque chose qui fonctionne plus souple pour d'autres cas.
Une solution pourrait être de détecter si l'itérateur a next. S'il n'y a pas de prochain attaché à l'itérateur, cela signifie que vous êtes dans la dernière boucle.
foreach ($some_array as $element) {
if(!next($some_array)) {
// This is the last $element
}
}
Donc, si votre tableau a des valeurs uniques, alors déterminer la dernière itération est trivial:
foreach($array as $element) {
if ($element === end($array))
echo 'LAST ELEMENT!';
}
Comme vous le voyez, cela fonctionne si le dernier élément apparaît une seule fois dans le tableau, sinon vous obtenez une fausse alarme. Dans le cas contraire, vous devez comparer les clés (qui sont uniques, bien sûr).
foreach($array as $key => $element) {
end($array);
if ($key === key($array))
echo 'LAST ELEMENT!';
}
Notez également l'opérateur de coparision strict, ce qui est très important dans ce cas.
En supposant que le tableau soit stocké dans une variable ...
foreach($array as $key=>$value)
{
echo $value;
if($key != count($array)-1) { echo ", "; }
}
Si vous avez besoin de faire quelque chose pour chaque élément sauf le premier ou le dernier et uniquement s'il y a plus d'un élément dans le tableau, je préfère la solution suivante.
Je sais qu'il existe de nombreuses solutions ci-dessus et publiées plusieurs mois/un an avant la mienne, mais je pense que c'est quelque chose d'assez élégant en soi. La vérification de chaque boucle est également une vérification booléenne, par opposition à une vérification numérique "i = (compte-1)", qui permet moins de temps système.
La structure de la boucle peut sembler délicate, mais vous pouvez la comparer à l'ordre des têtes (début), tfoot (fin), tbody (actuel) dans les balises de table HTML.
$first = true;
foreach($array as $key => $value) {
if ($first) {
$first = false;
// Do what you want to do before the first element
echo "List of key, value pairs:\n";
} else {
// Do what you want to do at the end of every element
// except the last, assuming the list has more than one element
echo "\n";
}
// Do what you want to do for the current element
echo $key . ' => ' . $value;
}
Par exemple, en termes de développement Web, si vous souhaitez ajouter un border-bas à chaque élément sauf le dernier dans une liste non ordonnée (ul), vous pouvez plutôt ajouter un border-top à chaque élément sauf le premier (le CSS: premier enfant, pris en charge par IE7 + et Firefox/Webkit supporte cette logique, alors que: last-enfant n'est pas pris en charge par IE7).
Vous pouvez également réutiliser la variable $ first pour chaque boucle imbriquée et tout fonctionnera correctement, car chaque boucle rend $ first faux lors du premier processus de la première itération (ainsi, les ruptures/exceptions ne causeront pas de problèmes). .
$first = true;
foreach($array as $key => $subArray) {
if ($first) {
$string = "List of key => value array pairs:\n";
$first = false;
} else {
echo "\n";
}
$string .= $key . '=>(';
$first = true;
foreach($subArray as $key => $value) {
if ($first) {
$first = false;
} else {
$string .= ', ';
}
$string .= $key . '=>' . $value;
}
$string .= ')';
}
echo $string;
Exemple de sortie:
List of key => value array pairs:
key1=>(v1_key1=>v1_val1, v1_key2=>v1_val2)
key2=>(v2_key1=>v2_val1, v2_key2=>v2_val2, v2_key3=>v2_val3)
key3=>(v3_key1=>v3_val1)
Cela devrait être le moyen facile de trouver le dernier élément:
foreach ( $array as $key => $a ) {
if ( end( array_keys( $array ) ) == $key ) {
echo "Last element";
} else {
echo "Just another element";
}
}
Référence: Link
Vous pouvez toujours utiliser cette méthode avec des tableaux associatifs:
$keys = array_keys($array);
for ($i = 0, $l = count($array); $i < $l; ++$i) {
$key = $array[$i];
$value = $array[$key];
$isLastItem = ($i == ($l - 1));
// do stuff
}
// or this way...
$i = 0;
$l = count($array);
foreach ($array as $key => $value) {
$isLastItem = ($i == ($l - 1));
// do stuff
++$i;
}
Comme votre intention de trouver le tableau EOF est juste pour la colle. Faites-vous présenter à la tactique ci-dessous. Vous n'avez pas besoin de l'EOF:
$given_array = array('column1'=>'value1',
'column2'=>'value2',
'column3'=>'value3');
$glue = '';
foreach($given_array as $column_name=>$value){
$where .= " $glue $column_name = $value"; //appending the glue
$glue = 'AND';
}
echo $where;
o/p:
column1 = value1 AND column2 = value2 AND column3 = value3
J'ai le sentiment que, à la racine de ce "problème XY", le PO voulait uniquement la fonction implode().
On dirait que tu veux quelque chose comme ça:
$array = array(
'First',
'Second',
'Third',
'Last'
);
foreach($array as $key => $value)
{
if(end($array) === $value)
{
echo "last index!" . $value;
}
}
Vous pouvez aussi faire quelque chose comme ça:
end( $elements );
$endKey = key($elements);
foreach ($elements as $key => $value)
{
if ($key == $endKey) // -- this is the last item
{
// do something
}
// more code
}
J'aime un peu ce qui suit car je trouve que c'est assez chouette. Supposons que nous créons une chaîne avec des séparateurs entre tous les éléments: par exemple. abc
$first = true;
foreach ( $items as $item ) {
$str = ($first)?$first=false:", ".$item;
}
vous pouvez faire un compte ().
for ($i=0;$i<count(arr);$i++){
$i == count(arr)-1 ? true : false;
}
ou si vous cherchez SEULEMENT le dernier élément, vous pouvez utiliser end ().
end(arr);
ne renvoie que le dernier élément.
et, comme il s'avère, vous pouvez indexer des tableaux php avec des entiers C'est parfaitement heureux avec
arr[1];
Que diriez-vous d'utiliser "fin"? http://php.net/manual/en/function.end.php
N'ajoutez pas de virgule après la dernière valeur:
Le tableau:
$data = ['lorem', 'ipsum', 'dolor', 'sit', 'amet'];
La fonction:
$result = "";
foreach($data as $value) {
$resut .= (next($data)) ? "$value, " : $value;
}
Le résultat:
print $result;
lorem ipsum dolor sit amet
foreach ($array as $key => $value) {
$class = ( $key !== count( $array ) -1 ) ? " class='not-last'" : " class='last'";
echo "<div{$class}>";
echo "$value['the_title']";
echo "</div>";
}
Plus facilement, la fonction end() est une fonction intégrée dans PHP et est utilisée pour trouver le dernier élément du tableau donné. La fonction end () modifie le pointeur interne d'un tableau pour qu'il pointe vers le dernier élément et renvoie la valeur du dernier élément.
Vous trouverez ci-dessous un exemple d'index non entier:
<?php
$arr = array(
'first' =>
array('id' => 1, 'label' => 'one'),
'second' =>
array('id' => 2, 'label' => 'two'),
'last' =>
array('id' => 9, 'label' => 'nine')
);
$lastIndexArr = end($arr);
print_r($lastIndexArr);
Vérifiez ici le dernier tableau en sortie.
Voici une autre façon de le faire:
$arr = range(1, 10);
$end = end($arr);
reset($arr);
while( list($k, $v) = each($arr) )
{
if( $n == $end )
{
echo 'last!';
}
else
{
echo sprintf('%s ', $v);
}
}
Voici ma solution: Obtenez simplement le nombre de votre tableau, moins 1 (car ils commencent à 0).
$lastkey = count($array) - 1;
foreach($array as $k=>$a){
if($k==$lastkey){
/*do something*/
}
}
Si je vous comprends bien, tout ce dont vous avez besoin est d’inverser le tableau et d’obtenir le dernier élément à l’aide d’une commande pop:
$rev_array = array_reverse($array);
echo array_pop($rev_array);
Une autre solution consiste à mémoriser le résultat du cycle de boucle précédent et à l'utiliser comme résultat final:
$result = $where = "";
foreach ($conditions as $col => $val) {
$result = $where .= $this->getAdapter()->quoteInto($col.' = ?', $val);
$where .= " AND ";
}
return $this->delete($result);
Vous pouvez directement obtenir le dernier index par:
$numItems = count($arr);
echo $arr[$numItems-1];
pour obtenir le premier et le dernier élément du tableau foreach
foreach($array as $value) {
if ($value === reset($array)) {
echo 'FIRST ELEMENT!';
}
if ($value === end($array)) {
echo 'LAST ITEM!';
}
}
Pour les scripts de génération de requêtes SQL, ou tout ce qui effectue une action différente pour le premier ou le dernier élément, il est beaucoup plus rapide (presque deux fois plus rapide) d'éviter d'utiliser des vérifications de variables inutiles.
La solution acceptée actuelle utilise une boucle et un contrôle dans la boucle qui seront effectués chaque_single_iteration, la manière correcte (rapide) de procéder est la suivante:
$numItems = count($arr);
$i=0;
$firstitem=$arr[0];
$i++;
while($i<$numItems-1){
$some_item=$arr[$i];
$i++;
}
$last_item=$arr[$i];
$i++;
Un petit repère maison a montré ce qui suit:
test1: 100000 exécutions de modèle morg
temps: 1869.3430423737 millisecondes
test2: 100000 exécutions du modèle si dernier
temps: 3235.6359958649 millisecondes
<?php foreach($have_comments as $key => $page_comment): ?>
<?php echo $page_comment;?>
<?php if($key+1<count($have_comments)): ?>
<?php echo ', '; ?>
<?php endif;?>
<?php endforeach;?>
Vous pouvez aussi essayer ceci pour faire votre requête ... montrée ici avec INSERT
<?php
$week=array('one'=>'monday','two'=>'tuesday','three'=>'wednesday','four'=>'thursday','five'=>'friday','six'=>'saturday','seven'=>'sunday');
$keys = array_keys($week);
$string = "INSERT INTO my_table ('";
$string .= implode("','", $keys);
$string .= "') VALUES ('";
$string .= implode("','", $week);
$string .= "');";
echo $string;
?>
J'utilise personnellement ce type de construction qui permet une utilisation facile avec les éléments html <ul> et <li>: il suffit de changer l'égalité pour une autre propriété ...
Le tableau ne peut pas contenir de faux éléments, mais tous les autres éléments qui sont convertis dans le faux booléen.
$table = array( 'a' , 'b', 'c');
$it = reset($table);
while( $it !== false ) {
echo 'all loops';echo $it;
$nextIt = next($table);
if ($nextIt === false || $nextIt === $it) {
echo 'last loop or two identical items';
}
$it = $nextIt;
}
Essayez cette solution simple
$test = ['a' => 1, 'b' => 2, 'c' => 3];
$last_array_value = end($test);
foreach ($test as $key => $value) {
if ($value === $last_array_value) {
echo $value; // display the last value
} else {
echo $value; // display the values that are not last elements
}
}