it-swarm-eu.dev

Explodieren, das keine leeren Zeichenfolgen zurückgibt?

Die PHP-Funktion explode gibt ein Array von Strings zurück, die auf einen bestimmten Teilstring aufgeteilt sind. Es werden leere Strings wie folgt zurückgegeben:

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

Gibt es eine andere Funktion oder Option oder irgendetwas, das alles außer die leeren Zeichenketten zurückgibt?

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

Versuchen Sie preg_split .

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

56
ceejayoz

array_filter entfernt die leeren Felder. Hier ist ein Beispiel ohne den Filter:

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

druckt:

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

Mit dem Filter:

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

Drucke:

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

Sie erhalten alle Werte, die auf "false" aufgelöst werden, herausgefiltert.

siehe http://uk.php.net/manual/en/function.array-filter.php

19
Dave Gregory

Nur zur Abwechslung:

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

Dies funktioniert auch, aber im Gegensatz zu preg_split werden die Array-Indizes durcheinander gebracht. Manche mögen es vielleicht besser, als eine Rückruffunktion deklarieren zu müssen, um array_filter zu verwenden.

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

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

Hier ist eine Lösung, die ein neu indiziertes Array ausgeben sollte.

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

Obwohl diese Implementierung einem anderen Vorschlag ziemlich ähnlich ist, hat sie den Vorteil der generischen Verwendung. Geben Sie für Arrays mit Nicht-String-Elementen einen eingegebenen leeren Wert als zweites Argument an.

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') );

.

.

.

Mit einem optionalen Filterargument.

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

Mit der Nutzung ..

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

Mit array_deflate können Sie ausgewählte Elemente verarbeiten und aus Ihrem Array entfernen. Schöner ist es auch, die if-Anweisung in eine Vergleichsfunktion zu verwandeln, die auch als Argument übergeben wird, falls Sie Lust haben.

Ist array_inflate umgekehrt, wird ein zusätzliches Array als erster Parameter verwendet, auf den Übereinstimmungen übertragen werden, während Nicht-Übereinstimmungen gefiltert werden.

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

Mit der Nutzung ..

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

Dies liefert einen idealen Algorithmus für die Bildungsprobleme der Welt. Und ich höre dort auf, bevor ich das in etwas anderes verwandle.

1
Garet Claborn

Ich habe dies in TYPO3 verwendet, siehe den Parameter $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;
}

Die Indizes werden nicht durcheinander gebracht:

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

Ergebnis:

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

Schreiben Sie eine Wrapper-Funktion, um sie zu entfernen

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

Ich habe die anderen Vorschläge hier nicht getestet, aber das funktioniert:

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

Lösungen für reguläre Ausdrücke sind in der Regel viel langsamer als das Ersetzen von einfachem Text. Daher ersetze ich doppelte Trennzeichen durch einfache Trennzeichen, schneide die Zeichenfolge von Leerzeichen ab und verwende dann explode:

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

Kein Regex-Overhead - sollte einigermaßen effizient sein, strlen zählt nur die Bytes

Löschen Sie array_values ​​(), wenn Sie sich nicht für Indizes interessieren

Machen Sie es in die Funktion explode_interesting ($ array, $ fix_index = 0), wenn Sie möchten

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

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

viel Spaß, Jeff

0
Jeff

Verwenden Sie diese Funktion, um die Ausgabe der Explosionsfunktion zu filtern

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

        $arrayvar = $newarray;
    }
0
AntonioCS