Массив – одна из самых полезных и часто используемых структур данных в любом языке программирования. Уметь управлять массивами и их элементами очень важно и полезно. В данной статье рассмотрим, как можно удалить отдельные элементы массива в 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", то на результат это никак не повлияет - они в новый массив добавлены не будут.
Данную задачу можно решить несколькими способами.
Способ 1. Скопировать в другой массив только нечетные элементы.
const N = 20 ; var a, b: array [ 1 .. N ] of integer ; i, m: byte ; begin randomize; for i: = 1 to N do begin a[ i] : = random(40 ) + 10 ; write (a[ i] : 3 ) ; end ; writeln ; m : = 0 ; for i: = 1 to N do if a[ i] mod 2 <> 0 then begin m : = m + 1 ; b[ m] : = a[ i] ; end ; for i: = 1 to m do begin write (b[ i] : 3 ) ; end ; writeln ; end .
Это самый простой способ удаления элементов массива (в данном случае четных чисел), так как не требуется сжимать исходный массив. В представленном выше решении задачи переменная m хранит количество найденных нечетных элементов и в то же время, при заполнении второго массива является меняющимся индексом элементов.
Способ 2. Удалять четные элементы в текущем массиве, перезаписывая их расположенными правее нечетными.
const N = 10 ; var a: array [ 1 .. N ] of integer ; i, k, m: byte ; begin randomize; for i: = 1 to N do begin a[ i] : = random(40 ) + 10 ; write (a[ i] : 3 ) end ; writeln ; i : = 1 ; m : = N; while i<= m do if a[ i] mod 2 = 0 then begin m : = m- 1 ; for k: = i to m do a[ k] : = a[ k+ 1 ] ; end else i : = i+ 1 ; for i: = 1 to m do write (a[ i] : 3 ) ; writeln ; end .
Этот способ решения задачи сложнее. Здесь если встречается четный элемент, то весь остаток массива сдвигается на одну ячейку вперед. При этом найденный четный элемент затирается. Переменная m уменьшается, т. к. количество элементов массива становится меньше.
Этот способ следует считать наиболее рациональным (однако в школьном курсе открытые массивы могут не изучаться). В предыдущих вариантах по-сути массивы не уменьшались, на экран выводилась лишь часть массива. Можно было бы вообще просто перебрать исходный массив, ничего с ним не делать и вывести на экран только нечетные элементы.
Открытый массив позволяет изменять свою длину. В решении задачи ниже после того как нечетные элементы сдвинуты и "затерли" нечетные, изменяется длина массива (процедурой setlength). Она устанавливает новую длину массива. Особенностью открытых массивов в Pascal является то, что их индексация начинается с нуля.
const N = 10 ; var a: array of integer ; i, j, m: byte ; begin randomize; SetLength(a, N) ; for i : = 0 to N- 1 do begin a[ i] : = random(40 ) + 10 ; write (a[ i] : 3 ) ; end ; writeln ; i : = 0 ; // индекс первого элемента m : = n- 1 ; // индекс последнего while i <= m do if a[ i] mod 2 = 0 then begin for j : = i to m- 1 do a[ j] : = a[ j+ 1 ] ; m : = m - 1 end else i : = i + 1 ; SetLength(a, m+ 1 ) ; // последний элемент имеет индекс m, но элементов m+1 for i: = 0 to m do write (a[ i] : 3 ) ; writeln ; end .
Пример выполнения кода программы.
Слияние массивов
Слияние (конкатенация) массивов - это операция создания массива, состоящего из элементов нескольких других массивов. Слияние массивов - это очень опасная операция, поскольку результат слияния подчиняется своей логике, забыв о которой можно потерять данные. Слияние массивов реализуется при помощи оператора "+ " или с помощью функции Слияние может осуществляться только с помощью функции 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
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 .
Рассмотрим несложную задачу: вставить число 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.
Рассмотрим, как можно передавать массивы в подпрограмму. Как известно (см. главу 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;
Распределение памяти и указание границ индексов
