tutorial - php भाषा




विस्फोट कि खाली तार वापस नहीं करता है? (9)

पीएचपी का विस्फोट फ़ंक्शन कुछ प्रदान किये गए सबस्ट्रिंग पर तार विभाजन की एक सरणी देता है। यह खाली स्ट्रिंग इस तरह वापस लौटाएगी:

var_dump(explode('/', '1/2//3/'));
array(5) {
  [0]=>
  string(1) "1"
  [1]=>
  string(1) "2"
  [2]=>
  string(0) ""
  [3]=>
  string(1) "3"
  [4]=>
  string(0) ""
}

क्या कुछ अलग फ़ंक्शन या विकल्प या कुछ भी है जो खाली स्ट्रिंग को छोड़कर सबकुछ वापस करेगा?

var_dump(different_explode('/', '1/2//3/'));
array(3) {
  [0]=>
  string(1) "1"
  [1]=>
  string(1) "2"
  [2]=>
  string(1) "3"
}

उन्हें पट्टी करने के लिए एक आवरण समारोह लिखें

function MyExplode($sep, $str)
{
    $arr = explode($sep, $str);
    foreach($arr as $item)
        if(item != "")
            $out[] = $item;
    return $out;
}

कोशिश करें preg_split

$exploded = preg_split('@/@', '1/2//3/', NULL, PREG_SPLIT_NO_EMPTY);


मैं आमतौर पर array_filter को कॉल में लपेटता हूं , उदा

var_dump(array_filter(explode('/', '1/2//3/'))
=>
array(3) {
  [0]=>
  string(1) "1"
  [1]=>
  string(1) "2"
  [3]=>
  string(1) "3"
}

ज़ाहिर रहें, कि सरणी कुंजी बनाए रखी जाती है; अगर आप यह व्यवहार नहीं करना चाहते हैं, तो याद रखें कि बाहरी_आकार (array_values) के लिए बाहरी आवरण कॉल जोड़ें


मैंने यहां अन्य सुझावों का परीक्षण नहीं किया है, लेकिन यह काम करता है:

function different_explode($mypattern,$mystring){
    $array1 = explode($mypattern,$mystring);
    $retArray = Array();
    foreach($array1 as $myval){
        if($myval != ''){
            array_push($retArray,$myval);
        }
    }
    return $retArray;
}

विस्फोट फ़ंक्शन के आउटपुट को फ़िल्टर करने के लिए इस फ़ंक्शन का उपयोग करें

  function filter_empty(&$arrayvar) {
        $newarray = array();
        foreach ($arrayvar as $k => $value)
            if ($value !== "")
                $newarray[$k] = $value;

        $arrayvar = $newarray;
    }

नियमित अभिव्यक्ति समाधान बुनियादी पाठ प्रतिस्थापन की तुलना में बहुत धीमी होते हैं, इसलिए मैं एकल सेपरेटर के साथ डबल सेपरेटर की जगह लेता हूं, किसी भी सफेद स्थान की स्ट्रिंग ट्रिम करता हूं और फिर विस्फोट का उपयोग करता हूं:

// assuming $source = '1/2//3/';
$source = str_replace('//', '/', $source);
$source = trim($source);
$parts = explode('/', $source);

मैंने इसे TYPO3 में उपयोग किया है, $onlyNonEmptyValues पैरामीटर को देखें:

function trimExplode($delim, $string, $onlyNonEmptyValues=0){
    $temp = explode($delim,$string);
    $newtemp=array();
    while(list($key,$val)=each($temp))      {
        if (!$onlyNonEmptyValues || strcmp("",trim($val)))      {
            $newtemp[]=trim($val);
        }
    }
    reset($newtemp);
    return $newtemp;
}

यह इंडेक्स को गड़बड़ नहीं करता है:

var_dump(trimExplode('/', '1/2//3/',1));

परिणाम:

array(3) {
  [0]=>
  string(1) "1"
  [1]=>
  string(1) "2"
  [2]=>
  string(1) "3"
}

array_filter रिक्त फ़ील्ड को निकाल देगा, फिल्टर के बिना यहां एक उदाहरण है:

print_r(explode('/', '1/2//3/'))

प्रिंट:

Array
(
    [0] => 1
    [1] => 2
    [2] =>
    [3] => 3
    [4] =>
)

फिल्टर के साथ:

php> print_r(array_filter(explode('/', '1/2//3/')))

प्रिंटों:

Array
(
    [0] => 1
    [1] => 2
    [3] => 3
)

आप सभी मान प्राप्त करेंगे जो "झूठे" फ़िल्टर किए जाने का समाधान करते हैं।

http://uk.php.net/manual/en/function.array-filter.php देखें


कोई regex ओवरहेड - उचित रूप से कुशल होना चाहिए, strlen सिर्फ बाइट्स की गणना करता है

Array_values ​​() ड्रॉप करें यदि आप अनुक्रमणिका के बारे में परवाह नहीं करते हैं

अगर आप चाहें तो फ़ंक्शन विस्फोट_संदर्भ में ($ सरणी, $ fix_index = 0) करें

$interesting = array_values( 
                 array_filter(
                   explode('/', '/1//2//3///4/0/false' ),
                   function ($val) { return strlen($val); }
               ));

echo "<pre>", var_export( $interesting, true ), "</pre>";

आनंद लें, जेफ





php