php - खाली सरणी तत्व निकालें




arrays string (16)

संक्षेप में:

यह मेरा सुझाया गया कोड है:

$myarray =  array_values(array_filter(array_map('trim', $myarray), 'strlen'));

स्पष्टीकरण:

मुझे लगता है कि array_filter का उपयोग अच्छा है, लेकिन पर्याप्त नहीं है, क्योंकि मान space तरह space और \n , ... सरणी में रखें और यह आमतौर पर खराब होता है।

तो मेरा सुझाव है कि आप मिश्रण array_filter और array_map उपयोग करें।

array_map trimming के लिए है, array_filter खाली मानों को हटाने के लिए है, strlen 0 मान रखने के लिए है, और अगर आपको आवश्यकता हो तो array_values पुन: अनुक्रमण के लिए है।

नमूने:

$myarray = array("\r", "\n", "\r\n", "", " ", "0", "a");

// "\r", "\n", "\r\n", " ", "a"
$new1 = array_filter($myarray);

// "a"
$new2 = array_filter(array_map('trim', $myarray));

// "0", "a"
$new3 = array_filter(array_map('trim', $myarray), 'strlen');

// "0", "a" (reindex)
$new4 = array_values(array_filter(array_map('trim', $myarray), 'strlen'));

var_dump($new1, $new2, $new3, $new4);

परिणाम:

array(5) {
  [0]=>
" string(1) "
  [1]=>
  string(1) "
"
  [2]=>
  string(2) "
"
  [4]=>
  string(1) " "
  [6]=>
  string(1) "a"
}
array(1) {
  [6]=>
  string(1) "a"
}
array(2) {
  [5]=>
  string(1) "0"
  [6]=>
  string(1) "a"
}
array(2) {
  [0]=>
  string(1) "0"
  [1]=>
  string(1) "a"
}

ऑनलाइन टेस्ट:

http://phpio.net/s/5yg0

मेरे सरणी में कुछ तत्व उपयोगकर्ता द्वारा सबमिट किए गए कार्यों के आधार पर खाली तार हैं। मुझे उन तत्वों को हटाने की जरूरत है। मेरे पास यह है:

foreach($linksArray as $link)
{
    if($link == '')
    {
        unset($link);
    }
}
print_r($linksArray);

लेकिन यह काम नहीं करता है, $linksArray अभी भी खाली तत्व है। मैंने empty() फ़ंक्शन के साथ ऐसा करने का भी प्रयास किया है लेकिन परिणाम वही है।


आप बस कर सकते हैं

array_filter($array)

array_filter: "अगर कोई कॉलबैक नहीं दिया जाता है, तो FALSE के बराबर इनपुट की सभी प्रविष्टियां हटा दी जाएंगी।" इसका मतलब है कि मूल्यों के साथ तत्व, 0, '0', '', FALSE, array () भी हटा दिए जाएंगे।

दूसरा विकल्प कर रहा है

array_diff($array, array(''))

जो मूल्यों के साथ तत्वों को हटा देगा, '' और गलत।

उम्मीद है की यह मदद करेगा :)

अद्यतन करें

यहाँ एक उदाहरण है।

$a = array(0, '0', NULL, FALSE, '', array());

var_dump(array_filter($a));
// array()

var_dump(array_diff($a, array(0))) // 0 / '0'
// array(NULL, FALSE, '', array());

var_dump(array_diff($a, array(NULL))) // NULL / FALSE / ''
// array(0, '0', array())

सारांश में:

  • 0 या '0' 0 और '0' को हटा देगा
  • नल, गलत या '' शून्य, गलत और 'हटा देगा

इस विषय पर सबसे लोकप्रिय जवाब बिल्कुल असंगत है।

निम्न PHP स्क्रिप्ट पर विचार करें:

<?php
$arr = array('1', '', '2', '3', '0');
// Incorrect:
print_r(array_filter($arr));
// Correct:
print_r(array_filter($arr, 'strlen'));

ऐसा क्यों है? चूंकि एक '0' वर्ण वाला एक स्ट्रिंग भी बूलियन झूठी का मूल्यांकन करता है, भले ही यह खाली स्ट्रिंग न हो, फिर भी यह फ़िल्टर हो जाएगा। वह एक बग होगा।

फ़िल्टरिंग फ़ंक्शन के रूप में अंतर्निहित स्ट्रेल फ़ंक्शन को पास करना, क्योंकि यह एक गैर-खाली स्ट्रिंग के लिए गैर-शून्य पूर्णांक देता है, और एक खाली स्ट्रिंग के लिए शून्य पूर्णांक देता है। बूलियन में परिवर्तित होने पर गैर-शून्य पूर्णांक हमेशा सत्य पर मूल्यांकन करते हैं, जबकि शून्य पूर्णांक हमेशा बूलियन में परिवर्तित होने पर झूठे मूल्यांकन करते हैं।

तो, पूर्ण, निश्चित, सही उत्तर है:

$arr = array_filter($arr, 'strlen');

खाली तत्वों को हटाने के लिए आप array_filter का उपयोग कर सकते हैं:

$emptyRemoved = array_filter($linksArray);

यदि आपके सरणी में (int) 0 है, तो आप निम्न का उपयोग कर सकते हैं:

$emptyRemoved = remove_empty($linksArray);

function remove_empty($array) {
  return array_filter($array, '_remove_empty_internal');
}

function _remove_empty_internal($value) {
  return !empty($value) || $value === 0;
}

संपादित करें: हो सकता है कि आपके तत्व प्रति से खाली न हों लेकिन एक या अधिक रिक्त स्थान हों ... आप array_filter का उपयोग करने से पहले निम्न का उपयोग कर सकते हैं

$trimmedArray = array_map('trim', $linksArray);

खाली सरणी तत्व निकालें

function removeEmptyElements(&$element)
{
    if (is_array($element)) {
        if ($key = key($element)) {
            $element[$key] = array_filter($element);
        }

        if (count($element) != count($element, COUNT_RECURSIVE)) {
            $element = array_filter(current($element), __FUNCTION__);
        }

        return $element;
    } else {
        return empty($element) ? false : $element;
    }
}

$data = array(
    'horarios' => array(),
    'grupos' => array(
        '1A' => array(
            'Juan' => array(
                'calificaciones' => array(
                    'Matematicas' => 8,
                    'Español' => 5,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => 10,
                    'marzo' => '',
                )
            ),
            'Damian' => array(
                'calificaciones' => array(
                    'Matematicas' => 10,
                    'Español' => '',
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => '',
                    'marzo' => 5,
                )
            ),
        ),
        '1B' => array(
            'Mariana' => array(
                'calificaciones' => array(
                    'Matematicas' => null,
                    'Español' => 7,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => null,
                    'febrero' => 5,
                    'marzo' => 5,
                )
            ),
        ),
    )
);

$data = array_filter($data, 'removeEmptyElements');
var_dump($data);

यह काम करता हैं!


चूंकि आप तारों की सरणी से निपट रहे हैं, आप केवल array_filter() उपयोग कर सकते हैं, जो आसानी से आपके लिए यह सब संभालता है:

print_r(array_filter($linksArray));

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

// PHP < 5.3
print_r(array_filter($linksArray, create_function('$value', 'return $value !== "";')));

// PHP 5.3 and later
print_r(array_filter($linksArray, function($value) { return $value !== ''; }));

बस एक पंक्ति: अद्यतन (@suther के लिए धन्यवाद):

$array_without_empty_values = array_filter($array);

बहुआयामी सरणी के लिए

$data = array_map('array_filter', $data);
$data = array_filter($data);

मैं सरणी से खाली तत्वों को हटाने के लिए निम्न स्क्रिप्ट का उपयोग करता हूं

for ($i=0; $i<$count($Array); $i++)
  {
    if (empty($Array[$i])) unset($Array[$i]);
  }

यदि आप संख्यात्मक सरणी के साथ काम कर रहे हैं और रिक्त तत्वों को हटाने के बाद सरणी को पुन: अनुक्रमणिका करने की आवश्यकता है, तो array_values फ़ंक्शन का उपयोग करें:

array_values(array_filter($array));

यह भी देखें: PHP reindex सरणी?


सबसे अधिक वोट दिया गया जवाब गलत है या कम से कम पूरी तरह से सच नहीं है क्योंकि ओपी केवल रिक्त तारों के बारे में बात कर रहा है। यहां एक संपूर्ण स्पष्टीकरण दिया गया है:

खाली मतलब क्या है?

सबसे पहले, हमें खाली साधनों पर सहमत होना चाहिए। क्या आप फ़िल्टर करना चाहते हैं:

  1. खाली तार केवल ("")?
  2. सख्ती से झूठे मूल्य? ( $element === false )
  3. झूठी मूल्य? (यानी 0, 0.0, "", "0", न्यूल, सरणी () ...)
  4. PHP के empty() फ़ंक्शन के बराबर?

आप मूल्यों को कैसे फ़िल्टर करते हैं

खाली तारों को केवल फ़िल्टर करने के लिए:

$filtered = array_diff($originalArray, array(""));

सख्ती से झूठे मूल्यों को फ़िल्टर करने के लिए, आपको कॉलबैक फ़ंक्शन का उपयोग करना होगा:

$filtered = array_diff($originalArray, 'myCallback');
function myCallback($var) {
    return $var === false;
}

कॉलबैक किसी भी संयोजन के लिए भी उपयोगी है जिसमें आप कुछ को छोड़कर "झूठी" मानों को फ़िल्टर करना चाहते हैं। (उदाहरण के लिए, प्रत्येक null और false , आदि फ़िल्टर करें, केवल 0 छोड़कर):

$filtered = array_filter($originalArray, 'myCallback');
function myCallback($var) {
    return ($var === 0 || $var === '0');
}

तीसरा और चौथा मामला (आखिरी बार हमारे उद्देश्यों के लिए) समकक्ष है, और इसके लिए आपको केवल डिफ़ॉल्ट उपयोग करना है:

$filtered = array_filter($originalArray);

    $myarray = array_filter($myarray, 'strlen');  //removes null values but leaves "0"
    $myarray = array_filter($myarray);            //removes all null values

$linksArray = array_filter($linksArray);

"अगर कोई कॉलबैक नहीं दिया जाता है, तो FALSE के बराबर इनपुट की सभी प्रविष्टियां हटा दी जाएंगी।" - php.net/manual/en/function.array-filter.php


$my = ("0"=>" ","1"=>"5","2"=>"6","3"=>" ");   

foreach ($my as $key => $value) {
    if (is_null($value)) unset($my[$key]);
}

foreach ($my as $key => $value) {
    echo   $key . ':' . $value . '<br>';
} 

उत्पादन

1: 5

2: 6


foreach($arr as $key => $val){
   if (empty($val)) unset($arr[$key];
}

foreach($linksArray as $key => $link) 
{ 
    if($link === '') 
    { 
        unset($linksArray[$key]); 
    } 
} 
print_r($linksArray); 




string