Как создать пустой массив в php

Объявить пустой массив php?

Как объявить пустой массив?
если $arr = array();
то заполнение начнется с индекса 1($arr[1]).
Можно так:
$arr = array();
unset($arr[0]);
но как это сделать правильнее и проще?

Вопрос задан более трёх лет назад
23083 просмотра

2 комментария

Оценить 2 комментария

с чего это вы интересно взяли что заполнение начнётся с индекса 1 в первом случае?
не нужно тянуть сюда паскаль
Решения вопроса 1

littleguga

littleguga @littleguga
Не стыдно не знать, а стыдно не интересоваться.
Вы ошибаетесь — заполнение идет с 0 индекса.(по ссылке fiddle)

$arr = array(); array_push($arr, "test"); print_r($arr);

Сами проверьте, вот здесь, например.
Ответ написан более трёх лет назад
Комментировать
Нравится 1 Комментировать
Ответы на вопрос 2

danil_sport

Danil Akhtarov @danil_sport
Web, android, C++
PHP.нет посмотри тут. В свое время помогло
Ответ написан более трёх лет назад
Комментировать
Нравится Комментировать

elevenelven

Alex Safonov @elevenelven
Php Dev @ Amadeus
Это описывается в руководстве.
php.net/manual/en/function.array.php

 'January', 'February', 'March'); print_r($firstquarter); ?>

Как вариант, можете после наполнения массива, вставить в начало элемент, и убрать. Что двинет все ключи на 1.

$array = [1,2,3]; array_unshift($array, '' ); unset($array[0]);

Ответ написан более трёх лет назад
Михаил @Madfisht3 Автор вопроса

Нужно пустой массив объявить. Чтобы там не было элементов. Объявить, но так, чтоб он был не инициализирован.

Алексей Объявляйте массив как обычно (array() или []). При добавлении в массив указываете нужный ключ ($arr[1] = 3.14)

Михаил @Madfisht3 Автор вопроса

krypt3r: а если у меня заполнение идёт через array_push? Тогда у меня первый элемент будет пустой, на сайте это лишняя строчка пустая.

Михаил @Madfisht3 Автор вопроса
Neoline: 500 Ошибка.
Михаил @Madfisht3 Автор вопроса
Второй листинг эквивалентен unset($arr[0])

elevenelven

Alex Safonov @elevenelven

Алексей: Будьте добры, приведите полностью код который эквивалентен второму листингу. Я думаю вы не имеете ввиду

$arr = array(); unset($arr[0]); array_push($arr, 1);

vadimkot

Алексей: вы каким то не тем php пользуетесь — при инициализации массива в него никакие элементы не добавляются и если выполнить array_push() после инициализации, то в массиве появится элемент с индексом 0.

Как создать пустой массив в php

Массивы и списки.

Массив — это упорядоченный набор данных. Каждый элемент массива имеет индекс и ключ. Индекс (ключ) служит для однозначной идентификации элемента внутри массива. В одном массиве не может быть двух элементов с одинаковыми индексами.

В PHP — длину массива не нужно задавать при объявлении массива, длина будет автоматически увеличена при добавлении нового элемента в массив. Простейший способ инициализации массива:

PHP определяет массив по квадратным скобкам. В квадратных скобках указывается индекс (ключ) отдельного элемента массива. В приведенном примере массив — $people , состоящий из четырех элементов. В PHP размер массива не задается явно.

Обратиться к элементу массива можно по имени массива и индексу элемента внутри массива:

Зная количество элементов массива, можно вывести все элементы массива с помощью цикла:

если неизвестно количество элементов массива, можно использовать функцию count(). Эта стандартная функция определяет размер массива, то есть количество элементов в нем. Соответственно:

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

Массивы, индексами которых являются строки, называются ассоциативными. Индексы ассоциативных массивов называются ключами. Например:

$people[» Иванов «] = » Иван «;

$people[» Сидоров «] = » Николай «;

$people[» Петров «] = » Петр «;

Доступ к элементам ассоциативных массивов осуществляется так же, как и к элементам обыкновенных массивов, и называется доступом по ключу:

echo $people[» Иванов «];

Пример: имеем массив, состоящий из трех элементов:

Необходимо передать эти значения элементов массива, соответственно, трем переменным $Ivanov, $Sidorov, $Petrov:

list ($Ivanov,$Sidorov,$Petrov) = $people;

Инструкция array() используется специально для создания массивов. При этом она позволяет создавать пустые массивы.

Методы использования инструкции array() :

$A = array (); // создает пустой массив

$A = array (» Иванов «=>» Иван «, » Петров «=>» Петр «); // создает ассоциативный массив с двумя элементами

$A = array (» Иванов «,» Петров «); // создает список с двумя элементами. Индексы нумеруются с нуля.

Инструкцию array() удобно использовать при создании многомерных массивов.

Пример: создать массив, элементами которого будут ассоциативные массивы с ключами name, sex, email.

$A[«Ivanov»] = array(«name»=>» Иванов И. «, «sex»=>» М «, «email»=>»ivanov@mail.ru»);

$A[«Petrov»] = array(«name»=>» Петров И. «, «sex»=>» М «, «email»=>»petrov@mail.ru»);

$A[«Sidorova»] = array(«name»=>» Сидорова Н. «, «sex»=>»F», «email»=>»sidorova@mail.ru»);

Добраться до элементов массива можно так:

echo $A[«Ivanov»][«name»]; // выведет Иванов И.

echo $A[«Ivanov»][«email»]; // выведет ivanov@mail.ru

Для удаления массива, как и любой переменной, используется функция UnSet():

Слияние (конкатенация) — это операция создания массива, состоящего из элементов нескольких других массивов. Слияние реализуется с помощью оператора +.

Пример: имеется два массива.

$A = array («1″=>» первый «,»2″=>» второй «);

$B = array(«3″=>» третий «,»4″=>» четвертый «);

«1»=>» первый «,»2″=>» второй «,»3″=>» третий «,»4″=>» четвертый » // именно в таком порядке

Особенно внимательными нужно быть при слиянии списков. Пример:

$A = array (10,11,12);

$B = array (15,17,18);

В результате: 10,11,12 т. к. при слиянии массивов, в которых содержатся элементы с одинаковыми индексами (ключами), в результирующем массиве останется элемент первого массива, причем на том же самом месте.

Функция array_merge() предназначена для слияния массивов. Она устраняет все недостатки оператора +.

Функция array_merge() соединяет массивы переданные ей в качестве аргументов в один большой массив. Если в соединяемых массивах встречаются одинаковые ключи (ключ= > значение), то в результирующий массив помещается пара ключ= > значение из массива, который стоит правее в списке аргументов функции array-merge().

$C = $A + $B; // $C = array(10,11,12);

$C = array_merge($A,$B); // $C = array (10,11,12,15,17,18);

Таким образом, функцию array_merge() очень удобно использовать для слияния списков.

Принцип косвенного перебора заключается в том, что сначала вычисляется очередной индекс (ключ), а затем по этому индексу косвенно находится значение элемента массива. Например:

Пояснения: цикл for перебрал индексы ( целые числа), последовательно увеличивая их на 1, и по индексам получил элементы массива.

Для ассоциативного массива, индексом которого является строка:

$people[» Иванов «] = » Иван «;

$people[» Сидоров «] = » Николай «;

$people[» Петров «] = » Петр «;

Перебор такого массива поможет следующий цикл:

for (Reset($people); ($k = key($people)); Next ($people));

Пояснения: функция Reset() устанавливает текущий элемент массива $people[ ] на первую позицию. Функция key() возвращает ключ текущего элемента. Если нет больше элементов в массиве, то эта функция возвратит 0, и цикл прекратиться. Функция Next() перемещает текущий элемент на одну позицию вперед.

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

foreach ($people as $key => $value) echo «$key = $value»;

Основные функции для сортировки массивов:

asort() и arsort() — сортировка по значениям;
ksort() — сортировка по ключам;
sort() — сортировка списка;
array_reverce() — «переворачивание» массива;
shuffle() — перемешивание списка.

Функция asort() выполняет сортировку массива по значениям элементов. При этом она располагает элементы массива таким образом, что их значения идут в алфавитном порядке (если это строки) или в возрастающем порядке (если это числа).

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

Пример: имеется массив

$FIO = array(«Sidorov»=>»Nikolay», «Ivanov»=>»Alexandr», «Petrov»=>»Petr»);

После выполнения функции asort($FIO) массив будет преобразован следующим образом:

array(«Ivanov»=>»Alexandr», «Sidorov»=>»Nikolay», «Petrov»=>»Petr»);

Для сортировки по ключам используется функция ksort() . При этом сортировка осуществляется по таким же принципам, что и функцией asort() , только не по значению, а по ключам. В результате обработки массива $FIO получаем:

array(«Ivanov»=>»Alexandr», «Petrov»=>»Petr», «Sidorov»=>»Nikolay»);

Для сортировки ключей в обратном порядке используется функция krsort().

Функции asort(), arsort(), ksort() и krsort() не разрывают пары ключ= > значение. Это очень важно. Например: имеем небольшой список:

$people = array(«Ivanov»=>»555-6677», «Sidorov»=>»345-4567», «Petrov»=>»777-5653»);

после сортировки массива по ключам, список выглядит так:

$people = array(«Ivanov»=>»555-6677», «Petrov»=>»777-5653», «Sidorov»=>»345-4567»);

Пары ключ= > значение не разорваны. Если необходимо отсортировать список, то удобнее использовать функцию sort(). Данная функция разрывает пары ключ= > значение, поэтому она используется только для списков. Например: имеется список

$List = array(«Name», «Address», «Email»);

Если вывести список в виде ключ= > значение, получим следующий результат:

После сортировки sort() имеем следующий список:

Для переворачивания массива используется функция array_reverce(). Она возвращает массив в обратном порядке относительно исходного массива. Например, чтобы отсортировать массив в обратном порядке, можно использовать функцию arsort(), а можно упорядочить массив в прямом порядке функцией asort() и перевернуть его функцией array_reverce().

Функция shuffle() — перемешивает список, то есть значения результирующего списка будут размещены в случайном порядке. Данная функция полностью изменяет массив, поэтому ее нужно применять только для списков.

Перед вызовом этой функции необходимо инициализировать генератор случайных чисел, иначе при каждом новом вызове функции shiffle() результат перемешивания будет один и тот же. Для инициализации генератора случайных чисел используется функция mt_srand():

Когда необходимо отсортировать массив не в алфавитном порядке, а по более сложному критерию, применяются функции uksort(), uasort() и usort() — пользовательские функции сортировки массивов. Каждой функции нужно передать два параметра:

массив, который нужно отсортировать;
функцию сравнения, которая определит, какой из элементов массива меньше, а какой больше, согласно выбранного критерия.

Функции сравнения нужно передать два параметра — два элемента массива ($e1_1 и $e1_2). В свою очередь, функция должна возвратить одно из трех значений:

1, если $e1_1>$e1_2

Пример: имеем список файлов и каталогов — $FilesDirs. Необходимо вывести сначала каталоги, а потом файлы. Сравнение проводится функцией cmp(), листинг которой имеет вид:

function cmp($e1_1, $1_2)

// Сначала каталог, а потом — файл

// Сравниваем по алфавиту

elseif ($e1_1>$e1_2) return 1;

Вызовем функцию uasort():

Функция uasort() аналогична функции uksort(), только она сортирует не ключи, как uksort() , а значения. Обе функции — uksort() и uasort() — сохраняют пары ключ= > значение.

Для получения части массива используется функция array_slice(). Ей нужно передать три параметра:

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

Данная функция возвращает часть указанного массива, начиная с указанного смещения от начала массива. Выборка элементов осуществляется подряд. Длина результирующего массива задается параметром Длина, который является необязательным. Если он не указан, то выборка элементов проходит до конца исходного массива.

$A = array (xox, ror, tot, pop, mom); // задаем исходный массив

$B = array_slice ($A,2); // получаем массив $B,

// в котором содержатся все элементы массива $A, начиная с третьей позиции (т.к. два надо пропустить).

// Таким образом массив $B будет содержать элементы tot, pop, mom.

$B = array_slice ($A, 0 , 2); // Получаем массив $B, в котором содержатся два элемента массива $A, начиная с первого (т.к.

// надо пропустить 0 элементов). Т.о. массив $B будет содержать элементы xox, ror.

Параметры смещение и длина могут быть отрицательными — в этом случае отчет производится от конца массива:

$B = array_slice ($A, 2,-1); // получаем массив $B, состоящий из элементов tot, pop.

Функция array_slpice() похожа на функцию array_slice(). Ей нужно передать еще один параметр — массив (для примера $R ). Как и array_slice(), функция array_splice() возвращает массив указанной длины, начиная со смещения $offset , но и заменяет переданные ей элементы на содержимое массива $R.

Пример: (вместо массива $R можно указать обыкновенное строковое значение).

$A = array («Audi», «Mersedes», «Toyota», «Honda», «Renault»);

array_splice ($A, 1, count($A), «BMW»);

// $A = array («Audi», «BMW»);

Функция array_push() добавляет элементы в конец массива точно так же как и оператор [ ] . Например, следующие операторы аналогичны:

Если необходимо добавить один элемент в массив (как в приведенном примере), то удобнее использовать оператор [ ]. Использование оператора array_push() оправдывает себя тогда, когда нужно добавить в конец массива несколько новых элементов. Например:

Вместо этого можно записать:

array_push ($A, 5,7,9,10,15);

Функция array_pop() противоположна функции array_push() , она возвращает значение последнего элемента массива и удаляет его из списка.

Функции array_pop() нужно передать всего один параметр — имя массива (списка):

$A = array (xox, ror, tot, pop, mom);

$T = array_pop ($A); // переменной $T присвоили значение mom , а массив $A лишился этого последнего элемента и теперь состоит из элементов xox, ror, tot, pop.

array_pop($A); // массив $A еще раз лишился последнего элемента и теперь состоит из xox, ror, tot.

Функции array_unshift() и array_shift() похожи на функции array_push() и array_pop(), но только работают не с концом списка, а с его началом.

Функция array_unshift() добавляет элементы в начало списка, а функция array_shift() возвращает значение первого элемента списка и удаляет его из списка:

array_unshift($A,1,2); // получаем $A = array (1,2,3,4,5)

array_shift($A); // получаем $A = array(2,3,4,5);

Функция array_unique() предназначена для извлечения уникальных значений массива вместе с ключами этих значений. Пример:

$Arr = array («a=>»AAA», «b»=>»BBB», «c», «d», «e»=»BBB», «d»);

$Unique_Arr = array_unque ($Arr); //$Unique_Arr = array («a»=>»AAA», «b»=»BBB», «c»,»d»);

Функция compact() — «упаковывает» переменные и их значения в массив. В результате получается ассоциативный массив, ключами которого являются имена переменных, а значениями элементов — значения переменных. Например, имеем две переменные:

Функция compact(«Name», «Email») упакует переменные в один массив:

$A = compact («Name», «Email»); // получаем $A = array(«Name»=>» Вася «, «Email»=>»vasya@vvv.org»);

Функция extract() — противоположна функции compact() . Она действует «с точностью до наоборот», то есть создает переменные с именами, соответствующими именами ключей и присваивает им значения элементов массива. Распакуем массив:

В процессе распаковки может оказаться, что уже существует переменная с именем, как имя ключа в массиве $A. Для решения этой проблемы у функции extract() предусмотрен второй параметр, который позволяет определить поведение функции extract() в случае совпадения имен. Значение EXTR_OVERWRITE означает, что существующая переменная с именем ключа будет перезаписана, а EXTR_SKIP — пропущена:

$A = compact («Name», «Email»);

extract ($A, EXTR_OVERWRITE); //$Name = «Ivan» , так как мы указали EXTR_OVERWRITE

Значение EXTR_WRITE используется по умолчанию и может не указываться, т.е. достаточно указать extract($A) и все переменные будут перезаписаны.

Иногда нужно создать диапазон чисел, например, для нумерации записей в выбранной таблице. Пример создания диапазона чисел:

Данный цикл создает список, заполненный целыми числами от 10 до 100 включительно. В PHP можно обойтись проще — одним вызовом функции range(10,100).

Массивы

— это упорядоченная коллекция значений. Значения в массиве называются , и каждый элемент характеризуется числовой позицией в массиве, которая называется . Массивы в языке JavaScript являются нетипизированными: элементы массива могут иметь любой тип, причем разные элементы одного и того же массива могут иметь разные типы. Элементы массива могут даже быть объектами или другими массивами, что позволяет создавать сложные структуры данных, такие как массивы объектов и массивы массивов.

Читать:

Где номер двигателя citroen c4

Отсчет индексов массивов в языке JavaScript начинается с нуля и для них используются 32-битные целые числа — первый элемент массива имеет индекс 0. Массивы в JavaScript являются динамическими: они могут увеличиваться и уменьшаться в размерах по мере необходимости; нет необходимости объявлять фиксированные размеры массивов при их создании или повторно распределять память при изменении их размеров.

Массивы в языке JavaScript — это специализированная форма объектов, а индексы массивов означают чуть больше, чем просто имена свойств, которые по совпадению являются целыми числами.

Создание массивов

Легче всего создать массив с помощью литерала, который представляет собой простой список разделенных запятыми элементов массива в квадратных скобках. Значения в литерале массива не обязательно должны быть константами — это могут быть любые выражения, в том числе и литералы объектов:

var empty = []; // Пустой массив var numbers = [2, 3, 5, 7, 11]; // Массив с пятью числовыми элементами var misc = [ 1.1, true, "a", ]; // 3 элемента разных типов + завершающая запятая var base = 1024; var table = [base, base+1, base+2, base+3]; // Массив с переменными var arrObj = [[1,], [2, ]]; // 2 массива внутри, содержащие объекты

Синтаксис литералов массивов позволяет вставлять необязательную завершающую запятую, т.е. литерал [,,] соответствует массиву с двумя элементами, а не с тремя.

Другой способ создания массива состоит в вызове конструктора Array(). Вызвать конструктор можно тремя разными способами:

var arr = new Array();

var arr = new Array(10);

var arr = new Array(5, 4, 3, 2, 1, "тест");

Чтение и запись элементов массива

Доступ к элементам массива осуществляется с помощью оператора []. Слева от скобок должна присутствовать ссылка на массив. Внутри скобок должно находиться произвольное выражение, возвращающее неотрицательное целое значение. Этот синтаксис пригоден как для чтения, так и для записи значения элемента массива. Следовательно, допустимы все приведенные далее JavaScript-инструкции:

// Создать массив с одним элементом var arr = ["world"]; // Прочитать элемент 0 var value = arr[0]; // Записать значение в элемент 1 arr[1] = 3.14; // Записать значение в элемент 2 i = 2; arr[i] = 3; // Записать значение в элемент 3 arr[i + 1] = 'привет'; // Прочитать элементы 0 и 2, записать значение в элемент 3 arr[arr[i]] = arr[0];

Напомню, что массивы являются специализированной разновидностью объектов. Квадратные скобки, используемые для доступа к элементам массива, действуют точно так же, как квадратные скобки, используемые для доступа к свойствам объекта. Интерпретатор JavaScript преобразует указанные в скобках числовые индексы в строки — индекс 1 превращается в строку «1» — а затем использует строки как имена свойств.

В преобразовании числовых индексов в строки нет ничего особенного: то же самое можно проделывать с обычными объектами:

var obj = <>; // Создать простой объект obj[1] = "one"; // Индексировать его целыми числами

Особенность массивов состоит в том, что при использовании имен свойств, которые являются неотрицательными целыми числами, массивы автоматически определяют значение свойства length. Например, выше был создан массив arr с единственным элементом. Затем были присвоены значения его элементам с индексами 1, 2 и 3. В результате этих операций значение свойства length массива изменилось и стало равным 4.

Следует четко отличать индексы в массиве от имен свойств объектов. Все индексы являются именами свойств, но только свойства с именами, представленными целыми числами являются индексами. Все массивы являются объектами, и вы можете добавлять к ним свойства с любыми именами. Однако если вы затрагиваете свойства, которые являются индексами массива, массивы реагируют на это, обновляя значение свойства length при необходимости.

Обратите внимание, что в качестве индексов массивов допускается использовать отрицательные и не целые числа. В этом случае числа преобразуются в строки, которые используются как имена свойств.

Добавление и удаление элементов массива

Мы уже видели, что самый простой способ добавить элементы в массив заключается в том, чтобы присвоить значения новым индексам. Для добавления одного или более элементов в конец массива можно также использовать метод push():

var arr = []; // Создать пустой массив arr.push('zero'); // Добавить значение в конец arr.push('one',2); // Добавить еще два значения

Добавить элемент в конец массива можно также, присвоив значение элементу arr[arr.length]. Для вставки элемента в начало массива можно использовать метод unshift(), при этом существующие элементы в массиве смещаются в позиции с более высокими индексами.

Удалять элементы массива можно с помощью оператора delete, как обычные свойства объектов:

var arr = [1,2,'three']; delete arr[2]; 2 in arr; // false, индекс 2 в массиве не определен arr.length; // 3: оператор delete не изменяет свойство length массива

Удаление элемента напоминает (но несколько отличается) присваивание значения undefined этому элементу. Обратите внимание, что применение оператора delete к элементу массива не изменяет значение свойства length и не сдвигает вниз элементы с более высокими индексами, чтобы заполнить пустоту, оставшуюся после удаления элемента.

Кроме того имеется возможность удалять элементы в конце массива простым присваиванием нового значения свойству length. Массивы имеют метод pop() (противоположный методу push()), который уменьшает длину массива на 1 и возвращает значение удаленного элемента. Также имеется метод shift() (противоположный методу unshift()), который удаляет элемент в начале массива. В отличие от оператора delete, метод shift() сдвигает все элементы вниз на позицию ниже их текущих индексов.

Наконец существует многоцелевой метод splice(), позволяющий вставлять, удалять и замещать элементы массивов. Он изменяет значение свойства length и сдвигает элементы массива с более низкими или высокими индексами по мере необходимости. Все эти методы мы разберем чуть позже.

Многомерные массивы

JavaScript не поддерживает «настоящие» многомерные массивы, но позволяет неплохо имитировать их при помощи массивов из массивов. Для доступа к элементу данных в массиве массивов достаточно дважды использовать оператор [].

Например, предположим, что переменная matrix — это массив массивов чисел. Каждый элемент matrix[x] — это массив чисел. Для доступа к определенному числу в массиве можно использовать выражение matrix[x][y]. Ниже приводится конкретный пример, где двумерный массив используется в качестве таблицы умножения:

// Создать многомерный массив var table = new Array(10); // В таблице 10 строк for(var i = 0; i < table.length; i++) table[i] = new Array(10); // В каждой строке 10 столбцов // Инициализировать массив и вывести на консоль for(var row = 0, str = ''; row < table.length; row++) < for(var col = 0; col < table[row].length; col++) < table[row][col] = (row+1)*(col+1); str += table[row][col] + ' '; >console.log(str + '\n'); str = ''; >

Использование многомерных массивов в JavaScript

Методы класса Array

Стандарт ECMAScript 3 определяет в составе Array.prototype множество удобных функций для работы с массивами, которые доступны как методы любого массива. Эти методы будут представлены в следующих подразделах.

Метод join()

Метод Array.join() преобразует все элементы массива в строки, объединяет их и возвращает получившуюся строку. В необязательном аргументе методу можно передать строку, которая будет использоваться для отделения элементов в строке результата. Если строка-разделитель не указана, используется запятая. Например, следующий фрагмент дает в результате строку «1,2,3»:

var arr = [1,2,3]; arr.join(); // '1,2,3' arr.join("-"); // '1-2-3'

Метод reverse()

Метод Array.reverse() меняет порядок следования элементов в массиве на обратный и возвращает переупорядоченный массив. Перестановка выполняется непосредственно в исходном массиве, т.е. этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве. Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку «3,2,1»:

var arr = [1,2,3]; arr.reverse().join(); // "3,2,1"

Метод sort()

Метод Array.sort() сортирует элементы в исходном массиве и возвращает отсортированный массив. Если метод sort() вызывается без аргументов, сортировка выполняется в алфавитном порядке (для сравнения элементы временно преобразуются в строки, если это необходимо). Неопределенные элементы переносятся в конец массива.

Для сортировки в каком-либо ином порядке, отличном от алфавитного, методу sort() можно передать функцию сравнения в качестве аргумента. Эта функция устанавливает, какой из двух ее аргументов должен следовать раньше в отсортированном списке. Если первый аргумент должен предшествовать второму, функция сравнения должна возвращать отрицательное число. Если первый аргумент должен следовать за вторым в отсортированном массиве, то функция должна возвращать число больше нуля. А если два значения эквивалентны (т.е. порядок их следования не важен), функция сравнения должна возвращать 0:

var arr = [33, 4, 1111, 222]; arr.sort(); // Алфавитный порядок: 1111, 222, 33, 4 arr.sort(function(a,b) < // Числовой порядок: 4, 33, 222, 1111 return a-b; // Возвращает значение < 0, 0 или >0 // в зависимости от порядка сортировки a и b >); // Сортируем в обратном направлении, от большего к меньшему arr.sort(function(a,b) );

Обратите внимание, насколько удобно использовать в этом фрагменте неименованную функцию. Функция сравнения используется только здесь, поэтому нет необходимости давать ей имя.

Метод concat()

Метод Array.concat() создает и возвращает новый массив, содержащий элементы исходного массива, для которого был вызван метод concat(), и значения всех аргументов, переданных методу concat(). Если какой-либо из этих аргументов сам является массивом, его элементы добавляются в возвращаемый массив. Следует, однако, отметить, что рекурсивного превращения массива из массивов в одномерный массив не происходит. Метод concat() не изменяет исходный массив. Ниже приводится несколько примеров:

var arr = [1,2,3]; arr.concat(4, 5); // Вернет [1,2,3,4,5] arr.concat([4,5]); // Вернет [1,2,3,4,5] arr.concat([4,5],[6,7]) // Вернет [1,2,3,4,5,6,7] arr.concat(4, [5,[6,7]]) // Вернет [1,2,3,4,5,[6,7]]

Метод slice()

Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива. Два аргумента метода определяют начало и конец возвращаемого фрагмента. Возвращаемый массив содержит элемент, номер которого указан в первом аргументе, плюс все последующие элементы, вплоть до (но не включая) элемента, номер которого указан во втором аргументе.

Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой-либо из аргументов имеет отрицательное значение, он определяет номер элемента относительно конца массива. Так, аргументу -1 соответствует последний элемент массива, а аргументу -3 — третий элемент массива с конца. Вот несколько примеров:

var arr = [1,2,3,4,5]; arr.slice(0,3); // Вернет [1,2,3] arr.slice(3); // Вернет [4,5] arr.slice(1,-1); // Вернет [2,3,4] arr.slice(-3,-2); // Вернет [3]

Метод splice()

Метод Array.splice() — это универсальный метод, выполняющий вставку или удаление элементов массива. В отличие от методов slice() и concat(), метод splice() изменяет исходный массив, относительно которого он был вызван. Обратите внимание, что методы splice() и slice() имеют очень похожие имена, но выполняют совершенно разные операции.

Метод splice() может удалять элементы из массива, вставлять новые элементы или выполнять обе операции одновременно. Элементы массива при необходимости смещаются, чтобы после вставки или удаления образовывалась непрерывная последовательность.

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

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

var arr = [1,2,3,4,5,6,7,8]; arr.splice(4); // Вернет [5,6,7,8], arr = [1,2,3,4] arr.splice(1,2); // Вернет [2,3], arr = [1,4] arr.splice(1,1); // Вернет [4]; arr = [1] arr = [1,2,3,4,5]; arr.splice(2,0,'a','b'); // Вернет []; arr = [1,2,'a','b',3,4,5]

Методы push() и pop()

Методы push() и pop() позволяют работать с массивами как со стеками. Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() выполняет обратную операцию — удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание, что оба эти метода изменяют исходный массив, а не создают его модифицированную копию.

Методы unshift() и shift()

Методы unshift() и shift() ведут себя почти так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в конце. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места, добавляет элемент или элементы в начало массива и возвращает новую длину массива. Метод shift() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива.

Как удалить пустые элементы в php массиве вместе с ключами?

Нередко когда пишешь программные модули на php возникает необходимость почистить массив от пустых элементов, ненужных ключей, нулей и.т.д. Для этого в языке php есть функция array_diff которая сравнивает текущий массив с одним или несколькими другими массивами и возвращает значения из текущего php массива, которых нет (которые не найдены) во всех других массивах. Рассмотрим 2 примера удаления пустых ключей из массива:

Удаление из php массива элементов в нулями и null

Помогла ли вам статья?

351 раз уже помогла

Комментарии: (0) Написать комментарий

Объявить пустой массив php?

Как создать пустой массив в php

Массивы

Создание массивов

Чтение и запись элементов массива

Добавление и удаление элементов массива

Многомерные массивы

Методы класса Array

Метод join()

Метод reverse()

Метод sort()

Метод concat()

Метод slice()

Метод splice()

Методы push() и pop()

Методы unshift() и shift()

Как удалить пустые элементы в php массиве вместе с ключами?

Как удалить пустые элементы в php массиве вместе с ключами?

Удаление из php массива элементов в нулями и null

Удаление из php массива элементов в нулями и null

КАТЕГОРИИ

Похожие записи