Перебираемые объекты

Summary

is -like collection that allows only objects as keys and removes them together with associated value once they become inaccessible by other means.

is -like collection that stores only objects and removes them once they become inaccessible by other means.

It’s main advantages are that they have weak reference to objects, so they can easily be removed by garbage colector.
That comes at the cost of not having support for , , , …

and are used as “secondary” data structures in addition to the “primary” object storage. Once the object is removed from the primary storage, if it is only found as the key of or in a , it will be cleaned up automatically.

Добавляем значения

Вы можете создать Map и добавить пары ключ-значение, используя функцию set.

let example = new Map()
example.set('test', 'value')
// пример Map { 'test' => 'value' }

Однако, если вы установите что-то с тем же ключом, значение будет перезаписано.

example.set('test', true)
// пример Map { 'test' => true }

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

if (!example.has('test')) {
  example.set('test', 'new value')
}
example.get('test').myFunctionForMessingWithThisKeyEntry()

И это не единственная подобная ситуация. Возможно, вы захотите вставить ключ, если он отсутствует, только обновить, если он присутствует, и т. д. Было бы неплохо не выполнять проверки существования и использовать set и get в любой момент.

Всё вместе

ParseInt принимает два аргумента: string и radix (основание). Если переданный radix является ложным, то по умолчанию устанавливается в 10.

Давайте рассмотрим этот пример шаг за шагом.

Так как является ложным, то для основания устанавливается значение по умолчанию — 10. parseInt() принимает только два аргумента, поэтому третий аргумент игнорируется. Строка ‘1’ по основанию 10 даст результат 1.

В системе по основанию 1 символа ‘7’ не существует. Как и в случае с первой итерацией, последний аргумент игнорируется. Таким образом parseInt() возвращает NaN.

В двоичной системе счисления ’11’ относится к числу 3. Последний аргумент вновь игнорируется.

Map

Map в основном представляет собой набор пар ключ/значение. Это похоже на Dictionary в C#, Map в Java, Hash в Ruby и Dictionary в Python.

Map также имеет свойство под названием size, которое дает нам информацию о количестве ключей/значений внутри коллекции.

Следующие методы присутствуют в экземпляре Map:

• clear() – Удаляет все элементы с Map
• delete(key) – Удаляет указанный элемент из Map
• forEach – как классический цикл forEach для массива
• get(key) – Получает элемент для указанного ключа
• has(key) – Возвращает true, если коллекция содержит элемент с этим ключом
• keys() – Возвращает все ключи коллекции Map
• set(key, value) – Добавляет новый элемент на карту
• values() – Возвращает все значения коллекции Map
• toString() – Распечатывает “”

Вот пример создания нового объекта Map:

let map = new Map(, , , ])

for (let  of map.entries()) {
  console.log('key is ' + key + ', value is ' + value);
}
/* Вывод:
key is name, value is CodingBlast
key is points, value is 33
key is true, value is 55
key is true, value is 44
*/

Мы также можем просмотреть список ключей или значений:

for (let key of map.keys()) {
  console.log('key:' + key);
}

for (let value of map.values()) {
  console.log('value:' + value);
}

Вопрос есть ли способ просто распечатать все ключи или значения данного Map. Да, есть!

Мы можем использовать удобный метод Array.from:

let map = new Map(, , , ])

console.log(Array.from(map.keys()))
console.log(Array.from(map.values()))
console.log(Array.from(map.entries()))
/*
(4) 
(4) 
(4) 
*/

Последняя строка console.log просто распечатает тот же массив, который мы указали при создании экземпляра карты. Ну, это массив, который имеет массивы в качестве элементов.

Map против Object

Вы, наверное, задаетесь вопросом, зачем нам использовать Map, если мы можем просто использовать объекты JavaScript. Они очень похожи на Map, и так же состоят из пар ключ/значения. Основные отличия Map от Object:

• В Map у нас есть несколько удобных встроенных методов, а также свойство size, позволяющее легко определить, сколько значений мы храним внутри Map.
• В Map все может быть ключом, в то время как с обычными объектами мы должны использовать только строки в качестве ключей.
• В Map доступ/изменение значения элемента осуществляется с помощью Map.prototype.get(key) / Map.prototype.set(key, value)

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

let obj = {};

console.log(obj)

console.log(obj)

console.log(obj)
/*
ƒ toString() {  }
ƒ hasOwnProperty() {  }
ƒ Object() {  }
*/

Но, конечно же, мы можем использовать встроенный метод hasOwnProperty, чтобы проверить, действительно ли ключ находится в объекте или в одном из прототипов. Также мы обычно используем метод Object.keys(), чтобы получить только собственные и перечисляемые ключи данного объекта.

Список критериев выбора Map или Object:

1. Object является отличным выбором для сценариев, когда нам нужна простая структура для хранения данных и мы знаем, что все ключи являются либо строками, либо целыми числами (или символами), потому что создание простого объекта и доступ к свойству объекта с определенным ключом намного быстрее, чем создание с Map.

2. Кроме того, в сценариях, где существует необходимость применять отдельную логику к отдельным свойствам/элементам, Object, безусловно, является выбором. Например:

var obj = {
    id: 1, 
    name: "It's Me!", 
    print: function(){ 
        return `Object Id: ${this.id}, with Name: ${this.name}`;
    }
}
console.log(obj.print());//Object Id: 1, with Name: It's Me.

3. Более того, JSON имеет прямую поддержку Object, но не с Map (пока). Поэтому в определенной ситуации, когда нам приходится много работать с JSON, рассмотрите Object как предпочтительный вариант.

4. В противоположность, Map является чисто хеш-функцией, Object — чем-то большим (с поддержкой внутренней логики). А использование оператора delete со свойством Object имеет несколько проблем с производительностью. Следовательно, в сценариях, которые требуют много добавления и удаления (особенно) новой пары, Map может работать намного лучше.

5. Кроме того, Map сохраняет порядок своих ключей — в отличие от Object, и Map был создан с учетом итерации, поэтому в случае, если итерация или порядок элементов очень важны, рассмотрите Map — он обеспечит стабильную производительность итерации во всех браузерах.

6

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

Hello, World

View example

let map;

function initMap() {
map = new google.maps.Map(document.getElementById(«map»), {
center: { lat: -34.397, lng: 150.644 },
zoom: 8,
});
}
/* Always set the map height explicitly to define the size of the div
* element that contains the map. */
#map {
height: 100%;
}

/* Optional: Makes the sample page fill the window. */
html,
body {
height: 100%;
margin: 0;
padding: 0;
}
<!DOCTYPE html>
<html>
<head>
<title>Simple Map</title>
<script src=»https://polyfill.io/v3/polyfill.min.js?features=default»></script>
<script
src=»https://maps.googleapis.com/maps/api/js?key=AIzaSyBIwzALxUPNbatRBj3Xi1Uhp0fFzwWNBkE&callback=initMap&libraries=&v=weekly»
defer
></script>
<!— jsFiddle will insert css and js —>
</head>
<body>
<div id=»map»></div>
</body>
</html>

Even in this simple example, there are a few things to note:

1. We declare the application as HTML5 using the declaration.
2. We create a element named «map» to hold the
   map.
3. We define a JavaScript function that creates a map in the
   .
4. We load the Maps JavaScript API using a tag.

These steps are explained below.

Перебор объекта Set

Мы можем перебрать содержимое объекта set как с помощью метода , так и используя :

Заметим забавную вещь. Функция в у имеет 3 аргумента: значение , потом снова то же самое значение , и только потом целевой объект. Это действительно так, значение появляется в списке аргументов дважды.

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

имеет те же встроенные методы, что и :

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

Случаи применения

У WeakMap есть несколько популярных вариантов использования. Их можно использовать для обеспечения конфиденциальности личных данных объекта, а также для отслеживания узлов / объектов DOM.

Пример использования c личными данными

var Person = (function() {
  var privateData = new WeakMap();

  function Person(name) {
    privateData.set(this, { name: name });
  }

  Person.prototype.getName = function() {
    return privateData.get(this).name;
  };

  return Person;
}());

Использование WeakMap упрощает процесс сохранения конфиденциальности данных объекта. Можно ссылаться на объект Person, но доступ к privateData WeakMap запрещен без конкретного экземпляра Person.

Случай использования с DOM-узлов

Проект Google Polymer использует WeakMap во фрагменте кода под названием PositionWalker.

PositionWalker отслеживает положение в поддереве DOM в качестве текущего узла и смещение в этом узле.

WeakMap используется для отслеживания изменений, удалений и изменений узла DOM:

_makeClone() {
  this._containerClone = this.container.cloneNode(true);
  this._cloneToNodes = new WeakMap();
  this._nodesToClones = new WeakMap();

  ...

  let n = this.container;
  let c = this._containerClone;

  // find the currentNode's clone
  while (n !== null) {
    if (n === this.currentNode) {
    this._currentNodeClone = c;
    }
    this._cloneToNodes.set(c, n);
    this._nodesToClones.set(n, c);

    n = iterator.nextNode();
    c = cloneIterator.nextNode();
  }
}

Troubleshooting

API Key and Billing Errors

Under certain circumstances, a darkened map, or ‘negative’ Street View image,
watermarked with the text «for development purposes only», may be displayed.
This behavior typically indicates issues with either an API key or billing.
In order to use Google Maps Platform products, billing must be enabled on your account,
and all requests must include a valid API key. The following flow will help troubleshoot this:

If your code isn’t working:

To help you get your maps code up and running, Brendan Kenny and Mano Marks point out
some common mistakes and how to fix them in this video.

• Look for typos. Remember that JavaScript is a case-sensitive
  language.
• Check the basics — some of the most common problems occur with the
  initial map creation. Such as:
  • Confirm that you’ve specified the
    and properties in your map
    options.
  • Ensure that you have declared a div element in which the map will
    appear on the screen.
  • Ensure that the div element for the map has a height. By default,
    div elements are created with a height of 0, and are therefore
    invisible.

  Refer to our examples for a
  reference
  implementation.

• Use a JavaScript debugger to help identify problems, like the one available
  in the Chrome
  Developer Tools. Start by looking in the JavaScript console for errors.
• Post questions to Stack
  Overflow. Guidelines on how to post great questions are available on
  the Support page.

Map

– коллекция для хранения записей вида .

В отличие от объектов, в которых ключами могут быть только строки, в ключом может быть произвольное значение, например:

Как видно из примера выше, для сохранения и чтения значений используются методы и . И ключи и значения сохраняются «как есть», без преобразований типов.

Свойство хранит общее количество записей в .

Метод можно чейнить:

При создании можно сразу инициализировать списком значений.

Объект с тремя ключами, как и в примере выше:

Аргументом должен быть итерируемый объект (не обязательно именно массив). Везде утиная типизация, максимальная гибкость.

В качестве ключей можно использовать и объекты:

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

Как map сравнивает ключи

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

Этот алгоритм нельзя изменять или задавать свою функцию сравнения.

Методы для удаления записей:

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

Для проверки существования ключа:

map.has(key) – возвращает true, если ключ есть, иначе false.

Для итерации по используется один из трёх методов:

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

Например:

Перебор идёт в том же порядке, что и вставка

Перебор осуществляется в порядке вставки. Объекты гарантируют это, в отличие от обычных объектов .

Кроме того, у есть стандартный метод , аналогичный встроенному в массивы:

Пример: дополнительные данные

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

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

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

Давайте рассмотрим один пример.

Предположим, у нас есть код, который ведёт учёт посещений для пользователей. Информация хранится в коллекции : объект, представляющий пользователя, является ключом, а количество визитов – значением. Когда пользователь нас покидает (его объект удаляется сборщиком мусора), то больше нет смысла хранить соответствующий счётчик посещений.

Вот пример реализации счётчика посещений с использованием :

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

Теперь объект должен быть удалён сборщиком мусора, но он продолжает оставаться в памяти, так как является ключом в .

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

Проблемы можно избежать, если использовать :

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

reduce и reduceRight

Если нам нужно
перебрать массив – мы можем использовать forEach, for или for..of. Если нужно
перебрать массив и вернуть данные для каждого элемента – мы используем map.

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

Синтаксис:

let value =
ar.reduce(function(previousValue, item, index, array) {

  // …

}, );

Функция
применяется по очереди ко всем элементам массива и «переносит» свой результат
на следующий вызов. Ее аргументы:

• previousValue
  – результат предыдущего вызова этой функции, равен initial при первом вызове
  (если передан initial);

• item
  – очередной элемент массива;

• index
  – его индекс;

• array
  – сам массив.

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

let digs = 1, -2, 100, 3, 9, 54;
 
let sum = digs.reduce((sum, current) => sum+current, );
console.log(sum);

Здесь значение sum при первом
вызове будет равно 0, так как мы вторым аргументом метода reduce указали 0 – это
начальное значение previousValue (то есть sum). Затем, на
каждой итерации мы будем иметь ранее вычисленное значение sum, к которому
прибавляем значение текущего элемента – current. Так и
подсчитывается сумма.

А вот примеры
вычисления произведения элементов массива:

let pr = digs.reduce((pr, current) => pr*current, 1);
console.log(pr);

Здесь мы уже
указываем начальное значение 1, иначе бы все произведение было бы равно нулю.

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

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

let digs = ;
let pr = digs.reduce((pr, current) => pr*current);

Поэтому, лучше
использовать начальное значение.

Метод
reduceRight работает аналогично, но проходит по массиву справа налево.

Объекты Set

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

Для инициализации Set используется синтаксис new Set():

Элементы можно добавить в Set с помощью метода add(). Не следует путать его с методом set(), который есть в Map, (хотя они похожи).

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

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

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

И наоборот, Set можно преобразовать в массив с помощью всего одной строки кода:

Set поддерживает много тех же методов и свойств, что и Map, включая delete(), has(), clear() и size.

Обратите внимание, Set не предоставляет доступа к значению по ключу или индексу, как Map.get(key) или arr

Ключи, значения и записи Set

У Map и Set есть методы keys(), values​​() и entries(), которые возвращают Iterator. В Map каждый из этих методов имеет отдельное назначение, но Set не имеет ключей, и поэтому ключи являются псевдонимами для значений. Это означает, что keys() и values​​() будут возвращать один и тот же Iterator, а entries() будет возвращать значение дважды. Лучше всего использовать в Set только values​​(), так как два других метода существуют для согласованности и перекрестной совместимости с Map.

Итерация Set

Как и Map, Set имеет встроенный метод forEach(). Поскольку Set не имеет ключей, первый и второй параметр обратного вызова forEach() возвращают одно и то же значение. Поэтому Set нельзя использовать вне совместимости с Map. Параметры forEach() – это (value, key, set).

В Set можно использовать как forEach(), так и for…of. Давайте посмотрим на итерацию forEach():

А теперь можно взглянуть на версию for…of:

Обе эти стратегии вернут такой результат:

Свойства и методы Set

В следующей таблице вы найдете список свойств и методов Set для быстрого ознакомления:

Свойства и методы	Описание	Вывод
add(value)	Добавляет в Set новый элемент	Объект Set
delete(value)	Удаляет указанный элемент из Set	Логическое значение
has()	Проверяет наличие элемента в Set	Логическое значение
clear()	Удаляет все элементы из Set	N/A
keys()	Возвращает все значения в Set (так же как values())	Объект SetIterator
values()	Возвращает все значения в Set (так же, как keys())	Объект SetIterator
entries()	Возвращает все значения в Set в формате	Объект SetIterator
forEach()	Перебирает Set в порядке вставки	N/A
size	Возвращает количество элементов в Set	Число

Использование структуры Set

Структура Set является полезным дополнением к инструментарию JavaScript, особенно для работы с дублирующимися значениями в данных.

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

Set может помочь вам определить пересечения и разницу между двумя наборами данных. Однако массивы имеют значительное преимущество перед Set, оно заключается в дополнительной обработке данных через методы sort(), map(), filter() и reduce(), а также в прямой совместимости с методами JSON.

map()

Мы почти у цели!

Map — это метод в прототипе массива, который возвращает новый массив из результатов вызова функции для каждого элемента исходного массива. Например, следующий код умножает каждый элемент массива на 3:

Теперь предположим, что я хочу вывести каждый элемент используя map() (и не используя return). Можно просто передать console.log в качестве аргумента в map() … правильно?

Происходит что-то странное. Вместо того чтобы выводить только значение, каждый вызов console.log выводит индекс и массив полностью.

При передаче функции в map() на каждой итерации она будет получать три аргумента: currentValue, currentIndex и полный array. Вот почему при каждой итерации выводятся три записи.

Теперь у нас есть всё что нужно для раскрытия тайны.

WeakSet

Коллекция ведёт себя похоже:

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

Будучи «слабой» версией оригинальной структуры данных, она тоже служит в качестве дополнительного хранилища. Но не для произвольных данных, а скорее для значений типа «да/нет». Присутствие во множестве может что-то сказать нам об объекте.

Наиболее значительным ограничением и является то, что их нельзя перебрать или взять всё содержимое. Это может доставлять неудобства, но не мешает выполнять их главную задачу – быть дополнительным хранилищем данных для объектов, управляемых из каких-то других мест в коде.

WeakMap

WeakMap — третья из новых коллекций ES6, которые мы представляем. WeakMap похожи на обычные Map, хотя с меньшим количеством методов и вышеупомянутой разницей в отношении сбора мусора.

const aboutAuthor = new WeakMap(); // Create New WeakMap
const currentAge = {}; // key must be an object
const currentCity = {}; // keys must be an object

aboutAuthor.set(currentAge, 30); // Set Key Values
aboutAuthor.set(currentCity, 'Denver'); // Key Values can be of different data types

console.log(aboutAuthor.has(currentCity)); // Test if WeakMap has a key

aboutAuthor.delete(currentAge); // Delete a key

WeakMap

The first difference between and is that keys must be objects, not primitive values:

Now, if we use an object as the key in it, and there are no other references to that object – it will be removed from memory (and from the map) automatically.

Compare it with the regular example above. Now if only exists as the key of – it will be automatically deleted from the map (and memory).

does not support iteration and methods , , , so there’s no way to get all keys or values from it.

has only the following methods:

Why such a limitation? That’s for technical reasons. If an object has lost all other references (like in the code above), then it is to be garbage-collected automatically. But technically it’s not exactly specified when the cleanup happens.

The JavaScript engine decides that. It may choose to perform the memory cleanup immediately or to wait and do the cleaning later when more deletions happen. So, technically, the current element count of a is not known. The engine may have cleaned it up or not, or did it partially. For that reason, methods that access all keys/values are not supported.

Now, where do we need such a data structure?

Итого

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

– это -подобная коллекция, которая хранит только объекты и удаляет их, как только они становятся недостижимыми иными путями.

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

и используются как вспомогательные структуры данных в дополнение к «основному» месту хранения объекта. Если объект удаляется из основного хранилища и нигде не используется, кроме как в качестве ключа в или в , то он будет удалён автоматически.

Итого

Объекты, которые можно использовать в цикле , называются итерируемыми.

• Технически итерируемые объекты должны иметь метод .
  • Результат вызова называется итератором. Он управляет процессом итерации.
  • Итератор должен иметь метод , который возвращает объект , где сигнализирует об окончании процесса итерации, в противном случае – следующее значение.
• Метод автоматически вызывается циклом , но можно вызвать его и напрямую.
• Встроенные итерируемые объекты, такие как строки или массивы, также реализуют метод .
• Строковый итератор знает про суррогатные пары.

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

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

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

Итого

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

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

К примеру, в обычном объекте нельзя использовать «совершенно любые» ключи. Есть встроенные методы, и уж точно есть свойство с названием , которое зарезервировано системой. Если название ключа даётся посетителем сайта, то он может попытаться использовать такое свойство, заменить прототип, а это, при запуске JavaScript на сервере, уже может привести к серьёзным ошибкам.

WeakMap и WeakSet – «урезанные» по функциональности варианты Map/Set, которые позволяют только «точечно» обращаться к элементам (по конкретному ключу или значению). Они не препятствуют сборке мусора, то есть, если ссылка на объект осталась только в WeakSet/WeakMap – она будет удалена.