Question

PHP的explode函数返回在一些提供的子字符串上拆分的字符串数组。它将返回如下的空字符串：

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

Answer 1

尝试preg_split。

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

Answer 2

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
)

您将解析所有解析为“false”的值。

请参阅http://uk.php.net/manual/en/function.array-filter.php

Answer 3

只是为了变化：

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

这也有效，但与preg_split不同，它确实搞乱了数组索引。有些人可能比声明一个回调函数使用array_filter更好。

Answer 4

function not_empty_string($s) {
  return $s !== "";
}

array_filter(explode('/', '1/2//3/'), 'not_empty_string');

Answer 5

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

Answer 6

这是一个应该输出新索引数组的解决方案。

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

虽然与其他一些建议非常相似，但这种实现具有通用性的优点。对于具有非字符串元素的数组，请提供类型化的空值作为第二个参数。

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转换为处理选择元素并从数组中删除它们的方法。同样更好的是将if语句转换为比较函数，该函数也作为参数传递，以防您喜欢。

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

从而为世界的教育问题提供理想的算法。 Aaand我会在我将其调整为其他内容之前停在那里..

Answer 7

编写一个包装函数来剥离它们

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

Answer 8

我没有在这里测试过其他建议，但这样做有效：

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

Answer 9

使用此功能过滤爆炸功能的输出

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

        $arrayvar = $newarray;
    }

Answer 10

正则表达式解决方案往往比基本文本替换慢得多，所以我用单个分隔符替换双分隔符，修剪任何空格的字符串然后使用explode：

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

Answer 11

没有正则表达式开销 - 应该合理有效，strlen只计算字节

如果您不关心索引，请删除array_values（）

如果你想要的话，将它变成函数explode_interesting（$ array，$ 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>";

享受，杰夫

Answer 12

我通常将其包裹在对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（）添加外部包装调用。

Answer 13

PHP的split function与explode函数类似，不同之处在于它允许您输入正则表达式作为分隔符。有什么影响：

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

爆炸不会返回空字符串？

13 个答案: