Массивы и объекты в 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 |
| Сериализация в JSON | JSON-массив в квадратных скобках; именованные свойства игнорируются | 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 → nullJavaScript ищет свойство сначала в самом объекте, затем в его прототипе. Значение 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)); // → nullObject.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); // → 3Object.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, status | Object | Имена свойств описывают смысл значений |
| Словарь с добавлением и удалением записей | 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); // → 2Map перебирает записи в порядке добавления.
Объект с такими же полями не заменяет исходный объект-ключ, потому что это другая ссылка. Методы коллекции описаны в справочнике 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); // → 2Set сравнивает объекты по ссылке, поэтому одинаковые поля не устраняют повторы.
Для уникальности пользователей по 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.
Популярное за неделю
- Как создать сайт самому в 2026: 4 способа + пошаговая инструкция 34 мин чтения
- Лучшие конструкторы для создания сайтов — плюсы, минусы и сравнения 22 мин чтения
- Как создать скрипт сокращения ссылок на PHP 3 мин чтения
- js переход на другую страницу: методы, примеры и сравнение 5 мин чтения
- Фотогалерея для сайта: способы реализации и рабочий код 11 мин чтения
- 15 плагинов календарей и событий для сайта 9 мин чтения
Комментарии