Некоторые элементы в моем массиве являются пустыми строками, основанными на том, что отправил пользователь. Мне нужно удалить эти элементы. У меня есть это:
foreach($linksArray as $link)
{
if($link == '')
{
unset($link);
}
}
print_r($linksArray);
Но это не работает. $linksArray все еще содержит пустые элементы. Я также пытался сделать это с помощью функции empty(), но результат тот же.
Поскольку вы имеете дело с массивом строк, вы можете просто использовать array_filter(), который удобно обрабатывает все это для вас:
print_r(array_filter($linksArray));
Помните, что , если обратный вызов не указан, все записи массива, равные FALSE (см. преобразование в логическое значение), будут удалены. Поэтому, если вам нужно сохранить элементы, которые являются точной строкой '0', вам потребуется специальный обратный вызов:
// PHP < 5.3
print_r(array_filter($linksArray, create_function('$value', 'return $value !== "";')));
// PHP 5.3 and later
print_r(array_filter($linksArray, function($value) { return !is_null($value) && $value !== ''; }));
Вы можете использовать array_filter для удаления пустых элементов:
$emptyRemoved = array_filter($linksArray);
Если у вас есть (int) 0 в вашем массиве, вы можете использовать следующее:
$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;
}
РЕДАКТИРОВАТЬ: Возможно, ваши элементы не пустые как таковые, но содержат одно или несколько пробелов... Вы можете использовать следующее, прежде чем использовать array_filter
$trimmedArray = array_map('trim', $linksArray);
Самый популярный ответ на эту тему абсолютно НЕПРАВИЛЬНЫЙ.
Рассмотрим следующий PHP script:
<?php
$arr = array('1', '', '2', '3', '0');
// Incorrect:
print_r(array_filter($arr));
// Correct:
print_r(array_filter($arr, 'strlen'));
Почему это? Поскольку строка, содержащая единственный символ "0", также вычисляет значение boolean false, поэтому, хотя это не пустая строка, она все равно будет отфильтрована. Это будет ошибкой.
Передача встроенной функции strlen, поскольку функция фильтрации будет работать, потому что она возвращает ненулевое целое для непустой строки и нулевое целое для пустой строки. Не нулевые целые числа всегда оценивают значение true при преобразовании в boolean, тогда как нулевые целые числа всегда вычисляются как false при преобразовании в boolean.
Итак, абсолютный, окончательный, правильный ответ:
$arr = array_filter($arr, 'strlen');
$linksArray = array_filter($linksArray);
"Если обратный вызов не передан, все записи ввода, равные FALSE, будут удалены." - 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
Вы можете просто сделать
array_filter($array)
array_filter: "Если обратный вызов не предоставляется, все записи ввода, равные FALSE, будут удалены". Это означает, что элементы со значениями NULL, 0, '0', '', FALSE, array() также будут удалены.
Другой вариант делает
array_diff($array, array(''))
который удалит элементы со значениями NULL, '' и FALSE.
Надеюсь, что это поможет:)
Вот пример.
$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())
Подводя итог:
foreach($linksArray as $key => $link)
{
if($link === '')
{
unset($linksArray[$key]);
}
}
print_r($linksArray);
Еще один вкладыш для удаления пустых ("" пустых строк) элементов из вашего массива.
$array = array_filter($array, function($a) {return $a !== "";});
Примечание. Этот код намеренно содержит null, 0 и false элементы.
Или, может быть, вы хотите сначала обрезать элементы массива:
$array = array_filter($array, function($a) {
return trim($a) !== "";
});
Примечание. Этот код также удаляет null и false элементы.
Это мой предложенный код:
$myarray = array_values(array_filter(array_map('trim', $myarray), 'strlen'));
Я думаю, что использовать array_filter хорошо, но недостаточно, потому что значения похожи на space и \n ,... сохраняются в массиве, а это обычно плохо.
Поэтому я предлагаю вам использовать смесь array_filter и array_map.
array_map - для обрезки, array_filter - для удаления пустых значений, strlen - для значения keep 0, а array_values - для повторной индексации, если вам нужно.
$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);
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"
}
Если вы работаете с числовым массивом и вам нужно повторно проиндексировать массив после удаления пустых элементов, используйте array_values :
array_values(array_filter($array));
Также смотрите: массив reindex PHP?
Самый проголосовавший ответ ошибочен или, по крайней мере, не совсем прав, поскольку OP говорит только о пустых строках. Вот подробное объяснение:
Прежде всего, мы должны договориться о том, какие пустые средства. Вы хотите отфильтровать:
$element === false)empty()?Чтобы отфильтровать только пустые строки:
$filtered = array_diff($originalArray, array(""));
Чтобы отфильтровать только значения строго false, вы должны использовать функцию обратного вызова:
$filtered = array_diff($originalArray, 'myCallback');
function myCallback($var) {
return $var === false;
}
Обратный вызов также полезен для любой комбинации, в которой вы хотите отфильтровать значения "falsey", кроме некоторых. (Например, фильтруйте каждый null и false и т.д., Оставив только 0):
$filtered = array_filter($originalArray, 'myCallback');
function myCallback($var) {
return ($var === 0 || $var === '0');
}
Третий и четвертый случаи (для наших целей наконец) эквивалентны, и для этого все, что вам нужно использовать, - это значение по умолчанию:
$filtered = array_filter($originalArray);
Мне пришлось сделать это, чтобы сохранить значение массива (string) 0
$url = array_filter($data, function ($value) {
return (!empty($value) || $value === 0 || $value==='0');
});
function trim_array($Array)
{
foreach ($Array as $value) {
if(trim($value) === '') {
$index = array_search($value, $Array);
unset($Array[$index]);
}
}
return $Array;
}
$a = array(1, '', '', '', 2, '', 3, 4);
$b = array_values(array_filter($a));
print_r($b)
$out_array = array_filter($input_array, function($item)
{
return !empty($item['key_of_array_to_check_whether_it_is_empty']);
}
);
Для многомерного массива
$data = array_map('array_filter', $data);
$data = array_filter($data);
Я использую следующий script для удаления пустых элементов из массива
for ($i=0; $i<$count($Array); $i++)
{
if (empty($Array[$i])) unset($Array[$i]);
}
Просто хочу внести альтернативу циклам... также устраняя пробелы в ключах...
В моем случае я хотел сохранить последовательные ключи массива, когда операция была завершена (а не просто нечетные числа, на что я смотрел. Настройка кода для просмотра только для нечетных ключей казалась хрупкой для меня, а не для будущего.)
Я искал что-то вроде этого: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/
Комбинация array_filter и array_slice делает трюк.
$example = array_filter($example);
$example = array_slice($example,0);
Отсутствует представление об эффективности или контрольных показателях, но оно работает.
foreach($arr as $key => $val){
if (empty($val)) unset($arr[$key];
}
$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>';
}
Выход
1: 5
2: 6
используйте array_filter функцию для удаления пустых значений:
$linksArray = array_filter($linksArray);
print_r($linksArray);
Только одна строка: Обновление (спасибо @suther):
$array_without_empty_values = array_filter($array);
Удалить пустые элементы массива
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);
¡он работает!
Согласно вашему методу, вы можете просто перехватить эти элементы в другом массиве и использовать его следующим образом:
foreach($linksArray as $link){
if(!empty($link)){
$new_arr[] = $link
}
}
print_r($new_arr);
попробуйте это ** ** Пример
$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
);
С такими вещами гораздо лучше быть откровенным о том, что вы хотите, а что нет.
Это поможет следующему парню не быть застигнутым врасплох поведением array_filter() без обратного вызова. Например, я остановился на этом вопросе, потому что я забыл, удаляет ли array_filter() NULL или нет. Я потратил впустую время, когда мог бы просто использовать приведенное ниже решение и получить ответ.
Кроме того, логика не зависит от языка в том смысле, что код может быть скопирован на другой язык без необходимости понимать поведение функции php, такой как array_filter, когда обратный вызов не передается.
В моем решении с первого взгляда ясно, что происходит. Удалите условие, чтобы сохранить что-либо, или добавьте новое условие, чтобы отфильтровать дополнительные значения.
Не обращайте внимания на фактическое использование array_filter(), так как я просто передаю ему пользовательский обратный вызов - вы можете пойти дальше и извлечь его из своей собственной функции, если хотите. Я просто использую его как сахар для цикла foreach.
<?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);
Еще одним преимуществом этого подхода является то, что вы можете разбить фильтрующие предикаты на абстрактные функции, которые фильтруют одно значение для каждого массива и выстраиваются в составное решение.
См. этот пример и встроенные комментарии для вывода.
<?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]
Теперь вы можете динамически создавать функцию с именем filterer(), используя pipe(), которая будет применять эти частично примененные функции для вас.
<?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]