Что такое массив в JavaScript

Ну ты представляешь, этот JavaScript, он такой, блядь, хитрая жопа. Вот берёшь ты массив — а это, по сути, просто упорядоченная куча всего подряд, пронумерованная с нуля, как будто ты в очереди за колбасой в девяностые встал. В Node.js это, конечно, объекты, но такие прокачанные, чтобы с данными быстро работать.

Создание, ёпта:

// Самый простой способ — в квадратных скобках
const fruits = ['apple', 'banana', 'orange']; // яблоки-бананы, ебушки-воробушки

// Через new Array — выглядит пафосно, но осторожно, там подвох может быть
const numbers = new Array(1, 2, 3);

// Array.of() — создаёт из того, что ты туда сунешь
const chars = Array.of('a', 'b', 'c');

// Array.from() — вот это мощь, можно из чего угодно массив сделать
const fromString = Array.from('hello'); // ['h', 'e', 'l', 'l', 'o']
const fromSet = Array.from(new Set([1, 2, 2, 3])); // [1, 2, 3] — дубли, бля, нахуй ушли

А теперь главные фишки, чувак:

1. Размер динамический, терпения ноль ебать. Можешь растягивать и сжимать как хочешь.

   const arr = [];
   arr.length = 0; // Обнулил — и всё, пустота.
   arr.push('new'); // Толкаешь в конец.
   arr.pop();       // Выдернул с конца — и нету.
   arr.unshift('first'); // Запихнул в самое начало, все остальные сдвинулись, ядрёна вошь.
   arr.shift();          // Выдрал первый элемент — остальные опять поехали.

2. Методы — это вообще песня, овердохуища возможностей.

   // map — прогоняешь всё через функцию, как через мясорубку
   const doubled = [1, 2, 3].map(x => x * 2); // [2, 4, 6]
   
   // filter — отсеиваешь всё ненужное, как мусор из крупы
   const evens = [1, 2, 3, 4].filter(x => x % 2 === 0); // [2, 4]
   
   // reduce — сводишь всё к одному значению, типа итог подводишь
   const sum = [1, 2, 3].reduce((acc, val) => acc + val, 0); // 6
   
   // find — ищешь первый подходящий элемент, как ключи в куртке
   const found = [{id: 1}, {id: 2}].find(item => item.id === 2); // {id: 2}
   
   // every / some — проверяешь, все ли или хоть один условие выполняют
   const allPositive = [1, 2, 3].every(x => x > 0); // true
   const hasNegative = [1, -2, 3].some(x => x < 0); // true, вот же он, гад, затесался

3. Асинхронщина в Node.js — это отдельный цирк.

   const fs = require('fs').promises;
   
   async function processFiles(filePaths) {
     // Запускаешь кучу чтений файлов параллельно — мощно
     const promises = filePaths.map(filePath =>
       fs.readFile(filePath, 'utf8')
     );
     const contents = await Promise.all(promises); // Ждёшь, пока все дочитают
   
     // А потом можешь обрабатывать по очереди, если порядок важен
     for (const content of contents) {
       await processContent(content);
     }
   }

4. Типизированные массивы — для серьёзных бинарных дел.

   // Buffer в Node.js с ними дружит
   const buffer = Buffer.from([1, 2, 3, 4]);
   const uint8Array = new Uint8Array(buffer); // Вот тебе и сырые байты
   
   // Int32Array — для целых чисел, чтоб по 4 байта ровненько
   const intArray = new Int32Array([100, 200, 300]);
   console.log(intArray.length); // 3
   console.log(intArray.BYTES_PER_ELEMENT); // 4 — вот сколько каждый элемент жрёт памяти

5. Производительность, блядь! С большими массивами шутить нельзя.

   const largeArray = new Array(1000000).fill(0); // Миллион нулей, ёперный театр!
   
   // forEach — красиво, но для таких дел не самый шустрый
   largeArray.forEach(item => { /* обработка */ });
   
   // Старый добрый for — часто быстрее, проверено
   for (let i = 0; i < largeArray.length; i++) {
     // делаешь что-то с largeArray[i]
   }

И напоследок, чтоб ты не обжёгся:

• Можешь пихать в массив что угодно: числа, строки, объекты, другие массивы — доверия ебать ноль к типам.
• Хочешь точно узнать, массив перед тобой или нет — Array.isArray(), не доверяй typeof.
• Разреженные массивы (с дырками) — это пиздец, они могут вести себя как хуй в пальто, неожиданно и странно.
• Держи данные однотипными — V8 в Node.js это любит и оптимизирует под это дело.