Encontre o último elemento de uma matriz enquanto usa um loop foreach no PHP

Estou escrevendo um criador de consultas SQL usando alguns parâmetros. Em Java, é muito fácil detectar o último elemento de uma matriz de dentro do loop for, apenas verificando a posição atual da matriz com o comprimento da matriz.

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

No PHP, eles têm índices não inteiros para acessar matrizes. Portanto, você deve iterar sobre uma matriz usando um loop foreach. Isso se torna problemático quando você precisa tomar alguma decisão (no meu caso, para adicionar ou / e parâmetro durante a criação da consulta).

Estou certo de que deve haver alguma maneira padrão de fazer isso.

Como você resolve isso em PHP?

Parece que você quer algo assim:

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

Dito isto, você não precisa iterar sobre um "array" usando foreachno php.

Você pode obter o valor da última chave da matriz usando end(array_keys($array))e compará-lo com a chave atual:

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

por que tão complicado?

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

Isso adicionará a, por trás de cada valor, exceto o último!

Quando toEnd atinge 0, significa que está na última iteração do loop.

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

O último valor ainda está disponível após o loop, portanto, se você quiser usá-lo para mais coisas após o loop, é melhor:

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

Se você não deseja tratar o último valor como loops internos especiais. Isso deve ser mais rápido se você tiver grandes matrizes. (Se você reutilizar a matriz após o loop dentro do mesmo escopo, precisará "copiar" a matriz primeiro).

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

E para responder à sua pergunta original "no meu caso, para adicionar ou / e parâmetro durante a criação da consulta"; isso fará um loop sobre todos os valores e juntará-os a uma string com "e" entre eles, mas não antes do primeiro valor ou após o último valor:

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

Já existem muitas respostas, mas vale a pena examinar também os iteradores, especialmente porque foi solicitado um caminho padrão:

$arr = range(1, 3);

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

Você também pode encontrar algo que funcione mais flexível para outros casos.

Uma maneira poderia ser detectar se o iterador possui next. Se não houver outro anexo ao iterador, significa que você está no último loop.

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

Portanto, se sua matriz possui valores exclusivos, determinar a última iteração é trivial:

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

Como você vê, isso funciona se o último elemento estiver aparecendo apenas uma vez na matriz, caso contrário, você receberá um alarme falso. Nesse caso, você deve comparar as chaves (que são únicas, com certeza).

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

Observe também o operador de coparisão estrito, o que é bastante importante neste caso.

Supondo que você tenha a matriz armazenada em uma variável ...

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

para obter o primeiro e o último elemento da matriz foreach

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

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

Você ainda pode usar esse método com matrizes associativas:

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

Se você precisar fazer algo para cada elemento, exceto o primeiro ou o último e somente se houver mais de um elemento na matriz, prefiro a solução a seguir.

Sei que existem muitas soluções acima e postadas meses / um ano antes da minha, mas isso é algo que considero bastante elegante por si só. A verificação de cada loop também é uma verificação booleana, em oposição a uma verificação numérica "i = (contagem-1)", que pode permitir menos sobrecarga.

A estrutura do loop pode parecer estranha, mas você pode compará-la com a ordem de thead (início), tfoot (final), tbody (atual) nas tags da tabela 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 exemplo, em termos de desenvolvimento da web, se você deseja adicionar uma borda inferior a todos os elementos, exceto o último de uma lista não ordenada (ul), poderá adicionar uma borda superior a todos os elementos, exceto o primeiro (o CSS: o primeiro filho, suportado pelo IE7 + e Firefox / Webkit, suporta essa lógica, enquanto que: o último filho não é suportado pelo IE7).

Você pode ficar à vontade para reutilizar a variável $ first para cada loop aninhado e tudo funcionará bem, pois cada loop torna o $ first falso durante o primeiro processo da primeira iteração (para que interrupções / exceções não causem 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;

Exemplo de saída:

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)

Essa deve ser a maneira mais fácil de encontrar o último elemento:

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

Referência: Link

Tenho uma forte sensação de que, na raiz desse "problema XY", o OP queria apenas implode()funcionar.

Como sua intenção de encontrar a matriz EOF é apenas para a cola. Seja apresentado à tática abaixo. Você não precisa do 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

Que tal usar "end"? http://php.net/manual/en/function.end.php

Parece que você quer algo assim:

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

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

Não adicione vírgula após o último valor:

A matriz:

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

A função:

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

O resultado:

print $result;

lorem, ipsum, dolor, sente-se, amet

você pode fazer uma contagem ().

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

ou se você estiver procurando APENAS o último elemento, poderá usar end ().

end(arr);

retorna apenas o último elemento.

e, como se vê, você PODE indexar matrizes php por números inteiros. É perfeitamente feliz com

arr[1];

Você também pode fazer algo assim:

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

     // more code
}

Eu meio que gosto do seguinte, pois acho que é bastante legal. Vamos supor que estamos criando uma string com separadores entre todos os elementos: por exemplo, 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>";

}

Referência

Aqui está outra maneira de fazer isso:

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

Se eu entendo você, tudo o que você precisa é reverter a matriz e obter o último elemento por um comando pop:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

Você também pode tentar fazer essa consulta ... mostrada aqui com 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 scripts de geração de consultas SQL, ou qualquer coisa que execute uma ação diferente para o primeiro ou o último elemento, é muito mais rápido (quase o dobro da velocidade) evitar o uso de verificações desnecessárias de variáveis.

A solução atual aceita usa um loop e uma verificação dentro do loop que será feita a cada_a única_iteração, a maneira correta (rápida) de fazer isso é a seguinte:

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

Um pequeno benchmark caseiro mostrou o seguinte:

test1: 100000 execuções do modelo morg

tempo: 1869.3430423737 milissegundos

test2: 100000 execuções do modelo, se houver

tempo: 3235.6359958649 milissegundos

Outro caminho a percorrer é lembrar o resultado do ciclo de loop anterior e usá-lo como resultado final:

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

Eu pessoalmente uso esse tipo de construção que permite um uso fácil com os elementos html <ul> e <li>: basta alterar a igualdade de uma outra propriedade ...

A matriz não pode conter itens falsos, mas todos os outros itens que são convertidos no falso booleano.

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

Você pode obter o último índice diretamente:

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

Aqui está minha solução: Simplesmente obtenha a contagem do seu array, menos 1 (já que eles começam em 0).

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