Перебор массива, объекта и элементов в jquery

Пустые элементы

Массивы JavaScript допускают пустые элементы. Массив ниже синтаксически верный и имеет длину 3 элемента:

const arr = ;

arr.length; // 3

Что еще более запутывает, так это то, что циклические конструкции трактуют иначе, чем . Ниже показано, как четыре циклических конструкции обрабатывают с пустым элементом. for/in и for/each пропускают пустой элемент, for и for/of — нет.

// Prints "a, undefined, c"
for (let i = 0; i < arr.length; ++i) {
  console.log(arr);
}

// Prints "a, c"
arr.forEach(v => console.log(v));

// Prints "a, c"
for (let i in arr) {
  console.log(arr);
}

// Prints "a, undefined, c"
for (const v of arr) {
  console.log(v);
}

Если вам интересно, все 4 конструкции выведут «a, undefined, c» для .

Есть еще один способ добавить пустой элемент в массив:

// Equivalent to ``
const arr = ;
arr = 'e';

forEach() и for/in пропускают пустые элементы в массиве, for и for/of — нет. Поведение forEach() может вызвать проблемы, однако можно заметить, что дыры в массивах JavaScript, как правило, встречаются редко, поскольку они не поддерживаются в JSON:

$ node
> JSON.parse('{"arr":}')
{ arr:  }
> JSON.parse('{"arr":}')
{ arr:  }
> JSON.parse('{"arr":}')
SyntaxError: Unexpected token , in JSON at position 12

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

Вывод: for/in и forEach() не реагируют на пустые элементы, также известные как «дыры», в массиве. Редко есть какая-либо причина рассматривать дыры как особый случай, а не рассматривать индекс как значение undefined. Если вы допускаете наличие дыр, ниже приведен пример файла .eslintrc.yml, который запрещает вызов forEach().

parserOptions:
  ecmaVersion: 2018
rules:
  no-restricted-syntax:
    - error
    - selector: CallExpression
      message: Do not use `forEach()`, use `for/of` instead

Доступ к элементам

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

Так как индексы нумеруются с 0, то для получение первого, второго и третьего элемента нужно использовать индексы 0, 1 и 2.

const colors = ;
console.log( colors ); // 'black'
console.log( colors ); // 'white'
console.log( colors ); // 'grey'

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

console.log( colors ); // undefined

Чтобы изменить элемент, ему нужно просто присвоить новое значение:

colors = 'yellow'; // 

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

colors = 'red'; // 

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

colors = 'green'; // 
console.log( colors ); // undefined

Определить количество элементов в массиве можно с помощью свойства :

console.log( colors.length ); // 6

Зная количество, получить последний элемент можно так:

const lastIndex = colors.length – 1;
console.log( colors ); // "green"

Пример массива, элементы которого содержат различные типы данных:

const arr = , true, function() { console.log('good'); }];

// получим элемент с индексом 1, который является объектом, а затем значение его свойства age
console.log( arr.age ); // 35
// получим элемент с индексом 2, который является массивом, а затем его элемент с индексом 1
console.log( arr ); // 35
// получим элемент с индексом 4, т.е. функцию и выполним её
arr(); // "good"

В качестве элементов массива можно использовать выражения:

const ratio = 5;
const point = ;

А. Перебор настоящих массивов

Для этого используются:
1. Известный метод Array.prototype.forEach.
2. Классический цикл for.
3. «Правильно» построенный цикл for…in.

Что же, давайте рассмотрим эти методы подробнее.

1. Метод forEach

Пример использования:

var a = "a", "b", "c"];
a.forEach(function(entry) {
    console.log(entry);
});

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

С помощью forEach вы не только сможете выполнить перебор всех элементов массива, но и получите возможность выполнения некоторых действий с массивами:
1) some — возвращает true, когда хотя бы для одного элемента массива колбэк возвращает значение, приводимое к true;
2) every — возвращает true, когда для каждого элемента массива колбэк возвращает значение, приводимое к true;
3) filter — обеспечивает создание нового массива, включающего те элементы исходного, для коих колбэк возвращает true;
4) reduce — сводит массив к единственному значению, т. е. колбэк применяется по очереди к каждому элементу массива, начиная с 1-го (полезно при вычислении суммы элементов массива и прочих итоговых функций);
5) map — обеспечивает создание нового массива, состоящего из значений, которые возвращаются колбэком;
6) reduceRight — работает так же, как и reduce с той лишь разницей, что перебирает элементы в обратном порядке.

2. Цикл for

Что тут скажешь — старый добрый for…

var a = "a", "b", "c"];
var index;
for (index = ; index < a.length; ++index) {
    console.log(aindex]);
}

Кстати, когда длина массива неизменна в течение цикла, а цикл принадлежит критическому с точки зрения производительности участку кода (что маловероятно), подходит «более оптимальная» версия for с хранением длины массива:

var a = "a", "b", "c"];
var index, len;
for (index = , len = a.length; index < len; ++index) {
    console.log(aindex]);
}

По идее, данный код должен выполняться немного быстрее предыдущего.

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

var a = "a", "b", "c"];
var index;
for (index = a.length - 1; index >= ; --index) {
    console.log(aindex]);
}

Однако справедливости ради стоит отметить, что в современных движках JavaScript вышеописанные игры с оптимизацией мало что значат.

3. Правильное использование цикла for…in

Вообще, цикл for…in не предназначен для перебора массивов. Он перебирает не индексы нашего массива, а перечисляемые свойства объекта.

Однако, если нам нужен перебор разреженных массивов, цикл for…in может быть весьма полезным, если, разумеется, соблюдать меры предосторожности:

// a — разреженный массив
var a = [];
a = "a";
a10 = "b";
a10000 = "c";
for (var key in a) {
    if (a.hasOwnProperty(key) &&
        /^0$|^\d*$/.test(key) &&
        key <= 4294967294) {
        console.log(akey]);
    }
}

В вышеописанном примере на каждой циклической итерации осуществляются 2 проверки:
1) то, что массив имеет своё свойство с именем key (ненаследованное из его прототипа);
2) то, что key — это строка, содержащая десятичную запись целого числа, значение которого менее 4294967294.

Да, такие проверки могут отнять много времени, но если мы имеем дело с разреженным массивом, данный способ эффективнее обычного цикла for, т. к. в последнем случае перебираются лишь элементы, которые определены в массиве явно. Например в коде выше произойдёт всего 3 итерации (для индексов 0, 10 и 10000), в то время как при использовании классического for — 10001 итерация.

Кстати, код проверок можете оформить в виде отдельной функции:

function arrayHasOwnIndex(array, key) {
    return array.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key <= 4294967294;
}

В таком случае тело цикла существенно сократится:

for (key in a) {
    if (arrayHasOwnIndex(a, key)) {
        console.log(akey]);
    }
}

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

for (key in a) {
    if (a.hasOwnProperty(key) && String(parseInt(key, 10)) === key) {
        console.log(akey]);
    }
}

Работа с массивами JS — перебор массива

В JavaScript перебор массива осуществляется с помощью цикла for:

var fruits = 
for(var i=0; i<fruits.length; i++) {
  alert(fruits)
}

Задание для самостоятельного выполнения

Создайте функцию find(arr,value), которая находит значение в заданном массиве и возвращает его индекс или -1, если значение не найдено.

Например:

arr = 
find(arr, "test") // 0
find(arr, 2) // 1
find(arr, 1.5) // 2
find(arr, 0) // -1

Возможное решение может выглядеть так:

function find(array, value) {
  for(var i=0; i<array.length; i++) {
    if (array == value) return i;
  }

  return -1;
}

Но это неверно, потому что == не определяет разницу между и false.

Более корректно при работе с массивами в JavaScript использовать ===. Кроме того новейший стандарт ES5 содержит функцию Array#indexOf. С ее помощью мы можем определить функцию следующим образом:

function find(array, value) {
  if (array.indexOf) return array.indexOf(value) 
  for(var i=0; i<array.length; i++) {
    if (array === value) return i;
  }

  return -1;
}
var arr = ;
var index = find(arr, 2);
alert(index);

Еще разумнее было бы определить find через условие, чтобы проверить, существует ли метод indexOf.

Задание для самостоятельного выполнения

Создайте функцию filterNumeric(arr), которая принимает массив и возвращает новый массив, содержащий только числовые значения из arr.

Пример того, как это должно работать:

arr = ;
arr = filterNumeric(arr);
// теперь arr = 

Ассоциативный массив — что это?

Под ассоциативным массивом подразумевают массив, в котором в качестве ключей применяются строки. То есть речь идёт о совокупности пар «ключ-значение». Таким образом, в ассоциативном массиве любое значение связано с конкретным ключом, а доступ к этому значению производится по имени ключа.

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

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()
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
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

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()

Методы перебора элементов

1. Перебор элементов массива с помощью метода forEach().

Пример:

2. Метод map() проходится по элементам массива и как результат возвращает новый массив.

Пример:

3. Метод filter() предназначен для фильтрации массива через функцию. Данный метод вернет новый массив в зависимости от истинности выполненного условия для каждого элемента.

Пример:

4. Метод every() используется для проверки значений массива на равенство. Если при вызове колкэк-функции каждый элемент массива будет соответствовать условиям, то данный метод вернет true.

Пример:

5. Метод some() похож на метод every(), но при этом он отличается тем, что возвращает true, если при вызове колбэк-функции хотя бы один из элементов будет равен указанному условию.

Пример:

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

Пример:

7. Метод reduceRight() работает так же как и reduce(), но идет по элементам массива справа налево.

MAP-массивы

Создание MAP-массива с данными

var mapArray = new Map(,
    ,
    ,
    
]);

Несколько операций, которые можно использовать в MAP-массиве

Добавление нового ключа и значения, либо изменение имеющегося значения ключа в массиве

mapArray.set('availability', true);

Удаление ключа и значения

mapArray.delete('quantity');

Полная очистка массива

mapArray.clear();

Проверка наличия ключа в массиве

mapArray.has('id');

если такой ключ есть, вернёт true

Список ключей в массиве

mapArray.keys();

Список значений в массиве

mapArray.values();

Показать значение ключа

mapArray.get('name');

Показать число элементов в массиве

mapArray.size;

Список ключей и элементов массива

mapArray.entries();

На этом пока всё.

Что такое ассоциативный массив

Ассоциативный массив — это массив, у которого в качестве ключей используются строки.

Представить структуру данных ассоциативного массива можно как совокупность пар «ключ-значение». В ассоциативном массиве каждое значение связано с определённым ключом. Доступ к значению осуществляется по имени ключа.

Представить ассоциативный массив можно как ящичек, в котором находятся коробочки. Каждая коробочка в этом ящичке имеет имя (ключ) и содержимое (значение).

Для того чтобы найти нужную коробочку в ящичке нужно знать её имя (ключ). Зная имя (ключ) коробочки можно получить её содержимое (значение).

Объявление массива в JS:

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

JavaScript

1 2	let arr1=// Объявление пустого массива let arr2=»Яблоко»,»Банан»,»Персик»// Объявляем массив с данными

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

JavaScript

1	let arr=»Яблоко»,835,true,function(){alert(«Привет»)}

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

Также для создания массива, вы можете использовать класс , вот как это делается.

LESS

1 2	Letarr1=newArray();//Объявлениепустогомассива Letarr2=newArray(«Персик»,»Яблоко»,»Банан»);//Объявлениемассивасданными

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

Найти элемент в массиве можно с помощью метода :

const disks = ;
const index = disks.indexOf('1Tb'); // 1

В качестве результата он возвращает индекс первого найденного элемента.

Если элемент не найден, то возвращает . Это можно использовать, например, чтобы проверить существует ли элемент в массиве:

const disks = ;
if (disks.indexOf('1Tb') > -1) {
  console.log( 'Этот элемент в массиве есть!' );
}

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

const nums = ;
nums.indexOf('One', 1); // 2

Метод выполняет то же самое что , только осуществляет это с конца:

// arr – массив, element – искомый элемент, from – индекс (по умолчанию arr.length)
arr.lastIndexOf(element)

Пример:

const nums = ;
nums.lastIndexOf('One'); // 3
nums.lastIndexOf('Two'); // 1

Начиная с версии ECMAScript 7 появился новый метод .

Он позволяет проверить содержит ли массив указанный элемент:

// arr – массив, element – искомый элемент, from – индекс (по умолчанию 0)
arr.includes(element)

Он похож на , но в отличие от него возвращает или .

.includes(2); // true
.includes(4); // false

С использованием второго аргумента:

.includes(2, 1); // true
.includes(2, -1); // false

При отрицательных значениях поиск выполняется начиная с .

В отличие от , в котором используется строгое равенство (Strict Equality Comparison), в используется алгоритм равенства SameValueZero. Это значит, что вы можете, например, определить, содержит ли массив :

.includes(NaN); // true
.indexOf(NaN); // -1

Также в отличие от , не пропускает отсутствующие элементы:

.includes(undefined); // true
.indexOf(undefined); // -1

Для чего предназначен оператор delete

Оператор используется не для удаления элемента из массива, а для присваиванию данному элементу массива значение .

let namePlanets = new Array ("Венера","Меркурий","Земля","Марс");
delete namePlanets;
for (let i=0; i <= namePlanets.length-1; i++)
{
  console.log(i + " элемент массива = " + namePlanets);
}

Работа с массивами JS — методы shift/unshift

Методы shift/unshift работают с концом массива, но вы также можете использовать shift, чтобы сдвинуть элементы вверх (первое значение массива удаляется со сдвигом элементов). Метод unshift позволяет в JavaScript добавить элемент в массив с конца:

var fruits = 
var apple = fruits.shift() // теперь у нас остался только 
fruits.unshift("Lemon") // теперь мы имеем 
alert(fruits.length) // 2

И shift, и unshift могут работать с несколькими элементами одновременно:

var fruits = 
fruits.push("Orange","Peach")
fruits.unshift("Pineapple","Lemon")
// теперь массив выглядит так: 

Задание для самостоятельного выполнения

Напишите код, чтобы вывести через alert случайное значение из массива arr:

var arr = 

Примечание: Код для получения случайного числа от минимального до максимального значения (включительно) следующий:

var rand = min + Math.floor(Math.random()*(max+1-min))

Решение

Нам нужно извлечь случайное число от до arr.length-1 (включительно):

var arr = 

var rand = Math.floor(Math.random()*arr.length)

alert(arr)

Глобальное запечатывание объекта

Дескрипторы свойств работают на уровне конкретных свойств.

Но ещё есть методы, которые ограничивают доступ ко всему объекту:

Object.preventExtensions(obj)

Запрещает добавлять новые свойства в объект.

Object.seal(obj)

Запрещает добавлять/удалять свойства. Устанавливает для всех существующих свойств.

Object.freeze(obj)

Запрещает добавлять/удалять/изменять свойства. Устанавливает для всех существующих свойств.

А также есть методы для их проверки:

Object.isExtensible(obj)

Возвращает , если добавление свойств запрещено, иначе .

Object.isSealed(obj)

Возвращает , если добавление/удаление свойств запрещено и для всех существующих свойств установлено .

Object.isFrozen(obj)

Возвращает , если добавление/удаление/изменение свойств запрещено, и для всех текущих свойств установлено .

На практике эти методы используются редко.

Работа с массивами JS — join и split

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

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

var fruits = ;
var str = fruits.join(', ');
alert(str);

Обратное преобразование легко выполняется с помощью метода split:

var fruits = "Apple,Orange,Peach";
var arr = fruits.split(',');
// arr содержит теперь 
alert(arr);

Задание для самостоятельного выполнения

Объект включает в себя свойство className, которое содержит имена классов, разделенные пробелами:

var obj = {
	className: 'open menu' 
}

Напишите функцию addClass(obj, cls), которая добавляет класс cls, но только если он не существует:

ddClass(obj, 'new') // obj.className='open menu new'
addClass(obj, 'open')  // без изменений (class already exists)
addClass(obj, 'me') // obj.className='open menu new me'
alert(obj.className)  //

Решение

Нужно разделить className и цикл на части. Если класс не найден, тогда он добавляется.

Цикл немного оптимизирован для увеличения производительности:

function addClass(elem, cls) {
  for(var c = elem.className.split(' '), i=c.length-1; i>=0; i--) {
    if (c == cls) return
  }
	
  elem.className += ' '+cls
}
var obj = { className: 'open menu' }
addClass(obj, 'new')
addClass(obj, 'open') 
alert(obj.className)   // open menu new

В приведенном выше примере переменная c определяется в начале цикла, и для ее последнего индекса задается значение i.

Сам цикл обрабатывается в обратном направлении, заканчиваясь условием i>=0. Потому что i>=0 проверить быстрее, чем i. Что в JavaScript ускоряет поиск в массиве.

Поиск в массиве

Далее рассмотрим методы, которые помогут найти что-нибудь в массиве.

Методы arr.indexOf, arr.lastIndexOf и arr.includes имеют одинаковый синтаксис и делают по сути то же самое, что и их строковые аналоги, но работают с элементами вместо символов:

• ищет , начиная с индекса , и возвращает индекс, на котором был найден искомый элемент, в противном случае .
• – то же самое, но ищет справа налево.
• – ищет , начиная с индекса , и возвращает , если поиск успешен.

Например:

Обратите внимание, что методы используют строгое сравнение. Таким образом, если мы ищем , он находит именно , а не ноль

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

Кроме того, очень незначительным отличием является то, что он правильно обрабатывает в отличие от :

Представьте, что у нас есть массив объектов. Как нам найти объект с определённым условием?

Здесь пригодится метод arr.find.

Его синтаксис таков:

Функция вызывается по очереди для каждого элемента массива:

• – очередной элемент.
• – его индекс.
• – сам массив.

Если функция возвращает , поиск прерывается и возвращается . Если ничего не найдено, возвращается .

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

В реальной жизни массивы объектов – обычное дело, поэтому метод крайне полезен.

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

Метод arr.findIndex – по сути, то же самое, но возвращает индекс, на котором был найден элемент, а не сам элемент, и , если ничего не найдено.

Метод ищет один (первый попавшийся) элемент, на котором функция-колбэк вернёт .

На тот случай, если найденных элементов может быть много, предусмотрен метод arr.filter(fn).

Синтаксис этого метода схож с , но возвращает массив из всех подходящих элементов:

Например:

Сортировка объектов в массивах

Выше упомянутые объекты можно отсортировать по следующим значениям:

по id товаров в порядке возрастания

purchase.sort((a, b) => a.id - b.id);

по id товаров в порядке убывания

purchase.sort((a, b) => b.id - a.id);

purchase.sort((a, b) => a.price - b.price);

purchase.sort((a, b) => b.price - a.price);

по количеству (quantity) в порядке возрастания

purchase.sort((a, b) => a.quantity - b.quantity);

по количеству (quantity) в порядке убывания

purchase.sort((a, b) => b.quantity - a.quantity);

по наименованию товара (алфавит) в порядке возрастания

purchase.sort((a, b) => a.name > b.name ? 1 : -1);

по наименованию товара (алфавит) в порядке убывания

purchase.sort((a, b) => a.name < b.name ? 1 : -1);

обратный порядок объектов (элементов)

purchase.reverse();

Итого

– коллекция пар ключ-значение.

Методы и свойства:

• – создаёт коллекцию, можно указать перебираемый объект (обычно массив) из пар для инициализации.
• – записывает по ключу значение .
• – возвращает значение по ключу или , если ключ отсутствует.
• – возвращает , если ключ присутствует в коллекции, иначе .
• – удаляет элемент по ключу .
• – очищает коллекцию от всех элементов.
• – возвращает текущее количество элементов.

Отличия от обычного объекта :

• Что угодно может быть ключом, в том числе и объекты.
• Есть дополнительные методы, свойство .

– коллекция уникальных значений, так называемое «множество».

Методы и свойства:

• – создаёт , можно указать перебираемый объект со значениями для инициализации.
• – добавляет значение (если оно уже есть, то ничего не делает), возвращает тот же объект .
• – удаляет значение, возвращает если было в множестве на момент вызова, иначе .
• – возвращает , если значение присутствует в множестве, иначе .
• – удаляет все имеющиеся значения.
• – возвращает количество элементов в множестве.

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