Pages

Assimilation !


ATTENTION : ne pas utiliser jsbin pour tester les réponses du QUIZZ. 

Jsbin ajoute votre code js dans un script, ce qui ajoute un élément dans le dom. Vous pourrez tester ce problème avec ce code jsbin.

Comparer le résultat en utilisant ce fichier et en tapant dans la console F12 :
console.log(document.body.lastElementChild.nodeName); 

JSbin affiche : Script
alors que la console dans le fichier affiche :  P

Revision !

(function talksAbout(node, _string) {
     if ( --?-- )
        Array.from( node.childNodes ).forEach( function( node ) {
          talksAbout( node, _string  )
         });
     else if ( --?-- )
        if( node.nodeValue.indexOf( _string) > -1 )//.includes
           action;
})(document.body, "Dupont");


Revision




Etudier le code 

const cards = [];
   for(let suit of ['H', 'C', 'D', 'S']) // hearts, clubs, diamonds, spades
       for(let value=1; value<=13; value++)
           cards.push({ suit,value });

Object.keys(cards).forEach(function (c,i) {
 console.log(`carte N°${i} ${cards[c].suit}${cards[c].value}`);
});

for (let c of cards){
   console.log(`${c.suit}${c.value}`);
}


let dictionnary = { 'H': '\u2665', 'C': '\u2663', 'D': '\u2666', 'S': '\u2660',  1: 'A', 11: 'J', 12: 'Q', 13: 'K'};


function cardToString({suit,value}) { // 

    if (!dictionnary[value]==0) value=dictionnary[value];

    return value+dictionnary[suit];
}

Object.keys(cards).forEach(function(c) {
 //console.log(cards[c]);
 console.log(`carte ${cardToString(cards[c])}`);
});

for (let c of cards){
   console.log(`${cardToString(c)}`);
}


console.log(` les cartes du paquet sont : ${cards.map(cardToString)}`);


Trouver le code pour afficher "les figures Rouges : J♥,Q♥,K♥,J♦,Q♦,K♦"

Révision Array ***








const words = ["Beau", "Balle", "Ange", "Ananas", "Reduce","Action"];
Ecrire la fonction donnant pour chaque première lettre les mots !
" B => Beau,Balle"
" A => Ange,Ananas,Action"
" R => Reduce"

Revision



const words = ["Beau", "Balle", "Ange",
"Ananas", "Reduce","Action"];

let l = 'A';

Ecrire une fonction qui donne les mots commençant par la lettre A.

console.log(`Les mots commençant par ${l} dans [ ${words} ] sont : 
** A completer ** `);

Révision !


Ecrire une fonction qui teste si tous les nombres d'un tableau sont pairs

const arr1 = [4, 6, 16, 36];
console.log(` Tous les nombres ${arr1} sont pairs ? = **A completer** `);

attribut data-


HTML permet d'associer des données directement dans un élément HTML à l'aide des attributs data-*.

Nous pouvons donc stocker et manipuler de l’information directement.

Voici les 7 selecteurs disponibles.

[data-value] {
  /* Attribute exists */
}

[data-value="foo"] {
  /* Attribute has this exact value */
}

[data-value*="foo"] {
  /* Attribute value contains this value somewhere in it */
}

[data-value~="foo"] {
  /* Attribute has this value in a space-separated list somewhere */
}

[data-value^="foo"] {
  /* Attribute value starts with this */
}

[data-value=|"foo"] {
  /* Attribute value has this in a dash-separated list somewhere */
}

[data-value$="foo"] {
  /* Attribute value ends with this */
}

Voici un exemple.


+ infos

Manipulation en JS


La propriété HTMLElement.dataset en lecture seule permet l'accès, à la fois en mode lecture et écriture, à tous les attributs de données sur mesure (data-*) définis sur l'élément.


chaîne = element.dataset.nomEnCamelCase;
element.dataset.nomEnCamelCase = chaîne;
Notre donc, les deux façons d'obtenir les valeurs stockées dans prof1

<li id="first" data-nom-prenom="denis dupont">prof1</li>

console.log(` ${document.getElementById("first").getAttribute("data-nom-prenom")}`) ;

console.log(` ${document.getElementById("first").dataset.nomPrenom}`) ;

[attribut css]

Voici la liste des Selecteurs CSS.


Selector
Example Example description
.class .intro Selects all elements with class="intro"
#id #firstname Selects the element with id="firstname"
* * Selects all elements
element p Selects all <p> elements
element,element div, p Selects all <div> elements and all <p> elements
element element div p Selects all <p> elements inside <div> elements
element>element div > p Selects all <p> elements where the parent is a <div> element
element+element div + p Selects all <p> elements that are placed immediately after <div> elements
element1~element2 p ~ ul Selects every <ul> element that are preceded by a <p> element
[attribute] [target] Selects all elements with a target attribute
[attribute=value] [target=_blank] Selects all elements with target="_blank"
[attribute~=value] [title~=flower] Selects all elements with a title attribute containing the word "flower"
[attribute|=value] [lang|=en] Selects all elements with a lang attribute value starting with "en"
[attribute^=value] a[href^="https"] Selects every <a> element whose href attribute value begins with "https"
[attribute$=value] a[href$=".pdf"] Selects every <a> element whose href attribute value ends with ".pdf"
[attribute*=value] a[href*="w3schools"] Selects every <a> element whose href attribute value contains the substring "w3schools"
:active a:active Selects the active link
::after p::after Insert something after the content of each <p> element
::before p::before Insert something before the content of each <p> element
:checked input:checked Selects every checked <input> element
:disabled input:disabled Selects every disabled <input> element
:empty p:empty Selects every <p> element that has no children (including text nodes)
:enabled input:enabled Selects every enabled <input> element
:first-child p:first-child Selects every <p> element that is the first child of its parent
::first-letter p::first-letter Selects the first letter of every <p> element
::first-line p::first-line Selects the first line of every <p> element
:first-of-type p:first-of-type Selects every <p> element that is the first <p> element of its parent
:focus input:focus Selects the input element which has focus
:hover a:hover Selects links on mouse over
:in-range input:in-range Selects input elements with a value within a specified range
:invalid input:invalid Selects all input elements with an invalid value
:lang(language) p:lang(it) Selects every <p> element with a lang attribute equal to "it" (Italian)
:last-child p:last-child Selects every <p> element that is the last child of its parent
:last-of-type p:last-of-type Selects every <p> element that is the last <p> element of its parent
:link a:link Selects all unvisited links
:not(selector) :not(p) Selects every element that is not a <p> element
:nth-child(n) p:nth-child(2) Selects every <p> element that is the second child of its parent
:nth-last-child(n) p:nth-last-child(2) Selects every <p> element that is the second child of its parent, counting from the last child
:nth-last-of-type(n) p:nth-last-of-type(2) Selects every <p> element that is the second <p> element of its parent, counting from the last child
:nth-of-type(n) p:nth-of-type(2) Selects every <p> element that is the second <p> element of its parent
:only-of-type p:only-of-type Selects every <p> element that is the only <p> element of its parent
:only-child p:only-child Selects every <p> element that is the only child of its parent
:optional input:optional Selects input elements with no "required" attribute
:out-of-range input:out-of-range Selects input elements with a value outside a specified range
:read-only input:read-only Selects input elements with the "readonly" attribute specified
:read-write input:read-write Selects input elements with the "readonly" attribute NOT specified
:required input:required Selects input elements with the "required" attribute specified
:root :root Selects the document's root element
::selection ::selection Selects the portion of an element that is selected by a user
:target #news:target Selects the current active #news element (clicked on a URL containing that anchor name)
:valid input:valid Selects all input elements with a valid value
:visited a:visited Selects all visited links


News version : cours DOM

Travail personel sur le DOM

Property / Method Description
element.appendChild() Adds a new child node, to an element, as the last child node
element.attributes Returns a NamedNodeMap of an element's attributes
element.childElementCount Returns the number of child elements an element has
element.childNodes Returns a collection of an element's child nodes (including text and comment nodes)
element.children Returns a collection of an element's child element (excluding text and comment nodes)
element.classList Returns the class name(s) of an element
element.className Sets or returns the value of the class attribute of an element
element.cloneNode() Clones an element
element.contains() Returns true if a node is a descendant of a node, otherwise false
element.contentEditable Sets or returns whether the content of an element is editable or not
element.firstChild Returns the first child node of an element
element.firstElementChild Returns the first child element of an element
element.getAttribute() Returns the specified attribute value of an element node
element.getAttributeNode() Returns the specified attribute node
element.getElementsByClassName() Returns a collection of all child elements with the specified class name
element.getElementsByTagName() Returns a collection of all child elements with the specified tag name
element.hasChildNodes() Returns true if an element has any child nodes, otherwise false
element.id Sets or returns the value of the id attribute of an element
element.innerHTML Sets or returns the content of an element
element.insertBefore() Inserts a new child node before a specified, existing, child node
element.lastChild Returns the last child node of an element
element.lastElementChild Returns the last child element of an element
element.nextSibling Returns the next node at the same node tree level
element.nextElementSibling Returns the next element at the same node tree level
element.nodeName Returns the name of a node
element.nodeType Returns the node type of a node
element.nodeValue Sets or returns the value of a node
element.parentNode Returns the parent node of an element
element.parentElement Returns the parent element node of an element
element.previousSibling Returns the previous node at the same node tree level
element.previousElementSibling Returns the previous element at the same node tree level
element.querySelector() Returns the first child element that matches a specified CSS selector(s) of an element
element.querySelectorAll() Returns all child elements that matches a specified CSS selector(s) of an element
element.removeAttribute() Removes a specified attribute from an element
element.removeChild() Removes a child node from an element
element.replaceChild() Replaces a child node in an element
element.setAttribute() Sets or changes the specified attribute, to the specified value
element.setAttributeNode() Sets or changes the specified attribute node
element.style Sets or returns the value of the style attribute of an element
element.tagName Returns the tag name of an element
element.textContent Sets or returns the textual content of a node and its descendants
nodelist.item() Returns the node at the specified index in a NodeList
nodelist.length Returns the number of nodes in a NodeList

TP : Afficher le nombre de chaque balise du DOM


Créer le code JS qui permet d'afficher le nombre de balises par type !

En action :

Injecter le code dans la console d'une page HTML prise au hasard.

Exemple :
Copier/coller puis exécuter le code directement dans la console du site le monde (ou autre) !
Si un message d'erreur apparaît relancer sur un autre fichier.


Besoin d'aide !

Etude du récursif en profondeur

Nous tentons de saisir encore une fois l'empilement des appels de fonctions dans le cas d'une fonction récursive.

Allez dans

http://dupontcours.free.fr/JavaScript/DOM-javascript/dom.html

Coller ce code dans la console.

let a=0,p =(e)=>{let a1=a++;console.groupCollapsed(`Begin ${e.nodeName} ${a1}`);Array.from(e.children,c=>p(c));console.log(`End ${e.nodeName} ${a1}`);console.groupEnd();};p(document.body);

Voici le déroulement des appels (nous devrions utiliser comme nous l'avons déjà fait le débogueur).

Etude de cas

Etude de la fonction findObj de MacroMedia dreamweaver
findObj on jsbin.com

parcours en profondeur

Nous allons étudier différents codes utilisant un parcours récursif.

L'idée est de parcourir le DOM à la recherche d'un item contenant un texte.
Si le nœud contient ce string on met le nœud en rouge.

Nous allons nous inspirer de la structure du code récursif pour parcourir le DOM

printDOM = (node, prefix) => {
  
    //action : affichage
  
    for(let nd of node.children) {
           printDOM ( nd, prefix + '-' );
     }
}
printDOM(document," ");


Remplaçons simplement action par :

 if (node.innerHTML.indexOf(string) > -1) {
         node.style.color="red";
       }
ce code met en rouge le noeud node contenant le mot string.

function find(node, string) {
       if (node.innerHTML.indexOf(string) > -1) {
         node.style.color="red";
       }
       for (n of node.children) {
          find(n, string);
       }
}

console.log(find(document.body, "para"));

Testez le code ;

  


Analyse : 

que vaut document.body.innerHTML.indexOf("second")
testez alors

       if (document.body.innerHTML.indexOf("second") > -1) {

         document.body.style.color="red";}

Passons à un code offrant une plus grande granularité sur les nœuds

Etudier le code suivant

function find(node, string) { if (node.nodeType == document.ELEMENT_NODE) { for (var i = 0; i < node.childNodes.length; i++) { if (find(node.childNodes[i], string)) return true; } return false; } else if (node.nodeType == document.TEXT_NODE) { if (node.nodeValue.indexOf(string) > -1) { alert("le HTLM contient le nom cherché"); return true; } return false; } }


coller le code suivant dans la console.

function find(node, string) {
    if (node.nodeType == document.ELEMENT_NODE) {
       for (var i = 0; i < node.childNodes.length; i++) {
          if (find(node.childNodes[i], string))
             return true;
          }
          return false;
    } else if (node.nodeType == document.TEXT_NODE) {
       if (node.nodeValue.indexOf(string) > -1) {
         alert("le HTLM contient le nom cherché");
         return true;
       }
        return false;
    }
}

puis tapez 
console.log(find(document.body, "evry"));

puis
console.log(find(document.body, "second"));

En action

Pourquoi ce code ne marche pas dans jsbin !

code

Trouver enfin un dernier bug !

Pourquoi ce code ne met pas en rouge l'item trouvé ?

function find(node, string) {
    if (node.nodeType == document.ELEMENT_NODE && node.nodeName !=
"SCRIPT") {
       for (var i = 0; i < node.childNodes.length; i++) {
          if (find(node.childNodes[i], string))
             return true;
          }
          return false;
    } else if (node.nodeType == document.TEXT_NODE) {
       if (node.nodeValue.indexOf(string) > -1) {
         //node.classList.add("find");
         node.style.color="red";
         return true;
       }
        return false;
    }
}

find(document.body, "second");

idée !

DOM