Trova l'ultimo elemento di un array mentre usi un ciclo foreach in PHP

Sto scrivendo un creatore di query SQL utilizzando alcuni parametri. In Java, è molto facile rilevare l'ultimo elemento di un array dall'interno del ciclo for semplicemente controllando la posizione corrente dell'array con la lunghezza dell'array.

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

In PHP hanno indici non interi per accedere agli array. Quindi è necessario scorrere su un array usando un ciclo foreach. Ciò diventa problematico quando è necessario prendere una decisione (nel mio caso aggiungere o / e parametri durante la creazione di query).

Sono sicuro che ci deve essere un modo standard per farlo.

Come risolvi questo problema in PHP?

Sembra che tu voglia qualcosa del genere:

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

Detto questo, non devi -erare su un "array" usando foreachin php.

È possibile ottenere il valore dell'ultima chiave dell'array utilizzando end(array_keys($array))e confrontandolo con la chiave corrente:

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

perché così complicato?

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

Questo aggiungerà un, dietro ogni valore tranne l'ultimo!

Quando toEnd raggiunge 0 significa che è all'ultima iterazione del ciclo.

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

L'ultimo valore è ancora disponibile dopo il ciclo, quindi se vuoi semplicemente usarlo per più cose dopo il ciclo, è meglio:

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

Se non si desidera trattare l'ultimo valore come speciali loop interni. Questo dovrebbe essere più veloce se si dispone di array di grandi dimensioni. (Se riutilizzi l'array dopo il loop all'interno dello stesso ambito, devi prima "copiare" l'array).

//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 per rispondere alla tua domanda originale "nel mio caso di aggiungere o / e parametro durante la creazione di query"; questo eseguirà il ciclo su tutti i valori, quindi li unirà insieme a una stringa con "e" tra loro ma non prima del primo valore o dopo l'ultimo valore:

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

Esistono già molte risposte, ma vale anche la pena esaminare gli iteratori, soprattutto perché è stato chiesto un modo standard:

$arr = range(1, 3);

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

Potresti trovare qualcosa che funzioni in modo più flessibile anche per altri casi.

Un modo potrebbe essere quello di rilevare se l'iteratore ha next. Se non c'è nessun prossimo attaccato all'iteratore significa che sei nell'ultimo ciclo.

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

Quindi, se l'array ha valori di array univoci, determinare l'ultima iterazione è banale:

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

Come vedi, questo funziona se l'ultimo elemento appare solo una volta nella matrice, altrimenti si ottiene un falso allarme. In caso contrario, devi confrontare le chiavi (che sono univoche di sicuro).

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

Si noti inoltre il rigoroso operatore di coparisione, che è abbastanza importante in questo caso.

Supponendo che l'array sia archiviato in una variabile ...

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

per ottenere il primo e l'ultimo elemento dall'array foreach

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

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

È ancora possibile utilizzare quel metodo con array associativi:

$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 devi fare qualcosa per ogni elemento tranne il primo o l'ultimo e solo se nell'array è presente più di un elemento, preferisco la seguente soluzione.

So che ci sono molte soluzioni sopra e pubblicate mesi / un anno prima della mia, ma questo è qualcosa che ritengo abbastanza elegante a sé stante. Il controllo di ogni ciclo è anche un controllo booleano rispetto a un controllo numerico "i = (count-1)", che può consentire un minor sovraccarico.

La struttura del loop può sembrare scomoda, ma puoi confrontarla con l'ordinamento di thead (inizio), tfoot (fine), tbody (corrente) nei tag della tabella 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;
}

Ad esempio, in termini di sviluppo Web, se si desidera aggiungere un bordo inferiore a ogni elemento tranne l'ultimo in un elenco non ordinato (ul), è possibile invece aggiungere un bordo superiore a ogni elemento tranne il primo (CSS: first-child, supportato da IE7 + e Firefox / Webkit supporta questa logica, mentre: last-child non è supportato da IE7).

Puoi sentirti libero di riutilizzare anche la prima variabile $ per ogni ciclo nidificato e le cose funzioneranno bene poiché ogni ciclo rende $ first falso durante il primo processo della prima iterazione (quindi interruzioni / eccezioni non causeranno problemi) .

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

Esempio di output:

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)

Questo dovrebbe essere il modo più semplice per trovare l'ultimo elemento:

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

Riferimento: Link

Ho la netta sensazione che alla radice di questo "problema XY" l'OP volesse semplicemente implode()funzionare.

Poiché la tua intenzione di trovare l'array EOF è solo per la colla. Fatti conoscere la tattica di seguito. Non è necessario richiedere 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;

operazione:

column1 = value1 AND column2 = value2 AND column3 = value3

Che ne dici di usare "end"? http://php.net/manual/en/function.end.php

Sembra che tu voglia qualcosa del genere:

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

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

Non aggiungere una virgola dopo l'ultimo valore:

La matrice:

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

La funzione:

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

Il risultato:

print $result;

Lorem ipsum dolor sit amet

puoi fare un conteggio ().

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

o se stai cercando SOLO l'ultimo elemento, puoi usare end ().

end(arr);

restituisce solo l'ultimo elemento.

e, a quanto pare, PUOI indicizzare matrici php per numeri interi. È perfettamente soddisfatto

arr[1];

Potresti anche fare qualcosa del genere:

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

     // more code
}

In un certo senso mi piace quanto segue perché mi sembra abbastanza pulito. Supponiamo di creare una stringa con separatori tra tutti gli elementi: ad esempio 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>";

}

Riferimento

Ecco un altro modo per farlo:

$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 ti capisco, tutto ciò che serve è invertire l'array e ottenere l'ultimo elemento con un comando pop:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

Puoi anche provare questo per rendere la tua query ... mostrata qui 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;
?>

Per le query SQL che generano script o tutto ciò che compie un'azione diversa per il primo o l'ultimo elemento, è molto più veloce (quasi due volte più veloce) per evitare l'uso di controlli variabili non necessari.

La soluzione attualmente accettata utilizza un ciclo e un controllo all'interno del ciclo che verrà eseguito every_single_iteration, il modo corretto (veloce) per farlo è il seguente:

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

Un piccolo benchmark fatto in casa ha mostrato quanto segue:

test1: 100000 serie di modelli morg

tempo: 1869.3430423737 millisecondi

test2: 100000 esecuzioni del modello se ultimo

tempo: 3235.6359958649 millisecondi

Un altro modo di procedere è ricordare il risultato del ciclo precedente e usarlo come risultato finale:

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

Personalmente uso questo tipo di costruzione che consente un facile utilizzo con gli elementi html <ul> e <li>: basta cambiare l'uguaglianza per un'altra proprietà ...

L'array non può contenere elementi falsi ma tutti gli altri elementi che vengono lanciati nel 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;
}

Puoi ottenere direttamente l'ultimo indice per:

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

Ecco la mia soluzione: è sufficiente ottenere il conteggio dell'array, meno 1 (poiché iniziano in 0).

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