Suchen Sie das letzte Element eines Arrays, während Sie eine foreach-Schleife in PHP verwenden

Ich schreibe einen SQL-Abfrageersteller mit einigen Parametern. In Java ist es sehr einfach, das letzte Element eines Arrays aus der for-Schleife heraus zu erkennen, indem Sie einfach die aktuelle Array-Position mit der Array-Länge überprüfen.

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

In PHP haben sie nicht ganzzahlige Indizes, um auf Arrays zuzugreifen. Sie müssen also mit einer foreach-Schleife über ein Array iterieren. Dies wird problematisch, wenn Sie eine Entscheidung treffen müssen (in meinem Fall das Anhängen oder / und Parameter beim Erstellen einer Abfrage).

Ich bin sicher, dass es dafür einen Standard geben muss.

Wie löst man das in PHP?

Es hört sich so an, als ob Sie so etwas wollen:

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

Davon abgesehen müssen Sie nicht über ein "Array" iterieren, das foreachin PHP verwendet wird.

Sie können den Wert des letzten Schlüssels des Arrays mithilfe von ermitteln end(array_keys($array))und mit dem aktuellen Schlüssel vergleichen:

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

warum so kompliziert?

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

Dies fügt hinter jedem Wert außer dem letzten einen Wert hinzu!

Wenn toEnd 0 erreicht, bedeutet dies, dass es sich um die letzte Iteration der Schleife handelt.

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

Der letzte Wert ist nach der Schleife noch verfügbar. Wenn Sie ihn also nach der Schleife nur für weitere Aufgaben verwenden möchten, ist dies besser:

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

Wenn Sie den letzten Wert nicht als spezielle Innenschleife behandeln möchten. Dies sollte schneller sein, wenn Sie große Arrays haben. (Wenn Sie das Array nach der Schleife innerhalb desselben Bereichs wiederverwenden, müssen Sie zuerst das Array "kopieren").

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

Und um Ihre ursprüngliche Frage zu beantworten "in meinem Fall Anhängen oder / und Parameter beim Erstellen der Abfrage"; Dadurch werden alle Werte durchlaufen und dann zu einer Zeichenfolge mit "und" zwischen ihnen zusammengefügt, jedoch nicht vor dem ersten Wert oder nach dem letzten Wert:

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

Es gibt bereits viele Antworten, aber es lohnt sich auch, sich mit Iteratoren zu befassen, zumal nach einem Standardweg gefragt wurde:

$arr = range(1, 3);

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

Möglicherweise finden Sie etwas, das auch in anderen Fällen flexibler funktioniert.

Eine Möglichkeit könnte darin bestehen, festzustellen, ob der Iterator dies getan hat next. Wenn dem Iterator kein nächster zugeordnet ist, bedeutet dies, dass Sie sich in der letzten Schleife befinden.

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

Wenn Ihr Array also eindeutige Array-Werte hat, ist es trivial, die letzte Iteration zu bestimmen:

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

Wie Sie sehen, funktioniert dies, wenn das letzte Element nur einmal im Array erscheint, andernfalls erhalten Sie einen Fehlalarm. In diesem Fall müssen Sie nicht die Schlüssel vergleichen (die mit Sicherheit eindeutig sind).

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

Beachten Sie auch den strengen Coparision-Operator, der in diesem Fall sehr wichtig ist.

Angenommen, Sie haben das Array in einer Variablen gespeichert ...

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

um das erste und letzte Element aus jedem Array zu erhalten

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

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

Sie können diese Methode weiterhin mit assoziativen Arrays verwenden:

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

Wenn Sie für jedes Element etwas tun müssen, außer für das erste oder das letzte, und nur wenn das Array mehr als ein Element enthält, bevorzuge ich die folgende Lösung.

Ich weiß, dass es oben viele Lösungen gibt, die Monate / ein Jahr vor meinen veröffentlicht wurden, aber dies ist etwas, das ich für ziemlich elegant halte. Die Prüfung jeder Schleife ist auch eine boolesche Prüfung im Gegensatz zu einer numerischen Prüfung "i = (count-1)", die möglicherweise weniger Overhead ermöglicht.

Die Struktur der Schleife mag sich unangenehm anfühlen, aber Sie können sie mit der Reihenfolge von thead (Anfang), tfoot (Ende), tbody (aktuell) in HTML-Tabellen-Tags vergleichen.

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

Wenn Sie beispielsweise in Bezug auf die Webentwicklung jedem Element mit Ausnahme des letzten in einer ungeordneten Liste (ul) einen unteren Rand hinzufügen möchten, können Sie stattdessen jedem Element mit Ausnahme des ersten (CSS :) einen oberen Rand hinzufügen. Das erste Kind, das von IE7 + und Firefox / Webkit unterstützt wird, unterstützt diese Logik, während das letzte Kind von IE7 nicht unterstützt wird.

Sie können die Variable $ first auch für jede verschachtelte Schleife wiederverwenden, und die Dinge funktionieren einwandfrei, da jede Schleife $ first während des ersten Prozesses der ersten Iteration falsch macht (sodass Unterbrechungen / Ausnahmen keine Probleme verursachen). .

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

Beispielausgabe:

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)

Dies sollte der einfache Weg sein, um das letzte Element zu finden:

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

Referenz: Link

Ich habe das starke Gefühl, dass das OP an der Wurzel dieses "XY-Problems" nur implode()funktionieren wollte .

Da Ihre Absicht, das EOF-Array zu finden, nur für den Kleber ist. Machen Sie sich mit der folgenden Taktik vertraut. Sie müssen den EOF nicht benötigen:

$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

Wie wäre es mit "Ende"? http://php.net/manual/en/function.end.php

Es hört sich so an, als ob Sie so etwas wollen:

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

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

Fügen Sie nach dem letzten Wert kein Komma hinzu:

Das Array:

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

Die Funktion:

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

Das Ergebnis:

print $result;

Lorem, Ipsum, Dolor, sitzen, amet

Sie können zählen ().

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

oder wenn Sie NUR das letzte Element suchen, können Sie end () verwenden.

end(arr);

gibt nur das letzte Element zurück.

und wie sich herausstellt, können Sie PHP-Arrays nach Ganzzahlen indizieren. Es ist vollkommen zufrieden mit

arr[1];

Sie könnten auch so etwas tun:

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

     // more code
}

Ich mag das Folgende, da ich finde, dass es ziemlich ordentlich ist. Nehmen wir an, wir erstellen eine Zeichenfolge mit Trennzeichen zwischen allen Elementen: z. B. 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>";

}

Referenz

Hier ist eine andere Möglichkeit, wie Sie es tun können:

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

Wenn ich Sie verstehe, müssen Sie nur das Array umkehren und das letzte Element mit einem Pop-Befehl abrufen:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

Sie können dies auch versuchen, um Ihre Abfrage zu stellen ... hier mit INSERT angezeigt

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

Bei Skripten zur Generierung von SQL-Abfragen oder bei Skripten, die eine andere Aktion für das erste oder letzte Element ausführen, ist es viel schneller (fast doppelt so schnell), unnötige Variablenprüfungen zu vermeiden.

Die aktuell akzeptierte Lösung verwendet eine Schleife und eine Prüfung innerhalb der Schleife, die bei jeder einzelnen Wiederholung durchgeführt wird. Der richtige (schnelle) Weg, dies zu tun, ist der folgende:

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

Ein kleiner hausgemachter Benchmark zeigte Folgendes:

Test1: 100000 Läufe von Model Morg

Zeit: 1869.3430423737 Millisekunden

Test2: 100000 Modellläufe, wenn zuletzt

Zeit: 3235.6359958649 Millisekunden

Ein anderer Weg besteht darin, sich das vorherige Ergebnis des Schleifenzyklus zu merken und dieses als Endergebnis zu verwenden:

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

Ich persönlich verwende diese Art von Konstruktion, die eine einfache Verwendung mit HTML-Elementen ul und ul ermöglicht: Ändern Sie einfach die Gleichheit für eine andere Eigenschaft ...

Das Array kann keine falschen Elemente enthalten, sondern alle anderen Elemente, die in den falschen Booleschen Wert umgewandelt werden.

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

Sie können den letzten Index direkt erhalten, indem Sie:

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

Hier ist meine Lösung: Ermitteln Sie einfach die Anzahl Ihres Arrays minus 1 (da sie bei 0 beginnen).

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