Einige Elemente in meinem Array sind leere Zeichenfolgen, basierend auf dem, was der Benutzer übermittelt hat. Ich muss diese Elemente entfernen. Ich habe das:

foreach($linksArray as $link)
{
    if($link == '')
    {
        unset($link);
    }
}
print_r($linksArray);

Aber es funktioniert nicht. $linksArrayhat noch leere Elemente. Ich habe es auch mit der empty()Funktion versucht , aber das Ergebnis ist das gleiche.

Da es sich um eine Reihe von Zeichenfolgen handelt, können Sie diese einfach verwenden array_filter(), um all dies bequem für Sie zu erledigen:

print_r(array_filter($linksArray));

Beachten Sie, dass, wenn kein Rückruf bereitgestellt wird , alle Einträge des Arrays gleich FALSE(siehe Konvertieren in Boolesche Werte ) entfernt werden. Wenn Sie also Elemente beibehalten müssen, bei denen es sich um exakte Zeichenfolgen handelt '0', benötigen Sie einen benutzerdefinierten Rückruf:

// PHP 7.4 and later
print_r(array_filter($linksArray, fn($value) => !is_null($value) && $value !== ''));

// PHP 5.3 and later
print_r(array_filter($linksArray, function($value) { return !is_null($value) && $value !== ''; }));

// PHP < 5.3
print_r(array_filter($linksArray, create_function('$value', 'return $value !== "";')));

Sie können array_filterdamit leere Elemente entfernen:

$emptyRemoved = array_filter($linksArray);

Wenn Sie (int) 0in Ihrem Array haben, können Sie Folgendes verwenden:

$emptyRemoved = remove_empty($linksArray);

function remove_empty($array) {
  return array_filter($array, '_remove_empty_internal');
}

function _remove_empty_internal($value) {
  return !empty($value) || $value === 0;
}

BEARBEITEN: Möglicherweise sind Ihre Elemente nicht per se leer, sondern enthalten ein oder mehrere Leerzeichen ... Sie können Folgendes verwenden, bevor Sie es verwendenarray_filter

$trimmedArray = array_map('trim', $linksArray);

Die beliebteste Antwort zu diesem Thema ist absolut falsch.

Betrachten Sie das folgende PHP-Skript:

<?php
$arr = array('1', '', '2', '3', '0');
// Incorrect:
print_r(array_filter($arr));
// Correct:
print_r(array_filter($arr, 'strlen'));

Warum ist das? Da eine Zeichenfolge, die ein einzelnes '0'-Zeichen enthält, auch als boolescher Wert false ausgewertet wird, wird sie gefiltert, auch wenn sie keine leere Zeichenfolge ist. Das wäre ein Fehler.

Das Übergeben der integrierten strlen-Funktion als Filterfunktion funktioniert, da für eine nicht leere Zeichenfolge eine Ganzzahl ungleich Null und für eine leere Zeichenfolge eine Ganzzahl Null zurückgegeben wird. Ganzzahlen ungleich Null werden bei der Konvertierung in Boolesche Werte immer als wahr ausgewertet, während Ganzzahlen bei der Konvertierung in Boolesche Werte immer als falsch ausgewertet werden.

Die absolute, endgültige und richtige Antwort lautet also:

$arr = array_filter($arr, 'strlen');

$linksArray = array_filter($linksArray);

"Wenn kein Rückruf bereitgestellt wird, werden alle Eingaben der Eingabe gleich FALSE entfernt." - http://php.net/manual/en/function.array-filter.php

    $myarray = array_filter($myarray, 'strlen');  //removes null values but leaves "0"
    $myarray = array_filter($myarray);            //removes all null values

Du kannst es einfach tun

array_filter($array)

array_filter: "Wenn kein Rückruf bereitgestellt wird, werden alle Eingaben der Eingabe gleich FALSE entfernt." Dies bedeutet, dass Elemente mit den Werten NULL, 0, '0', '', FALSE, array () ebenfalls entfernt werden.

Die andere Option ist zu tun

array_diff($array, array(''))

Dadurch werden Elemente mit den Werten NULL, '' und FALSE entfernt.

Hoffe das hilft :)

AKTUALISIEREN

Hier ist ein Beispiel.

$a = array(0, '0', NULL, FALSE, '', array());

var_dump(array_filter($a));
// array()

var_dump(array_diff($a, array(0))) // 0 / '0'
// array(NULL, FALSE, '', array());

var_dump(array_diff($a, array(NULL))) // NULL / FALSE / ''
// array(0, '0', array())

Um zusammenzufassen:

• 0 oder '0' entfernen 0 und '0'
• NULL, FALSE oder '' entfernen NULL, FALSE und ''

foreach($linksArray as $key => $link) 
{ 
    if($link === '') 
    { 
        unset($linksArray[$key]); 
    } 
} 
print_r($linksArray); 

Ein weiterer Liner zum Entfernen leerer ("" leerer String) Elemente aus Ihrem Array.

$array = array_filter($array, function($a) {return $a !== "";});

Hinweis: Dieser Code absichtlich hält null, 0und falseElemente.

Oder vielleicht möchten Sie zuerst Ihre Array-Elemente zuschneiden:

$array = array_filter($array, function($a) {
    return trim($a) !== "";
});

Hinweis: Dieser Code entfernt auch nullund falseElemente.

Zusamenfassend:

Dies ist mein vorgeschlagener Code:

$myarray =  array_values(array_filter(array_map('trim', $myarray), 'strlen'));

Erläuterung:

Ich denke, die Verwendung array_filterist gut, aber nicht genug, weil die Werte wie spaceund \n... im Array bleiben und dies normalerweise schlecht ist.

Also schlage ich vor , verwenden Sie Mischung array_filterund array_map.

array_mapdient zum Trimmen, array_filterzum Entfernen leerer Werte, strlenzum Beibehalten von 0Werten und array_valueszum erneuten Indizieren, falls erforderlich.

Proben:

$myarray = array("\r", "\n", "\r\n", "", " ", "0", "a");

// "\r", "\n", "\r\n", " ", "a"
$new1 = array_filter($myarray);

// "a"
$new2 = array_filter(array_map('trim', $myarray));

// "0", "a"
$new3 = array_filter(array_map('trim', $myarray), 'strlen');

// "0", "a" (reindex)
$new4 = array_values(array_filter(array_map('trim', $myarray), 'strlen'));

var_dump($new1, $new2, $new3, $new4);

Ergebnisse:

array(5) {
  [0]=>
" string(1) "
  [1]=>
  string(1) "
"
  [2]=>
  string(2) "
"
  [4]=>
  string(1) " "
  [6]=>
  string(1) "a"
}
array(1) {
  [6]=>
  string(1) "a"
}
array(2) {
  [5]=>
  string(1) "0"
  [6]=>
  string(1) "a"
}
array(2) {
  [0]=>
  string(1) "0"
  [1]=>
  string(1) "a"
}

Online-Test:

http://phpio.net/s/5yg0

Wenn Sie mit einem numerischen Array arbeiten und das Array nach dem Entfernen leerer Elemente neu indizieren müssen, verwenden Sie die Funktion array_values :

array_values(array_filter($array));

Siehe auch: PHP-Neuindizierungsarray?

Die am häufigsten gewählte Antwort ist falsch oder zumindest nicht ganz richtig, da das OP nur von leeren Zeichenfolgen spricht. Hier ist eine gründliche Erklärung:

Was bedeutet leer ?

Zunächst müssen wir uns darauf einigen, was leer bedeutet. Wollen Sie herausfiltern:

1. nur die leeren Strings ("")?
2. die streng falschen Werte? ( $element === false)
3. die falsey Werte? (dh 0, 0.0, "", "0", NULL, array () ...)
4. das Äquivalent der PHP- empty()Funktion?

Wie filtern Sie die Werte heraus?

So filtern Sie nur leere Zeichenfolgen heraus :

$filtered = array_diff($originalArray, array(""));

Um nur streng falsche Werte herauszufiltern , müssen Sie eine Rückruffunktion verwenden:

$filtered = array_diff($originalArray, 'myCallback');
function myCallback($var) {
    return $var === false;
}

Der Rückruf ist auch nützlich für jede Kombination, in der Sie die "Falsey" -Werte herausfiltern möchten, mit Ausnahme einiger. (Filtern Sie beispielsweise alle nullund falseusw. und lassen Sie nur übrig 0):

$filtered = array_filter($originalArray, 'myCallback');
function myCallback($var) {
    return ($var === 0 || $var === '0');
}

Der dritte und vierte Fall sind (endlich für unsere Zwecke) gleichwertig, und dafür müssen Sie nur die Standardeinstellung verwenden:

$filtered = array_filter($originalArray);

Ich musste dies tun, um einen Array-Wert von (string) 0 beizubehalten

$url = array_filter($data, function ($value) {
  return (!empty($value) || $value === 0 || $value==='0');
});

$a = array(1, '', '', '', 2, '', 3, 4);
$b = array_values(array_filter($a));

print_r($b)

Für mehrdimensionales Array

$data = array_map('array_filter', $data);
$data = array_filter($data);

$out_array = array_filter($input_array, function($item) 
{ 
    return !empty($item['key_of_array_to_check_whether_it_is_empty']); 
}
);

function trim_array($Array)
{
    foreach ($Array as $value) {
        if(trim($value) === '') {
            $index = array_search($value, $Array);
            unset($Array[$index]);
        }
    }
    return $Array;
}

Ich benutze das folgende Skript, um leere Elemente aus einem Array zu entfernen

for ($i=0; $i<$count($Array); $i++)
  {
    if (empty($Array[$i])) unset($Array[$i]);
  }

Ich möchte nur eine Alternative zu Schleifen beitragen ... auch Lücken in Schlüsseln schließen ...

In meinem Fall wollte ich nach Abschluss des Vorgangs sequentielle Array-Schlüssel behalten (nicht nur ungerade Zahlen, worauf ich starrte. Das Einrichten von Code für die Suche nach ungeraden Schlüsseln schien mir fragil und nicht zukunftsfreundlich.)

Ich suchte nach etwas Ähnlichem: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/

Die Kombination von array_filter und array_slice macht den Trick.

$example = array_filter($example); $example = array_slice($example,0);

Keine Ahnung von Effizienz oder Benchmarks, aber es funktioniert.

$my = ("0"=>" ","1"=>"5","2"=>"6","3"=>" ");   

foreach ($my as $key => $value) {
    if (is_null($value)) unset($my[$key]);
}

foreach ($my as $key => $value) {
    echo   $key . ':' . $value . '<br>';
} 

Ausgabe

1: 5

2: 6

foreach($arr as $key => $val){
   if (empty($val)) unset($arr[$key];
}

Nur eine Zeile: Update (danke an @suther):

$array_without_empty_values = array_filter($array);

Verwenden Sie die array_filterFunktion, um leere Werte zu entfernen:

$linksArray = array_filter($linksArray);
print_r($linksArray);

Leere Array-Elemente entfernen

function removeEmptyElements(&$element)
{
    if (is_array($element)) {
        if ($key = key($element)) {
            $element[$key] = array_filter($element);
        }

        if (count($element) != count($element, COUNT_RECURSIVE)) {
            $element = array_filter(current($element), __FUNCTION__);
        }

        return $element;
    } else {
        return empty($element) ? false : $element;
    }
}

$data = array(
    'horarios' => array(),
    'grupos' => array(
        '1A' => array(
            'Juan' => array(
                'calificaciones' => array(
                    'Matematicas' => 8,
                    'Español' => 5,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => 10,
                    'marzo' => '',
                )
            ),
            'Damian' => array(
                'calificaciones' => array(
                    'Matematicas' => 10,
                    'Español' => '',
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => '',
                    'marzo' => 5,
                )
            ),
        ),
        '1B' => array(
            'Mariana' => array(
                'calificaciones' => array(
                    'Matematicas' => null,
                    'Español' => 7,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => null,
                    'febrero' => 5,
                    'marzo' => 5,
                )
            ),
        ),
    )
);

$data = array_filter($data, 'removeEmptyElements');
var_dump($data);

Es klappt!

Gemäß Ihrer Methode können Sie diese Elemente einfach in einem anderen Array abfangen und das folgende wie folgt verwenden:

foreach($linksArray as $link){
   if(!empty($link)){
      $new_arr[] = $link
   }
}

print_r($new_arr);

versuchen Sie dieses ** ** Beispiel

$or = array(
        'PersonalInformation.first_name' => $this->request->data['User']['first_name'],
        'PersonalInformation.last_name' => $this->request->data['User']['last_name'],
        'PersonalInformation.primary_phone' => $this->request->data['User']['primary_phone'],
        'PersonalInformation.dob' => $this->request->data['User']['dob'],
        'User.email' => $this->request->data['User']['email'],
    );



 $or = array_filter($or);

    $condition = array(
        'User.role' => array('U', 'P'),
        'User.user_status' => array('active', 'lead', 'inactive'),
        'OR' => $or
    );

Ich denke, array_walk ist hier viel besser geeignet

$linksArray = array('name', '        ', '  342', '0', 0.0, null, '', false);

array_walk($linksArray, function(&$v, $k) use (&$linksArray){
    $v = trim($v);
    if ($v == '')
        unset($linksArray[$k]);
});
print_r($linksArray);

Ausgabe:

Array
(
    [0] => name
    [2] => 342
    [3] => 0
    [4] => 0
)

• Wir haben sichergestellt, dass leere Werte entfernt werden, auch wenn der Benutzer mehr als ein Leerzeichen hinzufügt

• Wir haben auch Leerzeichen von den gültigen Werten abgeschnitten

• Schließlich werden nur (null), (Boolean False) und ('') als leere Zeichenfolgen betrachtet

Was Falseist es in Ordnung , es zu entfernen, weil AFAIK der Benutzer nicht Boolesche Werte einreichen kann.

Bei solchen Dingen ist es viel besser, explizit anzugeben, was Sie wollen und was nicht.

Es wird dem nächsten Mann helfen, nicht überrascht zu werden, wenn er sich array_filter()ohne Rückruf verhält. Zum Beispiel bin ich auf diese Frage gekommen, weil ich vergessen habe, ob sie array_filter()entfernt wurde NULLoder nicht. Ich habe Zeit verschwendet, als ich die unten stehende Lösung hätte verwenden und meine Antwort erhalten können.

Außerdem ist die Logik sprachangnostisch in dem Sinne, dass der Code in eine andere Sprache kopiert werden kann, ohne das Verhalten einer PHP-Funktion verstehen zu müssen, wie array_filterwenn kein Rückruf übergeben wird.

In meiner Lösung ist auf einen Blick klar, was passiert. Entfernen Sie eine Bedingung, um etwas beizubehalten, oder fügen Sie eine neue Bedingung hinzu, um zusätzliche Werte zu filtern.

Ignorieren Sie die tatsächliche Verwendung von, array_filter()da ich nur einen benutzerdefinierten Rückruf übergebe. Sie können dies auch in eine eigene Funktion extrahieren, wenn Sie dies wünschen. Ich benutze es nur als Zucker für eine foreachSchleife.

<?php

$xs = [0, 1, 2, 3, "0", "", false, null];

$xs = array_filter($xs, function($x) {
    if ($x === null) { return false; }
    if ($x === false) { return false; }
    if ($x === "") { return false; }
    if ($x === "0") { return false; }
    return true;
});

$xs = array_values($xs); // reindex array   

echo "<pre>";
var_export($xs);

Ein weiterer Vorteil dieses Ansatzes besteht darin, dass Sie die Filterprädikate in eine abstrakte Funktion aufteilen können, die einen einzelnen Wert pro Array filtert und zu einer zusammensetzbaren Lösung aufbaut.

Siehe dieses Beispiel und die Inline-Kommentare für die Ausgabe.

<?php

/**
 * @param string $valueToFilter
 *
 * @return \Closure A function that expects a 1d array and returns an array
 *                  filtered of values matching $valueToFilter.
 */
function filterValue($valueToFilter)
{
    return function($xs) use ($valueToFilter) {
        return array_filter($xs, function($x) use ($valueToFilter) {
            return $x !== $valueToFilter;
        });
    };
}

// partially applied functions that each expect a 1d array of values
$filterNull = filterValue(null);
$filterFalse = filterValue(false);
$filterZeroString = filterValue("0");
$filterEmptyString = filterValue("");

$xs = [0, 1, 2, 3, null, false, "0", ""];

$xs = $filterNull($xs);        //=> [0, 1, 2, 3, false, "0", ""]
$xs = $filterFalse($xs);       //=> [0, 1, 2, 3, "0", ""]
$xs = $filterZeroString($xs);  //=> [0, 1, 2, 3, ""]
$xs = $filterEmptyString($xs); //=> [0, 1, 2, 3]

echo "<pre>";
var_export($xs); //=> [0, 1, 2, 3]

Jetzt können Sie dynamisch eine Funktion namens filterer()using erstellen pipe(), die diese teilweise angewendeten Funktionen für Sie anwendet.

<?php

/**
 * Supply between 1..n functions each with an arity of 1 (that is, accepts
 * one and only one argument). Versions prior to php 5.6 do not have the
 * variadic operator `...` and as such require the use of `func_get_args()` to
 * obtain the comma-delimited list of expressions provided via the argument
 * list on function call.
 *
 * Example - Call the function `pipe()` like:
 *
 *   pipe ($addOne, $multiplyByTwo);
 *
 * @return closure
 */
function pipe()
{
    $functions = func_get_args(); // an array of callable functions [$addOne, $multiplyByTwo]
    return function ($initialAccumulator) use ($functions) { // return a function with an arity of 1
        return array_reduce( // chain the supplied `$arg` value through each function in the list of functions
            $functions, // an array of functions to reduce over the supplied `$arg` value
            function ($accumulator, $currFn) { // the reducer (a reducing function)
                return $currFn($accumulator);
            },
            $initialAccumulator
        );
    };
}

/**
 * @param string $valueToFilter
 *
 * @return \Closure A function that expects a 1d array and returns an array
 *                  filtered of values matching $valueToFilter.
 */
function filterValue($valueToFilter)
{
    return function($xs) use ($valueToFilter) {
        return array_filter($xs, function($x) use ($valueToFilter) {
            return $x !== $valueToFilter;
        });
    };
}

$filterer = pipe(
    filterValue(null),
    filterValue(false),
    filterValue("0"),
    filterValue("")
);

$xs = [0, 1, 2, 3, null, false, "0", ""];
$xs = $filterer($xs);

echo "<pre>";
var_export($xs); //=> [0, 1, 2, 3]