Удалить определенный элемент из массива php. Использование языка Free Pascal для обработки массивов

35 ответов

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

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

Если вы хотите удалить только один элемент массива, вы можете использовать \unset() или альтернативно \array_splice() .

Также, если у вас есть значение и вы не знаете ключ для удаления элемента, вы можете использовать \array_search() чтобы получить ключ.

\unset() метод

Обратите внимание, что когда вы используете \unset() ключи массива не будут меняться/переиндексироваться. Если вы хотите переиндексировать ключи, вы можете использовать \array_values() после \unset() который преобразует все ключи в числовые нумерованные ключи, начиная с 0.

$array = array(0, 1, 2, 3); unset($array); $array = array_values($array); var_dump($array); /* array(3) { => int(0) => int(1) => int(3) } */

// Our initial array $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red"); print_r($arr); // Remove the elements who values are yellow or red $arr = array_diff($arr, array("yellow", "red")); print_r($arr);

Это вывод из кода выше:

Array ( => blue => green => red => yellow => green => orange => yellow => indigo => red) Array ( => blue => green => green => orange => indigo)

Теперь array_values () будет переиндексировать числовой массив, но он удалит все ключевые строки из массива и заменит их числами. Если вам нужно сохранить имена ключей (строки) или переиндексировать массив, если все ключи числовые, используйте array_merge():

$arr = array_merge(array_diff($arr, array("yellow", "red"))); print_r($arr);

Array ( => blue => green => green => orange => indigo)

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

Отображается следующее:

В этом примере элемент со значением "Чарльз" удаляется, как это можно проверить с помощью вызовов sizeof(), которые сообщают размер 4 для исходного массива и 3 после удаления.

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

unset()

$array1 = array("A", "B", "C", "D", "E"); unset($array1); // Delete known index(2) value from array var_dump($array1);

Выход будет:

Array(4) { => string(1) "A" => string(1) "B" => string(1) "D" => string(1) "E" }

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

$array1 = array_values($array1); var_dump($array1);

Тогда вывод будет:

Array(4) { => string(1) "A" => string(1) "B" => string(1) "D" => 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 ( => orange => banana => 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

unset() уничтожает указанные переменные.

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

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

Ответ приведенного выше кода будет бар .

Чтобы unset() глобальную переменную внутри функции:

Для ассоциативных массивов используйте 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)

Примечание

Если вам нужно удалить несколько значений в массиве, а записи в этом массиве - объекты или структурированные данные, - ваш лучший выбор. Те записи, которые возвращают true из функции обратного вызова, будут сохранены.

$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"]]

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ( => value 1 => value 3 => value 5)

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

Array ( => 193 => 5)

Чтобы удалить storage , выполните:

Unset($attributes["storage"]); $attributes = array_filter($attributes);

И вы получите:

Array ( => 193)

Я просто хотел бы сказать, что у меня был определенный объект, который имел переменные атрибуты (это было в основном отображение таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также могли бы меняться):

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 = array("test1","test2","test3","test3"); unset($Array);

$Array = array("test1","test2","test3","test3"); array_pop($Array);

$Array = array("test1","test2","test3","test3"); array_splice($Array,1,2);

$Array = array("test1","test2","test3","test3"); array_shift($Array);

Хотя 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" ]

Решения:

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);

Удалить элемент массива на основе ключа:

Используйте функцию unset , как показано ниже:

$a = array("salam", "10", 1); unset($a); print_r($a); /* Output: Array ( => salam => 1) */

Удалить элемент массива на основе значения:

Используйте 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) */

Создайте свой массив в переменной $array а затем, где я поместил "элемент, который вы хотите удалить", вы поместите что-то вроде: "a". А если вы хотите удалить несколько, то: "a", "b".

Фукции для работы с массивами и операции над массивами (Часть 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 ). "

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

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

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

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

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

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

X[ 3 ] : =X [ 4 ];

X[ 4 ] : =X [ 5 ];

X[ 5 ] : =X [ 6 ];

Таким образом, все элементы с третьего по пятый надо переместить влево на один - на место i -го элемента нужно записать (i+1) -й. Блок-схема алгоритма представлена на рис. 5.25 .

Рис. 5.25.

Теперь рассмотрим более общую задачу: необходимо удалить m -й элемент из массива X , состоящего из n элементов. Для этого достаточно записать элемент (m+1) -й на место элемента c номером m, (m+2) -й элемент - на место (m+1) -го и т. д., n -й элемент - на место (n–1) -го. Процесс удаления элемента из массива представлен на рис. 5.26 .

Алгоритм удаления из массива Х размерностью n элемента с номером m приведён на рис. 5.27 .

После удаления элемента 4А фактически сдвига части массива на один элемент влево из массива изменится количество элементов в массиве (уменьшится на один), и у части элементов изменится индекс . Если элемент удалён, то на место него приходит следующий, передвигаться к которому (путём увеличения индекса на один) нет необходимости. Следующий элемент сам сдвинулся влево после удаления.

Если обрабатывается массив , в котором часть элементов удаляется, то после удаления элемента не надо переходить к следующему (при этом уменьшается количество элементов). В качестве примера рассмотрим следующую задачу.

ЗАДАЧА 5.1. Удалить из массива отрицательные элементы.

Алгоритм решения задачи довольно прост: перебираем все элементы массива, если элемент отрицателен, то удаляем его путём сдвига всех последующих на один влево. Единственное, о чём стоить помнить, - что после удаления элемента не надо переходить к следующему для последующей обработки, он сам сдвигается на место текущего. Блок-схема решения задачи 5.1 представлена на рис. 5.28 .

Ниже представлен текст программы с комментариями.

program upor_massiv; var i, n, j: byte; X: array [ 1.. 100 ] of real; begin writeln (’введите размер массива ’); readln (n); {Ввод массива.} for i:=1 to n do begin write (’X[ ’, i, ’ ]= ’); readln (X[ i ]); end; writeln (’массив X ’); for i:=1 to n do write (x [ i ] : 5: 2, ’ ’); writeln; i: = 1; while (i<=n) do {Если очередной элемент массива X[i] отрицателен, то} if x [ i ]<0 then begin {удаляем элемент массива с номером i.} for j:= i to n_1 do x [ j ] : = x [ j + 1 ]; {Уменьшаем размер массива.} {Не надо переходить к следующему элементу массива.} n:=n -1; end else {Если элемент не удалялся, то переходим к следующему элементу массива.} i:= i +1; writeln (’Изменённый массив ’); for i:=1 to n do {Вывод преобразованного массива.} write (X[ i ] : 5: 2, ’ ’); writeln; end.

Результаты работы программы представлены на рис. 5.29 .

5.9 Вставка элемента в массив

Рассмотрим несложную задачу: вставить число b в массив X(10) , между третьим и четвёртым элементами.

Для решения этой задачи необходимо все элементы массива, начиная со четвёртого, сдвинуть вправо на один элемент. Затем в четвёртый элемент массива нужно будет записать b (X:=b;) . Но чтобы не потерять соседнее значение , сдвигать на один вправо нужно сначала десятый элемент, затем девятый, восьмой и т. д. до четвёртого. Блок-схема алгоритма вставки приведена на рис. 5.30 .

В общем случае блок-схема вставки числа b в массив X(N) , между элементами c номерами m и m+1 представлена на рис. 5.31 .

Ниже представлен фрагмент программы, реализующий этот алгоритм 5При описании массива необходимо предусмотреть достаточный размер для вставки одного элемента. .

var i, n,m: byte; X: array [ 1.. 100 ] of real; b: real; begin writeln (’N= ’); readln (n); for i:=1 to n do begin write (’X[ ’, i, ’ ]= ’); readln (X[ i ]); end; writeln (’Массив X ’); for i:=1 to n do write (x [ i ] : 5: 2, ’ ’); writeln; writeln (’m= ’); readln (m); writeln (’ b= ’); readln (b); for i:=n downto m+1 do x [ i +1]:=x [ i ]; x :=b; n:=n+1; writeln (’Изменённый массив ’); for i:=1 to n do write (X[ i ] : 5: 2, ’ ’); writeln; end.

5.10 Использование подпрограмм для работы с массивами

Рассмотрим, как можно передавать массивы в подпрограмму. Как известно (см. главу 4), чтобы объявить переменные в списке формальных параметров подпрограммы, необходимо указать их имена и типы. Однако типом любого параметра в списке может быть только стандартный или ранее объявленный тип. Поэтому для того, чтобы передать в подпрограмму массив , необходимо вначале описать его тип 6Тип данных массива, объявление массива см. в п. 2.4.9. Подробно работа с массивами описана в данной главе. , а затем объявлять процедуру:

тип_массива = array [ список_индексов ] of тип;

procedure

имя_процедуры(имя_массива: тип_массива);

Например:

type vector=array [ 1.. 10 ] of byte; matrica=array [ 1.. 3, 1.. 3 ] of real; procedure proc (A: matrica; b: vector; var x: vector);

Понятно, что передача в подпрограмму строки вида

имя_переменной: string [ длина_строки ];

которая фактически является массивом 7Тип данных "строка", объявление строки см. в п. 2.4.9 , должна осуществляться аналогично:

тип_строки = string [ длина_строки ];

procedure

имя_процедуры(имя_строки: тип_ строки);

Например:

type stroka_5=string [ 5 ]; stroka_10=string [ 1 0 ]; function fun (S t r: stroka_5) : stroka_10;

Массивы в подпрограмму можно передавать, используя понятие открытого массива. Открытый массив - это массив 8Тип данных "массив", объявление массива, обращение к массиву см. в п. 2.4.9. , при описании которого указывается тип элементов, из которых он состоит, но не определяются границы изменения индексов:

имя_открытого_массива: array of array of... тип;

Например:

var massiv_1: array of real; massiv_2: array of array of char; massiv_3: array of array of array of byte;

Распределение памяти и указание границ индексов