Modifying the document

DOM değişiklikleri “canlı” sayfalar oluşturmak için anahtardır.

Burada, “anında” nasıl yeni öğeler yaratmayı ve var olan sayfa içeriğini değiştirmeyi göreceğiz.

İlk önce, basit bir örnek göreceğiz ve ondan sonra yöntemleri açıklacağız.

Example: show a message

BaÅŸlangıç için, sayfa üzerinde alertten daha güzel görünen bir mesajın nasıl eklendiÄŸini görelim.

İşte nasıl görüneceği:

<style>
.alert {
  padding: 15px;
  border: 1px solid #d6e9c6;
  border-radius: 4px;
  color: #3c763d;
  background-color: #dff0d8;
}
</style>

<div class="alert">
  <strong>Hi there!</strong>You've read an important message.
</div>

Bu bir HTML örneÄŸidir. Åžimdi aynı divi JavaScript ile oluÅŸturalım (farzedelim ki, styles(strong kelimesine referans) hala HTML içinde veya bir dışsal CSS dosyasıdır).

Creating an element

DOM düğümleri(nodes) oluşturmak icin iki yöntem vardır:

document.createElement(tag)

Verilen etiketle birlikte yeni bir element düğümü(element node) oluşturur:

let div = document.createElement('div');

document.createTextNode(text)

Verilen metinle yeni bir metin düğümü(text node) oluşturur:

let textNode = document.createTextNode('Here I am');

Creating the message

Bizim durumumuzda, verilen sınıflarla ve içindeki mesajla bir “div” yapmak istiyoruz:

let div = document.createElement('div');
div.className = "alert alert-success";
div.innerHTML = "<strong>Merhaba</strong> Onemli bir mesaj okudunuz.";

Bundan sonra, DOM elementimiz hazırdır. Şu anda, o sadece bir değişkendir ve onu göremeyiz. Bunun sebebi, o henüz sayfanın içine işlenmemiştir.

Insertion methods

Divi göstermek için, onu document içinde bir yere eklememiz gerekir. ÖrneÄŸin, document.body içinde.

Bunun için özel bir yöntem appendChild vardır: document.body.appendChild(div).

Ä°ste tam kod:

<style>
.alert {
  padding: 15px;
  border: 1px solid #d6e9c6;
  border-radius: 4px;
  color: #3c763d;
  background-color: #dff0d8;
}
</style>

<script>
  let div = document.createElement('div');
  div.className = "alert alert-success";
  div.innerHTML = "<strong>Hi there</strong>You've read an important message.";

  document.body.appendChild(div);
</script>

Burada, bir üst öğeye(parent element) düğüm(node) eklemek için kullanılan yöntemlerin kısa bir listesi (kısaca parentElem):

parentElem.appendChild(node)

parentElemin son öğesi(last child) olarak 'node’ı ekler.

Asagidaki örnek, <ol>un sonuna yeni bir <li> ekler:

<ol id="list">
  <li>0</li>
  <li>1</li>
  <li>2</li>
</ol>

<script>
  let newLi = document.createElement('li');
  newLi.innerHTML = 'Hello, world!';

  list.appendChild(newLi);
</script>

parentElem.insertBefore(node, nextSibling)

nextSiblingden önce parentEleme node ekler.

AÅŸağıdakı kod, ikinci <li>den önce yeni bir liste ekler:

<ol id="list">
  <li>0</li>
  <li>1</li>
  <li>2</li>
</ol>
<script>
  let newLi = document.createElement('li');
  newLi.innerHTML = 'Hello, world!';

  list.insertBefore(newLi, list.children[1]);
</script>

newLiyi ilk oÄŸe olarak eklemek icin, bunu şöyle yapabiliriz:

list.insertBefore(newLi, list.firstChild);

parentElem.replaceChild(node, oldChild)

parentElemin alt öğeleri arasında node ile birlikte oldChildi yenisiyle yer degistirir.

Tüm bu yöntemler eklenen düğümü geri döndürür. DiÄŸer anlatımla,parentElem.appendChild(node) nodei geri döndürür.Ama genellikle geri döndürülen deÄŸer kullanılmaz, sadece yöntemi çalıştırırız.

Bu yöntemler “eskimiştir”: eski zamanlardan beri varlar ve onlarla birçok eski scriptlerde karsılasabiliriz. Ne yazık ki, bunlar yeterince esnek değillerdir.

Örneğin, bir string olarak varsa html nasıl eklenir? Ya da, verilen bir düğüm, üst öğeye(parent) başvurmadan nasıl kaldırılır? Elbette ki, bu yapılabilinir, ama zarif bir şekilde değil.

Bu yüzden, tüm durumları kolayca idare etmek için iki ekleme yöntemi daha vardır.

prepend/append/before/after

Bu yöntemler kümesi daha esnek eklemeler sunar.

• node.append(...nodes or strings) – düğümün sonuna veya düğümlerin sonundaki stringlere node(düğüm) ekler,
• node.prepend(...nodes or strings) – düğüm veya düğüm başındaki stringlere node(düğüm) ekler,
• node.before(...nodes or strings) –- node(düğüm)'den önce düğümler veya stringler ekler,
• node.after(...nodes or strings) –- node(düğüm)'den sonra düğümler veya stringlere ekler,
• node.replaceWith(...nodes or strings) –- verilen düğümler veya stringler, node ile yer deÄŸistirir.

Bunlarin hepsi DOM düğümler ve/veya stringlerinin bir listesini kabul eder. Eğer bir string verilirse, metin düğümü(text node) olarak eklenir.

İşte bir listeye daha fazla madde(item) ve onun öncesinde/sonrasında metin eklemek için bu yöntemleri kullanmanın bir örneği:

<ol id="ol">
  <li>0</li>
  <li>1</li>
  <li>2</li>
</ol>

<script>
  ol.before('before');
  ol.after('after');

  let prepend = document.createElement('li');
  prepend.innerHTML = 'prepend';
  ol.prepend(prepend);

  let append = document.createElement('li');
  append.innerHTML = 'append';
  ol.append(append);
</script>

İşte yöntemlerin ne yaptığına dair küçük bir resim:

Öyleyse son liste şöyle olacak:

before
<ol id="ol">
  <li>prepend</li>
  <li>0</li>
  <li>1</li>
  <li>2</li>
  <li>append</li>
</ol>
after

Bu yöntemler, tek bir çağrıda çoklu düğümler ve metin parçalarının listesi ekleyebilir.

Örneğin, buraya bir string ve bir element eklenir:

<div id="div"></div>
<script>
  div.before('<p>Hello</p>', document.createElement('hr'));
</script>

Tüm metinler metin olarak eklenir.

Öyleyse son HTML:

<p>Hello</p>
<hr>
<div id="div"></div>

DiÄŸer bir deyiÅŸle, stringler elem.textContentin yaptığı gibi güvenli bir ÅŸekilde eklenir.

Böylece, bu yöntemler sadece DOM düğümleri veya metin parçaları eklemek için kullanılabilinir.

Ama HTML’yi “html olarak”, eklemek istersek, tüm etiketler(tags) ve elementlerle elem.innerHTML gibi çalışıyorsa?

insertAdjacentHTML/Text/Element

BaÅŸka, oldukça çok yönlü bir yöntem var: elem.insertAdjacentHTML(where, html).

İlk parametre, “elem” e göre nereye ekleneceğini belirleyen bir kod kelimesidir. Aşağıdakilerden biri olmalıdır:

• "beforebegin" – elemden hemen önce, html ekler,
• "afterbegin" – başında eleme html ekler,
• "beforeend" – sonunda eleme html" ekler,
• "afterend" – elemden hemen sonra, html ekler.

İkinci parametre “HTML olarak” eklenmiş bir HTML dizisi(string)dir, .

Örneğin:

<div id="div"></div>
<script>
  div.insertAdjacentHTML('beforebegin', '<p>Hello</p>');
  div.insertAdjacentHTML('afterend', '<p>Bye</p>');
</script>

…Şuna yönlendirir:

<p>Hello</p>
<div id="div"></div>
<p>Bye</p>

Bu şekilde sayfamıza isteğe bağlı bir HTML ekleyebiliriz.

İşte ekleme türevlerinin resmi:

Bu ve önceki resim arasındaki benzerlikleri kolayca fark edebiliriz. Ekleme noktaları aslında aynıdır, ancak bu yöntem HTML ekler.

Yöntemin iki kardeşi vardır:

• elem.insertAdjacentText(where, text) – ayn sözdizimi(syntax), ama bir “metin” dizesi HTML yerine “metin olarak” eklenir,
• elem.insertAdjacentElement(where, elem) – ayni sözdizimi(syntax), ama bir oge ekler,

Esas olarak sözdizimini(syntax) “düzgün” yapmak için vardırlar. Uygulamada, çoÄŸu zaman yalnızca “insertAdjacentHTML” kullanılır. Çünkü öğeler ve metin için append/prepend/before/after yöntemlerimiz var – Onlari yazmak daha kısadır ve düğüm/metin parçası ekleyebilirler.

İşte size bir mesaj göstermenin alternatif bir çeşidi:

<style>
.alert {
  padding: 15px;
  border: 1px solid #d6e9c6;
  border-radius: 4px;
  color: #3c763d;
  background-color: #dff0d8;
}
</style>

<script>
  document.body.insertAdjacentHTML("afterbegin", `<div class="alert alert-success">
    <strong>Hi there!</strong> You've read an important message.
  </div>`);
</script>

Cloning nodes: cloneNode

Benzer bir mesaj daha nasıl eklenir?

Bir iÅŸlev(function) yapabilir ve kodu oraya koyabiliriz. Ama alternatif yol, var olan divi klonlamak ve içindeki metni degistirmek olacaktır (eÄŸer gerekliyse).

Bazen büyük bir unsurumuz olduğunda, bu daha hızlı ve daha basit olabilir.

-ÇaÄŸrı elem.cloneNode(true) öğenin “derin” bir klonunu oluÅŸturur – tüm nitelikler ve alt(child) elementler ile… EÄŸer elem.cloneNode(false)i çağırırsak, daha sonra klon alt(child) elementler olmadan yapılır.

Mesaji kopyalamanın bir örneği:

<style>
.alert {
  padding: 15px;
  border: 1px solid #d6e9c6;
  border-radius: 4px;
  color: #3c763d;
  background-color: #dff0d8;
}
</style>

<div class="alert" id="div">
  <strong>Hi there!</strong>You've read an important message.
</div>

<script>
  let div2 = div.cloneNode(true); // mesaji kopyala
  div2.querySelector('strong').innerHTML = 'Bye there!'; // kopyayı değiştir

  div.after(div2); // varolan div'den sonra kopyayı göster
</script>

DocumentFragment

DocumentFragment düğüm listelerini geçirmek için bir sarıcı olarak görevi olan özel bir DOM düğümüdür.

Buna diğer düğümler ekleyebiliriz, ama bunu herhangi bir yere yerleştirdiğimizde, daha sonra içeriği bunun yerine eklenir.

ÖrneÄŸin, aÅŸağıdaki getListContent <li> öğeleriyle bir parça oluÅŸturur, ki daha sonra <ul>içine eklenir:

<ul id="ul"></ul>

<script>
function getListContent() {
  let fragment = new DocumentFragment();

  for(let i=1; i<=3; i++) {
    let li = document.createElement('li');
    li.append(i);
    fragment.append(li);
  }

  return fragment;
}

ul.append(getListContent()); // (*)
</script>

Lütfen not edin, sondaki satıra (*), DocumentFragmenti ekleriz, ama o “içine karışır”, sonuçta ortaya çıkan yapı:

<ul>
  <li>1</li>
  <li>2</li>
  <li>3</li>
</ul>

‘DocumentFragment’ pek nadir açıkça kullanılır. Bunun yerine bir sıra düğümü geri döndürebiliyorsak, neden özel bir düğüme eklemeliyiz? Yeniden yazılmış örnek:

<ul id="ul"></ul>

<script>
function getListContent() {
  let result = [];

  for(let i=1; i<=3; i++) {
    let li = document.createElement('li');
    li.append(i);
    result.push(li);
  }

  return result;
}

ul.append(...getListContent()); // append + "..." operator = friends!
</script>

Temel olarak DocumentFragment ifadesinden bahsediyoruz. çünkü bunun üzerinde template element, gibi bazı kavramlar vardır, ki daha sonra bunlari ele alacağız.

Removal methods

Düğümleri kaldırmak için, aşağıdaki yöntemler vardır:

parentElem.removeChild(node)

parentElemden nodeı kaldırır (Farzedelim ki, o bir alt öğedir(child)).

node.remove()

nodeı kendi yerinden kaldırır.

Kolayca görebiliriz ki, ikinci yöntem çok daha kısadır. İlki tarihsel nedenlerden dolayı vardır.

Eğer biz bir öğeyi baska bir yere *taşımak* istiyorsak --- Onu eskisinden kaldırmaya gerek yok.

**Tüm ekleme yöntemleri düğümü otomatik olarak eski yerinden kaldırır.**

 Örneğin, elementleri değiştirelim:

```html run height=50
<div id="first">First</div>
<div id="second">Second</div>
<script>
  // remove'i cağırmaya gerek yok
  second.after(first); // #second'i al ve ondan sonra - #first'i ekle 
</script>
```

Mesajımız bir saniye sonra ortadan kaybolsun:

<style>
.alert {
  padding: 15px;
  border: 1px solid #d6e9c6;
  border-radius: 4px;
  color: #3c763d;
  background-color: #dff0d8;
}
</style>

<script>
  let div = document.createElement('div');
  div.className = "alert alert-success";
  div.innerHTML = "<strong>Hi there!</strong> You've read an important message.";

  document.body.append(div);
  setTimeout(() => div.remove(), 1000);
  // or setTimeout(() => document.body.removeChild(div), 1000);
</script>

A word about “document.write”

Bir web sayfasına bir ÅŸey eklemenin çok eski bir yöntemi daha var: document.write.

Sözdizimi(Syntax):

<p>Somewhere in the page...</p>
<script>
  document.write('<b>Hello from JS</b>');
</script>
<p>The end</p>

document.write(html) çaÄŸrısı “burada ve ÅŸimdi” sayfasına ‘html’ yazar. html string dinamik olarak oluÅŸturulmus olabilir, bu nedenle esnektir. Tam teÅŸekküllü bir web sayfası oluÅŸturmak ve yazmak için JavaScript kullanabiliriz.

Yöntem DOM’un, standartların olmadığı zamanlardan geliyor… Gerçekten eski zamanlar. O hala yaşıyor, çünkü onu kullanan scriptler vardır.

Modern scriptlerde, onu pek nadir görebiliriz, çünkü aşağıdaki önemli sınırlama nedeniyle:

“document.write” çağrısı yalnızca sayfa yüklenirken yapılır

Eğer onu daha sonra çağırırsak, var olan belge içeriği silinmiş olur.

Örneğin:

<p>Bir saniye sonra bu sayfanın içeriği değiştirilmiş olacak...</p>
<script>
  // document.write after 1 second
  // that's after the page loaded, so it erases the existing content
  setTimeout(() => document.write('<b>...By this.</b>'), 1000);
</script>

Öyleyse, yukarıda bahsettiğimiz diğer DOM yöntemlerinin aksine, “yüklendikten sonra” aşamasında kullanılamaz olur.

Bu olumsuz tarafıydı.

Teknik olarak, internet tarayıcı gelen HTML’yi okurken, (“parsing/ayrıştırma”) document.write çaÄŸrılır ve bir ÅŸey yazar, tarayıcı HTML metninde ilk baÅŸta olduÄŸu gibi onu iÅŸler.

Ki bize olumlu tarafı verir – o çok hızlı çalışır, çünkü DOM değişikligi yoktur. DOM henüz oluşturulmamışken, onu doğrudan sayfadaki metne yazar, ve internet tarayıcı oluşum-süresinde onu DOM’a yerleştirir.

Öyleyse, HTML’ye dinamik olarak çok fazla metin eklememiz gerekirse ve biz sayfa yükleme aşamasındayız ve hız önemlidir, bu yardım edebilir. Ama uygulamada bu gereksinimler pek nadir bir araya gelir. Ve genellikle biz bu yöntemi sadece eski olan scriptlerde görebiliriz.

Summary

Yeni düğümler yaratma yöntemleri:

• document.createElement(tag) – verilen etiketle(tag) bir element yaratır,
• document.createTextNode(value) – bir metin düğümü(text node) yaratır (pek nadir kullanılır),
• elem.cloneNode(deep) – elementi kopyalar, eÄŸer deep==true tüm alt içerikleriyle ise.

-Düğümlerin yerleştirilmesi ve çıkarılması:

– En üst ogeden(parent):

• parent.appendChild(node)
• parent.insertBefore(node, nextSibling)
• parent.removeChild(node)
• parent.replaceChild(newElem, node)

Tüm bu yöntemler nodeı geri dönderir.

• Düğümler ve komut dosyalarinin verilmis bir listesi:

  • node.append(...nodes or strings) – sonunda ‘düğüme’ ekler,
  • node.prepend(...nodes or strings) – başında “düğüme” ekler,
  • node.before(...nodes or strings) –- düğümden hemen önce ekler,
  • node.after(...nodes or strings) –- düğümden hemen sonra ekler,
  • node.replaceWith(...nodes or strings) –- “düğümü” deÄŸiÅŸtir.
  • node.remove() –- “düğümü” kaldırır.

  Metin stringler “metin olarak” eklenir.

• Bir parca verilen HTML: elem.insertAdjacentHTML(where, html), nereye baÄŸlı olduÄŸuna dair ekleme yapar:

  • "beforebegin" – elemden hemen önce html ekler,
  • "afterbegin" – baÅŸinda eleme html ekler,
  • "beforeend" – sonunda eleme html ekler,
  • "afterend" – elemden hemen sonra html ekler.

  Ayrıca benzer yöntemler elem.insertAdjacentText ve elem.insertAdjacentElement vardır, onlar metin stringler ve elementler ekler, ama pek nadir kullanılır.

• Yükleme tamamlanmadan önce HTML’yi sayfaya eklemek için:

  • document.write(html)

  Sayfa yüklendikten sonra böyle bir çağrı belgeyi siler. Çoğunlukla eski scriptlerde görülür