php - remove - strip_tags wordpress

¿Explotar que no devuelve cadenas vacías?

Question

La función de explosión de PHP devuelve una matriz de cadenas divididas en alguna subcadena proporcionada. Devolverá cadenas vacías como esta:

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

¿Hay alguna función u opción diferente o cualquier cosa que devuelva todo excepto las cadenas vacías?

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

Answer 1

Escribir una función de envoltura para despojarlos

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

Answer 2

Prueba preg_split .

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

Answer 3

La función de división de PHP es similar a la función de explosión, excepto que le permite ingresar un patrón de expresión regular como delimitador. Algo en el sentido de:

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

Answer 4

No he probado las otras sugerencias aquí, pero esto funciona:

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

Answer 5

Normalmente lo envuelvo en una llamada a array_filter , por ej.

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

Tenga en cuenta, por supuesto, que las claves de matriz se mantienen; si no desea este comportamiento, recuerde agregar una llamada contenedora externa a array_values ​​().

Answer 6

Solo por variedad:

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

Esto también funciona, pero estropea los índices de matriz a diferencia de preg_split. A algunas personas les puede gustar más que tener que declarar una función de devolución de llamada para usar array_filter.

Answer 7

Utilice esta función para filtrar la salida de la función de explosión

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

Answer 8

Las soluciones de expresión regular tienden a ser mucho más lentas que el reemplazo de texto básico, así que reemplazaría los separadores dobles con separadores únicos, recortaría la cadena de cualquier espacio en blanco y luego usaría explotar:

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

Answer 9

function not_empty_string($s) {
return $s !== "";
}
array_filter(explode(''/'', ''1/2//3/''), ''not_empty_string'');

Answer 10

Lo he usado en TYPO3 , mire el parámetro $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;
}

No estropea los índices:

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

Resultado:

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

Answer 11

array_filter eliminará los campos en blanco, aquí hay un ejemplo sin el filtro:

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

huellas dactilares:

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

Con el filtro:

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

Huellas dactilares:

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

Obtendrá todos los valores que se resuelven como "falsos" filtrados.

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

Answer 12

Aquí hay una solución que debería generar una nueva matriz indexada.

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

Si bien es bastante similar a otra sugerencia, esta implementación tiene el beneficio del uso genérico. Para matrices con elementos que no sean de cadena, proporcione un valor vacío tipado como segundo argumento.

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

.

.

.

Con un argumento de filtro opcional ...

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

Con el uso ..

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

Convirtiendo array_deflate en una forma de procesar elementos de elección y eliminarlos de su matriz. También es más agradable convertir la instrucción if en una función de comparación que también se pasa como argumento en caso de que te apetezca.

array_inflate siendo al revés, tomaría una matriz extra ya que el primer parámetro que coincide se presiona mientras que las no coincidencias se filtran.

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

Con el uso ..

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

Proporcionando así un algoritmo ideal para los problemas educativos del mundo. Y me detendré allí antes de modificar esto en otra cosa ...

Answer 13

Sin sobrecarga regex: debe ser razonablemente eficiente, strlen solo cuenta los bytes

Suelta los valores de matriz () si no te importan los índices

Conviértalo en función explode_interesting ($ array, $ fix_index = 0) si lo desea

$interesting = array_values(
array_filter(
explode(''/'', ''/1//2//3///4/0/false'' ),
function ($val) { return strlen($val); }
));
echo "<pre>", var_export( $interesting, true ), "</pre>";

disfruta, Jeff