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




php भाषा (11)

विविधता के लिए:

array_diff(explode('/', '1/2//3/'), array(''))

यह भी काम करता है, लेकिन सरग्रे संरेखित करता है जो preg_split के विपरीत है। कुछ लोगों को यह पसंद आती है कि वे array_filter का उपयोग करने के लिए एक कॉलबैक फ़ंक्शन को घोषित करते हैं।

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

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"
}

कोई 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>";

आनंद लें, जेफ


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

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

        $arrayvar = $newarray;
    }

मैंने इसे 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 को कॉल में लपेटता हूं , उदा

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 MyExplode($sep, $str)
{
    $arr = explode($sep, $str);
    foreach($arr as $item)
        if(item != "")
            $out[] = $item;
    return $out;
}

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 देखें


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

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

यहाँ एक समाधान है, जो एक नए अनुक्रमित सरणी को आउटपुट करना चाहिए।

$result = array_deflate( explode( $delim, $array) );

function array_deflate( $arr, $emptyval='' ){
    $ret=[];
    for($i=0,$L=count($arr); $i<$L; ++$i)
        if($arr[$i] !== $emptyval) $ret[]=$arr[$i];
    return $ret;
}

जबकि कुछ अन्य सुझाव के समान ही, इस कार्यान्वयन के सामान्य उपयोग के लाभ हैं गैर-स्ट्रिंग तत्वों के साथ arrays के लिए, दूसरे तर्क के रूप में टाइप किए गए खाली मान प्रदान करें।

array_deflate( $objArray, new stdClass() );

array_deflate( $databaseArray, NULL );

array_deflate( $intArray, NULL );

array_deflate( $arrayArray, [] );

array_deflate( $assocArrayArray, [''=>NULL] );

array_deflate( $processedArray, new Exception('processing error') );

एक वैकल्पिक फ़िल्टर तर्क के साथ ..

function array_deflate( $arr, $trigger='', $filter=NULL, $compare=NULL){
    $ret=[];
    if ($filter === NULL) $filter = function($el) { return $el; };
    if ($compare === NULL) $compare = function($a,$b) { return $a===$b; };

    for($i=0,$L=count($arr); $i<$L; ++$i)
        if( !$compare(arr[$i],$trigger) ) $ret[]=$arr[$i];
        else $filter($arr[$i]);
    return $ret;
}

उपयोग के साथ ..

function targetHandler($t){ /* .... */ }    
array_deflate( $haystack, $needle, targetHandler );

Array_deflate को विकल्प तत्वों को प्रोसेस करने और उन्हें अपने सरणी से निकालने के तरीके में बदलना। साथ ही अगर कथन एक तुलना समारोह में बदलना है जो एक तर्क के रूप में भी पारित हो जाता है, तो आपको फैंसी मिलती है।

array_inflate रिवर्स होने पर, अतिरिक्त array_inflate , क्योंकि पहले पैरामीटर जो मैच से मेल खाता है, जबकि गैर-मेल फ़िल्टर किए जाते हैं।

function array_inflate($dest,$src,$trigger='', $filter=NULL, $compare=NULL){
    if ($filter === NULL) $filter = function($el) { return $el; };
    if ($compare === NULL) $compare = function($a,$b) { return $a===$b; };

    for($i=0,$L=count($src); $i<$L; ++$i)
        if( $compare(src[$i],$trigger) ) $dest[]=$src[$i];
        else $filter($src[$i]);
    return $dest;
}

उपयोग के साथ ..

$smartppl=[];    
$smartppl=array_inflate( $smartppl,
                         $allppl,
                         (object)['intelligence'=>110],
                         cureStupid,
                         isSmart);

function isSmart($a,$threshold){
    if( isset($a->intellgence) )    //has intelligence?
        if( isset($threshold->intellgence) )    //has intelligence?
            if( $a->intelligence >= $threshold->intelligence )
                return true;
            else return INVALID_THRESHOLD; //error
        else return INVALID_TARGET; //error
    return false;
}

function cureStupid($person){
    $dangerous_chemical = selectNeurosteroid();
    applyNeurosteroid($person, $dangerous_chemical);

    if( isSmart($person,(object)['intelligence'=>110]) ) 
        return $person;
    else 
        lobotomize($person);

    return $person;
}

इस प्रकार दुनिया की शैक्षिक समस्याओं के लिए एक आदर्श एल्गोरिथ्म प्रदान करना। और मैं इसे कुछ और में ट्रिगर करने से पहले वहां रोकूंगा ..


कोशिश करें preg_split

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


पीएचपी का विभाजन समारोह विस्फोट समारोह के समान है, सिवाय इसके कि यह आपको एक रेगेक्स पैटर्न को सीमांकक के रूप में दर्ज करने की अनुमति देता है। के प्रभाव के लिए कुछ:

$exploded_arr = split('/\/+/', '1/2//3/');




php