कैसे जांचें कि PHP का उपयोग करके कोई सरणी खाली है या नहीं?

470

playersया तो खाली होगा या अल्पविराम से अलग की गई सूची (या एकल मान) होगी। खाली होने पर जांचने का सबसे आसान तरीका क्या है? मैं मान रहा हूं कि जैसे ही मैं $gameresultसरणी लाऊंगा मैं ऐसा कर सकता हूं $gamerow? इस मामले में, $playerlistयदि यह खाली है, तो विस्फोट को छोड़ना शायद अधिक कुशल होगा , लेकिन तर्क के लिए, यदि कोई सरणी खाली भी है तो मैं कैसे जांचूंगा?

$gamerow = mysql_fetch_array($gameresult);
$playerlist = explode(",", $gamerow['players']);

php arrays

— aslum
स्रोत

2

गिनती (), आकार (), खाली () का उपयोग न करें। खाली सरणी गलत है: यदि ($ सरणी) {

— सीमा

773

यदि आपको यह जांचने की आवश्यकता है कि क्या सरणी में कोई तत्व हैं या नहीं

if (empty($playerlist)) {
     // list is empty.
}

यदि आपको जाँच से पहले खाली मूल्यों को साफ करने की आवश्यकता है (आम तौर पर explodeइनग अजीब तारों को रोकने के लिए किया जाता है ):

foreach ($playerlist as $key => $value) {
    if (empty($value)) {
       unset($playerlist[$key]);
    }
}
if (empty($playerlist)) {
   //empty array
}

— टायलर कार्टर
स्रोत

2

क्या आपको सिर्फ खाली उपयोग नहीं करना चाहिए? गिनती बड़े सरणियों के लिए प्रदर्शन करने में अधिक समय लेगी।

— दान मैकग्राथ

1

किया हुआ। मैंने इसे इस तथ्य के लिए भी बदल दिया है कि आपको आईसेट और सामान का उपयोग नहीं करना है।

— टायलर कार्टर

5

उसके कोड उदाहरण को देखते हुए, चर सेट किया जाएगा ताकि आपको उपयोग करने की आवश्यकता न हो empty()।

— १०:३५ बजे कोबी

4

सावधान! if(!isset($emptyarray))है falseलेकिन if(empty($emptyarray))रिटर्न true। कि बस मुझे

— घोंसला बनाया

161

PHP में एक खाली सरणी गलत है, इसलिए आपको empty()दूसरों के सुझाव के अनुसार उपयोग करने की आवश्यकता नहीं है ।

<?php
$playerList = array();
if (!$playerList) {
    echo "No players";
} else {
    echo "Explode stuff...";
}
// Output is: No players

PHP के empty()निर्धारित करता है कि एक चर मौजूद नहीं है या एक falsey मूल्य (जैसे है array(), 0, null, false, आदि)।

ज्यादातर मामलों में आप सिर्फ जांच करना चाहते हैं !$emptyVar। empty($emptyVar)यदि चर सेट नहीं किया गया है और आप एक ट्रिगर को अभ्यस्त नहीं करते हैं, तो उपयोग करें E_NOTICE; IMO यह आमतौर पर एक बुरा विचार है।

— गठीला
स्रोत

2

मुझे आशा है कि यह कुछ मानक में नहीं बदलेगा ... यह दर्दनाक होगा

— डेविड कॉन्सटेंटाइन

79

कुछ सभ्य जवाब, लेकिन बस मैंने सोचा कि अगर PHP एक सरणी खाली है, तो अधिक स्पष्ट रूप से समझाने के लिए मैं थोड़ा विस्तार करूंगा।

मुख्य नोट्स:

कुंजी (या कुंजी) के साथ एक सरणी को PHP द्वारा खाली नहीं के रूप में निर्धारित किया जाएगा ।

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

इसलिए किसी सरणी की जाँच करना empty()यह नहीं बताता कि आपके पास मान हैं या नहीं, यह आपको बताता है कि क्या सरणी खाली है, और कुंजियाँ किसी सरणी का हिस्सा हैं।

तो विचार करें कि आप किस तरह से जाँच करने की विधि का उपयोग करने से पहले अपने सरणी का उत्पादन कर रहे हैं। जब किसी उपयोगकर्ता के पास प्रत्येक प्रपत्र फ़ील्ड में एक सरणी नाम (यानी ) होता है, तो
ईजी एक सरणी में कुंजियाँ होंगीname="array[]" । प्रत्येक क्षेत्र के लिए
एक गैर खाली सरणी का उत्पादन किया जाएगा क्योंकि प्रत्येक प्रपत्र फ़ील्ड के सरणी के लिए स्वत: इंक्रीमेंट किए गए प्रमुख मान होंगे।

उदाहरण के लिए ये सरणियाँ लें:

/* Assigning some arrays */

// Array with user defined key and value
$ArrayOne = array("UserKeyA" => "UserValueA", "UserKeyB" => "UserValueB");

// Array with auto increment key and user defined value
// as a form field would return with user input
$ArrayTwo[] = "UserValue01";
$ArrayTwo[] = "UserValue02";

// Array with auto incremented key and no value
// as a form field would return without user input
$ArrayThree[] = '';
$ArrayThree[] = '';

यदि आप उपरोक्त सरणियों के लिए सरणी कुंजियों और मूल्यों को प्रतिध्वनित करते हैं, तो आपको निम्नलिखित मिलते हैं:

ARRAY ONE:
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

ARRAY TWO:
[0] => [UserValue01]
[1] => [UserValue02]

ARRAY THREE:
[०] => []
[१] => []

और empty()निम्न परिणाम के साथ उपरोक्त सरणियों का परीक्षण :

ARRAY ONE:
$ ArrayOne खाली नहीं है

ARRAY TWO:
$ ArrayTwo खाली नहीं है

ARRAY THREE:
$ ArrayThree खाली नहीं है

जब आप कोई एरे असाइन करते हैं तो एरे हमेशा खाली रहेगा लेकिन उसके बाद उसका उपयोग न करें, जैसे:

$ArrayFour = array();

यह खाली होगा, यानी यदि empty()ऊपर का उपयोग कर रहा है तो PHP TRUE लौटाएगा ।

इसलिए यदि आपके सरणी में कुंजियाँ हैं - या तो उदाहरण के लिए किसी प्रपत्र के इनपुट नाम या यदि आप उन्हें मैन्युअल रूप से असाइन करते हैं (जैसे डेटाबेस स्तंभ नाम के साथ एक सरणी बनाएँ, लेकिन डेटाबेस से कोई मान / डेटा नहीं है), तो सरणी नहीं होगी empty()।

इस स्थिति में, आप सरणी को फ़ॉरच में लूप कर सकते हैं, परीक्षण कर सकते हैं कि क्या प्रत्येक कुंजी का मान है। यह एक अच्छी विधि है अगर आपको किसी भी तरह से सरणी के माध्यम से चलाने की आवश्यकता है, तो शायद कुंजियों की जांच करना या डेटा को साफ करना।

हालाँकि, यह सबसे अच्छा तरीका नहीं है अगर आपको बस यह जानने की ज़रूरत है कि "यदि मान मौजूद हैं" TRUE या FALSE देता है । यह निर्धारित करने के लिए विभिन्न तरीके हैं कि क्या किसी सरणी में कोई मान है जब यह पता होगा कि इसमें चाबियाँ होंगी। एक फ़ंक्शन या वर्ग सबसे अच्छा दृष्टिकोण हो सकता है, लेकिन हमेशा की तरह यह आपके पर्यावरण और सटीक आवश्यकताओं पर निर्भर करता है, साथ ही साथ अन्य चीजें जैसे कि आप वर्तमान में सरणी (यदि कुछ भी) के साथ करते हैं।

यहाँ एक दृष्टिकोण है जो किसी सरणी के मान के जाँचने के लिए बहुत कम कोड का उपयोग करता है:

उपयोग करना array_filter():
उन्हें कॉलबैक फ़ंक्शन में पास करने वाले सरणी में प्रत्येक मान पर Iterates। यदि कॉलबैक फ़ंक्शन सही है, तो सरणी से वर्तमान मान परिणाम सरणी में वापस आ जाता है। सरणी कुंजी संरक्षित हैं।

$EmptyTestArray = array_filter($ArrayOne);

if (!empty($EmptyTestArray))
  {
    // do some tests on the values in $ArrayOne
  }
else
  {
    // Likely not to need an else, 
    // but could return message to user "you entered nothing" etc etc
  }

चल रहा है array_filter()सभी तीन उदाहरण सरणियों पर (इस जवाब में पहली कोड ब्लॉक में बनाया गया) निम्नलिखित में परिणाम:

ARRAY ONE:
$ अरोनोन खाली नहीं है

ARRAY TWO:
$ arraytwo खाली नहीं है

ARRAY THREE:
$ arraythree खाली है

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

मैं ओवरहेड्स की जांच करने में अनुभवी नहीं हूं, लेकिन अगर मूल्य पाया जाता है, तो इसका उपयोग करने array_filter()और foreachजांच करने के बीच के अंतर को जानना अच्छा होगा ।

जाहिर है कि बेंचमार्क को विभिन्न मापदंडों पर, छोटे और बड़े सरणियों पर और जब मूल्य हैं और नहीं आदि की आवश्यकता होगी।

— जेम्स
स्रोत

2

इसके लिए बहुत - बहुत धन्यवाद। यह वास्तव में जानकारीपूर्ण गया था और मेरी समस्या का उपयोग कर हल करने में सक्षम थाarray_filter()

— ब्रायन पॉवेल

खाली (सरणी ()) हमेशा FALSE के लिए विकसित होगा, इसलिए गिनती (सरणी ()) == 0 जोड़ने से सही होगा

— timmz

1

count(array())==0चाबियाँ और कोई मान नहीं होने पर @mboullouz गलत है, इसलिए यह केवल मानों की जांच करने में मदद नहीं करता है। आपका कथन सही है, लेकिन आप परीक्षण के लिए मजबूर कर रहे हैं count(array())क्योंकि सरणी बिल्कुल खाली है। हमें यह जाँचने की आवश्यकता है कि सरणी कब फॉर्म या कहीं और से वापस आई है या नहीं यह जानने के लिए कि क्या यह खाली है (कुंजियाँ / मान) या केवल मान हैं या नहीं

— जेम्स

यह समाधान इस तरह के सरणियों के लिए एकदम सही है, उदाहरण के लिए यह मदद करता है जब आप एक इनपुट फ़ाइल को सत्यापित करना चाहते हैं array_filter($_FILES["documento"]['name'])

— Gendrith

20

count($gamerow['players']) 0 होगा।

— इग्नासियो वाज़क्वेज़-अब्राम्स
स्रोत

पुराने स्कूल दा हमेशा की तरह, बस सरणी के सूचकांक की जाँच करें।

— डेनिश

यह एक फ़ंक्शन कॉल बहुत अधिक है।

— मिकमैकुसा

12

यदि आप यह पता लगाना चाहते हैं कि आप जिस वेरिएबल का परीक्षण कर रहे हैं वह वास्तव में एक खाली सरणी है, तो आप कुछ इस तरह का उपयोग कर सकते हैं:

if ($variableToTest === array()) {
    echo 'this is explicitly an empty array!';
}

— टिम ओगिल्वी
स्रोत

11

यदि आप झूठी या खाली पंक्तियों (जैसे 0 => '') को बाहर करना चाहते हैं , जहां उपयोग empty()करना विफल हो जाएगा, तो आप कोशिश कर सकते हैं:

if (array_filter($playerlist) == []) {
  // Array is empty!
}

array_filter(): यदि कोई कॉलबैक आपूर्ति नहीं की जाती है, तो FALSE (बूलियन में कनवर्ट करना) के बराबर सरणी की सभी प्रविष्टियों को हटा दिया जाएगा।

यदि आप सभी NULL, FALSE और खाली स्ट्रिंग्स ( '') को हटाना चाहते हैं , लेकिन शून्य मान ( 0) छोड़ दें , तो आप strlenकॉलबैक के रूप में उपयोग कर सकते हैं , जैसे:

$is_empty = array_filter($playerlist, 'strlen') == [];

— kenorb
स्रोत

यह एक अलग प्रश्न का सही उत्तर है। एरे फिल्टर का उपयोग फाल्सी मूल्यों के साथ मौजूदा तत्वों को नष्ट कर देगा। यह वह नहीं है जो ओपी पूछ रहा है।

— मिकमैकुसा

8

किसी ने यह जवाब क्यों नहीं दिया:

$array = [];

if($array == []) {
    // array is empty
}

— लूटना
स्रोत

1

आपका कथन सही नहीं है। किसी ने कहा कि यह जवाब - टिम ओगिल्वी - एक साल पहले। इसके बजाय चौकोर ब्रेसिज़ का उपयोग करना array()एक ही बात है।

— मिकमैकुसा

जबकि हुड के तहत यह एक ही जवाब है ... तकनीकी रूप से। मैंने पुरानी सरणी फ़ंक्शन के बजाय वर्ग कोष्ठक का उपयोग किया।

— रोब

7

is_array($detect) && empty($detect);

is_array

— zloctb
स्रोत

ये अनावश्यक जाँच हैं। ओपी कॉल कर रहा है explode()- यह सरणी-प्रकार डेटा लौटाता है। जाँच empty()एक अनावश्यक फ़ंक्शन कॉल है। जैसा कि 2012 में Cobby द्वारा कहा गया था, if($detect)वह सब आवश्यक है। यह समाधान इस कार्य या अन्य के लिए लागू नहीं किया जाना चाहिए। आप तर्क दे सकते हैं कि आप इस प्रश्न के दायरे से परे की स्थितियों को कवर कर रहे हैं, ठीक है, empty()AFTER को कॉल करने की आवश्यकता कभी नहीं होती है is_array()क्योंकि यदि चर "सेट" नहीं है, तो is_array()"सूचना: अपरिभाषित चर" उत्पन्न करेगा, यदि isset()तब empty()ओवरकिल है, बस उपयोग करें कोबी का जवाब।

— मिकमैकुसा

6

मैंने पोस्ट के अंत में शामिल बेंचमार्क को चलाया। तरीकों की तुलना करने के लिए:

count($arr) == 0 : गिनती
empty($arr) : खाली
$arr == [] : अनुपालन करें
(bool) $arr : डाली

और निम्नलिखित परिणाम मिले

Contents  \method |    count     |    empty     |     comp     |     cast     |
------------------|--------------|--------------|--------------|--------------|
            Empty |/* 1.213138 */|/* 1.070011 */|/* 1.628529 */|   1.051795   |
          Uniform |/* 1.206680 */|   1.047339   |/* 1.498836 */|/* 1.052737 */|
          Integer |/* 1.209668 */|/* 1.079858 */|/* 1.486134 */|   1.051138   |
           String |/* 1.242137 */|   1.049148   |/* 1.630259 */|/* 1.056610 */|
            Mixed |/* 1.229072 */|/* 1.068569 */|/* 1.473339 */|   1.064111   |
      Associative |/* 1.206311 */|   1.053642   |/* 1.480637 */|/* 1.137740 */|
------------------|--------------|--------------|--------------|--------------|
            Total |/* 7.307005 */|   6.368568   |/* 9.197733 */|/* 6.414131 */|

एक बूलियन के लिए खाली और कास्टिंग के बीच का अंतर महत्वहीन है। मैंने यह परीक्षण कई बार चलाया है और वे अनिवार्य रूप से समतुल्य प्रतीत होते हैं। सरणियों की सामग्री महत्वपूर्ण भूमिका नहीं निभाती है। दो विपरीत परिणाम उत्पन्न करते हैं लेकिन तार्किक नकार मुश्किल से ज्यादातर समय जीतने के लिए कास्टिंग को धक्का देने के लिए पर्याप्त है इसलिए मैं व्यक्तिगत रूप से किसी भी मामले में उपयुक्तता के लिए खाली रहना पसंद करता हूं।

#!/usr/bin/php
<?php

//    012345678
$nt = 90000000;

$arr0 = [];
$arr1 = [];
$arr2 = [];
$arr3 = [];
$arr4 = [];
$arr5 = [];

for ($i = 0; $i < 500000; $i++) {
    $arr1[] = 0;
    $arr2[] = $i;
    $arr3[] = md5($i);
    $arr4[] = $i % 2 ? $i : md5($i);
    $arr5[md5($i)] = $i;
}

$t00 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr0) == 0;
}
$t01 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr0);
}
$t02 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr0 == [];
}
$t03 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr0;
}
$t04 = microtime(true);

$t10 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr1) == 0;
}
$t11 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr1);
}
$t12 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr1 == [];
}
$t13 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr1;
}
$t14 = microtime(true);

/* ------------------------------ */

$t20 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr2) == 0;
}
$t21 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr2);
}
$t22 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr2 == [];
}
$t23 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr2;
}
$t24 = microtime(true);

/* ------------------------------ */

$t30 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr3) == 0;
}
$t31 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr3);
}
$t32 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr3 == [];
}
$t33 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr3;
}
$t34 = microtime(true);

/* ------------------------------ */

$t40 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr4) == 0;
}
$t41 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr4);
}
$t42 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr4 == [];
}
$t43 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr4;
}
$t44 = microtime(true);

/* ----------------------------------- */

$t50 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr5) == 0;
}
$t51 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr5);
}
$t52 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr5 == [];
}
$t53 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr5;
}
$t54 = microtime(true);

/* ----------------------------------- */

$t60 = $t00 + $t10 + $t20 + $t30 + $t40 + $t50;
$t61 = $t01 + $t11 + $t21 + $t31 + $t41 + $t51;
$t62 = $t02 + $t12 + $t22 + $t32 + $t42 + $t52;
$t63 = $t03 + $t13 + $t23 + $t33 + $t43 + $t53;
$t64 = $t04 + $t14 + $t24 + $t34 + $t44 + $t54;

/* ----------------------------------- */

$ts0[1] = number_format(round($t01 - $t00, 6), 6);
$ts0[2] = number_format(round($t02 - $t01, 6), 6);
$ts0[3] = number_format(round($t03 - $t02, 6), 6);
$ts0[4] = number_format(round($t04 - $t03, 6), 6);

$min_idx = array_keys($ts0, min($ts0))[0];
foreach ($ts0 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts0[$idx] = "   $val   ";
    } else {
        $ts0[$idx] = "/* $val */";
    }

}

$ts1[1] = number_format(round($t11 - $t10, 6), 6);
$ts1[2] = number_format(round($t12 - $t11, 6), 6);
$ts1[3] = number_format(round($t13 - $t12, 6), 6);
$ts1[4] = number_format(round($t14 - $t13, 6), 6);

$min_idx = array_keys($ts1, min($ts1))[0];
foreach ($ts1 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts1[$idx] = "   $val   ";
    } else {
        $ts1[$idx] = "/* $val */";
    }

}

$ts2[1] = number_format(round($t21 - $t20, 6), 6);
$ts2[2] = number_format(round($t22 - $t21, 6), 6);
$ts2[3] = number_format(round($t23 - $t22, 6), 6);
$ts2[4] = number_format(round($t24 - $t23, 6), 6);

$min_idx = array_keys($ts2, min($ts2))[0];
foreach ($ts2 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts2[$idx] = "   $val   ";
    } else {
        $ts2[$idx] = "/* $val */";
    }

}

$ts3[1] = number_format(round($t31 - $t30, 6), 6);
$ts3[2] = number_format(round($t32 - $t31, 6), 6);
$ts3[3] = number_format(round($t33 - $t32, 6), 6);
$ts3[4] = number_format(round($t34 - $t33, 6), 6);

$min_idx = array_keys($ts3, min($ts3))[0];
foreach ($ts3 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts3[$idx] = "   $val   ";
    } else {
        $ts3[$idx] = "/* $val */";
    }

}

$ts4[1] = number_format(round($t41 - $t40, 6), 6);
$ts4[2] = number_format(round($t42 - $t41, 6), 6);
$ts4[3] = number_format(round($t43 - $t42, 6), 6);
$ts4[4] = number_format(round($t44 - $t43, 6), 6);

$min_idx = array_keys($ts4, min($ts4))[0];
foreach ($ts4 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts4[$idx] = "   $val   ";
    } else {
        $ts4[$idx] = "/* $val */";
    }

}

$ts5[1] = number_format(round($t51 - $t50, 6), 6);
$ts5[2] = number_format(round($t52 - $t51, 6), 6);
$ts5[3] = number_format(round($t53 - $t52, 6), 6);
$ts5[4] = number_format(round($t54 - $t53, 6), 6);

$min_idx = array_keys($ts5, min($ts5))[0];
foreach ($ts5 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts5[$idx] = "   $val   ";
    } else {
        $ts5[$idx] = "/* $val */";
    }

}

$ts6[1] = number_format(round($t61 - $t60, 6), 6);
$ts6[2] = number_format(round($t62 - $t61, 6), 6);
$ts6[3] = number_format(round($t63 - $t62, 6), 6);
$ts6[4] = number_format(round($t64 - $t63, 6), 6);

$min_idx = array_keys($ts6, min($ts6))[0];
foreach ($ts6 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts6[$idx] = "   $val   ";
    } else {
        $ts6[$idx] = "/* $val */";
    }

}

echo "             |    count     |    empty     |     comp     |     cast     |\n";
echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Empty |";
echo $ts0[1] . '|';
echo $ts0[2] . '|';
echo $ts0[3] . '|';
echo $ts0[4] . "|\n";

echo "     Uniform |";
echo $ts1[1] . '|';
echo $ts1[2] . '|';
echo $ts1[3] . '|';
echo $ts1[4] . "|\n";

echo "     Integer |";
echo $ts2[1] . '|';
echo $ts2[2] . '|';
echo $ts2[3] . '|';
echo $ts2[4] . "|\n";

echo "      String |";
echo $ts3[1] . '|';
echo $ts3[2] . '|';
echo $ts3[3] . '|';
echo $ts3[4] . "|\n";

echo "       Mixed |";
echo $ts4[1] . '|';
echo $ts4[2] . '|';
echo $ts4[3] . '|';
echo $ts4[4] . "|\n";

echo " Associative |";
echo $ts5[1] . '|';
echo $ts5[2] . '|';
echo $ts5[3] . '|';
echo $ts5[4] . "|\n";

echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Total |";
echo $ts6[1] . '|';
echo $ts6[2] . '|';
echo $ts6[3] . '|';
echo $ts6[4] . "|\n";

— kaan_a
स्रोत

अच्छा बेंचमार्क, लेकिन आप भूल गए sizeofजो [नहीं?] का उपनाम है empty... stackoverflow.com/a/51986794/1429432

— Yousha Aleayoub

5

यदि आप उस सरणी सामग्री की जांच कर सकते हैं जिसका आप उपयोग कर सकते हैं:

$arr = array();

if(!empty($arr)){
  echo "not empty";
}
else 
{
  echo "empty";
}

यहाँ देखें: http://codepad.org/EORE4k7v

— nothingchen01
स्रोत

जैसा कि 2012 में Cobby द्वारा दिखाया गया है, यह घोषित करने के लिए फ़ंक्शन को कॉल करने के लिए अनावश्यक है कि क्या कोई घोषित सरणी खाली है या नहीं।

— मिकमैकुसा

5

मेरी राय में एक अनुक्रमित सरणी के लिए सबसे सरल तरीका बस होगा:

    if ($array) {
      //Array is not empty...  
    }

सरणी पर एक 'अगर' स्थिति सही का मूल्यांकन करेगी यदि सरणी खाली है और गलत है तो सरणी खाली है । यह सहयोगी सरणियों पर लागू नहीं है ।

— PJately
स्रोत

2012 में कॉबी ने इस तकनीक को प्रभावी ढंग से बताया। उनके जवाब में वर्तमान में 133 अपवोट हैं।

— मिकमैकुसा

यह "साधारण" नहीं है, क्योंकि यह सबसे सरल है - यह सबसे सरल है क्योंकि इसमें कोई सिंटैक्स नहीं है जो अधिक संक्षिप्त हो सकता है और इसमें कोई फ़ंक्शन-कॉल ओवरहेड नहीं है। अनुक्रमणिका कुंजी बनाम साहचर्य कुंजियों के साथ एक सरणी तक पहुंचने के लिए ABSOLUTELY NO DIFFERENCE है। यह जवाब शोधकर्ताओं को गुमराह करने वाला है। यह उत्तर निरर्थक है , फिर अनैच्छिक । 3v4l.org/DSLha

— मिकमैकुसा

3

मैं इस कोड का उपयोग करता हूं

$variable = array();

if( count( $variable ) == 0 )
{
    echo "Array is Empty";
}
else
{
    echo "Array is not Empty";
}

लेकिन ध्यान दें कि यदि सरणी में बड़ी संख्या में चाबियां हैं, तो यह कोड उन्हें गिनने में बहुत समय बिताएगा, जैसा कि अन्य उत्तरों की तुलना में यहां है।

— जोसेफ असीर राजा
स्रोत

जैसा कि 2012 में Cobby द्वारा दिखाया गया है, यह घोषित करने के लिए फ़ंक्शन को कॉल करने के लिए अनावश्यक है कि क्या कोई घोषित सरणी खाली है या नहीं।

— मिकमैकुसा

3

आप उपयोग कर सकते हैं array_filter()जो सभी स्थितियों के लिए महान काम करता है:

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}

— user889030
स्रोत

1

यह उत्तर अनावश्यक जाँच को नियोजित कर रहा है। सबसे पहले, ओपी अपनी शून्यता की जांच करने से पहले सरणी से किसी भी गलत मूल्यों को फ़िल्टर करने में दिलचस्पी नहीं रखता है - इसलिए आपने पोस्ट किए गए प्रश्न से विचलित कर दिया है। दूसरा, जैसा कि 2012 में Cobby द्वारा दिखाया गया है, यह जांचने के लिए एक फ़ंक्शन को कॉल करने के लिए अनावश्यक है कि क्या एक घोषित सरणी खाली है या नहीं।

— मिकमैकुसा

2

 $gamerow = mysql_fetch_array($gameresult);

if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{

  // do stuf if array is empty
}

— अनीश राय
स्रोत

2

मुझे लगता है कि यह निर्धारित करने का सबसे अच्छा तरीका है कि सरणी खाली है या नहीं (जैसे) गिनती का उपयोग करें:

if(count($array)) {
    return 'anything true goes here';
}else {
    return 'anything false'; 
}

— अनस रेड
स्रोत

count()कॉल हटाया जा सकता है पूरी तरह से - गठीला के जवाब देखें।

— मिकमैकुसा

2

सबसे उचित निर्णय लेने के लिए आपके डेटा की गुणवत्ता और प्रक्रियाओं का पालन करना आवश्यक है।

यदि आप इस पंक्ति को अयोग्य / अस्वीकृत करने जा रहे हैं, तो निस्पंदन का सबसे प्रारंभिक बिंदु mysql क्वेरी में होना चाहिए।
- WHERE players IS NOT NULL
- WHERE players != ''
- WHERE COALESCE(players, '') != ''
- WHERE players IS NOT NULL AND players != ''
- ... यह आपके स्टोर डेटा पर निर्भर करता है और अन्य तरीके भी होंगे, मैं यहां रुकूंगा।
यदि आप 100% सुनिश्चित नहीं हैं कि यदि कॉलम परिणाम सेट में मौजूद होगा, तो आपको जांचना चाहिए कि कॉलम घोषित है। यह बुला मतलब होगा array_key_exists(), isset()या empty()स्तंभ पर। मैं यहाँ मतभेदों को दूर करने के लिए नहीं जा रहा हूँ (उस टूटने के लिए अन्य SO पृष्ठ हैं, यहाँ एक शुरुआत है: 1 , 2 , 3 )। उस ने कहा, यदि आप परिणाम सेट के कुल नियंत्रण में नहीं हैं, तो हो सकता है कि आपके पास अति-अनुप्रयोग अनुप्रयोग "लचीलापन" हो और यदि गैर-विद्यमान कॉलम डेटा तक पहुंचने की संभावित समस्या के लायक है, तो इसे वापस लेना चाहिए। प्रभावी रूप से, मैं कह रहा हूं कि आपको कभी भी यह जांचने की आवश्यकता नहीं होनी चाहिए कि क्या कोई स्तंभ घोषित किया गया है - एर्गो आपको empty()इस कार्य के लिए कभी भी आवश्यकता नहीं होनी चाहिए । अगर कोई ऐसा तर्क दे रहा हैempty()और अधिक उपयुक्त है, तो वे पटकथा की अभिव्यक्ति के बारे में अपनी निजी राय पर जोर दे रहे हैं। यदि आप अस्पष्ट होने के लिए नीचे # 5 में स्थिति पाते हैं, तो अपने कोड में एक इनलाइन टिप्पणी जोड़ें - लेकिन मैं नहीं करूंगा। लब्बोलुआब यह है कि फ़ंक्शन कॉल करने के लिए कोई प्रोग्रामेटिक लाभ नहीं है।
हो सकता है कि आपके स्ट्रिंग मान में कोई 0ऐसा हो, जिसे आप सत्य / मान्य / गैर-रिक्त करना चाहते हैं? यदि ऐसा है, तो आपको केवल यह जांचने की आवश्यकता है कि कॉलम का मूल्य लंबाई है या नहीं।

यहाँ एक डेमो का उपयोग कर रहा है strlen()। यह इंगित करेगा कि क्या स्ट्रिंग विस्फोट होने पर सार्थक सरणी तत्व बनाएगी या नहीं।
मुझे लगता है कि यह उल्लेख करना महत्वपूर्ण है कि बिना शर्त विस्फोट करके, आप गैर-रिक्त सरणी उत्पन्न करने के लिए निर्देशित हैं। यहाँ सबूत है: डेमो दूसरे शब्दों में, यह जाँचना कि क्या खाली है पूरी तरह से बेकार है - यह हर बार गैर-खाली होगा।
यदि आपकी स्ट्रिंग POSSIBLY नहीं होगी, तो इसमें एक शून्य मान होगा (क्योंकि, कहते हैं, यह एक csv है जिसमें आईडी शामिल हैं, जो 1केवल और केवल वेतन वृद्धि से शुरू होता है ), तो if ($gamerow['players']) {आप सभी की जरूरत है - कहानी का अंत।
... लेकिन रुकिए, इस मूल्य की शून्यता का निर्धारण करने के बाद आप क्या कर रहे हैं? यदि आपके पास कुछ डाउन-स्क्रिप्ट है जो अपेक्षा कर रहा है $playerlist, लेकिन आप सशर्त रूप से उस चर को घोषित कर रहे हैं, तो आप पिछली पंक्ति के मूल्य का उपयोग करके या फिर से नोटिस उत्पन्न करने का जोखिम उठाते हैं। तो तुम बिना शर्त घोषित करने के लिए की आवश्यकता है $playerlistके रूप में कुछ ? यदि स्ट्रिंग में कोई सत्य मूल्य नहीं हैं, तो क्या आपके एप्लिकेशन को खाली सरणी घोषित करने से लाभ होता है? संभावना है, जवाब हां है। इस स्थिति में, आप यह सुनिश्चित कर सकते हैं कि चर एक खाली सरणी में वापस गिरने से सरणी-प्रकार है - इस तरह यह कोई फर्क नहीं पड़ता अगर आप उस चर को लूप में खिलाते हैं। निम्नलिखित सशर्त घोषणाएं सभी समतुल्य हैं।
- `अगर ($ Gamerow ['खिलाड़ी']) {$ खिलाड़ी = विस्फोट ((',', $ gamerow ['खिलाड़ी']); } और {$ खिलाड़ी = []; }
- $playerlist = $gamerow['players'] ? explode(',', $gamerow['players']) : [];

मैं इस आधारभूत कार्य की व्याख्या करने के लिए इतनी लंबाई में क्यों गया हूं?

मेरे पास इस पृष्ठ पर लगभग हर उत्तर में सीटी है और यह उत्तर बदला हुआ वोट आकर्षित करने की संभावना है (यह अक्सर इस साइट का बचाव करने वाले सीटी बजाने वालों के लिए होता है - यदि किसी उत्तर में डाउनवोट्स हैं और कोई टिप्पणी नहीं है, तो हमेशा संदेहपूर्ण रहें)।
मुझे लगता है कि यह महत्वपूर्ण है कि स्टैकओवरफ़्लो एक विश्वसनीय संसाधन है जो शोधकर्ताओं को गलत सूचना और दत्तक तकनीक के साथ जहर नहीं देता है।
यह है कि मैं दिखाता हूं कि मैं आगामी डेवलपर्स के बारे में कितना ध्यान रखता हूं ताकि वे कॉपी-पेस्ट प्रोग्रामर की पीढ़ी को सिर्फ एक चम्मच खिलाने के बजाय कैसे और क्यों सीखें।
मैं अक्सर नए डुप्लिकेट पृष्ठों को बंद करने के लिए पुराने पृष्ठों का उपयोग करता हूं - यह दिग्गज स्वयंसेवकों की जिम्मेदारी है जो जानते हैं कि कैसे जल्दी से डुप्लिकेट ढूंढना है। मैं अपने आप को एक पुराने पृष्ठ को एक संदर्भ के रूप में खराब / गलत / असत्य / भ्रामक जानकारी के साथ उपयोग करने के लिए नहीं ला सकता हूं क्योंकि तब मैं एक नए शोधकर्ता के लिए एक सक्रिय रूप से काम कर रहा हूं।

— mickmackusa
स्रोत

@ यह यहाँ है।

— मिकमैकुसा

1

empty($gamerow['players'])

— डैन मैकग्राथ
स्रोत

कुछ समय बाद आप तत्व सरणी कुंजी मूल्य नहीं जान सके, $matches = preg_grep ( "/^$text (\w+)/i" , $array ) ; ताकि मैं इसका उपयोग कर if ( count ( $matches ) > 0 )

— सलेम

यह माना जाता है कि परिणाम सेट में कॉलम मौजूद है, इसलिए empty()बहुत अधिक काम कर रहा है।

— मिकमैकुसा

-1

मैंने निम्नलिखित कोड के साथ इस मुद्दे को हल किया है।

$catArray=array();                          

$catIds=explode(',',$member['cat_id']);
if(!empty($catIds[0])){
foreach($catIds as $cat_id){
$catDetail=$this->Front_Category->get_category_detail($cat_id);
$catArray[]=$catDetail['allData']['cat_title'];
}
echo implode(',',$catArray);
}

— सूरज कुमार
स्रोत

1

ढेर अतिप्रवाह में आपका स्वागत है! कोड स्निपेट के लिए धन्यवाद, जो कुछ सीमित, तत्काल सहायता प्रदान कर सकता है। एक उचित व्याख्या इस समस्या का एक अच्छा समाधान क्यों है, यह वर्णन करके अपने दीर्घकालिक मूल्य में बहुत सुधार करेगी , और भविष्य के पाठकों के लिए अन्य समान प्रश्नों के साथ इसे और अधिक उपयोगी बना देगी। कृपया कुछ स्पष्टीकरण जोड़ने के लिए अपने उत्तर को संपादित करें, जिसमें आपके द्वारा की गई धारणाएँ शामिल हैं।

— सेफर्रह

-3

यह सभी मामलों के लिए काम कर रहा है

if(!empty(sizeof($array)))

— मधु नायर
स्रोत

3

यह बहुत अधिक उपरि है। यह समाधान किसी भी कारण से किसी भी डेवलपर द्वारा लागू नहीं किया जाना चाहिए।

— मिकमैकुसा

@ मिकमैकुसा ग्रेट पॉइंट, लेकिन एक नौसिखिया यह कैसे पहचान लेता है कि कौन सा ऑपरेशन बहुत अधिक उपरिवेशन पर सहमति देता है? प्रदर्शन परीक्षण चलाने के बिना बहुत अधिक ओवरहेड के लिए सस्ता क्या है, या चेहरे का मानदंड क्या है ?

— पितृपक्ष

1

@ प्रत्येक फ़ंक्शन को कॉल करने के लिए "लागत" है। यदि कोई कार्य बिना फ़ंक्शन कॉल के पूरा किया जा सकता है, तो यह एक तकनीक को बेहतर बनाएगा जो फ़ंक्शन कॉल का उपयोग करता है।

— मिकमैकुसा

@ptr मैंने इस प्रश्न के लिए एक व्यापक उत्तर पोस्ट किया है। मुझे आशा है कि यह इस पृष्ठ के बारे में आपके द्वारा की गई किसी भी चिंता को दूर कर देगा।

— मिकमैकुसा

@mickmackusa क्या आपका मतलब किसी अन्य पोस्ट की लिंक को शामिल करने से है?

— ptrcao

-4

कैसा रहेगा:

विभागपेरस्कूल = सरणी ();
(खाली (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // या इको खाली नहीं है: सरणी ('सेट नहीं' => 'सेट नहीं। संपर्क व्यवस्थापक'); // या गूंज खाली है

— नगाटिया फ्रैंकलाइन
स्रोत