PHP'de foreach döngüsü kullanırken bir dizinin son öğesini bulma

Bazı parametreleri kullanarak bir SQL sorgu yaratıcısı yazıyorum. Java'da, geçerli dizi konumunu sadece dizi uzunluğu ile kontrol ederek for döngüsünün içinden bir dizinin son öğesini algılamak çok kolaydır.

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

PHP'de dizilere erişmek için tamsayı olmayan dizinler vardır. Bu nedenle, foreach döngüsü kullanarak bir dizi üzerinden yineleme yapmanız gerekir. Bazı kararlar almanız gerektiğinde bu sorunlu hale gelir (benim durumumda sorgu oluştururken veya / ve parametre eklemek için).

Eminim bunu yapmanın standart bir yolu olmalı.

PHP'de bunu nasıl çözersiniz?

Kulağa şöyle bir şey istiyormuşsunuz gibi geliyor:

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

Olduğu söyleniyor, foreachphp kullanarak bir "dizi" üzerinde yineleme -have- yok .

Kullanarak dizinin son anahtarının değerini alabilir end(array_keys($array))ve geçerli anahtarla karşılaştırabilirsiniz:

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

neden bu kadar karmaşık?

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

Bu, sonuncusu hariç her değerin arkasına a ekleyecektir!

ToEnd, 0'a ulaştığında, döngünün son tekrarında olduğu anlamına gelir.

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

Döngüden sonra son değer hala kullanılabilir, bu yüzden döngüden sonra daha fazla şey için kullanmak istiyorsanız, bu daha iyidir:

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

Son değeri döngüler içinde özel olarak değerlendirmek istemiyorsanız. Büyük dizileriniz varsa bu daha hızlı olmalıdır. (Diziyi aynı kapsamdaki döngüden sonra yeniden kullanırsanız, önce diziyi "kopyalamanız gerekir").

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

Ve orijinal sorunuzu cevaplamak için "benim durumumda sorgu oluşturmak için ve / veya parametre oluşturmak"; bu, tüm değerlerin üzerinden geçer ve ardından aralarında "ve" bulunan bir dizeye birleştirilir, ancak ilk değerden önce veya son değerden sonra olmaz:

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

Zaten birçok cevap var, ancak özellikle standart bir yol istendiği için yineleyicilere de bakmaya değer:

$arr = range(1, 3);

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

Diğer durumlar için de daha esnek çalışan bir şey bulabilirsiniz.

Bir yol, yineleyicinin olup olmadığını tespit etmek olabilir next. Yineleyiciye bir sonraki bağlı değilse, son döngüde olduğunuz anlamına gelir.

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

Dolayısıyla, dizinizde benzersiz dizi değerleri varsa, son yinelemeyi belirlemek önemsizdir:

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

Gördüğünüz gibi, bu son öğe dizide sadece bir kez görünüyorsa çalışır, aksi takdirde yanlış alarm alırsınız. İçinde değil, anahtarları karşılaştırmanız gerekir (ki bu kesinlikle benzersizdir).

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

Ayrıca, bu durumda oldukça önemli olan sıkı coparision operatörüne de dikkat edin.

Diziyi bir değişkende sakladığınız varsayılarak ...

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

foreach dizisinden ilk ve son öğeyi almak için

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

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

Yine de ilişkilendirilebilir dizilerle bu yöntemi kullanabilirsiniz:

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

İlk veya son hariç her öğe için bir şeyler yapmanız gerekiyorsa ve yalnızca dizide birden fazla öğe varsa, aşağıdaki çözümü tercih ederim.

Yukarıda birçok çözüm olduğunu biliyorum ve aylar / bir yıl önce yayınladım, ama bu kendi başına oldukça zarif olduğunu düşündüğüm bir şey. Her döngüyü kontrol et, sayısal "i = (sayım-1)" kontrolünün aksine bir boole kontrolüdür, bu da daha az ek yüke izin verebilir.

Döngünün yapısı garip gelebilir, ancak HTML tablosu etiketlerinde thead (başlangıç), tfoot (son), tbody (geçerli) sıralamasıyla karşılaştırabilirsiniz.

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

Örneğin, web geliştirme terimleriyle, sırasız bir listede (ul) sonuncusu hariç her öğeye kenarlık eklemek istiyorsanız, bunun yerine ilk öğenin (CSS: IE7 + ve Firefox / Webkit tarafından desteklenen ilk çocuk bu mantığı desteklerken, son çocuk IE7 tarafından desteklenmez).

Her bir iç içe döngü için $ first değişkenini yeniden kullanmakta özgürsünüz ve her döngü ilk yinelemenin ilk işlemi sırasında $ first false yapar (bu nedenle molalar / istisnalar sorunlara neden olmaz) .

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

Örnek çıktı:

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)

Son öğeyi bulmanın kolay yolu bu olmalıdır:

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

Referans: Bağlantı

Bu "XY probleminin" kökünde OP'nin sadece implode()işlev görmek istediğine dair güçlü bir his var .

EOF dizisini bulma niyetiniz sadece tutkal içindir. Aşağıdaki taktik tanıtılın. EOF'a ihtiyacınız yoktur:

$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

"End" kullanmaya ne dersiniz? http://php.net/manual/en/function.end.php

Kulağa şöyle bir şey istiyormuşsunuz gibi geliyor:

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

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

Son değerden sonra virgül eklemeyin:

Dizi:

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

İşlev:

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

Sonuç:

print $result;

lorem, ipsum, dolor, oturmak, amet

bir count () yapabilirsiniz.

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

veya SADECE son elemanı arıyorsanız end () öğesini kullanabilirsiniz.

end(arr);

yalnızca son öğeyi döndürür.

ve ortaya çıktığı gibi, php dizilerini tamsayılarla endeksleyebilirsiniz. İle çok mutlu

arr[1];

Bunun gibi bir şey de yapabilirsiniz:

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

     // more code
}

Oldukça düzenli olduğunu düşündüğüm için aşağıdaki gibi. Diyelim ki tüm öğeler arasında ayırıcılar olan bir dize oluşturuyoruz: örneğin 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>";

}

Referans

İşte bunu yapmanın başka bir yolu:

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

Seni anlıyorsam, o zaman tek gereken diziyi tersine çevirmek ve bir pop komutu ile son elemanı almak:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

Sorgunuzu yapmak için de bunu deneyebilirsiniz ... burada INSERT ile gösterilmiştir

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

SQL sorgusu üreten komut dosyaları veya ilk veya son öğeler için farklı bir işlem yapan herhangi bir şey için, gereksiz değişken denetimleri kullanmaktan kaçınmak çok daha hızlıdır (neredeyse iki kat daha hızlıdır).

Kabul edilen geçerli çözüm, döngü içinde bir döngü ve her_single_iteration yapılacak bir denetim kullanır, bunu yapmanın doğru (hızlı) yolu aşağıdaki gibidir:

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

Küçük bir ev yapımı kriter şunları gösterdi:

test1: model morg 100000 çalışır

zaman: 1869.3430423737 milisaniye

test2: 100000 model son çalışırsa

zaman: 3235.6359958649 milisaniye

Gitmenin bir başka yolu, önceki döngü döngüsü sonucunu hatırlamak ve bunu sonuç olarak kullanmaktır:

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

Ben şahsen html <ul> ve <li> elemanları ile kolay kullanım sağlayan bu tür bir yapı kullanıyorum: sadece başka bir mülk için eşitliği değiştirin ...

Dizi yanlış öğeler içeremez ancak false boolean içine dökülen diğer tüm öğeleri içerir.

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

Son dizini dirctly alabilirsiniz:

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

İşte benim çözümüm: Dizinizin sayısını (eksi 1) alın (0'da başladığından beri).

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