Массивы и объекты в JavaScript: в чем разница и что выбрать

Берите массив для упорядоченного списка, объект – для записи с именованными полями. Map подходит для словаря с ключами любых типов, Set – для уникальных значений. Массивы и объекты в JavaScript связаны наследованием, но по-разному работают с индексами, length и перебором. Разберитесь в этих отличиях, чтобы выбрать структуру под задачу и не потерять данные из-за «дыр» или лишних свойств.

Чем массив отличается от объекта

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

ХарактеристикаМассив ArrayОбычный объект Object
КлючиИндексы от 0; также возможны строковые и символьные свойстваСтроки и символы; числовой ключ превращается в строку
ПорядокИндексы задают позиции элементовПорядок собственных ключей задают правила языка, но объект не описывает список
lengthСпециальное свойство, связанное с индексами; оно может превышать число элементовАвтоматического счетчика нет; свойство length можно создать вручную
Методыpush, pop, map, filter, find и другие методы Array.prototypeДля ключей и значений используют статические методы Object
Проверка типаArray.isArray(value)Проверка зависит от задачи и прототипа
Переборfor...of, forEach и методы массиваObject.keys, Object.values, Object.entries
Сериализация в JSONJSON-массив в квадратных скобках; именованные свойства игнорируютсяJSON-объект в фигурных скобках; учитываются собственные перечисляемые строковые свойства

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

const products = ["чай", "кофе"];
const product = { title: "чай", price: 250 };

console.log(products[0]); // → "чай"
console.log(product.title); // → "чай"
console.log(JSON.stringify(products)); // → '["чай","кофе"]'
console.log(JSON.stringify(product)); // → '{"title":"чай","price":250}'

Объект товара удобно хранить внутри массива товаров. Эти структуры дополняют друг друга, поэтому выбирать одну структуру для всего проекта не нужно.

Запускайте листинги по отдельности в консоли браузера. Откройте инструменты разработчика через контекстное меню страницы и перейдите на вкладку Console.

Повторное объявление одинаковой переменной через const в одной консоли может вызвать SyntaxError (зависит от браузера), поэтому используйте отдельные вкладки или меняйте имена переменных.

Сохраните пример в файл example.js и выполните его через Node.js:

node example.js

Комментарии после // → показывают ожидаемый результат. Консоль может иначе оформить кавычки и отступы, сохранив сами значения.

Массив – это тоже объект

Массив относится к объектам, поэтому typeof [] возвращает "object". При этом Array хранит специальную связь между индексами и свойством length.

У массива из литерала цепочка прототипов выглядит так:

arr → Array.prototype → Object.prototype → null

JavaScript ищет свойство сначала в самом объекте, затем в его прототипе. Значение null завершает цепочку.

const arr = [1, 2];

console.log(typeof arr); // → "object"
console.log(Object.getPrototypeOf(arr) === Array.prototype); // → true
console.log(Object.getPrototypeOf(Array.prototype) === Object.prototype); // → true
console.log(Object.getPrototypeOf(Object.prototype)); // → null

Object.prototype – прототип объекта Array.prototype. Это связь наследования, которую показывает Object.getPrototypeOf, а не значение свойства prototype внутри Array.prototype.

Почему toString возвращает разные результаты

Обычный объект наследует toString от Object.prototype. Массив получает свою реализацию из Array.prototype и обычно соединяет элементы запятыми.

const person = { name: "Анна" };
const names = ["Анна", "Иван"];

console.log(person.toString()); // → "[object Object]"
console.log(names.toString()); // → "Анна,Иван"
console.log(Object.prototype.toString.call(names)); // → "[object Array]"

person.toString = function () {
  return this.name;
};

console.log(person.toString()); // → "Анна"

Собственный метод person.toString перекрывает унаследованный метод. Прототип объекта при этом не меняется.

Подробности о наследуемых методах есть в справочниках MDN по Array и Object.

Как проверить, массив перед вами или объект

Используйте Array.isArray, когда функция должна принять именно массив. Метод отличает Array от обычного объекта, строки и null.

console.log(Array.isArray([1, 2])); // → true
console.log(Array.isArray({ 0: "чай", length: 1 })); // → false
console.log(Array.isArray(null)); // → false

console.log(typeof []); // → "object"
console.log(typeof {}); // → "object"
console.log(typeof null); // → "object"

Объект с индексами и length может выглядеть как массив. Эти свойства сами по себе не превращают его в Array.

Почему instanceof Array подходит не всегда

Оператор instanceof ищет прототип конструктора в цепочке объекта. У другого окна или iframe есть собственный конструктор Array, поэтому настоящий массив из другого контекста может не пройти такую проверку.

const frame = document.createElement("iframe");
document.body.appendChild(frame);

const ForeignArray = frame.contentWindow.Array;
const foreignList = new ForeignArray(1, 2);

console.log(foreignList instanceof Array); // → false
console.log(Array.isArray(foreignList)); // → true

frame.remove();

Array.isArray распознает массив независимо от контекста создания.

Используйте его для входных данных функции или библиотеки.

Как проверить простой объект

Для локальных записей простым объектом можно считать значение с прототипом Object.prototype или null. Такая проверка исключает массивы, даты и экземпляры пользовательских классов.

function isPlainObject(value) {
  if (value === null || typeof value !== "object") return false;

  const proto = Object.getPrototypeOf(value);
  return proto === Object.prototype || proto === null;
}

console.log(isPlainObject({ name: "Анна" })); // → true
console.log(isPlainObject(Object.create(null))); // → true
console.log(isPlainObject([])); // → false
console.log(isPlainObject(new Date())); // → false

Проверка прототипа зависит от текущего контекста. Объект из другого iframe она отклонит.

Как работает length у массива

Свойство length задает границу индексированной последовательности. У плотного массива длина совпадает с числом элементов.

Запись по индексу за текущей границей увеличивает длину до индекса плюс 1. Индекс 9 увеличит длину массива с 2 до 10.

const groceries = ["хлеб", "молоко"];
console.log(groceries.length); // → 2

groceries[9] = "чай";

console.log(groceries.length); // → 10
console.log(Object.keys(groceries)); // → ["0", "1", "9"]
console.log(groceries[2]); // → undefined
console.log(2 in groceries); // → false

Позиции от 2 до 8 остались пустыми. Такой массив называют разреженным.

Формула «максимальный индекс плюс 1» описывает длину после записи по индексу. Ручное присваивание тоже может увеличить length: new Array(5) создает длину 5 без элементов.

Как методы видят дырки

forEach пропускает пустые позиции. map тоже пропускает их и сохраняет пустые позиции результата.

for...of проходит все позиции и получает undefined.

const sparse = [10, , 30];
const visited = [];

sparse.forEach((value, index) => visited.push(index));
console.log(visited); // → [0, 2]

const doubled = sparse.map(value => value * 2);
console.log(doubled.length); // → 3
console.log(Object.keys(doubled)); // → ["0", "2"]
console.log(1 in doubled); // → false

const values = [];
for (const value of sparse) values.push(value);
console.log(values); // → [10, undefined, 30]

Явное значение undefined отличается от отсутствующего свойства. Обработчики forEach и map посещают элемент с таким значением.

Как посчитать существующие элементы

Для обычного разреженного массива используйте filter(() => true).length. Метод пропустит дырки и сохранит существующие элементы, включая undefined.

const items = ["чай", , undefined];
items.sorted = true;

console.log(items.length); // → 3
console.log(items.filter(() => true).length); // → 2
console.log(Object.keys(items).length); // → 3

Object.keys посчитает также свойство sorted. Поэтому этот метод подходит только после отбора индексных ключей.

function countOwnElements(array) {
  let count = 0;
  for (let i = 0; i < array.length; i++) {
    if (Object.prototype.hasOwnProperty.call(array, i)) count++;
  }
  return count;
}

console.log(countOwnElements(["чай", , undefined])); // → 2

Цикл учитывает только собственные индексированные свойства.

Для коллекции с разреженными ключами используйте Map: его size показывает число записей.

Что произойдет при изменении length

Уменьшение length удаляет элементы с индексами от нового значения и выше.

const list = ["а", "б", "в", "г"];

list.length = 2;
console.log(list); // → ["а", "б"]
console.log(list[2]); // → undefined

list.length = 4;
console.log(list.length); // → 4
console.log(2 in list); // → false

Увеличение длины создает пустые позиции и не восстанавливает удаленные значения.

Перед обрезкой сохраните копию через slice(), если данные еще пригодятся.

Неиндексированные свойства у массива

Массив допускает именованные свойства, как обычный объект. Они не входят в индексированную последовательность и не увеличивают length.

const groceries = ["хлеб", "молоко"];
groceries.sorted = true;
groceries["authored by"] = "Анна";

console.log(groceries.length); // → 2
console.log(Object.keys(groceries));
// → ["0", "1", "sorted", "authored by"]

const keys = [];
for (const key in groceries) keys.push(key);
console.log(keys); // → ["0", "1", "sorted", "authored by"]

console.log(JSON.stringify(groceries)); // → '["хлеб","молоко"]'

Перечисляемые свойства видят Object.keys и for...in, но сериализация массива их игнорирует.

Дополнительные данные могут исчезнуть при отправке JSON.

const groceries = ["хлеб", "молоко"];
Object.defineProperty(groceries, "sorted", {
  value: false,
  enumerable: false,
  configurable: true,
  writable: true
});

console.log(groceries.sorted); // → false
console.log(Object.keys(groceries)); // → ["0", "1"]

Не храните служебные поля прямо на массиве: разные способы обработки видят их по-разному.

Оберните список в объект с отдельными полями.

const shopping = {
  items: ["хлеб", "молоко"],
  sorted: false,
  author: "Анна"
};

console.log(shopping.items.length); // → 2
console.log(shopping.author); // → "Анна"

Как перебирать массивы и объекты

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

const prices = [100, 250, 400];

for (const price of prices) {
  if (price > 200) {
    console.log(price); // → 250
    break;
  }
}

prices.forEach((price, index) => {
  console.log(index, price);
});
// → 0 100
// → 1 250
// → 2 400

console.log(prices.map(price => price * 2)); // → [200, 500, 800]
console.log(prices.filter(price => price > 200)); // → [250, 400]
console.log(prices.find(price => price > 200)); // → 250

Используйте map для преобразования каждого элемента, filter для отбора, find для первого совпадения.

Метод entries() возвращает пары «индекс – значение».

Почему for...in не подходит для массива

for...in перебирает перечисляемые строковые свойства, включая унаследованные. Дополнительное поле массива тоже попадет в обход.

const items = ["чай"];
items.note = "купить сегодня";

for (const key in items) {
  console.log(key, typeof key);
}
// → "0" "string"
// → "note" "string"

for (const value of items) {
  console.log(value); // → "чай"
}

Используйте for...of, когда нужны значения списка. for...in оставьте для намеренного перебора свойств.

Как получить ключи и значения объекта

Object.keys возвращает ключи, Object.values – значения, Object.entries – пары. Методы учитывают собственные перечисляемые строковые свойства.

const product = { title: "чай", price: 250 };

console.log(Object.keys(product)); // → ["title", "price"]
console.log(Object.values(product)); // → ["чай", 250]

for (const [key, value] of Object.entries(product)) {
  console.log(key, value);
}
// → "title" "чай"
// → "price" 250

Обычный объект не поддерживает for...of напрямую. Сначала получите пары через Object.entries.

В каком порядке идут ключи объекта

Целочисленные строковые ключи идут первыми по возрастанию. Затем следуют остальные строки и символы в порядке создания.

const marker = Symbol("marker");
const data = {};
data.b = "буква";
data[10] = "десять";
data[2] = "два";
data.a = "еще буква";
data[marker] = "метка";

console.log(Object.keys(data)); // → ["2", "10", "b", "a"]
console.log(Reflect.ownKeys(data));
// → ["2", "10", "b", "a", Symbol(marker)]

Reflect.ownKeys возвращает собственные ключи, включая символы и неперечисляемые свойства.

Для единого порядка добавления любых ключей используйте Map.

Как превратить объект в массив и обратно

Сначала решите, что должен сохранить массив: ключи, значения или пары. Пары сохраняют соответствие ключа и значения.

Object.entries и Object.fromEntries

Object.entries создает массив пар, а Object.fromEntries собирает объект из последовательности пар.

const stock = { tea: 3, coffee: 5 };
const pairs = Object.entries(stock);

console.log(pairs); // → [["tea", 3], ["coffee", 5]]

const restored = Object.fromEntries(pairs);
console.log(restored.tea); // → 3

const indexed = Object.fromEntries(["чай", "кофе"].entries());
console.log(indexed); // → { "0": "чай", "1": "кофе" }

Преобразование не сохраняет прототип и дескрипторы исходного объекта. Символьные и неперечисляемые свойства тоже не попадут в Object.entries.

Когда нужен Array.from

Array.from создает массив из перебираемого или массивоподобного значения. Массивоподобный объект содержит числовые позиции и свойство length.

const arrayLike = { 0: "чай", 1: "кофе", length: 2 };

console.log(Array.from(arrayLike)); // → ["чай", "кофе"]
console.log(Array.from({ title: "чай" })); // → []
console.log(Array.from(new Set([1, 1, 2]))); // → [1, 2]

const sparse = [1, , 3];
const dense = Array.from(sparse);
console.log(dense); // → [1, undefined, 3]
console.log(1 in dense); // → true

При копировании разреженного массива Array.from превращает дырки в явные значения undefined. Поэтому результат отличается от результата map.

Как собрать словарь и группы по ключу

Массив удобен для списка и последовательного поиска.

Для повторного доступа по идентификатору постройте словарь.

const users = [
  { id: 7, name: "Анна", role: "editor" },
  { id: 12, name: "Иван", role: "author" },
  { id: 15, name: "Олег", role: "editor" }
];

console.log(users.find(user => user.id === 12).name); // → "Иван"

const byId = Object.fromEntries(
  users.map(user => [user.id, user])
);
console.log(byId[12].name); // → "Иван"
console.log(Object.keys(byId)); // → ["7", "12", "15"]

const byRole = users.reduce((groups, user) => {
  const key = user.role;
  if (!groups[key]) groups[key] = [];
  groups[key].push(user);
  return groups;
}, Object.create(null));

console.log(byRole.editor.map(user => user.name)); // → ["Анна", "Олег"]

Словарь byId хранит одну запись на идентификатор. При повторе последняя запись заменит предыдущую.

Object.create(null) создает словарь без унаследованных свойств. Это исключает столкновение групп с именами вроде toString.

Когда брать массив, когда объект, а когда Map или Set

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

ЗадачаЧто выбратьПочему
Упорядоченный список товаров, задач или сообщенийArrayИндексы задают позиции; методы массива обрабатывают список
Запись с полями name, price, statusObjectИмена свойств описывают смысл значений
Словарь с добавлением и удалением записейMapМетоды set, get, has, delete и свойство size описывают коллекцию
Ключи-объекты или другие нестроковые ключиMapКлюч сохраняет свой тип и идентичность
Уникальные значенияSetКоллекция исключает повторы и поддерживает метод has

Map сохраняет типы ключей

Map принимает ключи любых типов. Число 7 и строка "7" обозначают разные записи.

const dictionary = new Map();
const user = { id: 7 };

dictionary.set(7, "число");
dictionary.set("7", "строка");
dictionary.set(user, "объект");

console.log(dictionary.get(7)); // → "число"
console.log(dictionary.get("7")); // → "строка"
console.log(dictionary.get(user)); // → "объект"
console.log(dictionary.get({ id: 7 })); // → undefined
console.log(dictionary.size); // → 3

console.log(dictionary.delete("7")); // → true
console.log(dictionary.size); // → 2

Map перебирает записи в порядке добавления.

Объект с такими же полями не заменяет исходный объект-ключ, потому что это другая ссылка. Методы коллекции описаны в справочнике MDN по Map.

Set исключает повторяющиеся значения

Set хранит уникальные значения в порядке добавления. Коллекция подходит для набора тегов или списка обработанных идентификаторов.

const tags = new Set(["js", "css", "js"]);

console.log(tags.size); // → 2
console.log(tags.has("js")); // → true

tags.add("html");
console.log([...tags]); // → ["js", "css", "html"]

const first = { id: 1 };
const second = { id: 1 };
console.log(new Set([first, first, second]).size); // → 2

Set сравнивает объекты по ссылке, поэтому одинаковые поля не устраняют повторы.

Для уникальности пользователей по id используйте этот идентификатор как ключ Map. Подробности есть в справочнике MDN по Set.

Map и Set не превращаются в содержательный JSON автоматически. Перед передачей преобразуйте их в массивы: [...map] даст пары, [...set] – значения.

const map = new Map([["tea", 3]]);
const set = new Set(["js", "css"]);

console.log(JSON.stringify(map)); // → "{}"
console.log(JSON.stringify([...map])); // → '[["tea",3]]'
console.log(JSON.stringify([...set])); // → '["js","css"]'

Совет от нашей редакции: сначала запишите, как код получает нужное значение. Доступ по позиции подсказывает массив, по имени поля – объект, по произвольному ключу – Map. Требование уникальности ведет к Set.

Комментарии

Оставьте свой комментарий
Пока никто не оставил комментариев