Про сравнение нескольких элементов HTML DOM-дерева с использованием JavaScript(сравнение знаком === идёт по совпадению ссылок на объект)

Описание товара

Несколько другая тема, хотя и будут общие моменты. Предположим что в HTML есть 3 тега видео. Их атрибуты одинаковы(src не используется, контент загружается через JavaScript). Предположим что получены эти элементы через getElementsByTagName и переменной var1230 присвоен второй элемент. Если где то в коде эти теги будут перебираться(например тем же getElementsByTagName или querySelector можно ли проверить текущий элемент совпадает ли с элементом, который присвоен переменной var1230 то-есть вторым элементом).

Да, можно проверить, совпадает ли текущий элемент в переборе с элементом, сохранённым в переменной var1230.

Способы сравнения элементов

В JavaScript DOM-элементы — это объекты, и их сравнение работает по ссылке. То есть два элемента считаются одинаковыми, только если они ссылаются на один и тот же объект в памяти.

Пример проверки. Допустим, у нас есть три <video> элемента:

    
<video></video>
<video></video>
<video></video>

  

Мы получаем их через getElementsByTagName и сохраняем второй элемент в var1230:

    
const videos = document.getElementsByTagName('video');
const var1230 = videos[1]; // Второй элемент (индексация с 0)

  

1. Перебор через цикл и сравнение

Если мы перебираем элементы (например, через for...of или forEach), можно просто сравнить текущий элемент с var1230:

    
for (const video of videos) {
    if (video === var1230) {
        console.log("Это второй элемент (var1230)!");
    } else {
        console.log("Это не он.");
    }
}

  

2. Использование Array.from и findIndex

Если нужно узнать позицию элемента в коллекции:

3. Проверка в querySelectorAll или других методах

Если используется querySelectorAll, логика та же:

    
const allVideos = document.querySelectorAll('video');
allVideos.forEach((video, index) => {
    if (video === var1230) {
        console.log(`Совпадение! Это элемент с индексом ${index}`);
    }
});

  

Вывод

• да, можно проверить, совпадает ли текущий элемент с var1230 через простое сравнение ===;
• если нужно найти его позицию, можно использовать indexOf или перебор с индексом;
• такой подход работает с любыми DOM-элементами, не только с <video>.

Пример итогового кода:

    
const videos = document.getElementsByTagName('video');
const var1230 = videos[1]; // Второй элемент
      
// Проверка в цикле
for (let i = 0; i < videos.length; i++) {
    if (videos[i] === var1230) {
        console.log(`Элемент с индексом ${i} совпадает с var1230!`);
    }
}
      
// Альтернативно: через Array.from
if (Array.from(videos).includes(var1230)) {
    console.log("var1230 есть в коллекции!");
}

  

Этот подход надежен и будет работать в любом современном браузере.

А уточните пожалуйста, ведь как я указал содержание атрибутов у тегов video одинаковое(у всех 3-х), и как Вы привели в примере у всех их совсем нет атрибутов. Поэтому вопрос про то как JavaScript определяет что это именно тот элемент, может быть при создании элементов в DOM-дереве им присваивается какой то идентификатор(возможно системный и тогда элементы всё же отличаются), тогда может быть можно этот идентификатор как то получить. Или может быть у элементов есть какое то другое отличительное свойство?

Отличный вопрос! Да, даже если у элементов одинаковые атрибуты (или вообще нет атрибутов), JavaScript всё равно различает их, потому что:

1. DOM-элементы — это уникальные объекты в памяти

Когда браузер создаёт DOM-узел (например, <video>), он выделяет под него отдельную область памяти. Даже если два элемента выглядят одинаково в HTML, они разные объекты, и JavaScript сравнивает их по ссылке, а не по содержимому.

Пример:

    
const video1 = document.createElement('video');
const video2 = document.createElement('video');
      
console.log(video1 === video2); // false (это разные объекты)

  

Хоть оба <video> пустые, они не равны, потому что это два разных объекта.

2. Как JavaScript понимает, что это "тот самый" элемент?

При сравнении element1 === element2 JavaScript проверяет, ссылаются ли переменные на один и тот же объект в памяти.

Пример с вашим случаем (var1230 и перебором):

    
const videos = document.getElementsByTagName('video');
const var1230 = videos[1]; // Запомнили второй элемент
      
for (const video of videos) {
    console.log(video === var1230); // true только для второго элемента
}

  

Здесь video === var1230 даст true только когда цикл дойдёт до второго элемента, потому что это тот же самый объект.

3. Есть ли у DOM-элементов "скрытый идентификатор"?

Да, косвенно. Браузеры внутренне помечают элементы уникальными идентификаторами, но:

• нет стандартного способа получить этот ID (это внутренняя реализация движка);
• но можно использовать WeakMap или Symbol для добавления своего идентификатора.

Пример с WeakMap:

    
const idMap = new WeakMap();
let counter = 0;
      
const videos = document.getElementsByTagName('video');
      
// Назначим каждому video уникальный ID
for (const video of videos) {
    idMap.set(video, counter++);
}
      
// Получаем ID элемента
const var1230 = videos[1];
console.log(idMap.get(var1230)); // 1 (если это второй элемент)

  

Так можно назначить элементам свои ID, но нативно их нет.

4. Другие способы отличить элементы (если атрибуты одинаковые)

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

а) Node.isSameNode() (устаревший, но работает)

    
const videos = document.querySelectorAll('video');
const var1230 = videos[1];
console.log(videos[1].isSameNode(var1230)); // true

  

б) Позиция в DOM (parentNode, previousSibling и т. д.)

    
const var1230 = document.getElementsByTagName('video')[1];
console.log(var1230.previousElementSibling); // Первый <video>
console.log(var1230.nextElementSibling);     // Третий <video>

  

в) Временное добавление data-id (если можно менять DOM)

    
document.getElementsByTagName('video')[1].dataset.id = "target";
// Потом можно искать: document.querySelector('[data-id="target"]')

  

Вывод

Да, JavaScript различает элементы, даже если они выглядят одинаково, потому что каждый DOM-узел — уникальный объект в памяти. Сравнение === работает, потому что проверяет ссылку на объект, а не атрибуты.

Скрытого ID нет, но можно добавить свой через WeakMap или data-атрибуты.

Если нужно найти элемент по позиции — можно использовать parentNode.children, previousSibling и т. д.

Итоговый пример:

    
// 1. Получаем все <video>
const videos = document.getElementsByTagName('video');
      
// 2. Запоминаем второй элемент
const var1230 = videos[1];
      
// 3. Проверяем, есть ли он в коллекции
console.log(Array.from(videos).includes(var1230)); // true
      
// 4. Проверяем, что это именно второй элемент
console.log(videos[1] === var1230); // true

  

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

Уточните пожалуйста, вы привели пример с самостоятельной индексацией с использованием idMap.set, а если таким образом 2-м элементам будет присвоен один идентификатор, будут ли они равны(имею ввиду операцию ===)?

Отличный уточняющий вопрос! Давайте разберёмся детально.

1. WeakMap не делает элементы равными (===), она просто связывает их с дополнительными данными

Когда вы используете:

    
const idMap = new WeakMap();
idMap.set(element1, 123);
idMap.set(element2, 123); // Тот же ID

  

element1 === element2 всё равно будет false, потому что:

WeakMap просто сопоставляет объект с каким-то значением (например, числом или строкой).

Она не изменяет сам объект и не влияет на сравнение через ===.

    
const video1 = document.createElement('video');
const video2 = document.createElement('video');
      
const idMap = new WeakMap();
idMap.set(video1, 100);
idMap.set(video2, 100); // Тот же ID
      
console.log(video1 === video2); // false (это разные объекты)
console.log(idMap.get(video1) === idMap.get(video2)); // true (но это сравнение чисел, не элементов)

  

Вывод:

video1 и video2 не равны через ===, даже если им назначен одинаковый ID в WeakMap.

WeakMap — это просто внешнее хранилище данных, а не способ изменить поведение оператора ===.

2. Когда два элемента будут равны (===)?

Только если это один и тот же объект в памяти:

    
const video1 = document.createElement('video');
const video2 = video1; // Передача по ссылке
      
console.log(video1 === video2); // true (это одна и та же ссылка)
Пример с вашим случаем (var1230):
javascript
const videos = document.querySelectorAll('video');
const var1230 = videos[1]; // Второй элемент
      
// Добавляем в WeakMap один и тот же ID для двух элементов
const idMap = new WeakMap();
idMap.set(videos[1], 10);
idMap.set(videos[2], 10); // Такой же ID
      
// Проверяем равенство
console.log(videos[1] === var1230); // true (это один и тот же элемент)
console.log(videos[1] === videos[2]); // false (разные элементы, даже если ID в WeakMap совпадает)

  

3. Можно ли сделать так, чтобы === возвращал true для разных элементов?

Нет, это невозможно.

Оператор === в JavaScript сравнивает:

• Примитивы (числа, строки) — по значению.
• Объекты (включая DOM-элементы) — по ссылке.

Нельзя переопределить === для объектов. Даже если:

• у элементов одинаковые атрибуты,
• им назначен одинаковый ID в WeakMap,
• они находятся в одном месте DOM,

они всё равно будут разными для ===, если это не один и тот же объект.

4. Что делать, если нужно сравнивать элементы по кастомному ID?

Если важно проверять элементы по значению из WeakMap, можно написать функцию-обёртку:

    
const idMap = new WeakMap();
      
function areElementsEqual(element1, element2) {
    return idMap.get(element1) === idMap.get(element2);
}
      
// Пример
const video1 = document.createElement('video');
const video2 = document.createElement('video');
      
idMap.set(video1, 5);
idMap.set(video2, 5);
      
console.log(areElementsEqual(video1, video2)); // true (потому что ID совпадают)
console.log(video1 === video2); // false (как и раньше)

  

Вывод

• WeakMap не влияет на сравнение === — два элемента будут равны только если это один и тот же объект;
• даже с одинаковыми id в WeakMap элементы остаются разными для ===;
• если нужно сравнивать по ID — используйте функцию-обёртку (как areElementsEqual выше).

Итоговый пример:

    
const videos = document.querySelectorAll('video');
const idMap = new WeakMap();
      
// Назначим второму и третьему video одинаковый ID
idMap.set(videos[1], 100);
idMap.set(videos[2], 100);
      
// Проверка
console.log(videos[1] === videos[2]); // false (разные объекты)
console.log(idMap.get(videos[1]) === idMap.get(videos[2])); // true (ID совпадают)

  

Таким образом, === сравнивает ссылки, а не содержимое WeakMap. Если нужно сравнение по ID — придётся писать дополнительную логику.

Другие товары