Техники работы с DOM: родительские, дочерние и соседние элементы
RightArrowParents = this.dom(); //.dom(); is the pseudo function ... it should show the whole

Псевдокод
alert(rightArrowParents);
Сообщение о тревоге будет:
body div.lol a.rightArrow
Как я могу получить это с помощью javascript / jquery?
Использование jQuery, как и это (за ним следует решение, которое не использует jQuery, за исключением события, намного меньше вызовов функций, если это важно):
Пример в реальном времени:
var rightArrowParents = ;
var entry = this.tagName.toLowerCase();
if (this.className) {
entry += "." + this.className.replace(/ /g, ".");
rightArrowParents.push(entry);
alert(rightArrowParents.join(" "));
return false;
Click here
(В живых примерах я обновил атрибут class на div как lol multi до продемонстрировать обработку нескольких классов.)
Вот решение для точного соответствия элемента.
Важно понимать, что селектор
( не является реальным
), которые показывают хром-инструменты, однозначно не идентифицируют элемент в DOM. ( , например, он не будет различать список последовательных элементов span . Нет информации о позиционировании / индексировании
var path = this.parents().addBack();
var self = $(item),
id = item.id ? "#" + item.id: "",
return "." + c;
}).join("") : "",
name = item.nodeName.toLowerCase(),
index = self.siblings(name).length ? ":nth-child(" + (self.index() + 1) + ")" : "";
if (name === "html" || name === "body") {
return name;
return name + index + id + clss;
}).join(" ");
return quickCss;
И вы можете использовать его так:
Console.log($("some-selector").fullSelector());
Я переместил фрагмент из T.J. Кроудер к крошечному плагину jQuery. Я использовал версию jQuery, даже если он прав, что это совершенно лишние накладные расходы, но я использую его только для целей отладки, поэтому мне все равно.
Использование:
Nested span
Simple span
Pre
// result (array): ["body", "div.sampleClass"]
$("span").getDomPath(false)
// result (string): body > div.sampleClass
$("span").getDomPath()
// result (array): ["body", "div#test"]
$("pre").getDomPath(false)
// result (string): body > div#test
$("pre").getDomPath()
Var obj = $("#show-editor-button"),
path = "";
while (typeof obj.prop("tagName") != "undefined"){
if (obj.attr("class")){
path = "."+obj.attr("class").replace(/\s/g , ".") + path;
if (obj.attr("id")){
path = "#"+obj.attr("id") + path;
path = " " +obj.prop("tagName").toLowerCase() + path;
obj = obj.parent();
console.log(path);
hello эта функция разрешает ошибку, связанную с текущим элементом, не отображаемым в пути
Проверьте это сейчас
selectedElement=$j(event.target);
var rightArrowParents = ;
var entry = this.tagName.toLowerCase();
if (this.className) {
entry += "." + this.className.replace(/ /g, ".");
}else if(this.id){
entry += "#" + this.id;
entry=replaceAll(entry,"..",".");
rightArrowParents.push(entry);
rightArrowParents.reverse();
//if(event.target.nodeName.toLowerCase()=="a" || event.target.nodeName.toLowerCase()=="h1"){
var entry = event.target.nodeName.toLowerCase();
if (event.target.className) {
entry += "." + event.target.className.replace(/ /g, ".");
}else if(event.target.id){
entry += "#" + event.target.id;
rightArrowParents.push(entry);
// }
Где $j = jQuery Variable
Также решить проблему с.. В классе имя
Здесь функция замены:
Function escapeRegExp(str) {
return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
function replaceAll(str, find, replace) {
return str.replace(new RegExp(escapeRegExp(find), "g"), replace);
Вот родная версия JS, которая возвращает путь jQuery. Я также добавляю идентификаторы для элементов, если они есть. Это даст вам возможность сделать кратчайший путь, если вы увидите идентификатор в массиве.
Var path = getDomPath(element);
console.log(path.join(" "));
Body > section:eq(0) > div:eq(3) > section#content > section#firehose > div#firehoselist > article#firehose-46813651 > header > h2 > span#title-46813651
Вот функция.
Function getDomPath(el) {
var stack = ;
while (el.parentNode != null) {
console.log(el.nodeName);
var sibCount = 0;
var sibIndex = 0;
for (var i = 0; i < el.parentNode.childNodes.length; i++) {
var sib = el.parentNode.childNodes[i];
if (sib.nodeName == el.nodeName) {
if (sib === el) {
sibIndex = sibCount;
sibCount++;
if (el.hasAttribute("id") && el.id != "") {
stack.unshift(el.nodeName.toLowerCase() + "#" + el.id);
} else if (sibCount > 1) {
stack.unshift(el.nodeName.toLowerCase() + ":eq(" + sibIndex + ")");
} else {
stack.unshift(el.nodeName.toLowerCase());
el = el.parentNode;
return stack.slice(1); // removes the html element
Как правило, когда нужно выполнить какие-либо действия с DOM, разработчики используют jQuery. Однако практически любую манипуляцию с DOM можно сделать и на чистом JavaScript с помощью его DOM API.
Рассмотрим этот API более подробно:
В конце вы напишете свою простенькую DOM-библиотеку, которую можно будет использовать в любом проекте.
DOM-запросы
DOM-запросы осуществляются с помощью метода.querySelector() , который в качестве аргумента принимает произвольный СSS-селектор.
Const myElement = document.querySelector("#foo > div.bar")
Он вернёт первый подходящий элемент. Можно и наоборот - проверить, соответствует ли элемент селектору:
MyElement.matches("div.bar") === true
Если нужно получить все элементы, соответствующие селектору, используйте следующую конструкцию:
Const myElements = document.querySelectorAll(".bar")
Если же вы знаете, на какой родительский элемент нужно сослаться, можете просто проводить поиск среди его дочерних элементов, вместо того чтобы искать по всему коду:
Const myChildElemet = myElement.querySelector("input")
// Вместо:
// document.querySelector("#foo > div.bar input")
Возникает вопрос: зачем тогда использовать другие, менее удобные методы вроде.getElementsByTagName() ? Есть маленькая проблема - результат вывода.querySelector() не обновляется, и когда мы добавим новый элемент (смотрите ), он не изменится.
Const elements1 = document.querySelectorAll("div")
const elements2 = document.getElementsByTagName("div")
const newElement = document.createElement("div")
document.body.appendChild(newElement)
elements1.length === elements2.length // false
Также querySelectorAll() собирает всё в один список, что делает его не очень эффективным.
Как работать со списками?
Вдобавок ко всему у.querySelectorAll() есть два маленьких нюанса. Вы не можете просто вызывать методы на результаты и ожидать, что они применятся к каждому из них (как вы могли привыкнуть делать это с jQuery). В любом случае нужно будет перебирать все элементы в цикле. Второе - возвращаемый объект является списком элементов, а не массивом. Следовательно, методы массивов не сработают. Конечно, есть методы и для списков, что-то вроде.forEach() , но, увы, они подходят не для всех случаев. Так что лучше преобразовать список в массив:
// Использование Array.from()
Array.from(myElements).forEach(doSomethingWithEachElement)
// Или прототип массива (до ES6)
Array.prototype.forEach.call(myElements, doSomethingWithEachElement)
// Проще:
.forEach.call(myElements, doSomethingWithEachElement)
У каждого элемента есть некоторые свойства, ссылающиеся на "семью".
MyElement.children
myElement.firstElementChild
myElement.lastElementChild
myElement.previousElementSibling
myElement.nextElementSibling
Поскольку интерфейс элемента (Element) унаследован от интерфейса узла (Node), следующие свойства тоже присутствуют:
MyElement.childNodes
myElement.firstChild
myElement.lastChild
myElement.previousSibling
myElement.nextSibling
myElement.parentNode
myElement.parentElement
Первые свойства ссылаются на элемент, а последние (за исключением.parentElement) могут быть списками элементов любого типа. Соответственно, можно проверить и тип элемента:
MyElement.firstChild.nodeType === 3 // этот элемент будет текстовым узлом
Добавление классов и атрибутов
Добавить новый класс очень просто:
MyElement.classList.add("foo")
myElement.classList.remove("bar")
myElement.classList.toggle("baz")
Добавление свойства для элемента происходит точно так же, как и для любого объекта:
// Получение значения атрибута
const value = myElement.value
// Установка атрибута в качестве свойства элемента
myElement.value = "foo"
// Для установки нескольких свойств используйте.Object.assign()
Object.assign(myElement, {
value: "foo",
id: "bar"
// Удаление атрибута
myElement.value = null
Можно использовать методы.getAttibute() , .setAttribute() и.removeAttribute() . Они сразу же поменяют HTML-атрибуты элемента (в отличие от DOM-свойств), что вызовет браузерную перерисовку (вы сможете увидеть все изменения, изучив элемент с помощью инструментов разработчика в браузере). Такие перерисовки не только требуют больше ресурсов, чем установка DOM-свойств, но и могут привести к непредвиденным ошибкам.
Как правило, их используют для элементов, у которых нет соответствующих DOM-свойств, например colspan . Или же если их использование действительно необходимо, например для HTML-свойств при наследовании (смотрите ).
Добавление CSS-стилей
Добавляют их точно так же, как и другие свойства:
MyElement.style.marginLeft = "2em"
Какие-то определённые свойства можно задавать используя.style , но если вы хотите получить значения после некоторых вычислений, то лучше использовать window.getComputedStyle() . Этот метод получает элемент и возвращает CSSStyleDeclaration , содержащий стили как самого элемента, так и его родителя:
Window.getComputedStyle(myElement).getPropertyValue("margin-left")
Изменение DOM
Можно перемещать элементы:
// Добавление element1 как последнего дочернего элемента element2
element1.appendChild(element2)
// Вставка element2 как дочернего элемента element1 перед element3
element1.insertBefore(element2, element3)
Если не хочется перемещать, но нужно вставить копию, используем:
// Создание клона
const myElementClone = myElement.cloneNode()
myParentElement.appendChild(myElementClone)
Метод.cloneNode() принимает булевое значение в качестве аргумента, при true также клонируются и дочерние элементы.
Конечно, вы можете создавать новые элементы:
Const myNewElement = document.createElement("div")
const myNewTextNode = document.createTextNode("some text")
А затем вставлять их как было показано выше. Удалить элемент напрямую не получится, но можно сделать это через родительский элемент:
MyParentElement.removeChild(myElement)
Можно обратиться и косвенно:
MyElement.parentNode.removeChild(myElement)
Методы для элементов
У каждого элемента присутствуют такие свойства, как.innerHTML и.textContent , они содержат HTML-код и, соответственно, сам текст. В следующем примере изменяется содержимое элемента:
// Изменяем HTML
myElement.innerHTML = `
New content {
console.log(event.target.value)
Предотвращение действий по умолчанию
Для этого используется метод.preventDefault() , который блокирует стандартные действия. Например, он заблокирует отправку формы, если авторизация на клиентской стороне не была успешной:
const name = this.querySelector("#name")
if (name.value === "Donald Duck") {
alert("You gotta be kidding!")
event.preventDefault()
Метод.stopPropagation() поможет, если у вас есть определённый обработчик события, закреплённый за дочерним элементом, и второй обработчик того же события, закреплённый за родителем.
Как говорилось ранее, метод.addEventListener() принимает третий необязательный аргумент в виде объекта с конфигурацией. Этот объект должен содержать любые из следующих булевых свойств (по умолчанию все в значении false):
- capture: событие будет прикреплено к этому элементу перед любым другим элементом ниже в DOM;
- once: событие может быть закреплено лишь единожды;
- passive: event.preventDefault() будет игнорироваться (исключение во время ошибки).
Наиболее распространённым свойством является.capture , и оно настолько распространено, что для этого существует краткий способ записи: вместо того чтобы передавать его в объекте конфигурации, просто укажите его значение здесь:
MyElement.addEventListener(type, listener, true)
Обработчики удаляются с помощью метода.removeEventListener() , принимающего два аргумента: тип события и ссылку на обработчик для удаления. Например свойство once можно реализовать так:
MyElement.addEventListener("change", function listener (event) {
console.log(event.type + " got triggered on " + this)
this.removeEventListener("change", listener)
Наследование
Допустим, у вас есть элемент и вы хотите добавить обработчик событий для всех его дочерних элементов. Тогда бы вам пришлось прогнать их в цикле, используя метод myForm.querySelectorAll("input") , как было показано выше. Однако вы можете просто добавить элементы в форму и проверить их содержимое с помощью event.target .
const target = event.target
if (target.matches("input")) {
console.log(target.value)
И ещё один плюс данного метода заключается в том, что к новым дочерним элементам обработчик будет привязываться автоматически.
Анимация
Проще всего добавить анимацию используя CSS со свойством transition . Но для большей гибкости (например для игры) лучше подходит JavaScript.
Вызывать метод window.setTimeout() , пока анимация не закончится, - не лучшая идея, так как ваше приложение может зависнуть, особенно на мобильных устройствах. Лучше использовать window.requestAnimationFrame() для сохранения всех изменений до следующей перерисовки. Он принимает функцию в качестве аргумента, которая в свою очередь получает метку времени:
Const start = window.performance.now()
const duration = 2000
window.requestAnimationFrame(function fadeIn (now)) {
const progress = now - start
myElement.style.opacity = progress / duration
if (progress < duration) {
window.requestAnimationFrame(fadeIn)
Таким способом достигается очень плавная анимация. В своей статье Марк Браун рассуждает на данную тему.
Пишем свою библиотеку
Тот факт, что в DOM для выполнения каких-либо операций с элементами всё время приходится перебирать их, может показаться весьма утомительным по сравнению с синтаксисом jQuery $(".foo").css({color: "red"}) . Но почему бы не написать несколько своих методов, облегчающую данную задачу?
Const $ = function $ (selector, context = document) {
const elements = Array.from(context.querySelectorAll(selector))
return {
elements,
html (newHtml) {
this.elements.forEach(element => {
element.innerHTML = newHtml
return this
css (newCss) {
this.elements.forEach(element => {
Object.assign(element.style, newCss)
return this
on (event, handler, options) {
this.elements.forEach(element => {
element.addEventListener(event, handler, options)
return this
Сложные и тяжелые веб-приложения стали обычными в наши дни. Кроссбраузерные и простые в использовании библиотеки типа jQuery с их широким функционалом могут сильно помочь в манипулировании DOM на лету. Поэтому неудивительно, что многие разработчики использую подобные библиотеки чаще, чем работают с нативным DOM API, с которым было немало проблем . И хотя различия в браузерах по-прежнему остаются проблемой, DOM находится сейчас в лучшей форме, чем 5-6 лет назад , когда jQuery набирал популярность.
Я дам данные о поддержке этих возможностей в браузерах, но учитывайте, что библиотека типа jQuery по-прежнему остается хорошей опцией в силу наличия багов и непоследовательностей в реализации нативного функционала.
Подсчет дочерних узлов
Для демонстрации я буду использовать следующую разметку HTML, в течение статьи мы ее несколько раз изменим:
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Var myList = document.getElementById("myList");
console.log(myList.children.length); // 6
console.log(myList.childElementCount); // 6
Как видите, результаты одинаковые, хотя техники используются разные. В первом случае я использую свойство children . Это свойство только для чтения, оно возвращает коллекцию элементов HTML, находящихся внутри запрашиваемого элемента; для подсчета их количества я использую свойство length этой коллекции.
Во втором примере я использую метод childElementCount , который мне кажется более аккуратным и потенциально более поддерживаемым способом (подробнее обсудим это позже, я не думаю, что у вас возникнут проблемы с пониманием того, что он делает).
Я мог бы попытаться использовать childNodes.length (вместо children.length), но посмотрите на результат:
Var myList = document.getElementById("myList");
console.log(myList.childNodes.length); // 13
Он возвращает 13, потому что childNodes это коллекция всех узлов, включая пробелы - учитывайте это, если вам важна разница между дочерними узлами и дочерними узлами-элементами.
Проверка существования дочерних узлов
Для проверки наличия у элемента дочерних узлов я могу использовать метод hasChildNodes() . Метод возвращает логическое значение, сообщающие об их наличии или отсутствии:
Var myList = document.getElementById("myList");
console.log(myList.hasChildNodes()); // true
Я знаю, что в моем списке есть дочерние узлы, но я могу изменить HTML так, чтобы их не было; теперь разметка выглядит так:
И вот результат нового запуска hasChildNodes() :
Console.log(myList.hasChildNodes()); // true
Метод по прежнему возвращает true . Хотя список не содержит никаких элементов, в нем есть пробел, являющийся валидным типом узла. Данный метод учитывает все узлы, не только узлы-элементы. Чтобы hasChildNodes() вернул false нам надо еще раз изменить разметку:
И теперь в консоль выводится ожидаемый результат:
Console.log(myList.hasChildNodes()); // false
Конечно, если я знаю, что могу столкнуться с пробелом, то сначала я проверю существование дочерних узлов, затем с помощью свойства nodeType определяю, есть ли среди них узлы-элементы.
Добавление и удаление дочерних элементов
Есть техника, которые можно использовать для добавления и удаления элементов из DOM. Наиболее известная из них основана на сочетании методов createElement() и appendChild() .
Var myEl = document.createElement("div");
document.body.appendChild(myEl);
В данном случае я создаю с помощью метода createElement() и затем добавляю его к body . Очень просто и вы наверняка использовали эту технику раньше.
Но вместо вставки специально создаваемого элемента, я также могу использовать appendChild() и просто переместить существующий элемент. Предположим, у нас следующая разметка:
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Example text
Я могу изменить место расположения списка с помощью следующего кода:
Var myList = document.getElementById("myList"),
container = document.getElementById("c");
container.appendChild(myList);
Итоговый DOM будет выглядеть следующим образом:
Example text
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Обратите внимание, что весь список был удален со своего места (над параграфом) и затем вставлен после него перед закрывающим body . И хотя обычно метод appendChild() используется для добавления элементов созданных с помощью createElement() , он также может использоваться для перемещения существующих элементов.
Я также могу полностью удалить дочерний элемент из DOM с помощью removeChild() . Вот как удаляется наш список из предыдущего примера:
Var myList = document.getElementById("myList"),
container = document.getElementById("c");
container.removeChild(myList);
Теперь элемент удален. Метод removeChild() возвращает удаленный элемент и я могу его сохранить на случай, если он потребуется мне позже.
Var myOldChild = document.body.removeChild(myList);
document.body.appendChild(myOldChild);
Таке существует метод ChildNode.remove() , относительно недавно добавленный в спецификацию:
Var myList = document.getElementById("myList");
myList.remove();
Этот метод не возвращает удаленный объект и не работает в IE (только в Edge). И оба метода удаляют текстовые узлы точно так же, как и узлы-элементы.
Замена дочерних элементов
Я могу заменить существующий дочерний элемент новым, независимо от того, существует ли этот новый элемент или я создал его с нуля. Вот разметка:
Example Text
Var myPar = document.getElementById("par"),
myDiv = document.createElement("div");
myDiv.className = "example";
myDiv.appendChild(document.createTextNode("New element text"));
document.body.replaceChild(myDiv, myPar);
New element text
Как видите, метод replaceChild() принимает два аргумента: новый элемент и заменяемый им старый элемент.
Я также могу использовать это метод для перемещения существующего элемента. Взгляните на следующий HTML:
Example text 1
Example text 2
Example text 3
Я могу заменить третий параграф первым параграфом с помощью следующего кода:
Var myPar1 = document.getElementById("par1"),
myPar3 = document.getElementById("par3");
document.body.replaceChild(myPar1, myPar3);
Теперь сгенерированный DOM выглядит так:
Example text 2
Example text 1
Выборка конкретных дочерних элементов
Существует несколько разных способов выбора конкретного элемента. Как показано ранее, я могу начать с использования коллекции children или свойства childNodes . Но взглянем на другие варианты:
Свойства firstElementChild и lastElementChild делают именно то, чего от них можно ожидать по их названию: выбирают первый и последний дочерние элементы. Вернемся к нашей разметке:
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Я могу выбрать первый и последний элементы с помощью этих свойств:
Var myList = document.getElementById("myList");
console.log(myList.firstElementChild.innerHTML); // "Example one"
console.log(myList.lastElementChild.innerHTML); // "Example six"
Я также могу использовать свойства previousElementSibling и nextElementSibling , если я хочу выбрать дочерние элементы, отличные от первого или последнего. Это делается сочетанием свойств firstElementChild и lastElementChild:
Var myList = document.getElementById("myList");
console.log(myList.firstElementChild.nextElementSibling.innerHTML); // "Example two"
console.log(myList.lastElementChild.previousElementSibling.innerHTML); // "Example five"
Также есть сходные свойства firstChild , lastChild , previousSibling , и nextSibling , но они учитывают все типы узлов, а не только элементы. Как правило, свойства, учитывающие только узлы-элементы полезнее тех, которые выбирают все узлы.
Вставка контента в DOM
Я уже рассматривал способы вставки элементов в DOM. Давайте перейдем к похожей теме и взглянем на новые возможности по вставке контента.
Во-первых, есть простой метод insertBefore() , он во многом похож на replaceChild() , принимает два аргумента и при этом работает как с новыми элементами, так и с существующими. Вот разметка:
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Example Paragraph
Обратите внимание на параграф, я собираюсь сначала убрать его, а затем вставить перед списком, все одним махом:
Var myList = document.getElementById("myList"),
container = document.getElementBy("c"),
myPar = document.getElementById("par");
container.insertBefore(myPar, myList);
В полученном HTML параграф будет перед списком и это еще один способ перенести элемент.
Example Paragraph
- Example one
- Example two
- Example three
- Example four
- Example five
- Example Six
Как и replaceChild() , insertBefore() принимает два аргумента: добавляемый элемент и элемент, перед которым мы хотим его вставить.
Этот метод прост. Попробуем теперь более мощный способ вставки: метод insertAdjacentHTML() .
Рубрика: Новичкам и программирование