Reg.ru: домены и хостинг
Крупнейший регистратор и хостинг-провайдер в России.
Более 2 миллионов доменных имен на обслуживании.
Продвижение, почта для домена, решения для бизнеса.
Более 700 тыс. клиентов по всему миру уже сделали свой выбор.
Фреймворк Bootstrap: быстрая адаптивная вёрстка
Пошаговый видеокурс по основам адаптивной верстки в фреймворке Bootstrap.
Научитесь верстать просто, быстро и качественно, используя мощный и практичный инструмент.
Верстайте на заказ и получайте деньги.
*Наведите курсор мыши для приостановки прокрутки.
Назад Вперед
PHP: Удаление элементов массива
Перед нами стоит тривиальная с виду задача: удалить элемент массива. Или несколько элементов.
Однако, при всей ее простоте, в ней есть варианты, которые не совсем очевидны, и о которых стоит знать, если вы хотите продвинуться в PHP чуть дальше, чем "Hello, world!":)
Начнем с самой базы: чтобы удалить один элемент, нужно воспользоваться функцией unset() :
Unset($array); unset($array["foo"]);
Unset($array, $array); unset($array["foo"], $array["bar"]);
Следующий логичный вопрос: как удалить несколько элементов, которые следуют друг за другом (т.е. смежных)? Чтобы удалить несколько смежных элементов, воспользуйтесь функцией array_splice() :
Array_splice($array, $offset, $length);
Обратите внимание, что при использовании данных функций пропадают все ссылки на эти элементы. Если вы хотите оставить ключ в массиве, но связать его с пустым значением, присвойте нужному элементу пустую строку:
$array = $array["foo"] = "";
Важно понимать, что функция unset() удаляет элемент, в то время как присвоение элементу "" не удаляет его, но означает что его значение становится равным пустой строке.
Если вы работаете с числами, вероятно, лучше будет связать с таким ключом значение 0.
Скажем, если компания прекратила производство деталей модели HBL-568, то в массив деталей можно внести изменение:
Unset($products["HBL-568"]);
Если же детали HBL-568 нет на складе лишь временно и ожидается ее поступление с завода, то лучше поступать иначе:
$products["HBL-568"] = 0;
Следующий момент, который нужно понимать, заключается в том, что при вызове функции unset() для элемента массива, PHP корректирует массив так, чтобы цикл по-прежнему работал правильно.
Иными словами, массив не сжимается для заполнения образовавшихся «дыр». По сути, это означает, что все массивы являются ассоциативными, даже если на первый взгляд кажутся числовыми. Давайте посмотрим на понятные примеры для иллюстрации этого поведения:
// Создание "числового" массива $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); print $animals; // Выводит "bee" print $animals; // Выводит "cat" count($animals); // Возвращает 6 // unset() unset($animals); // Удаляет элемент $animals = "bee" print $animals; // Ничего не выводит и выдает ошибку E_NOTICE print $animals; // Выводит "cat" count($animals); // Возвращает 5 при том, что элемент $array остается на месте и содержит "fox" // Добавление нового элемента $animals = "gnu"; // Добавляет новый элемент print $animals; // Ничего не выводит, также выдает ошибку E_NOTICE print $animals; // Выводит "gnu" count($animals); // Возвращает 6 // Присваивание "" (пустой строки) $animals = ""; // Устанавливается значение "пустая строка" print $animals; // Выводит "" count($animals); // Возвращает 6, т.е. учитывает пустой элемент массива при подсчете
Чтобы перейти к плотно заполненному числовому массиву, воспользуйтесь функцией array_values() :
$animals = array_values($animals);
Также функция array_splice() автоматически переиндексирует массивы для устранения «дыр»:
// Создание "числового" массива $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($animals, 2, 2); print_r($animals);
На выходе получим:
Array ( => ant => bee => elk => fox)
Где может пригодиться такая возможность?
Допустим, вы работаете с массивом как с очередью и хотите из этой очереди удалить элементы, не теряя при этом возможности произвольного доступа, когда вы могли бы случайно попасть в одну из образовавшихся "дыр".
Ну и, наконец, для безопасного удаления первого или последнего элемента из массива используются функции array_shift() и array_pop() соответственно.
С ними все очень просто:
$stack = array("orange", "banana", "apple", "raspberry"); $fruit = array_shift($stack); print_r($stack);
В результате выполнения кода выше мы получим такой вывод:
Array ( => banana => apple => raspberry)
Для удаления последнего элемента воспользуемся функцией array_pop() :
$stack = array("orange", "banana", "apple", "raspberry"); $fruit = array_pop($stack); print_r($stack);
На выходе получим следующую распечатку массива:
Array ( => orange => banana => apple)
На этом всё. Основные моменты по удалению элементов массива в PHP мы разобрали. Если что - официальная документация всегда в помощь.
Понравился материал и хотите отблагодарить?
Просто поделитесь с друзьями и коллегами!
Смотрите также:
Необходимо удалить один или более элементов из массива.
Решение
Для удаления одного элемента используйте функцию unset():
Unset($array);
unset($array["foo"]);
Для удаления нескольких непоследовательных элементов применяется функция unset():
Unset($array, $array);
unset($array["foo"], $array["bar"]);
Для удаления нескольких последовательных элементов используйте функцию array_splice():
Array_splice($array, $offset, $length);
Обсуждение
Применение этих функций удаляет все ссылки на эти элементы из PHP. Если необходимо сохранить ключ в массиве, но с пустым значением, присвойте элементу пустую строку:
$array = $array["foo"] = "";
Помимо синтаксиса есть еще и логическое отличие между использованием функции unset() и присваиванием элементу пустой строки (""). В первом случае говорится: «Это больше не существует», а во втором – «Это еще существует, но его значение равно пустой строке».
Если мы имеем дело с числами, то присвоение 0 может быть наилучшей альтернативой. Поэтому если компания прекратила производство звездочки модели XL1000, то следующий оператор обновит ее каталог:
Unset($products["XL1000"]);
Однако, если компания временно приостановила отпуск звездочки модели XL1000, но планирует получить с завода новую партию позже на этой неделе, это выражение подойдет больше:
$products["XL1000"] = 0;
После применения функции unset() к некоторому элементу PHP корректирует массив так, чтобы цикл продолжал работать правильно.
Он не сжимает массив для заполнения пустого пространства. Именно это мы имеем в виду, когда говорим, что все массивы являются ассоциативными, даже если кажутся числовыми. Например:
// создаем "нумерованный" массив
print $animals; // печатает "bee"
print $animals; // печатает "cat"
// unset()
unset($animals); // удаляет элемент $animals = "bee"
print $animals; // печатает "" и выдает ошибку E_NOTICE
print $animals; // все еще печатает "cat"
count($animals); // возвращает 5, даже если $array равно "fox"
// add new element
$animals = "gnu"; // добавляем новый элемент (не в Unix)
print $animals; // печатает "", все еще пустая
print $animals; // печатает "gnu", где "gnu" заканчивается
count($animals); // возвращает 6
// присваиваем ""
$animals = ""; // нулевое выходное значение
print $animals; // печатает ""
count($animals); // возвращаем 6, счетчик не уменьшается
Чтобы сжать массив до плотно заполненного числового массива, используйте функцию array_values():
$animals = array_values($animals);
В качестве альтернативы функция array_splice() автоматически реиндексирует массив, чтобы не оставлять «дыр»:
// создаем "числовой" массив
$animals = array("ant", "bee", "cat", "dog", "elk", "fox");
array_splice($animals, 2, 2);
print_r($animals);
Array
=> ant
=> bee
=> elk
=> fox
)
Это полезно, если с массивом работают как с очередью, в то же время разрешая произвольный доступ.
Для безопасного удаления первого или последнего элемента массива применяются функции array_shift() и array_pop() соответственно.
Однако если вы часто сталкиваетесь с проблемами из-за дыр в массивах, возможно, вы не «думаете на PHP».
Существуют разные способы удаления элемента массива, причем некоторые из них более полезны для некоторых конкретных задач, чем другие.
Удалить один элемент массива
Если вы хотите удалить только один элемент массива, вы можете использовать \unset() или альтернативно \array_splice() .
Также, если у вас есть значение и вы не знаете ключ для удаления элемента, вы можете использовать \array_search() чтобы получить ключ.
\unset() метод
Обратите внимание, что при использовании \unset() ключи массива не будут меняться/переиндексироваться. Если вы хотите переиндексировать ключи, вы можете использовать \array_values() после \unset() который преобразует все ключи в числовые нумерованные ключи, начиная с 0.
[ => a => c ]
\array_splice() метод
Если вы используете \array_splice() ключи будут автоматически переиндексированы, но ассоциативные ключи не изменятся в отличие от \array_values() который преобразует все ключи в числовые ключи.
Также \array_splice() нужно смещение, а не ключ! как второй параметр.
[ => a => c ]
array_splice() аналогично \unset() принимает массив по ссылке, а это означает, что вы не хотите присваивать возвращаемые значения этих функций обратно в массив.
Удалить несколько элементов массива
Если вы хотите удалить несколько элементов массива и не хотите вызывать \unset() или \array_splice() несколько раз, вы можете использовать функции \array_diff() или \array_diff_key() зависимости от того, знаете ли вы значения или ключи элементов, которые вы хотите удалить.
\array_diff() метод
Если вам известны значения элементов массива, которые вы хотите удалить, вы можете использовать \array_diff() . Как и раньше с \unset() он не будет изменять/переиндексировать ключи массива.
[ => b ]
\array_diff_key()
Если вы знаете ключи элементов, которые вы хотите удалить, то вы хотите использовать \array_diff_key() . Здесь вы должны убедиться, что вы передаете ключи как ключи во втором параметре, а не как значения. В противном случае вы должны перевернуть массив с помощью \array_flip() . А также здесь ключи не будут меняться/переиндексировать.
[ => b ]
Также, если вы хотите использовать \unset() или \array_splice() для удаления нескольких элементов с одинаковым значением, вы можете использовать \array_keys() чтобы получить все ключи для определенного значения, а затем удалить все элементы.
Массив – одна из самых полезных и часто используемых структур данных в любом языке программирования. Уметь управлять массивами и их элементами очень важно и полезно. В данной статье рассмотрим, как можно удалить отдельные элементы массива в PHP.
Данная задача может быть реализована разными методами, в зависимости от того, что мы знаем об удаляемом элементе – известен ли ключ (номер или идентификатор элемента в массиве) или только его значение.
Удаление элемента в массиве по его ключу
Если известен ключ элемента, то задача очень проста. Функция unset() позволяет удалить элемент массива или любую переменную (так же будет очищена задействованная под переменную память компьютера).
Например, имеем массив:
$myArr = array (1,2,3,4,5);
Для удаления элемента со значением "3" используем код:
unset($myArr);
Обратите внимание, что указывается не значение (3), а ключ элемента (2), начинающийся, в данном случае с 0. Так, если нужно удалить первый элемент массива, то указываем нулевой элемент:
unset($myArr);
Так же стоит учитывать, что после наших двух удалений, массив теперь содержит три элемента:
Array
=> 2
=> 4
=> 5
)
Все ключи оставшихся элементов сохраняются. Соответственно, если теперь нужно будет удалить первый элемент, то указывать надо будет в качестве ключа единицу. Поэтому, а так же, потому что мы не всегда знаем номер элемента в массиве, а лишь его значения такой вариант может не подходить.
Удаление элемента массива по его значению
Если ключ элемента не известен, а известно только значение массива, то придется перебрать все элементы массива циклом и удалить искомый. Например, удаляем элемент со значением "3":
$myArr = array
(1,2,3,4,5);
foreach
($myArr as $key => $item){
if ($item == 3){
unset($myArr[$key]);
}
}
* Обратите внимание, что проверяется в условии значение массива, доступное в цикле в переменной $item, а при удалении, указывается ключ элемента (переменная $key).
Такое алгоритм подходит еще и в случае, если нужно удалить сразу группу элементов. Ведь здесь имеется условие, определяющее какие элементы удалять.
Удаление пересекающихся элементов массива
Одним из удобных средств PHP является возможность получить массив из элементов, не пересекающихся с элементами других массивов. Для этого применяется функция array_diff (). В качестве параметров, она принимает массивы, возвращая новый массив. Например, имеется исходный массив $myArr из которого нам нужны только элементы не входящие в массив $myArr2:
$myArr = array
(1,2,3,4,5);
$myArr2 = array
(3,4);
Применив функцию array_diff() , получим новый массив, содержащий только необходимые элементы:
$resArr = array_diff($myArr, myArr2);
В результате $resArr будет содержать:
Array
=> 1
=> 2
=> 5
)
* Здесь стоит обратить внимание на то, что ключи при создании нового массива сохраняются. Кроме того, стоит знать, что выборка идет только из первого массива. Так, если в $myArr2 другие уникальные элементы, например "6" или "7", то на результат это никак не повлияет - они в новый массив добавлены не будут.
значению ключу (25)
Есть ли простой способ удалить элемент из массива с помощью PHP , так что foreach ($array) больше не включает этот элемент?
Я думал, что установить его в null будет делать это, но, видимо, это не сработает.
Answers
unset () несколько фрагментированных элементов из массива
Хотя unset () упоминается здесь несколько раз, еще не упоминается, что unset () принимает несколько переменных, что упрощает удаление нескольких несмежных элементов из массива за одну операцию:
// Delete multiple, noncontiguous elements from an array $array = [ "foo", "bar", "baz", "quz" ]; unset($array, $array); print_r($array); // Output: [ "foo", "bar" ]
unset () динамически
unset () не принимает массив ключей для удаления, поэтому приведенный ниже код завершится неудачно (хотя было бы немного проще использовать unset () динамически, хотя).
$array = range(0,5); $remove = ; $array = unset($remove); // FAILS: "unexpected "unset"" print_r($array);
Вместо этого unset () можно динамически использовать в цикле foreach:
$array = range(0,5); $remove = ; foreach ($remove as $k=>$v) { unset($array[$v]); } print_r($array); // Output: [ 0, 3, 4, 5 ]
Удаление ключей массива путем копирования массива
Существует еще одна практика, о которой еще не упоминалось. Иногда самый простой способ избавиться от определенных ключей массива - просто скопировать $ array1 в $ array2.
$array1 = range(1,10); foreach ($array1 as $v) { // Remove all even integers from the array if($v % 2) { $array2 = $v; } } print_r($array2); // Output: [ 1, 3, 5, 7, 9 ];
Очевидно, что такая же практика применяется к текстовым строкам:
$array1 = [ "foo", "_bar", "baz" ]; foreach ($array1 as $v) { // Remove all strings beginning with underscore if(strpos($v,"_")===false) { $array2 = $v; } } print_r($array2); // Output: [ "foo", "baz" ]
Ассоциативные массивы
Для ассоциативных массивов используйте unset() :
$arr = array("a" => 1, "b" => 2, "c" => 3); unset($arr["b"]); // RESULT: array("a" => 1, "c" => 3)
Числовые массивы
Для числовых массивов используйте array_splice() :
$arr = array(1, 2, 3); array_splice($arr, 1, 1); // RESULT: array(0 => 1, 1 => 3)
Заметка
$my_array = array("key1" => "value 1", "key2" => "value 2", "key3" => "value 3", "key4" => "value 4", "key5" => "value 5",); $to_remove = array("key2", "key4"); $result = array_diff_key($my_array, array_flip($to_remove)); print_r($result);Array ( => value 1 => value 3 => value 5)
Unset($array[$index]);
Существуют различные способы удаления элемента массива, где некоторые из них более полезны для некоторых конкретных задач, чем другие.
Удалить один элемент массива
Если вы хотите удалить только один элемент массива, вы можете использовать unset() или альтернативный array_splice() .
Также, если у вас есть значение и вы не знаете ключа для удаления элемента, вы можете использовать array_search() чтобы получить ключ.
метод unset()
Обратите внимание, что при использовании unset() ключи массива не будут меняться / переиндексироваться. Если вы хотите переиндексировать ключи, вы можете использовать array_values() после unset() который преобразует все ключи в числовые перечисляемые ключи, начиная с 0.
"a", 1 => "b", 2 => "c"); unset($array); // Key which you want to delete ?>
Array ( => a => c)
array_splice()
Если вы используете array_splice() ключи будут автоматически переиндексированы, но ассоциативные ключи не будут меняться в отличие от array_values() которые преобразуют все ключи в числовые ключи.
Кроме того, array_splice() требует смещения, а не ключа! как второй параметр.
"a", 1 => "b", 2 => "c"); array_splice($array, 1, 1); // Offset which you want to delete ?>
Array ( => a => c)
array_splice() как unset() принимает массив по ссылке, это означает, что вы не хотите назначать возвращаемые значения этих функций обратно в массив.
Удаление нескольких элементов массива
Если вы хотите удалить несколько элементов массива и не хотите вызывать unset() или array_splice() несколько раз, вы можете использовать функции array_diff() или array_diff_key() зависимости от того, знаете ли вы значения или ключи элементов, которые вы хотите удалить.
array_diff()
Если вам известны значения элементов массива, которые вы хотите удалить, вы можете использовать array_diff() . Как и раньше, с unset() он не будет изменять / переиндексировать ключи массива.
"a", 1 => "b", 2 => "c"); $array = array_diff($array, ["a", "c"]); //└────────┘→ Array values which you want to delete ?> $array = array(0, 1, 2, 3); unset($array); $array = array_values($array); var_dump($array); /* array(3) { => int(0) => int(1) => int(3) } */
Удалите элемент массива на основе ключа:
Используйте функцию unset как unset ниже:
$a = array("salam", "10", 1); unset($a); print_r($a); /* Output: Array ( => salam => 1) */
Удалите элемент массива на основе значения:
Используйте функцию array_search для получения ключа элемента и используйте вышеприведенный способ удаления элемента массива, как array_search ниже:
$a = array("salam", "10", 1); $key = array_search(10, $a); if($key !== false) { unset($a[ $key ]); } print_r($a); /* Output: Array ( => salam => 1) */
Решения:
- Чтобы удалить один элемент, используйте unset() :
unset($array); unset($array["foo"]);
- Чтобы удалить несколько несмежных элементов, также используйте unset() :
unset($array, $array); unset($array["foo"], $array["bar"]);
- Чтобы удалить несколько смежных элементов, используйте array_splice() :
array_splice($array, $offset, $length);
Дальнейшее объяснение:
$array = $array["foo"] = "";
Помимо синтаксиса, существует логическое различие между использованием unset() и назначением "" элементу. Первое говорит, что This doesn"t exist anymore, а второе говорит, что This still exists, but its value is the empty string.
Если вы имеете дело с цифрами, назначение 0 может быть лучшей альтернативой. Таким образом, если компания остановила производство звездочки модели XL1000, она обновит свой инвентарь с помощью:
Unset($products["XL1000"]);
Однако, если у него временно закончились звездочки XL1000, но на этой неделе планировалось получить новую отгрузку с завода, это лучше:
$products["XL1000"] = 0; $animals = array_values($animals);
Альтернативно, array_splice() автоматически переиндексирует массивы, чтобы избежать оставления отверстий:
// create a "numeric" array $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($animals, 2, 2); print_r($animals); Array ( => ant => bee => elk => fox)
Это полезно, если вы используете массив как очередь и хотите удалить элементы из очереди, сохраняя при этом произвольный доступ. Чтобы безопасно удалить первый или последний элемент из массива, используйте array_shift () и array_pop () соответственно.
"value 1","key2"=>"value 2","key3"=>"value 3"); print_r($my_array); if(array_key_exists("key1",$my_array)){ unset($my_array["key1"]); print_r($my_array); }else{ echo "Key does not exist"; } ?> "value 1","key2"=>"value 2","key3"=>"value 3"); print_r($my_array); $new_array=array_slice($my_array,1); print_r($new_array); ?> "; //To remove first array element to length //starts from first and remove two element $my_array = array("key1"=>"value 1","key2"=>"value 2","key3"=>"value 3"); print_r($my_array); $new_array=array_slice($my_array,1,2); print_r($new_array); ?>
Выход
Array ( => value 1 => value 2 => value 3) Array ( => value 2 => value 3) Array ( => value 1 => value 2 => value 3) Array ( => value 2 => value 3) Array ( => value 1 => value 2 => value 3) Array ( => value 2 => value 3)
Вы можете просто использовать unset() для удаления массива.
Помните, что массив должен быть отключен после функции foreach .
$arr = array("orange", "banana", "apple", "raspberry"); $result= array_pop($arr); print_r($result);
Это может помочь...
"red","b"=>"green","c"=>"blue","d"=>"yellow"); $a2=array("a"=>"purple","b"=>"orange"); array_splice($a1,0,2,$a2); print_r($a1); ?>
результатом будет:
Array ( => purple => orange [c] => blue [d] => yellow)
Предположим, у вас есть такой массив:
Array ( => 193 => 5)
Чтобы удалить storage , выполните следующие действия:
Unset($attributes["storage"]); $attributes = array_filter($attributes);
И вы получаете:
Array ( => 193)
Выполнение функций по умолчанию
I) $Array = array("test1","test2","test3","test3"); unset($Array); ii) $Array = array("test1","test2","test3","test3"); array_pop($Array); iii) $Array = array("test1","test2","test3","test3"); array_splice($Array,1,2); iv) $Array = array("test1","test2","test3","test3"); array_shift($Array);
Чтобы избежать поиска, вы можете играть с array_diff:
$array = array(3, 9, 11, 20); $array = array_diff($array, array(11)); // removes 11
В этом случае не нужно искать / использовать ключ.
Верхний ответ выше - фантастический. Однако, если вы extend его двумя разными способами, то какое бы расширение не было выполнено, первые результаты в вызове функций создадут кеш. Этот кеш будет использоваться всеми последующими вызовами, независимо от того, какое расширение вызывает инициирование вызовов...
Чтобы решить эту проблему, замените переменную и первую функцию следующим образом:
Private static $constCacheArray = null; private static function getConstants() { if (self::$constCacheArray === null) self::$constCacheArray = array(); $calledClass = get_called_class(); if (!array_key_exists($calledClass, self::$constCacheArray)) { $reflect = new \ReflectionClass($calledClass); self::$constCacheArray[$calledClass] = $reflect->getConstants(); } return self::$constCacheArray[$calledClass]; }