Как удалить элемент массива в PHP?
Одним из мощнейших инструментов PHP-разработчика являются массивы. Если вы работали с массивами в других языках программирования (Delphi, Fortrain, C++), то помните, что везде массив надо объявлять, указывая размерность и тип элементов. В PHP всё обстоит иначе.
Дело в том, что в PHP массив не является линейным объектом. Это, по сути, хеш-массив, представляющий собой набор пар — ключей с их значениями.
Теперь давайте посмотрим, как удалять элементы из хеш-массива в PHP. В вышеупомянутых языках программирования для таких действий придётся создавать специальный объект, односвязный либо 2-связный список, бережно выделять и освобождать память, наблюдать за восстановлением связей в списке. Что касается PHP, то тут весь необходимый «менеджмент» спрятан, но всегда готов к применению.
1. Удаляем элемент массива в PHP
Чтобы удалить элемент в PHP, достаточно всего лишь знать его ключ — в таком случае удаление будет сведено к вызову функции unset() :
2. Как удалить 1-й элемент массива?
В нашем случае 1-й элемент удаляется, а элемент 5 => ‘b’, попадает под перенумерацию. Что касается элементов со строковыми ключами, то их перенумерация не затронет.
3. Как удалить последний элемент массива?
После удаления последнего элемента массива в PHP перенумерация оставшихся элементов не выполняется.
4. Как удалить пустые элементы из массива?
Итак, мы в цикле проверим каждый элемент массива, используя функцию empty() и удалим пустые элементы. Здесь важно понять, что строковый скаляр ‘0’ — тоже пустой элемент. А вот ’00’ пустым не является.
Очевидно, что данный способ более гибок.
5. Удаляем повторяющиеся элементы массива в PHP
Порой возникает необходимость удалить повторяющиеся элементы массива в PHP. Для решения этой задачи существует специальная функция под названием array_unique() :
Из кода видно, что функция удалила из PHP-массива повторяющиеся элементы. При этом функция имеет ещё один параметр, указывающий, как сравнивать элементы.
Возможные типы сравнения: • SORT_REGULAR — сравнение без преобразования типа элементов; • SORT_STRING — сравнение как строки; • SORT_NUMERIC — сравнение как чисел (пытаемся преобразовать в число); • SORT_LOCALE_STRING — сравнение как строки, но с учётом выбранного набора символов.
По умолчанию применяется SORT_STRING. Выбирая типы сравнения, помните, что это важно. Давайте изменим тип в прошлом примере на SORT_NUMERIC:
Во время сравнения все элементы массива были преобразованы к численному типу скаляра. В нашем случае это неизменно давало значение ноль, в результате чего у нас остался лишь первый элемент.
Хотите знать о PHP больше? Записывайтесь на курс «Backend-разработчик на PHP»!
unset
(PHP 4, PHP 5, PHP 7, PHP 8)
unset — Удаляет переменную
Описание
unset() удаляет перечисленные переменные.
Поведение unset() внутри пользовательской функции может отличаться, в зависимости от того, какой тип имеет переменная, которую необходимо удалить.
Результат выполнения данного примера:
Результат выполнения данного примера:
Если статическая переменная удаляется внутри функции, unset() удалит переменную только в контексте дальнейшего выполнения функции. При последующем вызове предыдущее значение переменной будет восстановлено.
Результат выполнения данного примера:
Список параметров
Возвращаемые значения
Функция не возвращает значения после выполнения.
Примеры
Пример #1 Пример использования unset()
Пример #2 Использование приведения типа (unset)
Результат выполнения данного примера:
Примечания
Замечание: Поскольку это языковая конструкция, а не функция, она не может вызываться при помощи переменных функций.
Существует возможность удалить даже атрибуты объекта, видимые в текущем контексте.
При использовании unset() на недоступных или необъявленных свойствах объекта, будет вызван встроенный метод объекта __unset(), если он определён.
Смотрите также
User Contributed Notes 31 notes
This doesn’t apply to properties of objects that have __isset() methods that visibly change object state or __unset() methods that don’t properly check their arguments or have extra side effects.
The latter case means that __unset shouldn’t do more than what it says on the tin, and also has the responsibility for checking (possibly using __isset()) that what it’s being asked to do makes sense.
The former case is just plain bad design.
if you try to unset an object, please be careful about references.
Objects will only free their resources and trigger their __destruct method when *all* references are unsetted.
Even when they are *in* the object. sigh!
class A <
function __destruct () <
echo «cYa later!!\n» ;
>
>
echo «Finally that thing is gone\n» ;
?>
Of course the object completely dies at the end of the script.
Since unset() is a language construct, it cannot be passed anything other than a variable. It’s sole purpose is to «unset» this variable, ie. to remove it from the current scope and destroy it’s associated data. This is true especially for reference variables, where not the actual value is destroyed but the reference to that value. This is why you can’t wrap ‘unset()’ in a user defined function: You would either unset a copy of the data if the parameter is passed by value, or you would just unset the reference variable within the functions scope if the parameter is passed by reference. There is no workaround for that, as you cannot pass ‘scope’ to a function in PHP. Such a function can only work for variables that exist in a common or global scope (compare ‘unset($_GLOBALS[variable])’).
I don’t know how PHP handles garbage collection internally, but I guess this behavior can result in a huge memory leak: if a value variable goes out of scope with a second variable still holding a reference to the in-memory value, then unsetting that reference would still hold the value in memory but potentially unset the last reference to that in-memory data, hence: occupied memory that is rendered useless as you cannot reference it anymore.
A sample how to unset array elements from an array result coming from a mysql request. In this sample it is checking if a file exists and removes the row from the array if it not exists.
1.
it gets the array from the table (mysql)
3.
unset if record does not exist
Here is another way to make ‘unset’ work with session variables from within a function :
Only This works with register_globals being ‘ON’.
The above will not work with register_globals turned on (will only work outside of a function).
The above will work with register_globals on & inside a function
To clarify what hugo dot dworak at gmail dot com said about unsetting things that aren’t already set:
unsetting a non-existent key within an array does NOT throw an error.
Adding on to what bond at noellebond dot com said, if you want to remove an index from the end of the array, if you use unset, the next index value will still be what it would have been.
but you actually get
Array ( [0] => 1 [4] => 2 [5] => 3 [6] => 4 )
This is since even though the last key is removed, the auto indexing still keeps its previous value.
The only time where this would not seem right is when you remove a value off the end. I guess different people would want it different ways.
Hope this helps someone who may need this for some odd reason, I did.
In addition to what timo dot hummel at 4fb dot de said;
>For the curious: unset also frees memory of the variable used.
>
>It might be possible that the in-memory size of the PHP Interpreter isn’t reduced, but your scripts won’t touch the memory_limit boundary. Memory is reused if you declare new variables.
It might be worth adding that functions apparently don’t free up memory on exit the same way unset does..
Maybe this is common knowledge, but although functions destroys variables on exit, it (apparently) doesn’t help the memory.
So if you use huge variables inside functions, be sure to unset them if you can before returning from the function.
In my case, if I did not unset before return, then the script would use 20 MB more of memory than if I did unset.
This was tested with php 5.0.4 on apache 2 on windows xp, with no memory limit.
Before I did the test, I was under the impression that when you exit from functions, the memory used inside it would be cleared and reused. Maybe this should be made clear in the manual, for either unset() or in the chapter for functions.
Despite much searching, I have not yet found an explanation as to how one can manually free resources from variables, not so much objects, in PHP. I have also seen many comments regarding the merits and demerits of unset() versus setting a variable to null. Thus, here are the results of some benchmarks performed comparing unset() of numerous variables to setting them to null (with regards to memory usage and processing time):
10 variables:
Unset:
Memory Usage: 296
Time Elapsed: 1.0013580322266E-5
Null set:
Memory Usage: 1736
Time Elapsed: 5.9604644775391E-6
50 variables:
Unset:
Memory Usage: 296
Time Elapsed: 3.6001205444336E-5
Null set:
Memory Usage: 8328
Time Elapsed: 3.2901763916016E-5
100 variables:
Unset:
Memory Usage: 296
Time Elapsed: 5.6982040405273E-5
Null set:
Memory Usage: 15928
Time Elapsed: 5.8174133300781E-5
1000 variables:
Unset:
Memory Usage: 296
Time Elapsed: 0.00041294097900391
Null set:
Memory Usage: 168096
Time Elapsed: 0.00067591667175293
10000 variables:
Unset:
Memory Usage: 296
Time Elapsed: 0.0042569637298584
Null set:
Memory Usage: 1650848
Time Elapsed: 0.0076930522918701
100000 variables:
Unset:
Memory Usage: 296
Time Elapsed: 0.042603969573975
Null set:
Memory Usage: 16249080
Time Elapsed: 0.087724924087524
300000 variables:
Unset:
Memory Usage: 296
Time Elapsed: 0.13177299499512
Null set:
Memory Usage: 49796320
Time Elapsed: 0.28617882728577
Perhaps my test code for the null set was flawed, but despite that possibility it is simple to see that unset() has minimal processing time impact, and no apparent memory usage impact (unless the values returned by memory_get_usage() are flawed). If you truly care about the
4 microseconds saved over
In PHP 5.0.4, at least, one CAN unset array elements inside functions from arrays passed by reference to the function.
As implied by the manual, however, one can’t unset the entire array by passing it by reference.
Note that PHP 4 will generate a warning if you try to unset an array index that doesn’t exist and whose parent doesn’t exist.
?>
RESULT: «Notice: Undefined index: Bar»
On PHP5 no error is raised, which seems to me like the correct behaviour.
Note that using unset($foo[‘Bar’]) in the above example does not generate a warning in either version.
(Tested on 4.4.9 and 5.2.4)
Just to confirm, USING UNSET CAN DESTROY AN ENTIRE ARRAY. I couldn’t find reference to this anywhere so I decided to write this.
The documentation is not entirely clear when it comes to static variables. It says:
If a static variable is unset() inside of a function, unset() destroys the variable and all its references.
The above example would output:
And it does! But the variable is NOT deleted, that’s why the value keeps on increasing, otherwise the output would be:
The references are destroyed within the function, this handeling is the same as with global variables, the difference is a static variable is a local variable.
Be carefull using unset and static values as the output may not be what you expect it to be. It appears to be impossible to destroy a static variable. You can only destroy the references within the current executing function, a successive static statement will restore the references.
The documentation would be better if it would say:
«If a static variable is unset() inside of a function, unset() destroys all references to the variable. «
Here’s my variation on the slightly dull unset method. It throws in a bit of 80’s Stallone action spice into the mix. Enjoy!
/**
* function rambo (first blood)
*
* Completely and utterly destroys everything, returning the kill count of victims
*
* @param It don’t matter, it’s Rambo baby
* @return Integer Body count (but any less than 500 and it’s not really worth mentioning)
*/
function rambo () <
// Get the victims and initiate that body count status
$victims = func_get_args ();
$body_count = 0 ;
about unset for arrays
if you unset the last array member
$ar[0]==2
$ar[1]==7
$ar[2]==9
So, unset has no effect to internal array counter.
further I realized that an object, when getting detroyed, does care about destroying variable in object space visibility but not those in local visibility, be aware of the found pattern:
Instead of using the unset function for unregistering your session or other array values you can also do this samll feature and get this task done with just 1 line code.
Suppose, if you like to unregister your session store values.
You can use:
Well this syntax saves lot’s of time instead of unsetting each values.
you may wan’t to unset all variables which are defined, here’s one way:
?>
you can also save than a serialized var of the «memory» and perhaps store this in a temporary file.. very usefull if you work with text files and/or file uploads when you’ve got very large variables.
When unset from an array, if you unset all elements, the array is always set
In regard to some confusion earlier in these notes about what causes unset() to trigger notices when unsetting variables that don’t exist.
Sometimes you need to assigne values to an array index in some loop (if, while, foreach etc.) but you wish to set starting index key to some number greater then zero (lets say 5). One idea how to do this is:
Array ( [5] => 5 [6] => 10 [7] => 15 [8] => 100 )
You can not unset a numeric key of an array, if key is a string. See this example:
And here is the output:
Test: 1
array(3) <
[10]=>
array(1) <
[0]=>
string(6) «apples»
>
[20]=>
array(1) <
[0]=>
string(7) «bananas»
>
[30]=>
array(1) <
[0]=>
string(7) «peaches»
>
>
key: 10
key exists: bool(true)
typeof key is: integer
key: 20
key exists: bool(true)
typeof key is: integer
key: 30
key exists: bool(true)
typeof key is: integer
array(0) <
>
Two ways of unsetting values within an array:
$SomeObj = new TheObj ;
This applied to the «virtual» array variable too, see more at http://bugs.php.net/bug.php?id=33513 (at feedback) about it.
PS: we used PHP version 5.1.0-dev from the CVS snapshot when we wrote the above codes.
1) unsetting of superglobals is done globally, i.e. unsetting inside the function affects GLOBALLY.
foo ();
bar (); //issues E_NOTICE ($GLOBALS not defined)
$GLOBALS = 3 ;
bar (); //displays int(3)
PHP: удаление элемента из массива
Я думал, что установка его на null сделал бы это, но, видимо, это не работает.
30 ответов
существуют различные способы удаления элемента массива, где некоторые из них более полезны для определенных задач, чем другие.
удалить один элемент массива
также, если у вас есть значение и не знаете ключ для удаления элемента, вы можете использовать array_search() получить ключ.
unset() метод
обратите внимание, что при использовании unset() ключи массива не изменятся/reindex. Если вы хотите переиндексировать ключи вы можете использовать array_values() после unset() который преобразует все ключи в числовые перечисляемые ключи, начиная с 0.
array_splice() метод
если вы используете array_splice() ключи будут автоматически переиндексируется, но ассоциативные ключи не будут меняться в отличие от array_values() который преобразует все ключи в числовые ключи.
и array_splice() требуется смещение, а не ключ! в качестве второго параметра.
array_splice() же unset() принять массив по ссылке, это означает, что вы не хотите присвоить возвращаемые значения этих функций в массив.
удалить несколько элементы массива
если вы хотите удалить несколько элементов массива и не хочу называть unset() или array_splice() несколько раз, вы можете использовать функции array_diff() или array_diff_key() в зависимости от того, знаете ли Вы значения или ключи элементов, которые вы хотите удалить.
array_diff() метод
array_diff_key() метод
также, если вы хотите использовать unset() или array_splice() для удаления нескольких элементов с одинаковым значением можно использовать array_keys() чтобы получить все ключи для определенного значения, а затем удалить все элементы.
следует отметить, что unset() сохранит индексы нетронутыми, чего и следовало ожидать при использовании строковых индексов (массив в качестве хэш-таблицы), но может быть довольно удивительно при работе с целочисленными индексированными массивами:
так array_splice() может использоваться, если вы хотите нормализовать целочисленные ключи. Другой вариант-использовать array_values() после unset() :
это вывод из кода выше:
теперь array_values () красиво переиндексирует числовой массив, но удалит все ключевые строки из массива и заменит их числами. Если вам нужно сохранить имена ключей (строки) или переиндексировать массив, если все ключи числовые, используйте array_merge ():
Если у вас есть численно индексированный массив, где все значения уникальны (или они не уникальны, но вы хотите удалить все экземпляры определенного значения), вы можете просто использовать array_diff () для удаления соответствующего элемента, например:
это отображает следующее:
в этом примере элемент со значением ‘Charles’ удаляется, что может быть проверено вызовами sizeof (), которые сообщают размер 4 для исходный массив, и 3 после удаления.
также для именованного элемента:
уничтожить один элемент массива
unset()
Если вам нужно повторно индексировать массив:
mixed array_pop(array &$array)
mixed array_shift ( array &$array )
чтобы избежать поиска, можно поиграть с array_diff :
в этом случае не нужно искать/использовать ключ.
unset() уничтожает указанные переменные.
поведение unset() внутри функции может варьироваться в зависимости от типа переменной, которую вы пытаетесь уничтожить.
если глобализованная переменная unset() внутри функции уничтожается только локальная переменная. Переменная в вызывающей среде сохранит то же значение, что и раньше unset() называлась.
ответ вышеуказанного кода будет бар
до unset() глобальная переменная внутри функции
Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными, [array_filter][1] это ваш лучший ставку. Те записи, которые возвращают true из функции обратного вызова будут сохранены.
ассоциативные массивы
числовые массивы
Примечание
Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать array_diff_key () (здесь используется с array_flip ()):
Я просто хотел сказать, что у меня был определенный объект, который имел переменные атрибуты (это было в основном отображение таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также будут отличаться
цель $fields было просто так, что мне не нужно смотреть везде в коде, когда они меняются, я просто смотрю в начале класса и меняю список атрибутов и $fields содержимое массива для отражения новых атрибутов.
Мне потребовалось некоторое время, чтобы понять это. Надеюсь, это может кому-то помочь.
следуйте функциям по умолчанию
Предположим, у вас есть такой массив:
а также вы получаете:
unset () несколько фрагментированных элементов из массива
хотя unset() упоминалось здесь несколько раз, еще не упоминалось, что unset () принимает несколько переменных, что упрощает удаление нескольких несмежных элементов из массива за одну операцию:
unset () динамически
unset() не принимает массив ключей для удаления, поэтому приведенный ниже код завершится ошибкой (это сделало бы его немного проще использовать unset() динамически хотя.)
вместо этого unset () можно использовать динамически в цикле foreach:
удалите ключи массива, скопировав массив
очевидно, что такая же практика применяется к текстовым строкам:
решения:
далее объяснение:
использование этих функций удаляет все ссылки на эти элементы из PHP. Если вы хотите сохранить ключ в массиве, но с пустым значением, присвоить пустую строку к элементу:
помимо синтаксиса, есть логическая разница между использованием unset () и присвоение » элементу. Первый говорит: This doesn’t exist anymore, в то время как второй говорит This still exists, but its value is the empty string.
если вы имеете дело с числами, присвоение 0 может быть лучшая альтернатива. Таким образом, если компания остановила производство звездочки модели XL1000, она обновит свой инвентарь с помощью:
однако, если у него временно закончились звездочки XL1000, но он планировал получить новую партию с завода позже на этой неделе, это лучше:
если вы unset () элемент, PHP настраивает массив так, чтобы цикл все еще работал правильно. Он не компактирует массив, чтобы заполнить недостающие отверстия. Этот это то, что мы имеем в виду, когда говорим, что все массивы ассоциативны, даже когда они кажутся числовыми. Вот пример:
чтобы сжать массив в плотно заполненный числовой массив, используйте array_values ():
кроме того, array_splice () автоматически оленей массивы, чтобы избежать оставляя отверстия:
это полезно, если вы используете массив в очереди и хотите, чтобы удалить элементы из очереди в то же время позволяя случайный доступ. Чтобы безопасно удалить первый или последний элемент из массива, используйте array_shift () и array_pop (), соответственно.
Удалить элемент объекта php
Reg.ru: домены и хостинг
Крупнейший регистратор и хостинг-провайдер в России.
Более 2 миллионов доменных имен на обслуживании.
Продвижение, почта для домена, решения для бизнеса.
Более 700 тыс. клиентов по всему миру уже сделали свой выбор.
Бесплатный Курс «Практика HTML5 и CSS3»
Освойте бесплатно пошаговый видеокурс
по основам адаптивной верстки
на HTML5 и CSS3 с полного нуля.
Фреймворк Bootstrap: быстрая адаптивная вёрстка
Пошаговый видеокурс по основам адаптивной верстки в фреймворке Bootstrap.
Научитесь верстать просто, быстро и качественно, используя мощный и практичный инструмент.
Верстайте на заказ и получайте деньги.
Что нужно знать для создания PHP-сайтов?
Ответ здесь. Только самое важное и полезное для начинающего веб-разработчика.
Узнайте, как создавать качественные сайты на PHP всего за 2 часа и 27 минут!
Создайте свой сайт за 3 часа и 30 минут.
После просмотра данного видеокурса у Вас на компьютере будет готовый к использованию сайт, который Вы сделали сами.
Вам останется лишь наполнить его нужной информацией и изменить дизайн (по желанию).
Изучите основы HTML и CSS менее чем за 4 часа.
После просмотра данного видеокурса Вы перестанете с ужасом смотреть на HTML-код и будете понимать, как он работает.
Вы сможете создать свои первые HTML-страницы и придать им нужный вид с помощью CSS.
Бесплатный курс «Сайт на WordPress»
Хотите освоить CMS WordPress?
Получите уроки по дизайну и верстке сайта на WordPress.
Научитесь работать с темами и нарезать макет.
Бесплатный видеокурс по рисованию дизайна сайта, его верстке и установке на CMS WordPress!
Хотите изучить JavaScript, но не знаете, как подступиться?
После прохождения видеокурса Вы освоите базовые моменты работы с JavaScript.
Развеются мифы о сложности работы с этим языком, и Вы будете готовы изучать JavaScript на более серьезном уровне.
*Наведите курсор мыши для приостановки прокрутки.
PHP: Удаление элементов массива
Перед нами стоит тривиальная с виду задача: удалить элемент массива. Или несколько элементов.
Однако, при всей ее простоте, в ней есть варианты, которые не совсем очевидны, и о которых стоит знать, если вы хотите продвинуться в PHP чуть дальше, чем «Hello, world!»:)
Начнем с самой базы: чтобы удалить один элемент, нужно воспользоваться функцией unset():
Здесь все просто и понятно.
Дальше. Для удаления нескольких несмежных элементов также используется функция unset(), просто мы передаем ей несколько параметров:
Следующий логичный вопрос: как удалить несколько элементов, которые следуют друг за другом (т.е. смежных)? Чтобы удалить несколько смежных элементов, воспользуйтесь функцией array_splice():
Обратите внимание, что при использовании данных функций пропадают все ссылки на эти элементы. Если вы хотите оставить ключ в массиве, но связать его с пустым значением, присвойте нужному элементу пустую строку:
Важно понимать, что функция unset() удаляет элемент, в то время как присвоение элементу » не удаляет его, но означает что его значение становится равным пустой строке.
Если вы работаете с числами, вероятно, лучше будет связать с таким ключом значение 0.
Скажем, если компания прекратила производство деталей модели HBL-568, то в массив деталей можно внести изменение:
Если же детали HBL-568 нет на складе лишь временно и ожидается ее поступление с завода, то лучше поступать иначе:
Следующий момент, который нужно понимать, заключается в том, что при вызове функции unset() для элемента массива, PHP корректирует массив так, чтобы цикл по-прежнему работал правильно.
Иными словами, массив не сжимается для заполнения образовавшихся «дыр». По сути, это означает, что все массивы являются ассоциативными, даже если на первый взгляд кажутся числовыми. Давайте посмотрим на понятные примеры для иллюстрации этого поведения:
Чтобы перейти к плотно заполненному числовому массиву, воспользуйтесь функцией array_values():
Также функция array_splice() автоматически переиндексирует массивы для устранения «дыр»:
Где может пригодиться такая возможность?
Допустим, вы работаете с массивом как с очередью и хотите из этой очереди удалить элементы, не теряя при этом возможности произвольного доступа, когда вы могли бы случайно попасть в одну из образовавшихся «дыр».
Ну и, наконец, для безопасного удаления первого или последнего элемента из массива используются функции array_shift() и array_pop() соответственно.
С ними все очень просто:
В результате выполнения кода выше мы получим такой вывод:
Для удаления последнего элемента воспользуемся функцией array_pop():
На выходе получим следующую распечатку массива:
Понравился материал и хотите отблагодарить?
Просто поделитесь с друзьями и коллегами!