Есть ли простой способ удалить элемент из массива с помощью PHP, чтобы foreach ($array)
больше не содержал этот элемент?
Я думал, что установка на null
поможет, но, видимо, это не работает.
33 ответа
Существуют разные способы удаления элемента массива, некоторые из которых более полезны для некоторых конкретных задач, чем другие.
Удаление одного элемента массива
Если вы хотите удалить только один элемент массива, вы можете использовать unset()
a> или, альтернативно, \array_splice()
.
Если вы знаете значение и не знаете ключ для удаления элемента, вы можете использовать \array_search()
, чтобы получить ключ. Это работает, только если элемент встречается не более одного раза, поскольку \array_search
возвращает только первое совпадение.
unset()
Обратите внимание, что при использовании unset()
ключи массива не изменятся. Если вы хотите переиндексировать ключи, вы можете использовать \array_values()
после unset()
, который преобразует все ключи в ключи с числовой нумерацией, начиная с 0.
Код:
$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
// ↑ Key which you want to delete
Выход:
[
[0] => a
[2] => c
]
Метод \array_splice()
Если вы используете \array_splice()
, ключи будут автоматически переиндексированы, но ассоциативные ключи не изменятся - в отличие от \array_values()
, который преобразует все ключи в цифровые.
\array_splice()
требует смещения , а не ключа в качестве второго параметра.
Код:
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
// ↑ Offset which you want to delete
Выход:
[
[0] => a
[1] => c
]
array_splice()
, так же, как unset()
, взять массив по ссылке. Вы не присваиваете возвращаемые значения этих функций массиву.
Удаление нескольких элементов массива
Если вы хотите удалить несколько элементов массива и не хотите вызывать unset()
или \array_splice()
несколько раз, вы можете использовать функции \array_diff()
или \array_diff_key()
в зависимости от того, знаете ли вы значения или ключи элементов, которые вы хотите удалить.
Метод \array_diff()
Если вам известны значения элементов массива, которые вы хотите удалить, вы можете использовать \array_diff()
. Как и раньше с unset()
, он не изменит ключи массива.
Код:
$array = [0 => "a", 1 => "b", 2 => "c", 3 => "c"];
$array = \array_diff($array, ["a", "c"]);
// └────────┘
// Array values which you want to delete
Выход:
[
[1] => b
]
Метод \array_diff_key()
Если вы знаете ключи элементов, которые хотите удалить, тогда вы хотите использовать \array_diff_key()
. Вы должны убедиться, что вы передаете ключи как ключи во втором параметре, а не как значения. Ключи не индексируются.
Код:
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
// ↑ ↑
// Array keys which you want to delete
Выход:
[
[1] => b
]
Если вы хотите использовать unset()
или \array_splice()
для удаления нескольких элементов с одинаковым значением, вы можете использовать \array_keys()
, чтобы получить все ключи для определенного значения, а затем удалить все элементы.
Метод \array_filter()
Если вы хотите удалить все элементы с определенным значением в массиве, вы можете использовать \array_filter()
.
Код:
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_filter($array, static function ($element) {
return $element !== "b";
// ↑
// Array value which you want to delete
});
Выход:
[
[0] => a
[1] => c
]
array (3) { [0]=>int(0) ...
, когда вы unset($x[2])
из $x = array(1, 2, 3, 4);
Результат должен быть var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }
(вероятно, это была опечатка)
unset
может иметь несколько аргументов: void unset ( mixed $var [, mixed $... ] )
.
unset
- это не функция, а языковая конструкция (и ключевое слово). Он не должен и не может начинаться с префикса ``
Шаг первый, начните с php syntex
<?php
Шаг второй
Создать массив с именами животных
<?php
$animals= array(
'cat', // [0]
'dog', // [1]
'cow' // [2]
);
Шаг третий
Удалить элемент с индексом 1, который предназначен для
unset($animals1[1]);
Шаг четвертый
Распечатать измененный массив
var_dump($danimals1);
Шаг пятый
Переиндексировать элементы массива
$newarray = array_values($animals1);
Шаг шестой
Распечатать переиндексированный массив
var_dump($newarray);
Шаг седьмой
Закрыть php-код
?>
Чтобы избежать поиска, можно поиграться с array_diff
:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
В этом случае не нужно искать / использовать ключ.
Используйте array_search, чтобы получить ключ, и удалите его с неустановленным, если он найден:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Создайте свой массив в переменной $array
, а затем там, где я поместил «элемент, который вы хотите удалить», вы помещаете что-то вроде: «a». А если вы хотите удалить несколько элементов, то: «a», «b».
Для ассоциативных массивов с нецелочисленными ключами:
Просто unset($array[$key])
подойдет.
Для массивов с целочисленными ключами и если вы хотите сохранить свои ключи:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]); $array = array_values($array);
array_splice($array, 2, 1);
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
Это может помочь ...
<?php
$a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
$a2 = array("a"=>"purple", "b"=>"orange");
array_splice($a1, 0, 2, $a2);
print_r($a1);
?>
Результат будет:
Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать array_diff_key ( ) (здесь используется с array_flip ()):
$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 ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
// Our initial array
$arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
print_r($arr);
// Remove the elements who's values are yellow or red
$arr = array_diff($arr, array("yellow", "red"));
print_r($arr);
Это вывод из кода выше:
Array
(
[0] => blue
[1] => green
[2] => red
[3] => yellow
[4] => green
[5] => orange
[6] => yellow
[7] => indigo
[8] => red
)
Array
(
[0] => blue
[1] => green
[4] => green
[5] => orange
[7] => indigo
)
Теперь array_values () красиво переиндексирует числовой массив, но удалит все ключевые строки из массива и заменит их числами. Если вам нужно сохранить имена ключей (строки) или переиндексировать массив, если все ключи числовые, используйте array_merge ():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
Выходы
Array
(
[0] => blue
[1] => green
[2] => green
[3] => orange
[4] => indigo
)
array_merge(array_diff(
вы сэкономили мне время, спасибо за оба примера, 1.keys are not re-indexed
и another one with keys are indexed again from 0...n
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
unset($array[$index]);
Если у вас есть массив с числовым индексом, в котором все значения уникальны (или они не уникальны, но вы хотите удалить все экземпляры определенного значения), вы можете просто использовать array_diff () для удаления соответствующего элемента, например:
$my_array = array_diff($my_array, array('Value_to_remove'));
Например:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
Это отображает следующее:
4
3
В этом примере элемент со значением Charles удаляется, что можно проверить с помощью вызовов sizeof (), которые сообщают размер 4 для исходного массива и 3 после удаления.
Также для именованного элемента:
unset($array["elementName"]);
$a = array("A"=>1, "B"=>2, "C"=>"a");
print_r($a);
unset($a["B"]);
print_r($a);
дает (отформатировано): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
unset()
еще в 2008 году! Если вы хотите улучшить этот совет, вам следовало отредактировать этот ответ. На этой странице с несколькими вкладками слишком много избыточного контента!
Уничтожить отдельный элемент массива
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
Результат будет:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
Если вам нужно переиндексировать массив:
$array1 = array_values($array1);
var_dump($array1);
Тогда вывод будет:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Извлечь элемент за пределы массива - вернуть значение удаленного элемента.
mixed array_pop(array &$array)
$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array
На выходе будет
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
Удалить первый элемент (красный) из массива , - вернуть значение удаленного элемента
mixed array_shift ( array &$array )
$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);
Результат будет:
Array
(
[b] => green
[c] => blue
)
First Color: red
array_shift
повторно индексирует ключевые элементы, если это целое число, значит, это плохо, поэтому вы можете использовать это: stackoverflow.com/a / 52826684/1407491
array_shift()
составляет O (n) (из-за повторной индексации числовых индексов) а для array_pop()
это O (1). Как узнать индекс первого элемента? Просто запустите foreach
и break
прямо на первой итерации.
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Выход:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
array_shift
может удалить только первый элемент в массиве. аналогично используйте array_pop
для удаления последнего элемента в массиве.
Ассоциативные массивы
Для ассоциативных массивов используйте 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)
Заметка
Использование unset
для числовых массивов приведет к не выдаст ошибку, но испортит ваши индексы:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными, array_filter()
a> - ваш лучший выбор. Те записи, которые возвращают истину из функции обратного вызова, будут сохранены.
$array = [
['x'=>1,'y'=>2,'z'=>3],
['x'=>2,'y'=>4,'z'=>6],
['x'=>3,'y'=>6,'z'=>9]
];
$results = array_filter($array, function($value) {
return $value['x'] > 2;
}); //=> [['x'=>3,'y'=>6,z=>'9']]
Следует отметить, что unset()
сохранит индексы нетронутыми, чего и следовало ожидать при использовании строковых индексы (массив как хеш-таблица), но это может быть довольно неожиданным при работе с целочисленными индексированными массивами:
$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[3]=>
int(3)
} */
$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
Таким образом, array_splice()
можно использовать, если вы хотите нормализовать целочисленные ключи. Другой вариант - использовать array_values()
после unset()
:
$array = array(0, 1, 2, 3);
unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
array_splice
может иметь смысл (среди прочего).
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
array_search()
, то его возвращаемое значение false
эффективно удалит ключевой элемент [0]
, который не предназначен и наносит ущерб входным данным. Я призываю исследователей не использовать этот фрагмент.
Следуйте функциям по умолчанию:
- PHP: не установлен
unset()
уничтожает указанные переменные. Для получения дополнительной информации вы можете обратиться к PHP unset
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
- PHP: array_pop
Функция array_pop()
удаляет последний элемент массива. Для получения дополнительной информации вы можете обратиться к PHP array_pop
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
- PHP: array_splice
Функция array_splice()
удаляет выбранные элементы из массива и заменяет их новыми элементами. Для получения дополнительной информации вы можете обратиться к PHP array_splice
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
- PHP: array_shift
Функция array_shift()
удаляет первый элемент из массива. Для получения дополнительной информации вы можете обратиться к PHP array_shift
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
Я просто хотел бы сказать, что у меня был конкретный объект с переменными атрибутами (он в основном отображал таблицу, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также будут различаться):
class obj {
protected $fields = array('field1','field2');
protected $field1 = array();
protected $field2 = array();
protected loadfields(){}
// This will load the $field1 and $field2 with rows of data for the column they describe
protected function clearFields($num){
foreach($fields as $field) {
unset($this->$field[$num]);
// This did not work the line below worked
unset($this->{$field}[$num]); // You have to resolve $field first using {}
}
}
}
Вся цель $fields
была проста, поэтому мне не нужно смотреть везде в коде, когда они меняются, я просто смотрю на начало класса и меняю список атрибутов и $ fields массив содержимого для отражения новых атрибутов.
Предположим, у вас есть следующий массив:
Array
(
[user_id] => 193
[storage] => 5
)
Чтобы удалить storage
, выполните:
unset($attributes['storage']);
$attributes = array_filter($attributes);
И вы получите:
Array
(
[user_id] => 193
)
array_filter
?
array_filter()
абсолютно бессмысленен в вашей демонстрации.
unset()
был рекомендован годами ранее. Этот ответ не добавляет новой ценности этой канонической странице.
Два способа удаления первого элемента массива с сохранением порядка индекса, а также если вы не знаете имя ключа первого элемента.
Решение # 1
// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);
Решение # 2
// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);
Для этого образца данных:
$array = array(10 => "a", 20 => "b", 30 => "c");
У вас должен быть такой результат:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
array_slice()
и unset()
уже были продемонстрированы много раз, прежде чем вы опубликовали свой ответ. Этот ответ является избыточным и только портит опыт исследователя.
Unset () несколько фрагментированных элементов из массива
Хотя unset()
упоминался здесь несколько раз, еще не упоминалось, что unset()
принимает несколько переменных, что упрощает удаление нескольких несмежных элементов из массива за одну операцию:
// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]
Unset () динамически
Unset () не принимает массив ключей для удаления, поэтому приведенный ниже код завершится ошибкой (хотя это немного упростило бы динамическое использование unset ()).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
Вместо этого unset () можно динамически использовать в цикле foreach:
$array = range(0,5);
$remove = [1,2];
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
, как показано ниже:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Удалить элемент массива на основе значения:
Используйте функцию array_search
, чтобы получить ключ элемента, и используйте описанный выше способ для удаления элемента массива, как показано ниже:
$a = array(
'salam',
'10',
1
);
$key = array_search(10, $a);
if ($key !== false) {
unset($a[$key]);
}
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
unset()
и array_search()
с unset()
уже были опубликованы к 2017 году. Этот ответ дает только избыточную информацию.
Редактировать
Если вы не можете принять, что объект находится в этом массиве, вам нужно добавить проверку:
if(in_array($object,$array)) unset($array[array_search($object,$array)]);
Оригинальный ответ
Если вы хотите удалить определенный объект массива по ссылке на этот объект, вы можете сделать следующее:
unset($array[array_search($object,$array)]);
Примере:
<?php
class Foo
{
public $id;
public $name;
}
$foo1 = new Foo();
$foo1->id = 1;
$foo1->name = 'Name1';
$foo2 = new Foo();
$foo2->id = 2;
$foo2->name = 'Name2';
$foo3 = new Foo();
$foo3->id = 3;
$foo3->name = 'Name3';
$array = array($foo1,$foo2,$foo3);
unset($array[array_search($foo2,$array)]);
echo '<pre>';
var_dump($array);
echo '</pre>';
?>
Результат:
array(2) {
[0]=>
object(Foo)#1 (2) {
["id"]=>
int(1)
["name"]=>
string(5) "Name1"
}
[2]=>
object(Foo)#3 (2) {
["id"]=>
int(3)
["name"]=>
string(5) "Name3"
}
}
Обратите внимание, что если объект встречается несколько раз, он будет удален только при первом появлении!
array_search()
, то его возвращаемое значение фактически уничтожит ключевой элемент [0]
. Этот фрагмент опасен и должен быть удален. Существовали более ранние ответы, в которых не было этой ошибки.
in_array()
, а затем еще одно потенциально полное сканирование снова с помощью array_search()
. Это просто плохая практика. Моя позиция остается неизменной - этот ответ допускает ошибки, которых не было в предыдущих ответах. Исправление этого ответа только сделает его дублирующим из более ранних ответов. Эта страница будет улучшена, если этот ответ будет удален.
Используйте следующий код:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
array_pop($arr)
удаляет последнюю запись. `=` Не требуется.
Я пришел сюда, потому что хотел увидеть, есть ли более элегантное решение этой проблемы, чем использование unset ($ arr [$ i]). К моему разочарованию, эти ответы либо неверны, либо не охватывают все крайние случаи.
Вот почему array_diff () не работает. Ключи в массиве уникальны, а элементы не всегда уникальны.
$arr = [1,2,2,3];
foreach($arr as $i => $n){
$b = array_diff($arr,[$n]);
echo "\n".json_encode($b);
}
Полученные результаты...
[2,2,3]
[1,3]
[1,2,2]
Если два элемента совпадают, они будут удалены. Это также относится к array_search () и array_flip ().
Я видел много ответов с array_slice () и array_splice (), но эти функции работают только с числовыми массивами. Все ответы я знаю, если здесь нет ответа на вопрос, и поэтому вот решение, которое будет работать.
$arr = [1,2,3];
foreach($arr as $i => $n){
$b = array_merge(array_slice($arr,0,$i),array_slice($arr,$i+1));
echo "\n".json_encode($b);
}
Results...
[2,3];
[1,3];
[1,2];
Поскольку unset ($ arr [$ i]) будет работать как с ассоциативными массивами, так и с числовыми массивами, это все еще не отвечает на вопрос.
Это решение заключается в сравнении ключей и с помощью инструмента, который будет обрабатывать как числовые, так и ассоциативные массивы. Для этого я использую array_diff_uassoc (). Эта функция сравнивает ключи в функции обратного вызова.
$arr = [1,2,2,3];
//$arr = ['a'=>'z','b'=>'y','c'=>'x','d'=>'w'];
foreach($arr as $key => $n){
$b = array_diff_uassoc($arr, [$key=>$n], function($a,$b) {
if($a != $b){
return 1;
}
});
echo "\n".json_encode($b);
}
Полученные результаты.....
[2,2,3];
[1,2,3];
[1,2,2];
['b'=>'y','c'=>'x','d'=>'w'];
['a'=>'z','c'=>'x','d'=>'w'];
['a'=>'z','b'=>'y','d'=>'w'];
['a'=>'z','b'=>'y','c'=>'x'];
<?php
// If you want to remove a particular array element use this method
$my_array = array("key1"=>"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";
}
?>
<?php
//To remove first array element
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
$new_array = array_slice($my_array, 1);
print_r($new_array);
?>
<?php
echo "<br/> ";
// 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 ( [key1] => value 1 [key2] => value 2 [key3] =>
value 3 ) Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
unset()
. Если ключ не найден в массиве, то unset()
ничего не сделает (как и ожидалось). unset()
и array_slice()
уже были рекомендованы до публикации этого ответа. Этот ответ не добавляет новой ценности этой странице.
unset()
уничтожает указанные переменные.
Поведение unset()
внутри функции может варьироваться в зависимости от типа переменной, которую вы пытаетесь уничтожить.
Если глобальная переменная находится внутри функции unset()
, уничтожается только локальная переменная. Переменная в вызывающей среде сохранит то же значение, что и до вызова unset()
.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
Ответом на приведенный выше код будет bar .
Чтобы unset()
глобальная переменная внутри функции:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
Решения:
- Чтобы удалить один элемент, используйте unset ():
unset($array[3]); unset($array['foo']);
- Чтобы удалить несколько несмежных элементов, также используйте unset ():
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Чтобы удалить несколько смежных элементов, используйте array_splice ():
array_splice($array, $offset, $length);
Дальнейшее объяснение:
Использование этих функций удаляет все ссылки на эти элементы из PHP. Если вы хотите сохранить ключ в массиве, но с пустым значением, присвойте элементу пустую строку:
$array[3] = $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;
Если вы unset () элемент, PHP настраивает массив так, чтобы цикл продолжал работать правильно. Он не сжимает массив, чтобы заполнить недостающие дыры. Это то, что мы имеем в виду, когда говорим, что все массивы ассоциативны, даже если они кажутся числовыми. Вот пример:
// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1]; // Prints 'bee'
print $animals[2]; // Prints 'cat'
count($animals); // Returns 6
// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1]; // Prints '' and throws an E_NOTICE error
print $animals[2]; // Still prints 'cat'
count($animals); // Returns 5, even though $array[5] is 'fox'
// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1]; // Prints '', still empty
print $animals[6]; // Prints 'gnu', this is where 'gnu' ended up
count($animals); // Returns 6
// Assign ''
$animals[2] = ''; // Zero out value
print $animals[2]; // Prints ''
count($animals); // Returns 6, count does not decrease
Чтобы сжать массив в плотно заполненный числовой массив, используйте array_values () :
$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
(
[0] => ant
[1] => bee
[2] => elk
[3] => fox
)
Это полезно, если вы используете массив в качестве очереди и хотите удалить элементы из очереди, сохраняя при этом произвольный доступ. Чтобы безопасно удалить первый или последний элемент из массива, используйте array_shift () и array_pop () соответственно.
Если указан индекс:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // $arr = ['b', 'c']
Если у нас есть значение вместо индекса:
$arr = ['a', 'b', 'c'];
// search the value to find index
// Notice! this will only find the first occurrence of value
$index = array_search('a', $arr);
if($index !== false){
unset($arr[$index]); // $arr = ['b', 'c']
}
Условие if
необходимо потому что, если index
не найден, unset()
автоматически удалит первый элемент массива, который нам не нужен.
unset()
уже несколько раз рекомендовали на этой странице несколькими годами ранее. array_search()
с unset()
был продемонстрирован еще в 2011 году. stackoverflow.com/a/8135667/2943403 Этот ответ не добавляет новой ценности этой странице.
Похожие вопросы
Связанные вопросы
Новые вопросы
php
PHP — это широко используемый язык сценариев общего назначения с открытым исходным кодом, мультипарадигмальный, динамически типизированный и интерпретируемый, изначально разработанный для веб-разработки на стороне сервера. Используйте этот тег для вопросов о программировании на языке PHP.
unset()
итерации по массиву больше не будут включать удаленное значение. OTOH, это правда, что Стеван ответил достаточно, и, на самом деле, это был ответ, который я искал, но не OP :)