W przypadku tego typu rzeczy o wiele lepiej jest wyraźnie powiedzieć, czego chcesz, a czego nie.
Pomoże to następnemu facetowi nie dać się zaskoczyć zachowaniem array_filter()bez oddzwaniania. Na przykład skończyłem na tym pytaniu, ponieważ zapomniałem, czy je array_filter()usuwa, NULLczy nie. Zmarnowałem czas, kiedy mogłem po prostu skorzystać z poniższego rozwiązania i otrzymać odpowiedź.
Logika jest również angnostyczna w tym sensie, że kod można skopiować na inny język bez konieczności rozumienia zachowania funkcji php, na przykład array_filtergdy nie jest przekazywane żadne wywołanie zwrotne.
W moim rozwiązaniu na pierwszy rzut oka widać, co się dzieje. Usuń warunek, aby coś zachować, lub dodaj nowy warunek, aby przefiltrować dodatkowe wartości.
Zignoruj faktyczne użycie, array_filter()ponieważ po prostu przekazuję mu niestandardowe wywołanie zwrotne - możesz, jeśli chcesz, wyodrębnić to do własnej funkcji. Po prostu używam go jako cukru na foreachpętlę.
<?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);
Inną zaletą tego podejścia jest to, że można podzielić predykaty filtrowania na funkcję abstrakcyjną, która filtruje pojedynczą wartość na tablicę i tworzy rozwiązanie kompozycyjne.
Zobacz ten przykład i wbudowane komentarze dla danych wyjściowych.
<?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]
Teraz możesz dynamicznie utworzyć funkcję o nazwie filterer()using pipe(), która zastosuje te częściowo zastosowane funkcje.
<?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]