new Function en action

(new Function( 'A='+ 3 +';'))(); console.log(A); // expected output: 3 JS Bin on jsbin.com

regexp

function f2c(x) {
  function convert(str, p1, offset, s) {
    return `${Math.trunc((p1 - 32) * 5/9)}C`;
  }
  let reg = /(-?\d+(?:\.\d*)?)F\b/;
  return x.replace(reg, convert);
}


f2c("la valeur de 100F vaut 100F"); // "la valeur de 37C vaut 100F"

(-?                 # pour une valeur négative (optionnel) : 
  \d+               #  recherche au - 1 chiffre  (obligatoire)
  (?:               #   essai de matcher : 
    \.\d*           #     un . suivi de zéro ou plusieurs chiffres
  )?                #  groupe option sans référence, donc soit 12.3 ou 12)
)                   # groupe avec référence
F\b                 # F est en fin de nombre 12.3F blabla

JS Bin on jsbin.com

regexp : greedy versus lazy !

soit le lien suivant :

let lien = `<a class="show" href="dupontcours">cours</a>`;

On remarque qu'il y a deux chevrons ">" dans l'écriture

`<a class="show" href="dupontcours">cours</a>`;

Cas greedy match

Soit l'expression régulière suivante.

On recherche une chaîne commençant par <a et qui stoppe au dernier chevron > que l'on peut trouver !

result = lien.match(/<a .*>/g);

`<a class="show" href="dupontcours">cours</a>`;

↑En Action

Cas lazy match

La présence du ? permet d'arrêt la recherche de gauche à droite à la première expression possible de fin.

result = lien.match(/<a .* ? >/g);

`<a class="show" href="dupontcours">cours</a>`;

→En Action

package : platformio-ide-terminal

platformio-ide

regexp : ?: et ?=

<p id="demo">bla bli bla bli bla </p>

The ?=n quantifier matches any string that is followed by a specific string n.
On ne prend pas en compte n dans le remplacement
<script>
function myFunction() {

    let patt1 = /bla(?= (bli|bla))/g;
    let t = document.getElementById("demo").innerHTML;

    t = t.replace(patt1,"moi");
    document.getElementById("demo").innerHTML = t;
}
myFunction()
</script>

<p id="demo">bla bli bla bli bla </p>


moi bli moi bli bla

The ?:n quantifier matches any string  that is followed by a specific string n.
On prend en compte n dans le remplacement
<script>
function myFunction() {

    let patt1 = /bla(?: (bli|bla))/g; // et pris dans le remplacement
    let t = document.getElementById("demo").innerHTML;

    t = t.replace(patt1,"moi");
    document.getElementById("demo").innerHTML = t;


}
myFunction()
</script>
<p id="demo">bla bli bla bli bla </p>
moi moi bla

fetch

     let requestObj = `images/${i}.jpg`;

     fetch(requestObj).then(function(response) {
         return response.blob();
     }).then(function(myBlob) {
        
         let {size,type} = myBlob,
             objectURL = URL.createObjectURL(myBlob);

         document.querySelector("#idImage").src = objectURL;
          
      });


en action

ObjectURL : en action

Créer un répertoire de la forme

code