Encuentre el último elemento de una matriz mientras usa un bucle foreach en PHP

Estoy escribiendo un creador de consultas SQL usando algunos parámetros. En Java, es muy fácil detectar el último elemento de una matriz desde el interior del bucle for simplemente comprobando la posición actual de la matriz con la longitud de la matriz.

for(int i=0; i< arr.length;i++){
     boolean isLastElem = i== (arr.length -1) ? true : false;        
}

En PHP tienen índices no enteros para acceder a las matrices. Por lo tanto, debe iterar sobre una matriz utilizando un bucle foreach. Esto se vuelve problemático cuando necesita tomar alguna decisión (en mi caso, agregar o parámetro durante la consulta).

Estoy seguro de que debe haber alguna forma estándar de hacerlo.

¿Cómo se resuelve esto en PHP?

Parece que quieres algo como esto:

$numItems = count($arr);
$i = 0;
foreach($arr as $key=>$value) {
  if(++$i === $numItems) {
    echo "last index!";
  }
}    

Dicho esto, no tienes que iterar sobre una "matriz" usando foreachphp.

Puede obtener el valor de la última clave de la matriz usando end(array_keys($array))y compararlo con la clave actual:

$last_key = end(array_keys($array));
foreach ($array as $key => $value) {
    if ($key == $last_key) {
        // last element
    } else {
        // not last element
    }
}

¿Por qué tan complicado?

foreach($input as $key => $value) {
    $ret .= "$value";
    if (next($input)==true) $ret .= ",";
}

¡Esto agregará un, detrás de cada valor, excepto el último!

Cuando toEnd alcanza 0 significa que está en la última iteración del bucle.

$toEnd = count($arr);
foreach($arr as $key=>$value) {
  if (0 === --$toEnd) {
    echo "last index! $value";
  }
}

El último valor aún está disponible después del ciclo, por lo que si solo desea usarlo para más cosas después del ciclo, esto es mejor:

foreach($arr as $key=>$value) {
  //something
}
echo "last index! $key => $value";

Si no desea tratar el último valor como bucles internos especiales. Esto debería ser más rápido si tiene matrices grandes. (Si reutiliza la matriz después del ciclo dentro del mismo alcance, primero debe "copiar" la matriz).

//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";

Y para responder a su pregunta original "en mi caso, agregar o / y parámetros al crear la consulta"; esto recorrerá todos los valores, luego los unirá en una cadena con "y" entre ellos, pero no antes del primer valor o después del último valor:

$params = [];
foreach ($array as $value) {
    $params[] = doSomething($value);
}
$parameters = implode(" and ", $params);

Ya hay muchas respuestas, pero también vale la pena buscar iteradores, especialmente porque se le ha pedido una forma estándar:

$arr = range(1, 3);

$it = new CachingIterator(new ArrayIterator($arr));
foreach($it as $key => $value)
{
  if (!$it->hasNext()) echo 'Last:';
  echo $value, "\n";
}

Es posible que también encuentre algo que funcione más flexible para otros casos.

Una forma podría ser detectar si el iterador tiene next. Si no hay un próximo adjunto al iterador, significa que está en el último bucle.

foreach ($some_array as $element) {
    if(!next($some_array)) {
         // This is the last $element
    }
}

Entonces, si su matriz tiene valores de matriz únicos, entonces determinar la última iteración es trivial:

foreach($array as $element) {
    if ($element === end($array))
        echo 'LAST ELEMENT!';
}

Como puede ver, esto funciona si el último elemento aparece solo una vez en la matriz; de lo contrario, obtendrá una falsa alarma. En caso contrario, debe comparar las claves (que son únicas de seguro).

foreach($array as $key => $element) {
    end($array);
    if ($key === key($array))
        echo 'LAST ELEMENT!';
}

También tenga en cuenta el operador de copago estricto, que es bastante importante en este caso.

Suponiendo que tiene la matriz almacenada en una variable ...

foreach($array as $key=>$value) 
{ 
    echo $value;
    if($key != count($array)-1) { echo ", "; }
}

para obtener el primer y el último elemento de la matriz foreach

foreach($array as $value) {
    if ($value === reset($array)) {
        echo 'FIRST ELEMENT!';
    }

    if ($value === end($array)) {
        echo 'LAST ITEM!';
    }
}

Todavía puede usar ese método con matrices asociativas:

$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;
}

Si necesita hacer algo para cada elemento, excepto el primero o el último y solo si hay más de un elemento en la matriz, prefiero la siguiente solución.

Sé que hay muchas soluciones anteriores y publicadas meses / un año antes que la mía, pero esto es algo que creo que es bastante elegante en sí mismo. La comprobación de cada bucle también es una comprobación booleana en lugar de una comprobación numérica "i = (cuenta-1)", que puede permitir menos gastos generales.

La estructura del bucle puede parecer incómoda, pero puede compararla con el orden de thead (principio), tfoot (final), tbody (actual) en las etiquetas de tabla 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;
}

Por ejemplo, en términos de desarrollo web, si desea agregar un borde inferior a cada elemento, excepto el último en una lista desordenada (ul), puede agregar un borde superior a cada elemento excepto el primero (el CSS: first-child, compatible con IE7 + y Firefox / Webkit admite esta lógica, mientras que: last-child no es compatible con IE7).

Puede sentirse libre de reutilizar la variable $ first para todos y cada uno de los bucles anidados y las cosas funcionarán bien, ya que cada bucle hace que $ first sea falso durante el primer proceso de la primera iteración (por lo que los saltos / excepciones no causarán problemas) .

$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;

Salida de ejemplo:

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)

Esta debería ser la manera fácil de encontrar el último elemento:

foreach ( $array as $key => $a ) {
    if ( end( array_keys( $array ) ) == $key ) {
        echo "Last element";
     } else {
        echo "Just another element";
     }
}  

Referencia: Enlace

Tengo la fuerte sensación de que en la raíz de este "problema XY" el OP solo quería implode()funcionar.

Como su intención de encontrar la matriz EOF es solo para el pegamento. Conozca la siguiente táctica. No necesita requerir el 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

¿Qué tal usar "fin"? http://php.net/manual/en/function.end.php

Parece que quieres algo como esto:

$array = array(
    'First',
    'Second',
    'Third',
    'Last'
);

foreach($array as $key => $value)
{
    if(end($array) === $value)
    {
       echo "last index!" . $value;
    }
}

No agregue una coma después del último valor:

La matriz:

$data = ['lorem', 'ipsum', 'dolor', 'sit', 'amet'];

La función:

$result = "";
foreach($data as $value) {
    $resut .= (next($data)) ? "$value, " : $value;
}

El resultado:

print $result;

lorem, ipsum, dolor, sentarse, amet

puedes hacer un conteo ().

for ($i=0;$i<count(arr);$i++){
    $i == count(arr)-1 ? true : false;
}

o si está buscando SOLO el último elemento, puede usar end ().

end(arr);

devuelve solo el último elemento.

y, como resultado, PUEDES indexar matrices php por enteros. Es perfectamente feliz con

arr[1];

También podrías hacer algo como esto:

end( $elements );
$endKey = key($elements);
foreach ($elements as $key => $value)
{
     if ($key == $endKey) // -- this is the last item
     {
          // do something
     }

     // more code
}

Me gusta un poco lo siguiente, ya que siento que es bastante ordenado. Supongamos que estamos creando una cadena con separadores entre todos los elementos: por ejemplo, a, b, c

$first = true;
foreach ( $items as $item ) {
    $str = ($first)?$first=false:", ".$item;
}

foreach ($array as $key => $value) {

  $class = ( $key !== count( $array ) -1 ) ? " class='not-last'" : " class='last'";

  echo "<div{$class}>";
  echo "$value['the_title']";
  echo "</div>";

}

Referencia

Aquí hay otra forma de hacerlo:

$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);
    }
}

Si te entiendo, todo lo que necesitas es invertir la matriz y obtener el último elemento mediante un comando pop:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

También puede probar esto para hacer su consulta ... que se muestra aquí con 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;
?>

Para los scripts de generación de consultas SQL, o cualquier cosa que realice una acción diferente para el primer o el último elemento, es mucho más rápido (casi el doble de rápido) evitar el uso de comprobaciones de variables innecesarias.

La solución actual aceptada utiliza un bucle y una verificación dentro del bucle que se realizará en cada_site_iteración, la forma correcta (rápida) de hacer esto es la siguiente:

$numItems = count($arr);
$i=0;
$firstitem=$arr[0];
$i++;
while($i<$numItems-1){
    $some_item=$arr[$i];
    $i++;
}
$last_item=$arr[$i];
$i++;

Un pequeño punto de referencia casero mostró lo siguiente:

test1: 100000 ejecuciones del modelo morg

tiempo: 1869.3430423737 milisegundos

test2: 100000 ejecuciones de modelo si duran

tiempo: 3235.6359958649 milisegundos

Otra forma de hacerlo es recordar el resultado del ciclo de bucle anterior y usarlo como resultado final:

    $result = $where = "";
    foreach ($conditions as $col => $val) {
        $result = $where .= $this->getAdapter()->quoteInto($col.' = ?', $val);
        $where .=  " AND ";
    }
    return $this->delete($result);

Personalmente utilizo este tipo de construcción que permite un uso fácil con los elementos html <ul> y <li>: simplemente cambie la igualdad para otra propiedad ...

La matriz no puede contener elementos falsos, pero todos los demás elementos que se convierten en el booleano falso.

$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;
}

Puede obtener directamente el último índice de la siguiente manera:

$numItems = count($arr);

echo $arr[$numItems-1];

<?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;?>

Aquí está mi solución: simplemente obtenga el recuento de su matriz, menos 1 (ya que comienzan en 0).

$lastkey = count($array) - 1;
foreach($array as $k=>$a){
    if($k==$lastkey){
        /*do something*/
    }
}