Меню Рубрики

Удаление из массива php. Удаление элемента в массиве 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».

В этом уроке вы не только узнаете, как удалить массив PHP , но и как удалить один или несколько элементов массива разными способами. Начнем с простого:

  • Для того, чтобы удалить один из элементов массива , воспользуемся функцией unset():

Unset($array); unset($array["foo"]);

  • Для удаления нескольких непоследовательных элементов также пригодится функция unset():
unset($array, $array); unset($array["foo"], $array["bar"]);
  • Для удаления нескольких последовательных элементов используйте функцию array_splice():
array_splice($array, $offset, $length);
  • Для того, чтобы удалить массив полностью, необходимо воспользоваться той же функцией UnSet(), аргументом которой будет сам удаляемый массив. Вот пример удаления массива:
PHP UnSet array
"; $array = 0; $array = 1; $array = 2; $array = 3; $arrayCount = count($array); echo "array count = "; echo $arrayCount; echo "
"; for($inn = 0; $inn < $arrayCount; $inn++) { echo "array["; echo $inn; echo "] = "; echo "$array[$inn]
"; } echo "
"; UnSet($array); $arrayCount = count($array); echo "array count after UnSet = "; echo $arrayCount; ?>

Применение этих функций удалит все ссылки на эти элементы из PHP кода . Для сохранения в массиве ключа с пустым значением необходимо присвоить элементу пустую строку:

$array = $array["foo"] = "";

Есть логическое отличие между использованием функции unset() и присваиванием элементу пустой строки (»). В первом случае говорится: «Этого элемента больше не существует», а во втором – «Этот элемент еще существует, но его значение равно пустой строке».

После применения функции 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" // 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()

значению ключу (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) */

Решения:

  1. Чтобы удалить один элемент, используйте unset() :
unset($array); unset($array["foo"]);
  1. Чтобы удалить несколько несмежных элементов, также используйте unset() :
unset($array, $array); unset($array["foo"], $array["bar"]);
  1. Чтобы удалить несколько смежных элементов, используйте 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]; }

Существуют разные способы удаления элемента массива, причем некоторые из них более полезны для некоторых конкретных задач, чем другие.

Удалить один элемент массива

Если вы хотите удалить только один элемент массива, вы можете использовать \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() чтобы получить все ключи для определенного значения, а затем удалить все элементы.

Фукции для работы с массивами и операции над массивами (Часть 2)

Слияние массивов

Слияние (конкатенация) массивов - это операция создания массива, состоящего из элементов нескольких других массивов. Слияние массивов - это очень опасная операция, поскольку результат слияния подчиняется своей логике, забыв о которой можно потерять данные. Слияние массивов реализуется при помощи оператора "+ " или с помощью функции Слияние может осуществляться только с помощью функции array_merge() .

Предположим, мы имеем два массива:

$A = array("1"=>"Первый", "2"=>"Второй");
$B = array("3"=>"Третий", "4"=>"Четвертый");

Теперь сольем данные два массива в один массив $C :

Оператор "+ " для массивов не коммутативен. Это означает, что $A + $B не равно $B + $A .

В результате рассмотренного примера мы получим массив $C следующего вида:

"1"=>"Первый", "2"=>"Второй", "3"=>"Третий", "4"=>"Четвертый"

А в результате $B + $A мы получим такой массив:

"3"=>"Третий", "4"=>"Четвертый", "1"=>"Первый", "2"=>"Второй"

При слиянии списков такой метод не работает. Поясним данный факт на примере:

Предположим, у нас есть два массива:

$A = array(10,11,12);
$B = array(13,14,15);

В результате слияния списков $A и $B ($A + $B ) мы получим: 10,11,12. А это совсем не тот результат, который мы хотели получить... Связано это с тем, что при слиянии списков с одинаковыми индексами в результирующем массиве остается элемент первого массива, причем на том же месте. В таком случае нам необходимо использовать функцию

Пример использования функции count() :

$ arr = 5 ;
$ arr = 4 ;
$ arr = 8 ;
$ arr = 3 ;
$ arr = 8 ;
echo "

Число элементов массива: " . count ($ arr ). "

" ;
// Выводит: Число элементов массива: 5
?>

Удаление массива и его элементов

Если вы хотите удалить массив целиком, воспользуйтесь функцией unset() .

Если вы хотите удалить пару ключ/значение, вы также можете использовать функцию unset() . Приведем конкретные примеры:

$arr = array(5 => 1 , 12 => 2 );

$arr = 56 ; // В этом месте скрипта это
// эквивалентно $arr = 56;

$arr [ "x" ] = 42 ; // Это добавляет к массиву новый
// элемент с ключом "x"
форум портала PHP . SU



➤