Как обозначить пустой массив в условии? — efim360.ru

Есть два массива (полный и пустой):

var massiv1 = [1, 2, 3, 4, 5] // полный массив
var massiv2 = []              // пустой массив
Полный и пустой массивы — JavaScript

На пустоту массива влияет значение его «длины». Давайте взглянем на стандарт ECMAScript, где описано это свойство у экземпляров класса Array.

Стандарт ECMAScript — свойства экземпляров Array

 

То есть у каждого массива есть своё собственное значение длины — свойство «length«. Если массив пустой, то у него нет элементов, а значит и длина такого массива равна 0.

massiv1.length // вернётся 5
massiv2.length // вернётся 0
Разные длины массивов — JavaScript

 

Решение задачи — написание условия пустоты массива

Решение вопроса сводится к тому, чтобы отлавливать массивы длиной 0. То есть наше условие будет выглядеть примерно так:

arr.length == 0

Мы не присваиваем ноль, а сравниваем с нулём — поэтому два знака равенства.

 

Как это выглядит в блоке IF?

В блоке IF срабатывает приведение к логическому типу, если мы передаём в него числовое значение (целое).

Длина массива — это всегда целое число. Не важно 0 это, или что-то большее.

В итоге мы можем просто записать выражение arr.length без сравнивания с нулём.

if(arr.length){
  console.log("В массиве есть элементы")
}else{
  console.log("Массив пустой")
}

Скриншот работы из консоли браузера:

Условие пустоты массива в JavaScript

Оба выражения [].length и [1,2,3].length неявно приводятся к логическому типу внутри круглых скобок оператора if.

Мы можем увидеть это при создании логического объекта через конструктор класса Boolean.

  • Boolean([].length)
  • Boolean([1,2,3].length)
Приведение длины массива к логическому типу через класс Boolean в JavaScript

 

 

Функция, которая проверяет массив на пустоту

Напишем функцию, которая будет проверять массив на пустоту и возвращать соответствующее сообщение в консоль браузера:

function is_arr_0 (arr){return !Boolean(arr. length)}

В этом случае нам нужно применить отрицание в виде восклицательного знака, чтобы поменять ИСТИНУ на ЛОЖЬ или наоборот ЛОЖЬ на ИСТИНУ т. к. мы хотим понять пустой ли он или нет.

Если вернётся TRUE — значит массив пустой. Если вернётся FALSE — значит массив полный.

Пример работы:

Функция проверки массива на пустоту — JavaScript возвращает логический тип

Или с выводом в консоль

function massiv_pustoi_ili_net (arr){
   arr.length == 0 ? console.log("Массив пустой") : console.log("В массиве есть элементы")
}
Функция проверки массива на пустоту — JavaScript

Мы использовали «тернарный оператор» JavaScript. Он работает так:

  1. Условие
  2. Знак вопроса «?»
  3. Действие если условие истинно — TRUE
  4. Знак двоеточия «:»
  5. Действие если условие ложно — FALSE

 

Теперь при помощи этой функции мы будем получать результат полноты/пустоты массива.

Передадим в функцию massiv1:

massiv_pustoi_ili_net (massiv1)
Ответ консоли — массив полный — JavaScript

Передадим в функцию massiv2:

massiv_pustoi_ili_net (massiv2)
Ответ консоли — массив пустой — JavaScript

 

Итог

Мы выполнили задачу и научились обозначать пустоту массивов в условии.

 

Информационные ссылки

Стандарт ECMAScript — https://tc39.es/ecma262/multipage/

JavaScript | Массивы (Array)

JavaScript | Как уменьшить длину массива?

JavaScript | Как увеличить длину массива?

JavaScript | Как изменить длину массива?

javascript — Как просто заполнить пустой массив данными в цикле?

То, что в PHP называется массивами, в JSON делится на две части: массивы [] и объекты {}. Массив — это такая коллекция элементов, где для доступа к элементам используется порядковый номер

(индекс) элемента. Объект — это такая коллекция элементов, где для доступа к элементам используется строковое имя (свойство объекта) элемента. В PHP и то и другое — есть массивы. Поэтому, в JS массивы и объекты управляются немного по-разному.

Аналогом циклов PHP

foreach($array as $item){ 
  /* Тут в $array будет ссылка на массив
         в $item будет копия текущего элемента */
}
foreach($array as $index => $item){ 
  /* Тут в $array будет ссылка на массив
         в $index будет индекс или ключ элемента
         в $item будет копия текущего элемента */
}

в JS будет для массивов:

for(const item of array){
  /* Тут в array будет ссылка на массив
         в item будет ссылка на текущий элемент */
}
for(const [index, item] of array.entries()){
  /* Тут в array будет ссылка на массив
         в item будет ссылка на текущий элемент 
         в index будет индекс элемента */
}

и для объектов:

for(const [propertyKey, propertyValue] of Object.entries(object)){
  /* Тут в object будет ссылка на объект
         в propertyKey будет название текущего свойства
         в propertyValue будет значение текущего свойства */
}

Приведу пример.

Чтобы создать объект со структурой JSON как здесь:

{"menu": {
  "id": "file",
  "value": "File",
  "popup": {
    "menuitem": [
      {"value": "New", "onclick": "CreateNewDoc()"},
      {"value": "Open", "onclick": "OpenDoc()"},
      {"value": "Close", "onclick": "CloseDoc()"}
    ]
  }
}}

можно просто сгенерировав такой код:

const header = {"menu": {
  "id": "file",
  "value": "File",
  "popup": {
    "menuitem": [
      {"value": "New", "onclick": "CreateNewDoc()"},
      {"value": "Open", "onclick": "OpenDoc()"},
      {"value": "Close", "onclick": "CloseDoc()"}
    ]
  }
}}

Либо, если json находится в строке, можно использовать JSON.parse()

 
const header = JSON.parse('{"menu":{"id":"file","value":"File",\
"popup":{"menuitem":[{"value":"New","onclick":"CreateNewDoc()"},\
{"value":"Open","onclick":"OpenDoc()"},\
{"value":"Close","onclick":"CloseDoc()"}]}}}')

Либо, если генерировать объект частями, формально эквивалентно предыдущим вариантам будет такой:

const header = {};
header. menu = {};
header.menu.id = "file";
header.menu.value = "File";
header.menu.popup = {};
header.menu.popup.menuitem = [];
header.menu.popup.menuitem[0] = {};
header.menu.popup.menuitem[0].value = "New";
header.menu.popup.menuitem[0].onclick = "CreateNewDoc()";
header.menu.popup.menuitem[1] = {};
header.menu.popup.menuitem[1].value = "Open";
header.menu.popup.menuitem[1].onclick = "OpenDoc()";
header.menu.popup.menuitem[2] = {};
header.menu.popup.menuitem[2].value = "Close";

javascript — Как проверить, пуст ли массив или не существует?

Вы хотите сначала проверить undefined . Если вы сделаете это наоборот, это сгенерирует ошибку, если массив не определен.

 если (массив === не определено || array.length == 0) {
    // массив не существует или пуст
}

Обновление

Этот ответ привлекает достаточно внимания, поэтому я хотел бы отметить, что мой первоначальный ответ больше, чем что-либо еще, касался неправильного порядка оценивания условий в вопросе.

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

Надежный подход
Вдохновленный комментариями, ниже я привожу то, что в настоящее время считаю надежным способом проверки того, является ли массив пустым или не существует. Также учитывается, что переменная может ссылаться не на массив, а на объект другого типа со свойством length .

 if (!Array.isArray(массив) || !array.length) {
  // массив не существует, не является массивом или пуст
  // ⇒ не пытаться обрабатывать массив
}

Чтобы разбить его:

  1. Array.isArray() , что неудивительно, проверяет, является ли его аргумент массивом. Это отсеивает такие значения, как null , undefined и все остальное, что не является массивом.
    Обратите внимание, что это также устранит массивоподобных объектов , таких как объект аргументов и объекты DOM NodeList . В зависимости от вашей ситуации, это может быть не то поведение, которое вам нужно.

  2. Условие array.length проверяет, соответствует ли свойство length переменной истинному значению . Поскольку предыдущее условие уже установило, что мы действительно имеем дело с массивом, более строгие сравнения, такие как array.length != 0 или array.length !== 0 , здесь не требуются.

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

В таких случаях я предпочитаю следующий, более идиоматический JavaScript:

 if (!array || !array.length) {
    // массив или array.length ошибочны
    // ⇒ не пытаться обрабатывать массив
}

Или, чаще, наоборот:

 if (array && array. length) {
    // массив и array.length верны
    // ⇒ вероятно, можно обработать массив
}

С введением в ECMAScript 2020 необязательного оператора цепочки (оператор Элвиса) его можно сократить еще больше:

 если (!массив?.длина) {
    // массив или array.length ошибочны
    // ⇒ не пытаться обрабатывать массив
}

Или наоборот:

 if (массив?.длина) {
    // массив и array.length верны
    // ⇒ вероятно, можно обработать массив
}

5 способов проверить, пуст ли массив Javascript | by Miroslav Šlapka

plus Совет по Typescript

Photo by Pawel Czerwinski на Unsplash

Я кратко опишу, что такое массив Javascript (JS), как мы его используем, а затем я опишу, как мы можем проверить, пуст ли он. Есть и другие способы сделать это, поэтому я буду описывать их постепенно, так как язык JS развивается, и теперь у нас есть лучшие и более краткие способы сделать это. Если вы работаете с Typescript (TS), есть интересный и более надежный способ проверки пустых массивов.

Массивы JS служат для хранения нескольких значений в списке. Массив JS — это подтип объекта JS. Это означает, что он каким-то образом расширяет поведение JS-объекта. Буквальный синтаксис массива использует квадратные скобки:

 let myArray = []

, а объект использует фигурные скобки:

 let myObject = {}

Массивы JS используют числовые индексы, начиная с индекса 0 . У них также есть свойство length , что говорит само за себя. Вот пример: 9( числа, строки, объекты и т. д.) Вот как мы можем получить доступ к отдельным значениям:

 myArray[0] 
 // 1myArray[2] 
 // 'яблоко'

Предостережение

Существуют так называемые «пустые слоты в массивах JS.

Если вы назначаете индекс массива более чем на одну позицию за текущим концом массива, JS оставит промежуточные слоты «пустыми», а не автоматически присвоит им значение undefined, как вы могли ожидать.

Учитывая массив, который мы определили выше, мы могли бы сделать следующее:

 myArray[10] = 'carrot' 
 myArray.length 
 // 11

Все остальные позиции были бы неопределенными.

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

Опишем 5 способов проверки того, что массив JS пуст и существует ли он.

1. Свойство длины

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

 myArray.length ? true : false

Это вернет false, если длина равна 0. Что если, например, myArray не определено? Или что, если вместо мы получим null , потому что значение поступает из бэкенда? Нам нужно убедиться, что myArray существует, иначе мы получим следующую ошибку:

Uncaught TypeError: Cannot read properties of undefined (чтение «длина»)

2.

Оператор And (&&) и длина

Мы можем использовать оператор && , чтобы избежать предыдущей ошибки.

 myArray && myArray.length ? true : false

Это хорошо, но есть более короткий путь с использованием необязательного оператора цепочки .? .

3. Необязательная цепочка (.?)

Вместо использования оператора && для проверки существования myArray и одновременного наличия свойства length мы можем написать:

 myArray?.length ? правда : ложь

Говоря об операторах, я хотел бы упомянуть также оператор объединения Nullish (??). Наш массив также содержит объект, поэтому мы можем проверить его свойство.

 let myArray = [1, 245, 'яблоко', {тип: 'фрукт'}] 
 myArray?.[3]?.type ?? 'No type property' 
 // 'fruit'

Мы получаем то, что оцениваем слева, если это правда, иначе мы получаем то, что находится справа от ?? .

4. Логическое НЕ(!)

Смотря что вам действительно нужно, а тут другой способ. Логический оператор not инвертирует значения. Следующее вернет true в случае, если myArray пуст, то есть [] или undefined или null .

 !myArray?.length ? true : false

5. Метод isArray()

Как мы действительно узнаем, работаем ли мы с массивом? Свойство длины существует также в строке. Мы могли бы использовать метод isArray():

 let myArray = [1, 245, 'apple', { type: 'fruit' }]Array.isArray(myArray) 
 // true

Очевидно, вы можете комбинировать подходы, перечисленные выше. . Например:

 if (Array.isArray(myArray) && myArray.length) { 
 // массив существует и не пуст 
 }

Я рекомендую прочитать эту статью Луки Дель Пуппо, чтобы увидеть, как работает приведенный ниже фрагмент.

 интерфейс экспорта NonEmptyArray extends ReadonlyArray { 
 // tslint:disable-next-line: readonly-keyword 
 0: A; 
 } 
 type ReadOnlyNotEmptyArray = Readonly>; function isNotEmptyArray(as: T[]): as NotEmptyArray { 
 возврат as.
No related posts.