PHP में फ़ॉरच लूप का उपयोग करते हुए किसी सरणी का अंतिम तत्व खोजें

Question

मैं कुछ मापदंडों का उपयोग करते हुए SQL क्वेरी क्रिएटर लिख रहा हूं। जावा में, सरणी की लंबाई के साथ केवल वर्तमान सरणी स्थिति की जांच करके लूप के लिए अंदर से किसी सरणी के अंतिम तत्व का पता लगाना बहुत आसान है।

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

PHP में सरणियों का उपयोग करने के लिए उनके पास गैर-पूर्णांक अनुक्रमित हैं। तो आपको एक फॉरेस्ट लूप का उपयोग करके एक सरणी पर पुनरावृत्त करना होगा। यह तब समस्याग्रस्त हो जाता है जब आपको कुछ निर्णय लेने की आवश्यकता होती है (क्वेरी के निर्माण के दौरान अपील करने और / या पैरामीटर के मामले में)।

मुझे यकीन है कि ऐसा करने का कुछ मानक तरीका होना चाहिए।

आप इसे PHP में कैसे हल करते हैं?

Comments

क्या आप यह निर्धारित करने की कोशिश कर रहे हैं कि क्या आपको एक खंड के कुछ हिस्सों के बीच "और" या "या" को संक्षिप्त करना चाहिए?

— डैरिल हेन

सिर्फ यह इंगित करने के लिए कि आपको प्रत्येक पुनरावृत्ति के लिए एक विधि को कॉल करने के बजाय कुल को एक चर में संग्रहीत करना चाहिए। for (int i = 0, int t = arr.length; मैं <t; i ++)।

— OIS

stackoverflow.com/questions/156650/…

— xtofl

इस समाधान पर एक नज़र डालें: stackoverflow.com/a/29474468/1478566

— vbarbarosh

उपयोग अंत (ऐरे) सिमेरिलर उत्तर का उपयोग करें

— विशाख बी सुजानथन

Answer 1

ऐसा लगता है कि आप ऐसा कुछ चाहते हैं:

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

कहा जा रहा है, आप foreachphp का उपयोग कर एक "सरणी" पर पुनरावृति करने के लिए -have नहीं है ।

Comments

मुझे लगता है कि मैं इस समाधान के लिए जाऊंगा क्योंकि यह लगभग मेरे द्वारा पोस्ट किए गए कोड के समान है। यहां तक ​​कि जेरेमी का जवाब अच्छी तरह से फिट है, लेकिन मुझे लगता है कि यह इस की तुलना में थोड़ा जटिल है। मैंने कोई परीक्षण नहीं किया है, लेकिन मुझे लगता है कि यह उत्तर तेज होगा क्योंकि यह कुंजी का सरणी नहीं निकाल रहा है। इसमें O (1) की गति होगी

— वैभव कांबले

$numItems = count($arr)चाल की जरूरत नहीं है और पठनीयता को कम करता है - PHP में हर बार गिनती ($ गिरफ्तारी) तक पहुंचने के लिए कोई प्रदर्शन दंड नहीं है। इसका कारण यह है कि आइटम की गिनती को आंतरिक रूप से सरणी हेडर में विशेष क्षेत्र के रूप में सहेजा जाता है और ऐसा नहीं है गणना ऑन-द-फ्लाई जाती है। यह ट्रिक अन्य भाषाओं (C, Java; ... ...) से आती है।

— जॉन्डोडो

यह दिलचस्प @johndodo है कि हर बार गिनती ($ गिरफ्तारी) तक पहुँचने के लिए कोई प्रदर्शन जुर्माना नहीं है। क्या आपके पास कोई लिंक / स्रोत है जहाँ इस विशेष अनुकूलन को प्रलेखित किया गया है? धन्यवाद!

— ज़ुलाउज़

यह बल्कि दुख की बात है कि PHP में इस समस्या का सबसे सही समाधान

— असाध्य

@tomsihap $ मुझे लूप के अंदर बढ़ाना पड़ता है, सरणी पुनरावृत्ति के साथ अग्रानुक्रम में। $ i को सरणी में आइटम की संख्या का प्रतिनिधित्व करने की आवश्यकता है, ताकि इसका उपयोग यह निर्धारित करने के लिए किया जा सके कि अंतिम आइटम कब पहुंचा है। ++ के बिना लूप केवल "0" आइटम की कुल संख्या के साथ तुलना करेगा।

— बॉबी जैक

Answer 2

आप सरणी के अंतिम कुंजी का मान प्राप्त कर सकते हैं end(array_keys($array))और वर्तमान कुंजी से तुलना कर सकते हैं:

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

Comments

+1 I सहमत - अन्य समाधान संख्यात्मक सूचकांक वाले सरणी पर निर्भर करते हैं।

— पैट्रिक ग्लैंडियन

मेरी खुद की रक्षा में, मेरा जवाब संख्यात्मक कुंजियाँ रखने वाले सरणी पर निर्भर नहीं है :)

— रिचर्ड लेवाससेय

स्ट्रिंग तुलना धीमी है तो पूर्णांक, और हमेशा सटीक नहीं होती है जब तार से पूर्णांक की तुलना करें (आपको कम से कम === का उपयोग करना चाहिए)। Im यह नीचे मतदान।

— OIS

यह सुरुचिपूर्ण है, लेकिन STRICT नोटिस का कारण बनता है क्योंकि "अंत" एक संदर्भ मूल्य की उम्मीद करता है :(

— विलीम

STRICT सूचना के लिए फिक्स:$lastKey = array_search(end($array), $array);

— Ajax

Answer 3

इतना जटिल क्यों?

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

यह पिछले एक को छोड़कर हर मान के पीछे एक जोड़ देगा!

Comments

नहीं अगर अगले $ इनपुट में गलत का बूलियन मान है, जो अगले () के साथ एक बड़ी समस्या है।

— आत्मासेकाह

जब तक मैं गलत नहीं हूँ, यह काम नहीं करता है क्योंकि कॉलिंग आगे () सरणी पॉइंटर को आगे बढ़ाती है, इसलिए आप हर दूसरे तत्व को लूप में छोड़ रहे हैं।

— जॉर्डन लेव

मेरे लिए काम करने के लिए प्रतीत नहीं होता है। दूसरा अंतिम तत्व अल्पविराम नहीं मिलता है, लेकिन यह होना चाहिए।

— ज़ुलाउज़

यदि मान बूल झूठी के बराबर है तो यह काम नहीं करता है। अंतिम से अंतिम और अंतिम मान के बीच अंतिम कॉमा भी मुद्रित नहीं करता है।

— OIS

PHP7 में इसका उपयोग करने के इच्छुक किसी व्यक्ति के लिए एक नोट - सरणी पॉइंटर फ़ॉरच लूप में नहीं जाता है, और यह काम नहीं करेगा।

— स्कॉट फ्लैक

Answer 4

जब टोन्ड 0 पर पहुंचता है तो इसका मतलब है कि यह लूप के अंतिम पुनरावृत्ति पर है।

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

अंतिम मूल्य लूप के बाद भी उपलब्ध है, इसलिए यदि आप इसे लूप के बाद अधिक सामान के लिए उपयोग करना चाहते हैं तो यह बेहतर है:

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

यदि आप अंतिम मूल्य को विशेष छोरों के रूप में इलाज नहीं करना चाहते हैं। यदि आपके पास बड़े एरेज़ हैं तो यह तेज़ होना चाहिए। (यदि आप उसी दायरे के अंदर लूप के बाद सरणी का पुन: उपयोग करते हैं तो आपको पहले सरणी को "कॉपी" करना होगा)।

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

और क्वेरी बनाने के दौरान अपने मूल प्रश्न का उत्तर देने के लिए "मेरे मामले में अपील या / और पैरामीटर के लिए"; यह सभी मानों पर लूप करेगा, फिर उन्हें एक स्ट्रिंग में "और" के साथ मिलाएं, लेकिन पहले मान से पहले या अंतिम चरण के बाद नहीं:

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

Comments

निश्चित रूप से यह - प्रत्येक प्रदर्शन के लिए $ $ और प्रदर्शन करेगा, इस बिंदु पर। अगर मैं इसे लूप के बाहर ले जाता, तो यह काम नहीं करता।

— OIS

अब तक की सबसे सरल विधि। $lastValue = array_pop($array);धन्यवाद।

— इलायस निकोलस

Answer 5

पहले से ही कई जवाब हैं, लेकिन यह पुनरावृत्तियों पर भी ध्यान देने योग्य है, खासकर यह एक मानक तरीके के लिए कहा गया है:

$arr = range(1, 3);

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

आपको ऐसा कुछ मिल सकता है जो अन्य मामलों के लिए अधिक लचीला काम करता है।

Comments

बहुत बढ़िया जवाब। मैं सराहना करता हूं कि आप उस भाषा की विशेषताओं का उपयोग कर रहे हैं जो कार्य के लिए अभिप्रेत है। i=0;और ++i;हमेशा PHP जैसी स्क्रिप्टिंग भाषा में हैकिंग लगता है।

— चेडरमोन्की

Answer 6

एक तरीका यह पता लगाने के लिए हो सकता है कि क्या इटरेटर है next। यदि पुनरावृत्ति से कोई अगला जुड़ा नहीं है, तो इसका मतलब है कि आप अंतिम लूप में हैं।

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

Comments

मुझे लगता है कि यह सबसे आसान तरीका है और इसके लिए सबसे कम राशि की आवश्यकता होती है!

— हाय इम ज़वहेन

PHP 7+ के साथ काम नहीं करता है "PHP 7 में, फॉर्च्यूनर आंतरिक सरणी पॉइंटर का उपयोग नहीं करता है।"

— डेमियन डेबिन

Answer 7

इसलिए, यदि आपके सरणी में विशिष्ट सरणी मान हैं, तो अंतिम पुनरावृत्ति का निर्धारण तुच्छ है:

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

जैसा कि आप देखते हैं, यह काम करता है यदि अंतिम तत्व सरणी में सिर्फ एक बार दिखाई दे रहा है, अन्यथा आपको गलत अलार्म मिलता है। इसमें, आपको कुंजियों की तुलना नहीं करनी है (जो निश्चित रूप से अद्वितीय हैं)।

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

सख्त कॉपर्शन ऑपरेटर पर भी ध्यान दें, जो इस मामले में काफी महत्वपूर्ण है।

Comments

यह काफी अक्षम तरीका है।

— आपका कॉमन सेंस

नहीं। यह नहीं। अंत () O (1) करता है। यह अन्य समाधानों की तुलना में भी कम है, और यह अच्छी तरह से पढ़ता है -> यदि तत्व सरणी के अंत के बराबर होता है "अंतिम" लिखें।

— रोक क्रालज

यह 100000 मूल्यों के लिए मेरे पहले और अंतिम उदाहरणों की तुलना में दोगुना है।

— OIS

Answer 8

मान लें कि आपके पास एक चर में संग्रहीत सरणी है ...

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

Comments

यह बहुत ही सरल और उपयोगी है। मैं केवल पहले फॉरेस्ट लूप के बाहर सरणी की गणना करूंगा ताकि प्रोग्राम को प्रत्येक आइटम का मूल्यांकन करने के लिए हर बार गिनना न पड़े।

— पथरोस

यह साहचर्य सरणियों पर काम नहीं करेगा। $ कुंजी हमेशा एक संख्या नहीं होती है।

— जोनाथन

Answer 9

पहले और अंतिम तत्व के लिए foreach array से प्राप्त करें

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

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

Answer 10

आप अभी भी सहयोगी सरणियों के साथ उस विधि का उपयोग कर सकते हैं:

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

Comments

कृपया $ कुंजी = $ सरणी [$ i] बदलें; से $ कुंजी = $ कुंजी [$ i]; लूप के लिए पहले में।

— नारेक

Answer 11

यदि आपको पहले या अंतिम को छोड़कर हर तत्व के लिए कुछ करने की आवश्यकता है और केवल अगर सरणी में एक से अधिक तत्व हैं, तो मैं निम्नलिखित समाधान पसंद करता हूं।

मुझे पता है कि मेरे पहले एक / एक साल से ऊपर और पोस्ट किए गए कई समाधान हैं, लेकिन यह कुछ ऐसा है जो मुझे लगता है कि अपने आप में काफी सुरुचिपूर्ण है। चेक प्रत्येक लूप भी एक बूलियन चेक है जो एक संख्यात्मक "i = (काउंट -1)" चेक के विपरीत है, जो कम ओवरहेड के लिए अनुमति दे सकता है।

लूप की संरचना अजीब लग सकती है, लेकिन आप इसे HTML तालिका टैग्स में थ्रेड (शुरुआत), tfoot (अंत), tbody (वर्तमान) के क्रम से तुलना कर सकते हैं।

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

उदाहरण के लिए, वेब डेवलपमेंट के संदर्भ में, यदि आप अनऑर्डर किए गए सूची (ul) में अंतिम को छोड़कर हर तत्व में बॉर्डर-बॉटम जोड़ना चाहते हैं , तो आप पहले (CSS) को छोड़कर हर एलिमेंट में बॉर्डर-टॉप जोड़ सकते हैं : IE7 + और फ़ायरफ़ॉक्स / वेबकिट द्वारा समर्थित पहला-बच्चा इस तर्क का समर्थन करता है, जबकि: पिछला बच्चा IE7 द्वारा समर्थित नहीं है)।

आप प्रत्येक और हर नेस्टेड लूप के लिए $ पहले चर का फिर से उपयोग करने के लिए स्वतंत्र महसूस कर सकते हैं और चीजें ठीक काम करेंगी क्योंकि हर लूप पहले पुनरावृत्ति की पहली प्रक्रिया के दौरान $ फर्जी बनाता है (इसलिए ब्रेक / अपवाद मुद्दों का कारण नहीं होगा) ।

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

उदाहरण आउटपुट:

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)

Comments

Thanx, यह मेरा पसंदीदा समाधान है! यह बहुत लचीला है और इसकी कीमत केवल एक बूलियन है। BTW, मुझे लगता है कि यह कम से कम एक तत्व भी सरणी के लिए काम करेगा (न केवल एक तत्व से अधिक )।

— jc

Answer 12

यह अंतिम तत्व खोजने का आसान तरीका होना चाहिए:

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

संदर्भ: लिंक

Comments

- टूटी हुई कड़ी -

— T30

Answer 13

मुझे इस बात का अहसास है कि इस "XY समस्या" की जड़ में ओपी सिर्फ implode()कार्य करना चाहता था ।

Comments

सच। हालांकि ऐसे मामले भी हैं, जिनमें निहितार्थ उतना व्यावहारिक नहीं है। उदाहरण के लिए कल्पना करें कि इसमें बहुत सारे डायनामिक वैरिएबल के साथ html की एक लंबी स्ट्रिंग को फंसाने की कोशिश की जा रही है। निश्चित रूप से, आप इस पर एक ob_start / ob_get_clean कर सकते हैं, या बस इसे $ str = '...' के रूप में निर्मित कर सकते हैं। लेकिन, कई बार ऐसा होता है जब इसे सिर्फ एक ओवर ओवरकिल माना जा सकता है

— एलेस्टेयर ब्रायन

Answer 14

EOF सरणी को खोजने का आपका उद्देश्य सिर्फ गोंद के लिए है। नीचे दिए गए रणनीति से परिचित कराएं। आपको 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;

ओ / p:

column1 = value1 AND column2 = value2 AND column3 = value3

Answer 15

"अंत" का उपयोग करने के बारे में कैसे? http://php.net/manual/en/function.end.php

Answer 16

ऐसा लगता है कि आप ऐसा कुछ चाहते हैं:

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

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

Comments

मान का उपयोग करना आमतौर पर एक अच्छा विचार नहीं है क्योंकि अगर सरणी के दो समान मूल्य हैं तो यह ठीक से काम नहीं करेगा।

— ०

Answer 17

अंतिम मान के बाद अल्पविराम न जोड़ें:

सरणी:

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

कार्यक्रम:

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

परिणाम:

print $result;

लोरेन इपसाम डलार सिट आमेट

Answer 18

आप एक गिनती () कर सकते हैं।

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

या यदि आप केवल अंतिम तत्व की तलाश कर रहे हैं, तो आप अंत () का उपयोग कर सकते हैं।

end(arr);

केवल अंतिम तत्व देता है।

और, जैसा कि यह पता चला है, आप पूर्णांक द्वारा php सरणियों को अनुक्रमित कर सकते हैं। इससे पूरी तरह खुश हैं

arr[1];

Comments

अंत में दोष (गिरफ्तारी) यह सरणी के आंतरिक पॉइंटर को अंतिम तत्व पर सेट करता है ..

— विजय

नहीं, आप सरणियों का उपयोग करने के लिए पूर्णांक का उपयोग नहीं करते हैं जब तक कि आपको पता न हो कि चाबियाँ संख्यात्मक और अनुक्रमिक हैं। पर विचार करें: $a = array(0=>'A', 2=>'B', 'aaa'=>'C')। यदि आप एक्सेस करते हैं तो आपको क्या मिलेगा $a[count($a)-1]?

— जॉन्डोडो 12

Answer 19

आप भी कुछ ऐसा कर सकते हैं:

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

     // more code
}

Comments

अंत में मान नहीं है, तो जिस तरह से आप इसे बनाया काम नहीं करता है। स्ट्रिंग तुलना भी धीमी है तो पूर्णांक।

— OIS

तुम सही हो। इसे समाप्त होना चाहिए ($ तत्व); $ एंडके = कुंजी ($ तत्व);

— KOGI

Answer 20

मुझे लगता है कि यह काफी साफ-सुथरा है, मुझे यह पसंद है। मान लें कि हम सभी तत्वों के बीच विभाजकों के साथ एक स्ट्रिंग बना रहे हैं: उदाहरण के लिए a, b, c

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

Comments

पहले $ घोषित किए बिना इसे और अधिक सरल बनाएं; foreach का उपयोग करें ($ कुंजी के रूप में $ आइटम => $ आइटम) तब $ str = ($ key == 0)?

— मिलन रिलेक्स रिक्ति

Answer 21

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

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

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

}

संदर्भ

Answer 22

यहाँ एक और तरीका है जो आप इसे कर सकते हैं:

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

Answer 23

यदि मैं आपको समझता हूं, तो आपको जरूरत है कि आप सरणी को उलट दें और एक पॉप कमांड द्वारा अंतिम तत्व प्राप्त करें:

   $rev_array = array_reverse($array);

   echo array_pop($rev_array);

Answer 24

आप अपनी क्वेरी बनाने के लिए यह भी कोशिश कर सकते हैं ... 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;
?>

Answer 25

SQL क्वेरी स्क्रिप्ट बनाने के लिए, या ऐसी कोई भी चीज़ जो पहले या अंतिम तत्वों के लिए अलग-अलग क्रिया करती है, यह बहुत अधिक तेज़ (लगभग दो बार तेज़) है, जो कि अस्वाभाविक वैरिएबल चेक का उपयोग करने से बचती है।

वर्तमान स्वीकृत समाधान एक लूप और लूप के भीतर एक चेक का उपयोग करता है जिसे हर_सिंघल_टिरियन बनाया जाएगा, ऐसा करने का सही (तेज़) तरीका निम्नलिखित है:

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

थोड़ा घर का बना बेंचमार्क निम्नलिखित दिखाया:

test1: मॉडल मॉर्ग के 100000 रन

समय: 1869.3430423737 मिलीसेकंड

test2: यदि अंतिम हो तो मॉडल के 100000 रन

समय: 3235.6359958649 मिलीसेकंड

Answer 26

जाने का एक अन्य तरीका पिछले लूप चक्र परिणाम को याद रखना और अंतिम परिणाम के रूप में उपयोग करना है:

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

Answer 27

मैं व्यक्तिगत रूप से इस तरह के निर्माण का उपयोग करता हूं जो html <ul> और <li> तत्वों के साथ एक आसान उपयोग सक्षम करता है: बस एक दूसरे के लिए समानता को बदलते हैं ...

सरणी में गलत आइटम नहीं हो सकते हैं, लेकिन अन्य सभी आइटम जो झूठी बूलियन में डाले गए हैं।

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

Answer 28

आप अंतिम रूप से निम्न सूचकांक प्राप्त कर सकते हैं:

$numItems = count($arr);

echo $arr[$numItems-1];

Answer 29

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

Answer 30

यहाँ मेरा समाधान है: बस अपने सरणी की संख्या, शून्य से 1 प्राप्त करें (क्योंकि वे 0 में शुरू होते हैं)।

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