Array

Создание объектов

Объекты можно создать методом наполнения, то есть сначала объект создаётся пустым, а затем наполняется ключами и значениями

var item1 = {};
item1.id = '1';
item1.name = 'Туалетная бумага';
item1.price = '17.00';
item1.quantity = 3;
item1.hq = true;

var item2 = {};
item2.id = '2';
item2.name = 'Полотенце';
item2.price = '85.50';
item2.quantity = 1;
item2.dopinfo = ;
item2.hq = false;

var item3 = {};
item3.id = '3';
item3.name = 'Бумажные салфетки';
item3.price = '23.66';
item3.quantity = 2;
item3.hq = false;

Ещё один способ создания объектов — сразу задавать ему ключи со значениями

var item4 = {
    'id': '4',
    'name': 'Верёвка',
    'price': '7.00',
    'quantity': 1,
    'hq': true,
};

Аналогично можно создать и массив, сначала пустой:

var purchase = [];

а затем наполнить его объектами методом push

purchase.push(item1, item2, item3);

Также, методом push можно добавить объект в уже наполненный массив:

purchase.push(item4);

Это будет аналогично

purchase.push(item1, item2, item3, item4);

Метод push отправляет данные или объекты в конец массива.

Свойства объектов также могут содержать в себе массивы, и объекты в них. Как, например, в объекте item2 — свойство item2.dopinfo

С помощью метода unshift можно добавить данные или объекты в начало массива:

purchase.unshift({id: "5", name: "Носки", price: "28.00", quantity: 7, 'hq': true});

Эта строчка добавить данные по носкам в начало массива

Для извлечения объекта с начала или с конца массива используются методы shift и pop соответственно.

Поиск индекса элемента в JS

Функции indexOf() и lastIndexOf() вернут индекс 1-го и последнего включения элемента в массиве. К примеру:

    var fruit = "яблоки", "груши", "огурцы", "яблоки", "груши"];

var firstIndex = fruit.indexOf("яблоки");
var lastIndex = fruit.lastIndexOf("яблоки");
var otherIndex = fruit.indexOf("черешня");
document.write(firstIndex); // 0
document.write(lastIndex);  // 3
document.write(otherIndex); // -1

У firstIndex значение 0, так как первое включение «яблоки» в нашем массиве приходится на индекс 0, последнее — на индекс № 3. Если же элемент в массиве отсутствует, функции indexOf() и lastIndexOf() вернут значение -1.

every()

С помощью every() мы проверим, все ли наши элементы соответствуют какому-нибудь условию:

    var numbers =  1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
    var result = false;
    if (value > ) {
        result = true;
    }
    return result;
};
var passed = numbers.every(condition);
document.write(passed); // false

В метод every() в качестве параметра осуществляется передача функции, представляющей условие. Данная функция принимает 3 параметра:

    function condition(value, index, array) {

}

Здесь параметр value представляет перебираемый текущий элемент массива, параметр index представляет индекс данного элемента, а параметр array осуществляет передачу ссылки на массив.

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

В результате, когда осуществляется вызов метода numbers.every(condition) он выполняет перебор всех элементов нашего массива numbers, а потом поочерёдно передает их в функцию condition. Когда эта функция возвращает значение true для всех элементов, метод every() тоже возвращает true. Когда хоть один элемент условию не соответствует, возвращается false.

some()

Функция/метод some() похожа на every() с той лишь разницей, что осуществляется проверка на соответствие условию хотя бы одного элемента.

Здесь some() вернёт true. Но если соответствующих условию элементов в массиве не будет, вернётся false:

    var numbers =  1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
    var result = false;
    if (value === 8) {
        result = true;
    }
    return result;
};
var passed = numbers.some(condition); // true

filter()

Как some() и every(), метод filter()принимает функцию условия. Но тут возвращается массив элементов, соответствующих условию:

    var numbers =  1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
    var result = false;
    if (value > ) {
        result = true;
    }
    return result;
};
var filteredNumbers = numbers.filter(condition);

for(var i=; i < filteredNumbers.length; i++)
    document.write(filteredNumbersi + "<br/>");

Вот результат вывода:

1
8
25
62

forEach() и map()

Функции forEach() и map() выполняют перебор элементов, осуществляя с ними некоторые операции. К примеру, чтобы вычислить квадраты чисел в массиве, делаем так:

    var numbers =  1, 2, 3, 4, 5, 6];
for(var i = ; i<numbers.length; i++){

    var result = numbersi * numbersi];

    document.write("Квадрат нашего числа " + numbersi + " равен " + result + "<br/>");
}

Конструкция может быть упрощена посредством forEach():

    var numbers =  1, 2, 3, 4, 5, 6];

function square(value, index, array) {

    var result = value * value;
    document.write("Квадрат нашего числа " + value + " равен " + result + "<br/>");
};

numbers.forEach(square);

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

Что касается map(), то этот метод похож на forEach с той лишь разницей, что map() возвращает новый массив, где отображены результаты операций над элементами массива.

Допустим, давайте, применим map к вычислению квадратов чисел нашего массива:

    var numbers =  1, 2, 3, 4, 5, 6];

function square(value, index, array) {

    return result = value * value;
};

var squareArray = numbers.map(square);
document.write(squareArray);

Функция, передаваемая в map(), получает текущий перебираемый элемент, выполняя над ним операции и возвращая некоторое значение. Именно это значение и попадает в результирующий массив squareArray.

How to Recognize an Array

A common question is: How do I know if a variable is an array?

The problem is that the JavaScript operator returns
«»:

const fruits = ;
let type = typeof fruits;

The typeof operator returns object because a JavaScript array is an
object.

To solve this problem ECMAScript 5 (JavaScript 2009) defined a new method :

Array.isArray(fruits);

Solution 2:

The operator returns true if an object is created
by a given constructor:

const fruits = ;fruits instanceof Array;

Complete Array Reference

For a complete Array reference, go to our:

The reference contains descriptions and examples of all Array
properties and methods.

❮ Previous
Next ❯

Definition and Usage

The method returns the first index (position) of a specified value.

The method returns -1 if the value is not found.

The method starts at a specified index and searches from left to right.

By defalt the search starts at the first element and ends at the last.

Negative start values counts from the last element (but still searches from right to left).

Parameters

Parameter	Description
item	Required.The value to search for.
start	Optional.Where to start the search.Default value is 0. Negative values start the search from the end of the array.

Browser Support

is an ES5 feature (JavaScript 2009).
It is fully supported in all modern browsers:

Chrome	IE	Edge	Firefox	Safari	Opera
Yes	9.0	Yes	Yes	Yes	Yes

More Examples

Find the first index of «Apple», starting from the last element:

const fruits = ;
let index = fruits.indexOf(«Apple», -1);

Что изучать?

Java — это такой промышленный язык. На нём работают терминалы оплаты, умные устройства, огромные серверные системы. Мир потных инженеров, серверных комнат и финансовых рынков. Если хотите, чтобы у вас была работа по поддержке и совершенствованию всего этого хозяйства на много лет вперёд — вам сюда.

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

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

История Java и JavaScript в общих чертах выглядит так.

Начало девяностых. В компании Sun Microsystems пилят язык программирования, который можно будет использовать для умных устройств — телеприставок, холодильников и всякого такого. Задача была придумать такую систему, чтобы код писался один раз, а исполнять его можно было бы на разном железе. В 1995 году выходят первые версии этого языка, он называется Java.

Параллельно с этим в другой области идёт война браузеров. Технологии веба ещё очень слабые, плохо стандартизированные, HTML ещё мало что умеет, дизайна мало. В ходу несколько браузеров, каждый из которых рисует веб-страницы по-своему. Один из этих браузеров — Netscape Navigator.

Создатели Netscape Navigator мечтают, чтобы браузеры умели красиво себя вести; чтобы там был интерактив и анимации; чтобы в браузере можно было запускать программы и делать хотя бы простые вещи (а не только читать). И они разрабатывают технологию Mocha — язык скриптования, который умел работать напрямую с веб-страницей. В те времена это было ново и интересно.

Слово за слово, Netscape входит в состав Sun Microsystems, и в порыве маркетингового креатива язык Mocha переименовывают в JavaScript, чтобы попиарить одно на другом. Якобы JavaScript — это компаньон Java для веба (хотя разрабатывали JavaScript совсем другие люди и с другими задачами).

Пиар не зашёл. Лет пять разработчики плевались из-за кажущейся кривизны JavaScript и общего разлада в веб-технологиях. Уже позднее, в двухтысячных, началась бескомпромиссная стандартизация веб-технологий (огнём и мечом), и всё постепенно наладилось. Но осадочек остался.

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

Associative Arrays

Many programming languages support arrays with named indexes.

Arrays with named indexes are called associative
arrays (or hashes).

JavaScript does not support arrays with named indexes.

In JavaScript, arrays always use numbered indexes.  

Example

const person = [];
person = «John»;
person = «Doe»;
person = 46;
person.length;    // Will return 3
person;        // Will return «John»

WARNING !!
If you use named indexes, JavaScript will redefine the array to an object.

After that, some array methods and properties will produce incorrect
results.

 Example:

const person = [];
person = «John»;
person = «Doe»;
person = 46;
person.length;     // Will return 0
person;         // Will return undefined

The Array reduce() Method

The method runs a function on each array element to produce (reduce it to) a single value.

The method works from left-to-right in the array. See also .

The method does not reduce the original array.

This example finds the sum of all numbers in an array:

Example

const numbers = ;
let sum = numbers.reduce(myFunction);function myFunction(total, value, index, array) { 
return total + value;}

Note that the function takes 4 arguments:

• The total (the initial value / previously returned value)
• The item value
• The item index
• The array itself

The example above does not use the index and array parameters. It can be
rewritten to:

Example

const numbers = ;
let sum = numbers.reduce(myFunction);function myFunction(total, value) { 
return total + value;}

The method can accept an initial value:

Example

const numbers = ;
let sum = numbers.reduce(myFunction,
100);function myFunction(total, value) {  return total + value;}

Как извлечь часть массива

Если вы хотите извлечь часть массива (то есть подмассив), но оставить исходный массив без изменений, вы можете использовать метод slice(). Этот метод принимает 2 параметра: начальный индекс (индекс, с которого начинается извлечение) и необязательный конечный индекс (индекс, перед которым заканчивается извлечение), например arr.slice(startIndex, endIndex). Пример:

var fruits = ;
var subarr = fruits.slice(1, 3);
document.write(subarr); // Результат: Banana,Mango

Если параметр endIndex опущен — извлекаются все элементы до конца массива. Вы также можете указать отрицательные индексы или смещения — в этом случае метод slice() извлекает элементы из конца массива, а не из начала.

find

Чем метод отличается от метода includes()? Если в нашем примере мы просто заменим “includes” на “find”, мы получим следующее сообщение об ошибке:

Это связано с тем, что метод find требует передачи функции. Метод find не будет просто использовать простой оператор сравнения как это делает “includes()”. Вместо этого он будет передавать каждый элемент в функцию и смотреть, какой результат она возвращает: true или false. Итак, хотя это сработает: , вы наверное захотите поместить в функцию собственный оператор сравнения, чтобы она возвращала актуальный результат.

Эта простая функция в нашем методе find ищет каждый элемент массива с псевдонимом ‘el’, который мы присвоили, и останавливается, когда находит первый результат, дающий значение true. В нашем случае true имеет свойство длины менее 12 (у чисел нет свойства длины). Разумеется, вы можете сделать эту функцию настолько сложной, насколько это необходимо, чтобы условие true соответствовало вашим потребностям.

Обратите внимание, что этот код не возвращает. Метод find возвращает не логическое значение, а первый совпадающий элемент

Если совпадающего элемента нет, то есть, если ни один элемент не соответствует критериям, определенным в вашей функции, она возвращает значение . Обратите внимание, что функция возвращает только первое совпадение, так что если критериям соответствует несколько элементов, функция выведет только первый из них. Если бы в нашем примере была другая строка длиной меньше 12 после ‘4 feet tall’, результат бы не изменился.

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

Мы знаем, что в нашем массиве есть 3 разных элемента, соответствующих первому условию (typeof el === ‘string’). Если бы это было единственное условие, метод бы возвратил первый результат, ‘thick scales’. Однако отличие заключается в том, что только у одного элемента есть индекс 2, и это элемент ‘4 foot tall’.

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

Совершенствование кросс-браузерного поведения

Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью и IE < 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции , опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, де-факто стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом , явно определённым как /, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE >= 9, поддерживают данное поведение.)

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sinh()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
Modifiers:
g
i
m
Groups:

(x|y)
Metacharacters:
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx
Quantifiers:
+
*
?
{X}
{X,Y}
{X,}
$
^
?=
?!
Properties:
constructor
global
ignoreCase
lastIndex
multiline
source
Methods:
compile()
exec()
test()
toString()

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Перебор элементов

Одним из самых старых способов перебора элементов массива является цикл for по цифровым индексам:

Но для массивов возможен и другой вариант цикла, :

Цикл не предоставляет доступа к номеру текущего элемента, только к его значению, но в большинстве случаев этого достаточно. А также это короче.

Технически, так как массив является объектом, можно использовать и вариант :

Но на самом деле это – плохая идея. Существуют скрытые недостатки этого способа:

1. Цикл выполняет перебор всех свойств объекта, а не только цифровых.

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

2. Цикл оптимизирован под произвольные объекты, не массивы, и поэтому в 10-100 раз медленнее. Увеличение скорости выполнения может иметь значение только при возникновении узких мест. Но мы всё же должны представлять разницу.

В общем, не следует использовать цикл для массивов.

Методы для работы с массивами

Для удаления последнего элемента массива используется метод pop. Пример:

let mas = 
console.log(mas.pop()) //Выведет удаляемый элемент, то есть “монитор”
console.log(mas) //Выведет 

Для добавления элемента в конец массива используется метод push. Пример:

let mas = 
mas.push( “компьютер”)
console.log(mas) //Выведет 

Для удаления первого элемента массива используется метод shift. Пример:

let mas = 
console.log(mas.shift()) //Выведет удаляемый элемент, то есть “мышка”
console.log(mas) //Выведет 

Для добавления элемента в начало массива используется метод unshift. Пример:

let mas = 
mas.shift( “компьютер”)
console.log(mas) //Выведет 

Из-за того, что методы push/pop не требуют смещения порядка элементов массива, они выполняются значительно быстрее методов shift/unshift. Особенно это заметно на примере массивов с большим количеством элементов.

С помощью метода toString мы можем получить все элементы текущего массива через запятую в виде строки. Пример:

let mas = 
console.log(mas.toString())//Выведет “мышка,клавиатура,монитор”

Работа с массивами JS — метод slice

Можно извлечь часть массива с помощью метода slice(begin):
var arr = ;
var arr2 = arr.slice(0,2) // принимает 2 элемента, начиная с 0
alert(arr2.join(', ')) // "Why, learn"

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

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

var arr = ;
var arr2 = arr.slice(1) // принимает все элементы, начиная с 1
alert(arr2.join(', ')) // "learn, JavaScript"

Метод поддерживает отрицательные индексы, так же, как String#slice.

Удаление элемента по индексу в JavaScript

splice()

Функция splice() удалит элементы с определённого индекса. Вот как выглядит удаление элементов с 3-го индекса:

    var users = "Tom", "Bob", "Bill", "Alice", "Kate"];
var deleted = users.splice(3);
console.log(deleted);       // 
console.log(users);         // 

А возвратит удалённые элементы метод slice.

Как видите, удаление идёт с начала массива. Но если передадим отрицательный индекс, удаление начнётся с конца массива. Давайте удалим лишь последний элемент:

    var users = "Tom", "Bob", "Bill", "Alice", "Kate"];
var deleted = users.splice(-1);
console.log(deleted);       // 
console.log(users);         // 

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

    var users = "Tom", "Bob", "Bill", "Alice", "Kate"];
var deleted = users.splice(1,3);
console.log(deleted);       // 
console.log(users);         // 

Можно вставить новые элементы вместо удаляемых:

    var users = "Tom", "Bob", "Bill", "Alice", "Kate"];
var deleted = users.splice(1,3, "Ann", "Roy");
console.log(deleted);       // 
console.log(users);         // 

Обратите внимание, что мы удалили 3 элемента (с первого по третий индексы), а вместо них вставили только два элемента

concat()

Метод или функция concat() нужна, чтобы объединять массивы:

    var fruit = "груши", "яблоки", "сливы"];
var vegetables = "огурцы", "помидоры", "картошка"];
var products = fruit.concat(vegetables);

for(var i=; i < products.length; i++)
    document.write(productsi + "<br/>");

И совсем необязательно объединять лишь однотипные массивы, можно и разнотипные:

    var fruit = "груши", "яблоки", "сливы"];
var prices = 20, 30, 70];
var products = fruit.concat(prices);

join()

Функцией join() можем объединить в одну строку все элементы массива:

    var fruit = "груши", "яблоки", "сливы", "абрикосы", "апельсины"];
var fruitString = fruit.join(", ");
document.write(fruitString);

В функцию join() передаётся разделитель между элементами массива. В нашем случае в качестве разделителя используется запятая и пробел («, «).

sort()

Функция sort() позволяет сортировать массив по возрастанию:

    var fruit = "груши", "яблоки", "сливы", "абрикосы", "пони"];
fruit.sort();

for(var i=; i < fruit.length; i++)
    document.write(fruiti + "<br/>");

В результате элементы будут отсортированы по алфавиту:

абрикосы
груши
пони
сливы
яблоки

reverse()

С помощью reverse() мы перевернём массив задом наперед:

    var fruit = "груши", "яблоки", "сливы", "абрикосы", "апельсины"];
fruit.reverse();

for(var i=; i < fruit.length; i++)
    document.write(fruiti + "<br/>");

Итог:

апельсины
абрикосы
сливы
яблоки
груши

Ассоциативные массивы

Многие языки программирования поддерживают массивы с именованными индексами.

Массивы с именованными индексами называются ассоциативными массивами (или хэшами).

JavaScript не поддерживает массивы с именованными индексами.

В JavaScript массивы всегда используют пронумерованные индексы.

Пример

var person = [];
person = «John»;
person = «Doe»;
person = 46;var x = person.length;        
// person.length will return 3var y = person;            
// person will return «John»

Предупреждение!!При использовании именованных индексов JavaScript будет переопределять массив в стандартный объект.После этого некоторые методы и свойства массива будут давать неверные результаты.

Пример:

var person = [];
person = «John»;
person = «Doe»;
person = 46;var x = person.length;         // person.length will
return 0var y = person;            
// person will return undefined

Создание массива

Создать массив в JavaScript можно двумя способами:

• Через литерал массива, который использует квадратные скобки.
• Через конструктор массива, в котором используется новое ключевое слово.

Попробуйте создать массив с видами акул через литерал массива, который инициализируется с помощью []. Создайте файл sharks.js и добавьте в него:

Такой же массив можно создать с помощью конструктора массивов:

Оба метода создадут массив. Однако литерал массива (квадратные скобки) является гораздо более распространенным и предпочтительным методом, так как конструктор new Array() может стать причиной несогласованности, и программа будет выдавать неожиданные результаты.

Вывести весь массив можно так:

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

Теперь нужно разобраться, как массивы индексируются.

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

Обратите внимание, что конечные запятые не допускаются в файлах JSON

Синтаксис

let new_array = arr.map(function callback( currentValue[, index[, array]]) {
    // Возвращает элемент для new_array
}[, thisArg])

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

Функция , создающая элемент в новом массиве, принимает три аргумента:

Текущий обрабатываемый элемент массива.

Необязательный

Индекс текущего обрабатываемого элемента в массиве.

Необязательный

Массив, по которому осуществляется проход.

Необязательный

Необязательный параметр. Значение, используемое в качестве при вызове функции

Новый массив, где каждый элемент является результатом  функции.