Range

Opérations élémentaires :

console.log(/^0b[01]+$/i.test("0b0011"));
console.log(/^0b[01]+$/i.test("0b0013"));
console.log("0b0011".slice(2));
console.log(parseInt("0011", false ? 2 : 8))

console.log("0o0011".slice(2));
console.log(parseInt("0011", true ? 2 : 8))
console.log()


let reTrim = /^\s+|\s+$/g,
    reIsBinary = /^0b[01]+$/i,
    reIsOctal = /^0o[0-7]+$/i,
    reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

function toNumber(value) {
    if (typeof value == 'number') {
        return value;
    }

    if (typeof value != 'string') {
        return value === 0 ? value : +value;
    }
    value = value.replace(reTrim, '');
    let isBinary = reIsBinary.test(value);
    return (isBinary || reIsOctal.test(value))
        ? parseInt(value.slice(2), isBinary ? 2 : 8)
        : (reIsBadHex.test(value) ? NAN : +value);
}


console.log( toNumber("     0b0011 "))

code

Range

range(0b011, "10", 1)

[ 3, 4, 5, 6, 7, 8, 9 ]

range("  0b011 ", "     000005", "NON")

[ 3, 3 ]

range("  0b011 ", "     000005", " 0o1")

[ 3, 4 ]

code

Transposée d'une matrice

Closure :

Examiner le code Python

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

En JS,

function mult(nb){
   return v=>v*nb
}

let triple = mult(3);

triple(3);

La mémorisation est obtenue par une fermeture (closure)
La figure ci dessous est obtenue dans un débogueur, elle montre explicitement la fermeture.

Itérateurs : SYMBOL

const m = 'myMethod';
class Foo {
    [m]() {}
}

Donc, on pourra écrire : 

class IterableClass {
    [Symbol.iterator]() {
        ···
    }
}

Deep destructuration

Exemple

const itemInfos = [
{name:"id20199",infos:{min:66864,max:66927}},
{name:"id34555",infos:{min:7615,max:119296}}
]

let min1 = itemInfos[0].infos.min;

for (let { infos: { min } } of itemInfos) {

    console.log(` la valeur min = ${min}`);

}

code

Cas des tableaux

Trie avec le premier élément du tableau comme critère.

COMPAGNIES.sort( ({ ranges: [A] } , {ranges: [B] }) => A < B );

code

Passage des arguments

1. function baseRange(start, end, step=1, fromRight=false) {
2.     let index = -1,
3.         length = Math.max(Math.ceil((end - start) / (step)), 0),
4.         result = Array(length);
5. 
   
6.     while (length--) {
7.       result[fromRight ? length : ++index] = start;
8.       start += step;
9.     }
10.     return result;
11.   } 
12. let t = baseRange(0,9,4,false);

1. const baseRange = function (...arg) {
2.     let [start, end, step = 1, fromRight = false] = arg;
3.     let index = -1,
4.         length = Math.max(Math.ceil((end - start) / (step)), 0),
5.         result = Array(length);
6.     while (length--) {
7.         result[fromRight ? length : ++index] = start;
8.         start += step;
9.     }
10.     return result;
11. }
12. let t = baseRange(0, 9, 4, false);

code

Test A fond la forme

range("  0b011 "," 5",0.5));

Range avec test ! 

Notion avancée

Notez également l'utilisation d'un générateur


 let range = function(start,end,step){
   
   return {
    *[Symbol.iterator]() {
          let value = start;
          while (value < end) {
              yield value;
              value = value + step;
          }
   }
   }
 }

 for (let e of range(1,6,2)) console.log(e);
 let [a,b,...c] = [...range(1,6,1)]
 console.log(a,b,c)

Reduce à fond la forme 6

reduce 1
reduce 2
reduce 3
reduce 4
reduce 5

Améliorations

const words = [10,2,2,1,10,10,10,10,10];

const o = words.reduce((a, x) => {

   if (!a[x]) a[x] = 0;

   a[x]=a[x]+1;

return a},{});

Reduce à fond la forme 5

reduce 1
reduce 2
reduce 3
reduce 4

Amélioration

const words = [0,2,0,0,6];

let t = words.reduce(function( {max, min}, x) {

   min = Math.min(min,x);

   max = Math.max(max,x);

   return { min, max }

},

{min : Number.MAX_VALUE,

max : Number.MIN_VALUE,

});

const nbOccurences = words.reduce((a, x) => {

   a[x]= a[x]+1;

return a},Array.from({length:t.max+1},()=>0));

Reduce : à fond la forme 4

reduce 1
reduce 2
reduce 3

Améliorations :

const words = [1,2,2,1,5];

let { max, average } = words.reduce(function( {max, min, sum, nb}, x) {

   min = Math.min(min,x);
   max = Math.max(max,x);
   sum = sum + x;
   let average = sum/++nb;

   return { min, max, nb, sum, average, nb }

},
{min : Number.MAX_VALUE,
max : Number.MIN_VALUE,
sum : 0,
average : 0,
nb : 0});

🥷la valeur initiale est un 🥇objet et quel objet !

console.log(average, max);

Reduce : à fond la forme 3

reduce 1
reduce 2

Amélioration

const words = [1,2,2,1,5];


let { min, max } = words.reduce(function( {max, min}, x) {

   min = Math.min(min,x);
   max = Math.max(max,x);

   return { min, max }

},
{min : Number.MAX_VALUE,
max : Number.MIN_VALUE});

🥷la valeur initiale est un objet ! 

console.log(min,max);

Reduce : fond la forme 2

reduce 1

Amélioration :

const words = [1,2,2,1,5];


let { min } = words.reduce(function( {min}, x) {

   min = Math.min(min,x);

   return { min }

},
{min : Number.MAX_VALUE});


🥷la valeur initiale de l'acuumulateur est une objet !


console.log(JSON.stringify(min));

Reduce : à fond la forme

const words = [1,2,2,1,5];

let min = words.reduce(function(acc, x) {

   acc = Math.min(acc,x);

   return acc

},Number.MAX_VALUE);

🥷la valeur initiale est une valeur !


console.log(min);

ou let min = words.reduce( (acc, x) => Math.min(acc,x),Number.MAX_VALUE);


code

fonction : objet

Une fonction est un objet qui possède donc des propriétés.

On peut "cacher" des résultats, voici un exemple avec la plus lente fonction de fibonachi

f(n) {
   if (n<= 1) return n;
   return f(n - 1) + f(n - 2);
}

/**
 *                         f(5)
 *                   /              \
 *                f(4)                f(3)
 *             /       \             /    \
 *          f(3)       f(2)        f(2)   f(1)
 *         /    \      /   \       /   \   
 *      f(2)   f(1)  f(1)  f(0)  f(1)  f(0)  
 *      /   \   
 *    f(1) f(0)  

let fib = function (n) {
  if ( fib.cache[n] ) { 
    return fib.cache[n]; 
  } 
  else { 
     if (n<= 1) {
       fib.cache[n] = n
       return n;
       }
     let u = fib(n - 1) + fib(n - 2);
       fib.cache[n] = u; 
       return u;
  }

  return results;
};

fib.cache={};


console.time("appel 1");
console.log(fib(9));
console.timeEnd("appel 1");
console.time("appel 2");
console.log(fib(10));
console.timeEnd("appel 2");
code

P.S. pas de récursif pour fibo dans tous les cas.