Как проверить пустой ли массив php

Язык PHP: Массивы и списки

Для создания массива в php предусмотрена следующая конструкция:

$array = [1, 2, 3, 4, 5, 6]; 

Для объявления массивов используются квадратные скобки [ и ] .

Однако существует и старая конструкция для объявления массивов, более громоздкая и неудобная:

$array = array(1, 2, 3, 4, 5, 6); 

Вы также можете объявить именованный массив с ключами, через символ => :

$array = ['x' => 10, 'y' => 20, 'score' => 90]; 

Обращаться к элементам массива можно через квадратные скобки:

$array = ['x' => 10, 'y' => 20]; alert($array['x']); // выведет в сообщении 10. 

Как сделать цикл по массиву?

Простой способ перебора всех элементов массива.

Для этого в php есть специальный цикл foreach , который перебирает все элементы массива, например:

$array = [1, 2, 3, 4]; foreach ($array as $value)

Вы также можете перебирать массив вместе с его ключами:

$array = ['x' => 10, 'y' => 20, 'z' => 30]; foreach ($array as $key => $value)

foreach работает и для списков UI объектов, например для свойства ->items .

Как узнать количество элементов списка или массива?

Для этого используйте функцию count() , это очень просто:

$array = [1, 2, 3]; $result = count($array); 

Или для компонента список:

$result = count($this->listView->items); 

Как проверить, что массив пустой?

Для проверки на то что массив пустой, в php есть небольшое упрощение:

$array = []; if (!$array)

PHP умеет сам проверять, пустой массив или нет.

Осторожно, это не работает для списков-объектов, для них используйте count() == 0 .

Как сконвертировать массив в строку?

Описание функций по склейке массивов — join, implode и т.п.

Для того, чтобы сконвертировать массив в строку, есть класс php\lib\str и метод join :

use php\lib\str; $array = [1, 2, 3]; $message = str::join($array, '-'); alert($message); 

PHP API

Описание стандартных классов и функций php.

• IDE, Среда
• Переход с DevelStudio
• Переход с GameMaker
• Язык PHP
• Файловая система
• Дата и время
• UI, Дизайн
• JavaFX CSS
• Игры и развлечения
• Интернет и сети
• Аудио и видео
• Системные утилиты
• Лаунчеры и оболочки
• SQL, Базы данных
• Разное

Как проверить пустой ли массив php

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

Есть несколько способов определения массивов. Первый способ представляет использование функции array() :

$numbers = array();

В данном случае определяется пустой массив $numbers .

Второй способ представляет использование квадратных скобок [] :

$numbers = [];

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

$numbers = [1, 2, 3, 4];

Аналогичное определение массива с помощью функции array() :

$numbers = array(1, 2, 3, 4);

В качестве элементов массива могут выступать объекты любого типа.

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

Для обычных массивов ключ представляет число. Числовые ключи еще называют индексами. Нумерация индексов начинается с нуля, то есть первый элемент массива имеет индекс 0, второй элемент — индекс 1 и так далее.

Например, обратимся к третьему элементу массива:

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

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

При этом нужно учитывать количество элементов массива. Так, мы не можем обратиться к элементу с несуществующим индексом:

В данном случае в массиве $numbers всего 4 элемента, поэтому индексом последнего элемента будет 3. Таким образом, элемента с индексом 4 в массиве не существует, и при попытке получить его значение echo $numbers[4] PHP нам покажет предупреждение.

Тем не менее если мы хотим установить элемент по еще не существующему индексу, мы можем это сделать:

Здесь устанавливается элемент с индексом 5. После установки мы можем получать его значение. При этом элемента с индексом 4 по прежнему не существует.

Для добавления нового элемента в массив мы можем, как в примере выше, просто установить новый элемент по еще не установленному индексу. Но есть и другой способ:

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

Чтобы получить полное наглядное представление о том, как в конкретном массиве сопоставляются ключи и значения элементов, можно использовать функцию print_r , в которую в качестве параметра передается массив:

Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

Также следует отметить, что необязательно как-то специально инициализровать переменную массива — мы можем по ходу добавлять элементы в массив:

 20 [1] => 120 [2] => 720 ) ?>

Оператор =>

Оператор => позволяет сопоставить ключ с определенным значением. Хотя при определении массива выше нам не требовался подобный оператор, тем не менее мы можем его применять. Например, следующий массив:

$numbers = [1, 4, 9, 16];

Будет аналогичен следующему массиву:

$numbers = [0=>1, 1=>4, 2=>9, 3=>16]; // $numbers = array(0=>1, 1=>4, 2=>9, 3=>16);

Каждый элемент определяется в следующем формате: ключ => значение

В дальнейшем мы также можем обращаться к элементам этого массива.

Этот оператор может понадобится, если мы хотим переопределить порядок индексов. Так, по умолчанию нумеация индексов начинается с нуля и каждый следующий элемент имеет индекс предыдущего элемента + 1. Оператор => же позволяет определить свои индексы вручную для элементов, необязательно с нуля и необязательно по порядку:

$numbers = [1=> 1, 2=> 4, 5=> 25, 4=> 16]; echo $numbers[2]; // 4

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

$numbers = [4=> 16, 25, 36, 49, 64]; print_r($numbers);

В данном случае индексация начинается с числа 4 — это индекс элемента 16. Тогда для элемента 25 индексом будет число 5 и так далее.

Array ( [4] => 16 [5] => 25 [6] => 36 [7] => 49 [8] => 64 )

Перебор массива

Для перебора массива мы можем применять стандартный метод for :

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

Результат работы скрипта:

Tom Sam Bob Alice

Цикл foreach

Тем не менее выше использованный способ перебора не поможет, если индексы определяются вручную и отличаются они от соседних индексов не на единицу, а на произвольную величину. В этом случае мы можем использовать специальный цикл — foreach :

 "Tom", 4 => "Sam", 5 => "Bob", 21 => "Alice"]; foreach($users as $element) < echo "$element
"; > ?>

В цикле foreach из массива последовательно извлекаются все элементы, и их значение помещается в переменную, указанную после ключевого слова as . В данном случае в переменную $element по очереди помещаются все четыре значения из массива $users . Когда будет извлечен последний элемент из массива, цикл завершается.

В итоге мы получим тот же результат:

Tom Sam Bob Alice

Цикл foreach позволяет извлекать не только значения, но и ключи элементов:

 "Tom", 4 => "Sam", 5 => "Bob", 21 => "Alice"]; foreach($users as $key => $value) < echo "$key - $value
"; > ?>

Здесь при переборе элементов цикла в переменную $key будет передаваться ключ элемента, а в переменную $value — его значение.

Результат работы скрипта:

1 - Tom 4 - Sam 5 - Bob 21 - Alice

Как проверить пустой ли массив php

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

Объявление массива

Объявление массива имеет следующие формы записи:

// Полная форма var имяМассива: Array // Краткая форма var имяМассива: [Тип]

var numbers: [Int]

Здесь объявлен массив numbers, который хранит объекты типа Int .

Но просто объявить массив недостаточно. Его, как и любую другую переменную, надо инициализировать перед использованием. То есть определить для него начальное значение. Все значения, которые входят в массив, перечисляются в квадратных скобках: [элемент1, элемент2, элемент3, . ] . Например:

var numbers: [Int] = [1, 2, 3, 4, 5] var numbers2: Array = [1, 2, 3, 4, 5] print(numbers)

Здесь массивы numbers и numbers2 содержит по 5 элементов. Мы также можем при объявлении не указывать тип массива, в этом случае система сама выведет тип исходя из входящих в него элементов:

var numbers = [1, 2, 3, 4, 5]

Мы также можем определить пустой массив:

var numbers = [Int]() // или так var numbers2 : [Int] = [] print("В массиве numbers \(numbers.count) элементов") // В массиве numbers 0 элементов

В таком массиве будет 0 элементов. С помощью свойства count можно получить количество элементов в массиве.

Доступ к элементам массива

Каждый элемент в массиве имеет определенный индекс, по которому мы можем получить или изменить элемент:

var numbers = [11, 12, 13, 14, 15] print(numbers[0]) // 11 numbers[0] = 21 print(numbers[0]) // 21

Для обращения к элементу массива после названия массива в квадратных скобках используется индекс элемента: numbers[0]

В данном случае у нас пять элементов в массиве, индексация в массивах начинается с нуля, поэтому первый элемент всегда имеет индекс 0, а последний элемент в данном случае будет иметь индекс 4. Если же мы попытаемся обратиться к элементу с большим индексом, например:

print(numbers[5]) // ошибка

То мы получим ошибку.

Если нам надо изменить несколько элементов подряд, то мы можем использовать операцию последовательности для записи индексов:

var numbers = [5, 6, 7, 8, 3] numbers[1. 3] = [105, 106, 103] print(numbers) // 5, 105, 106, 103, 3

В данном случае выражение 1. 3 указывает на набор индексов от 1 до 3. И таким образом, элементам с этими индексами мы можем присвоить значения.

Размер массива

С помощью свойства count можно получить число элементов массива:

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] print("В массиве numbers \(numbers.count) элементов") // В массиве numbers 8 элементов

В дополнение к нему свойство isEmpty позволяет узнать, пуст ли массив. Если он пуст, то возвращается значение true :

var numbers: [Int] = [1, 4, 8] if numbers.isEmpty < print("массив пуст") >else

Перебор массива

С помощью цикла for можно перебрать элементы массива:

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] for i in numbers < print(i) // 1, 2, 3, 4, 5, 6, 7, 8, >

Перебор массива через индексы:

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] for i in 0 .. < numbers.count < print(numbers[i]) // 1, 2, 3, 4, 5, 6, 7, 8, >

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

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] numbers.forEach()

В данном случае передается анонимная функция, которая также с помощью функции print выводит значение элемента.

С помощью метода enumerated() можно одновременно получить индекс и значение элемента:

var names: [String] = [«Tom», «Alice», «Kate»] names.enumerated().forEach() for (index, value) in names.enumerated()

Создание массива из последовательности

Специальная форма инициализатора в качестве параметра принимает последовательность, из которой создается массив:

var numbers = Array (1. 5) // [1, 2, 3, 4, 5] var numbers2 = [Int] (3..<7) // [3, 4, 5, 6] print(numbers) // [1, 2, 3, 4, 5] print(numbers2) // [3, 4, 5, 6]

Еще одна форма инициализатора позволяет инициализировать массив определенным числом элементов одного значения:

var numbers = [Int] (repeating: 5, count: 3) // или так var numbers2 = Array (repeating: 5, count: 3) // эквивалентно массиву var numbers: [Int] = [5, 5, 5] print(numbers) // [5, 5, 5]

Однако стоит учитывать, что если подобным образом создается массив из объектов классов - ссылочных типов, то все элементы массива будут хранить ссылку на один и тот же элемент в памяти:

class Person < var name: String init(name: String)< self.name = name >> let tom = Person(name: "Tom") var people = Array (repeating: tom, count: 3) people[0].name = "Bob" for person in people < print(person.name) >// Bob // Bob // Bob

Сравнение массивов

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

var numbers: [Int] = [1, 2, 3, 4, 5] let nums = [1, 2, 3, 4, 5] if numbers == nums < print("массивы равны") >else

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

Копирование массива

Массив является значимым типом, поэтому при копировании одного массива в другой второй массив получает копию первого:

var numbers: [Int] = [1, 2, 3, 4, 5] var nums: [Int] = numbers nums[0] = 78 print(numbers) // [1, 2, 3, 4, 5] print(nums) // [78, 2, 3, 4, 5]

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

var numbers: [Int] = [1, 2, 3, 4, 5] var nums = numbers[1. 3] print(nums[1]) // 2 print(nums) // [2, 3, 4]

В данном случае в массив nums копируются элементы из numbers с 1 по 3 индексы. При этом первым индексом в массиве nums будет не 0, а 1, так как именно с этого индекса производится копирование из numbers.

Добавление в массив

Для добавления элемента в массив применяется метод append() :

var numbers = [8, 11, 13, 14] numbers.append(20) print(numbers) // 8, 11, 13, 14, 20

Другой метод insert() управляет вставкой элемента в определенное место массива:

var numbers = [8, 11, 13, 14] numbers.insert(10, at: 3) // вставка числа 10 на 3-й индекс print(numbers) // 8, 11, 13, 10, 14

Удаление из массива

Ряд операций позволяют удалять элемент:

• remove(at: index) : удаляет элемент по определенному индексу
• removeFirst() : удаляет первый элемент
• removeLast() : удаляет последний элемент
• dropFirst() : удаляет первый элемент
• dropLast() : удаляет последний элемент
• removeAll() : удаляет все элементы массива

var numbers = [8, 11, 13, 14] numbers.remove(at: 2) // удаляем 3-й элемент print(numbers) // 8, 11, 14

Разница между методами removeFirst/removeLast и dropFirst/dropLast заключается в том, что первые возвращают удаленный элемент, а вторые - модифицированный массив:

var numbers = [8, 11, 13, 14] var n = numbers.removeFirst() // 8 var subNumbers = numbers.dropFirst() print(subNumbers) // [13, 14]

И если из массива необходимо удалить все элементы, применяется метод removeAll() :

var numbers = [8, 11, 13, 14] numbers.removeAll() print(numbers) // []

Сортировка массива

Для сортировки массива применяется метод sort

var numbers: [Int] = [10, 4, 12, 1, 3] numbers.sort() print(numbers) // [1, 3, 4, 10, 12]

Если метод sort сортирует оригинальный массив, то метод sorted() возвращает новый отсортированный массив, никак не изменяя старый:

var numbers: [Int] = [10, 4, 12, 1, 3] var nums = numbers.sorted() print(nums) // [1, 3, 4, 10, 12]

Обе функции принимают параметр by , который задает принцип сортировки. Он представляет функцию, которая принимает два параметра. Оба параметра представляют тип элементов массива. На выходе функция возвращает объект Bool. Если это значение равно true, то первое значение ставится до второго, если false - то после.

var numbers: [Int] = [10, 4, 12, 1, 3] numbers.sort(by: $1>) print(numbers) // [12, 10, 4, 3, 1] var nums = numbers.sorted(by: <) print(nums) // [1, 3, 4, 10, 12]

Выражение $1> представляет анонимную функцию, которая возвращает true, если значение первого параметра меньше второго, то есть в данном случае сортировка в обратном порядке. Мы можем задать более сложную логику, но в данном случае мы просто сравниваем два значения, поэтому мы можем упрастить данный вызов: numbers.sort(by: >) и Swift опять же будет применять операцию > к обоим параметрам.

Объединение массивов

С помощью операции сложения можно объединить два однотипных массива:

var numbers1 = [5, 6, 7] var numbers2 = [1, 2, 3] var numbers3 = numbers1 + numbers2 print(numbers3) // 5, 6, 7, 1, 2, 3

Фильтрация массивов

Для фильтрации массива применяется метод filter() , который возвращает отфильтрованный массив. В качестве параметра метод принимает функцию - если перебирает все эелементы и возвращает значение типа Bool. Если это значение - true, то элемент попадает в отфильтрованный массив:

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.filter() print(filteredNums) // [2, 4, 6, 8]

В данном случае метод filter принимает анонимную функцию, которая возвращает результат условия $0 % 2==0 , то есть если число делится на 2 без остатка (четное), то оно попадает в отфильтрованный массив.

Еще один способ фильтрации представляет метод prefix() . Он также возвращает отфильтрованный массив, при этом он перебирает подряд все элементы, пока условие возвращает true. Условие задается с помощью параметра while, который представляет функцию, возвращающую значение Bool:

var numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.prefix(while: ) print(filteredNums) // [1, 2, 3, 4]

Противоположным образом работает метод drop() - он, наоборт, удаляет все элементы до того, пока они не станут соответствовать условию:

var numbers: [Int] = [1, 2, 5, 3, 4, 5, 6, 7, 8] var filteredNums = numbers.drop(while: ) print(filteredNums) // [5, 3, 4, 5, 6, 7, 8]

Причем удаляются именно первые элементы, пока не найдется элемент, который удовлетворяет условию.

Преобразование массива

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

var numbers: [Int] = [1, 2, 5, 3, 4, 5, 6, 7, 8] var mapedNums = numbers.map() print(mapedNums) // [1, 4, 25, 9, 16, 25, 36, 49, 64]

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

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

Выше мы использовали простые массивы, которые можно представить в виду строки или расположить в ряд:

var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

Но мы можем создавать более сложные массивы, которые в качестве элементов могут включать в себя другие массивы:

var table = [[1,2,3], [4,5,6], [7,8,9]] // получаем вторую строку var row2 = table[1] // [4,5,6] // получаем первый элемент второй строки var cell1 = row2[0] // 4 // получаем второй элемент первой строки var cell2 = table[0][1] // 2

Внутри массива у нас три подмассива. Фактически данный массив можно представить как таблицу, в которой 3 строки. Выражение table[1] позволяет получить второй элемент - второй подмассив. А выражение row2[0] возвращает первый элемент этого подмассива.

Либо мы можем использовать набор квадратных скобок для доступа к элементам внутри подмассивов: table[0][1]

Подобным образом можно изменять элементы массива

// изменим вторую строку table[1] = [16, 25, 36] // изменим второй элемент первой строки table[0][1] = -12

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

// перебор по строкам for row in table < print(row) >// перебор таблицы по строкам и столбцам for row in table < for cell in row< print(cell) >>