Pages

vw : l'unité de la fenêtre.



vh
1/100e de la hauteur du viewport.
vw
1/100e de la largeur du viewport.

Game : drag and drop

Voici une utilisation de drag and drop !

code

Web Server for Chrome

Installer un serveur sur votre navigateur Chrome

take easy !

Mise en place d’événement sur les blocs


Array.from(document.querySelectorAll('div'),el => {
  
  let c = "votre couleur";
  el.style.color = el.style.background = c;
  
  el.addEventListener("mouseover", function( event ) {   
    // highlight the mouseover target
    event.target.style.color = "white";

    // reset the color after a short delay
    setTimeout(function() {
      event.target.style.color = c;
    }, 5000);
  }, false);}
 );

Action


JS Bin on jsbin.com

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 sur le fichier DOM ouvert !
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


la balise marquee

<marquee>La balise marquee en Action  !</marquee>
La balise marquee en Action !

transposée : explication

const A = [ [4,5,6], [1,2,3] ]; 

let At = A[0].map( (_,col) => A.map( (lig,_) => lig[col]));


Parcours du DOM

Ecrire une fonction de parcours du DOM : printDomEle



HTML

<body>
article{article $}>section{section $}*2>p{para $}*3(puis Tab)
</body>


JS
fonctions utiles :   console.groupCollapsed(); console.groupEnd();
on utilise children pour avoir les enfants d'un noeud.
on utilise for of pour réaliser une boucle

printDomEle(document.body);




transformer le code

const B=[
  [1,2,3],
  [4,5,6],
];

// c = col, l = lig
function maxi(A){
      let maxC = [];
      for( let c=0; c < A[0].length; c++){ // A[0]=indique la dim
          let tmp = [];
          let max = -10000; //  
          for ( let l=0; l < A.length; l++){
                 tmp.push(A[l][c]); 
                 if ( max < A[l][c] ) max = A[l][c];
          }
          console.log(tmp);
          //console.log(Math.max(...tmp)); //top version
          console.log(max);
          maxC.push(max);
      }
      console.log(maxC);
      return maxC;

}

console.log(`les valeurs Max par colonnes : ${maxi(B)}`);

Remplacer ce code avec reduce et map 

reduce en action

Utiliser reduce  pour rechercher le plus grand mot dans :
motL = "anticonstitutionnelement myélosaccoradiculographie cyclopentanoperhydrophénanthrène intergouvernementalisation";

Utiliser le code suivant pour afficher le résultat :

let newL = motL.replace(Max, "**" + Max + "**");

console.log(newL);


"anticonstitutionnelement myélosaccoradiculographie **cyclopentanoperhydrophénanthrène** intergouvernementalisation"


reduce

Utiliser reduce pour afficher t = ["abcdefghi"] ainsi :

"abc
 def
 ghi"
ou ainsi

"ab
 cd
 ef
 gh
 i"

ou

...


sol

correction projet : reduce, map

Enoncé

Solution :

DS = 1H

EX1

const liste = [
    {prenom : "Lalo", nom: "Madone", age:"18"},
    {prenom : "Denis", nom: "Moutrond" , age:"28"},
    {prenom : "Alice", nom: "Mooogo",  age:"8"}
];

Ecrire le code pour afficher les personnes de plus de 17 ans de la façon suivante
["MADONE Lalo", "MOUTROND Denis"]

EX2

Compléter le code de la transposée d'un tableau avec deux fonctions map

let At = ?.map( (_,col) => A.map( (lig,_) => ? ));

const A = [
  [1,3,5],
  [2,4,6]
];



EX3


Ecrire la fonction Process permettant de garder les nombres entre [1,10]

function Process(prevA, cur) {
   
}


var Moyennes = [20, 1, -5, 6, 50, 3];

var resultArray = Moyennes.reduce(Process, []); // [1,6,3]

Sol

Paramètres des fonctions

Lire article

Révision sélecteur CSS


Voici la liste des sélecteurs : Révision !

Code HTML

<div class="top">div : class top
          <h1>h1</h1>
          <ul id="tmpPlants" class="tmpExample">
             <li class="A B tmpExample" id="item.A">li : class =A et B id=item.A</li>
             <li class="A tmpExample" id="b">li : class =A id=b</li>
             <li class="B tmpExample" id="c">li : class =B id=c</li>
          </ul>
          <footer> footer </footer>
</div>


Pour chaque sélecteur, encadrer les éléments sélectionnés

Selecteurs ('ul, li')
Selecteurs ('li:not(#b)')
Selecteurs ( "#item.A" )
Selecteurs ( ".A.B" )
Selecteurs ( ".top :first-child" )
Selecteurs ( "ul:first-child" )
Selecteurs ( "li:not(:hover)" )
Selecteurs ( "li.B + *" )
Selecteurs (".top :nth-child(2)")
Selecteurs (".top :nth-of-type(1)")
Selecteurs (".top :not(:last-child)")

Exemple : 

Selecteurs ('h1')


------------- Auto correction


div : class top

h1

  • li : class =A et B id=item.A
  • li : class =A id=b
  • li : class =B id=c

footer

********* Projet



Etudier et compléter le code pour obtenir l'alignement du texte !

le plus grand nombre de mots dans un paragraphe


nous sommes editables
C'est moi le plus grand !
Ecrivez ici des mots

Projet

Compléter la fonction pour mettre en rouge le paragraphe qui contient le max de mots.
(ne pas utiliser Math.max()

const paras = document.querySelectorAll('p.sel');
// recherche les paragraphes concernés du document

const nodesP =  Array.from(paras, function(p){
  return {node : p, nbChar:p.textContent.length}
} );
// on crée un tableau des paragraphes et du nombre de mots/paragraphe

// completer la fonction(
const maxMotP = nodesP.reduce(function(){});
//retourne le plus grand nombre de mots et le paragraphe

if (maxMotP)
maxMotP.node.classList.add("red");
//met le paragraphe en rouge !

 


Un acide aminé est un acide carboxylique qui possède également un groupe fonctionnel amine. De tels composés organiques ont donc à la fois un groupe carboxyle –COOH et un groupe amine, par exemple une amine primaire –NH2 ou une amine secondaire –NH–. On connaît environ 500 acides aminés, dont environ 140 sont présents dans les protéines1. Ces acides aminés peuvent être classés de nombreuses manières différentes2 : on les classe ainsi souvent en fonction de la position du groupe amine par rapport au groupe carboxyle en distinguant par exemple les acides α-aminés, β-aminés, γ-aminés ou δ-aminés ; on peut également les classer en fonction de leur polarité, de leur point isoélectrique ou de leur nature aliphatique, aromatique, cyclique ou à chaîne ouverte, voire de la présence de groupes fonctionnels autres que le carboxyle et l'amine qui définissent cette classe de composés.
En biochimie, les acides α-aminés jouent un rôle crucial dans la structure, le métabolisme et la physiologie des cellules et de tous les êtres vivants connus, en tant que constituants des peptides et des protéines. Ils constituent à ce titre l'essentiel de la masse du corps humain après l'eau. Ils présentent, à de rares exceptions près3, une structure générique du type H2N–HCR–COOH, où R est la chaîne latérale identifiant l'acide α-aminé. Toutes les protéines de tous les êtres vivants connus ne sont constituées — à quelques exceptions près — que de 22 acides aminés différents, parfois légèrement modifiés, dits acides aminés protéinogènes. Parmi ceux-ci, 19 acides aminés ne contiennent que quatre éléments chimiques : le carbone, l'hydrogène, l'oxygène et l'azote ; deux acides aminés contiennent en plus un atome de soufre, et un acide aminé assez rare contient un atome de sélénium. Ces acides aminés forment de longs biopolymères linéaires, appelés polypeptides, dans lesquels les monomères sont unis entre eux par des liaisons peptidiques. Un acide aminé engagé dans une ou deux liaisons peptidiques au sein d'un polypeptide est un résidu d'acide aminé. L'ordre dans lequel ces résidus se succèdent dans les polypeptides est la séquence peptidique et est déterminé par les gènes à travers le code génétique, qui établit une relation entre les codons de trois bases nucléiques et chacun de ces résidus.
Les acides aminés naturels les plus abondants sont les acides α-aminés, dont font partie tous les acides aminés protéinogènes. Hormis la glycine, dont la chaîne latérale se réduit à un simple atome d'hydrogène et dont le carbone α n'est donc pas un centre stéréogène, tous ces acides aminés sont des composés chiraux présentant une stéréoisomérie D/L. Les acides aminés protéinogènes incorporés dans les protéines par les ribosomes sont tous des énantiomères L, mais des acides aminés D peuvent être présents dans des protéines à la suite de modifications post-traductionnelles, notamment dans le réticulum endoplasmique, comme c'est le cas chez certains organismes marins tels que les gastéropodes du genre Conus5. Des acides aminés D sont également des constituants importants du peptidoglycanne de la paroi bactérienne6, et la D-sérine jouerait le rôle de neurotransmetteur dans le cerveau7. La désignation D/L provient de la position respectivement à droite ou à gauche du groupe –NH2 dans la projection de Fischer, le carboxyle se trouvant en haut dans cette représentation, avec comme ordre de priorité des groupes est généralement (selon les règles de Cahn, Ingold et Prelog) : l'atome d'azote de l'amine primaire –NH2 ; l'atome de carbone du carboxyle –COOH ; l'atome de carbone α de la chaîne latérale R s'il ne porte pas d'atome de numéro atomique supérieur à celui de l'oxygène, sinon il passe en 2e position (c'est le cas pour la cystéine et la sélénocystéine) ; l'atome d'hydrogène.