Feu d'artifice !

/**
 *
 * @param {number} start The start of the createTab.
 * @param {number} end The end of the createTab.
 * @param {number} step The value to increment or decrement by.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Array} Returns the createTab of numbers.
 */

createTab(10,20) = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

createTab&(0,9,3) = [ 0, 3, 6 ]

createTab(0,9,3,true) = [ 6, 3, 0 ]

Transformer notre code en une application : http://localhost:3000/

TD : Min Max

 
// pour un tableau simpleconst t = [20, 12, 2, 12];
const [min, max] = t.reduce(([min, max], cur) => {

    if (min > cur) min = cur;
    if (max < cur) max = cur;

    return [min, max];

}, [Number.MAX_VALUE, Number.MIN_VALUE]);

code

//tableau de persconst etudiants = [
    { nom: "superA", note: 20 },
    { nom: "superB", note: 12 },
    { nom: "superC", note: 2 },
    { nom: "superD", note: 12 },
];

//retourne un tableau de valeurs
const [minE, maxE] = etudiants.reduce(([min, max], { note }) => {

    if (min > note) min = note;
    if (max < note) max = note;

    return [min, max];

}, [Number.MAX_VALUE, Number.MIN_VALUE]);

code

//retourne un tableau de pointeurs
const [dernier, major] = etudiants.reduce(([dernier, premier], etudiant) => {

    if (dernier.note > etudiant.note) dernier = etudiant;
    if (premier.note < etudiant.note) premier = etudiant;

    return [dernier, premier];

}, [etudiants[0], etudiants[0]]);

code


//retourne un objet
const { dernier, major } = etudiants.reduce(({ dernier, major }, etudiant) => {

    if (dernier.note > etudiant.note) dernier = etudiant;
    if (major.note < etudiant.note) major = etudiant;

    return { dernier, major };

}, { dernier: etudiants[0], major: etudiants[0] });


code

Dans le grand bain des applications WEB

En action

Un petit tour du côté des méthodes !

Some, every

rappel : destructuration

map

filter

reduce

some

Nous connaissons la méthode some ?

La méthode some() teste si au moins un élément du tableau passe le test implémenté par la fonction fournie. Elle renvoie un booléen indiquant le résultat du test.

const T = [41, 23, 65, 43, 57],
test = (element) => element % 2;
console.log(t.some(test));

code

Que recherchons nous dans ce tableau avec la fonction test ?

Modifier le code précédent, sans utiliser la négation, pour tester si un élément du tableau est pair.

Donner le code de la fonction some qui teste si au moins un élément du tableau vérifie la fonction test.

const T = [41, 23, 65, 43, 57];
test = (element) => element % 2;
console.log(some(T,test));

Pourrait on appliquer de telle fonction à des tableaux de vidéos ?

Préparation au DS

→ Cours

Rappelez le corps de la fonction filtre vue en cours filtre(array, test)
Donner le corps de la fonction some(array, test) qui teste si au moins un élément du tableau en argument passe le test implémenté par la fonction fournie.

→ Exercice

Soit la BD d'animaux, comprenant des 🐶 et des 🐱.

Animals = [

{name: 'Butters', age: 3, type: '🐶'},

{name: 'Lizzy', age: 6, type: '🐶'},

…

{name: 'Minou', age: 10, type: ''🐱"}, ];

La fonction getAges, calcul la somme des âges des chiens en équivalent humain !

function getAges(array) {
let sum = 0;
for (var i = 0; i < array.length; i++){
if (array[i].type === 'dog'){
let tempAge = array[i].age;
sum += (tempAge * 7);
}
}
return sum;
}

Réécrire la fonction getAges sous la forme let ageDogs = Animal.filter(?).map(?).reduce(?);
Donnez également ageCats (pensez à minimiser la taille du code).

→ Exercice

Soit la BD des régions Française

const Régions = [{name: "IDF", villes: [26 200, 120000, ...]}

, {name: "PACA", villes: [116 703, 65000, ... ]},

...

]

villes est un tableau du nombre d'habitants 👫 pour les villes de plus de 10 000 habitants.

Trouver les régions qui ont au moins une ville au dessus de 1 000 000 👫.
Donner les deux régions, parmi celles qui ont au moins une ville à plus de 120 000👫, les villes les moins peuplées.
Donner un tableau donnant l'écart de population entre la ville la plus peuplée et la moins peuplée pour chaque Région.

Plus d'infos »

TD

code

Ecrire le code pour créer un nouveau tab

Ecrire le code pour modifier le tableau existant

Plus d'infos »

Je suis végétarien !

Nous allons utiliser notre fonction de filtre pour retirer les ingrédient qui n'appartiennent pas à un ensemble regroupant ["🐷", "🐑","🐔"].

Nous reviendrons sur cet objet Ensemble qui est très facile d'utilisation.

en action

5 fruits - 5 légumes par jours

Commençons l'aventure "5 fruits par jours" en coupant les fruits en 2.

Répétons sur chaque fruit, l'action de 🔪. Pour cela nous utilisons notre fonction forEach !

voir code "Ora🔪"

Je vous laisse découvrir le sens de l'action : `${fruit.substring(0, fruit.length / 2)}\ud83d\udd2a`

Amélioration :

Nous pourrions à la place de valeur "2" (pour couper les fruits en deux), mettre une variable pour pouvoir couper les fruits en des quartiers de taille variable.

Code

lecture

foreach

Plus jamais de boucles for ! Génial

Voici les dupont/dupond


Nous voulons obtenir après filtrage et transformation le tableau des DUPONT.


Compléter les codes des fonctions forEach, trans, filter
   


const dupontd = [
    { name: "Dupont", sex: "m" },
    { name: "DUPONT", sex: "m" },
    { name: "duPont", sex: "f" },
    { name: "dupond", sex: "f" }
];

--------------------------------------- A compléter ----------------------------

function forEach(t, fx) {
   
}

function trans(t, fx) {
   
}

function filter(t, fx) {
   
}
-----------------------------   les callbacks        ------------------------------

function upperCase(pers) {
    pers.name = pers.name.toUpperCase();
}

function isDupont(pers) {
    return pers.name == "DUPONT"
}

function civilite({ name, sex }) {
    sex == 'm' ? name = `Monsieur ${name}` : name = `Madame ${name}`
    return { name }
}
----------------------------------- APPELS -------------------------------------

forEach(dupontd, upperCase);
const dupontFamily = filter(dupontd, isDupont)
const tid = trans(dupontFamily, civilite)

Pages

Students for DS 19/11

please go to this reading

Objectifs

Définir la fonction createArray

Transformer notre code en une application : http://localhost:3000/

// pour un tableau simple

const t = [20, 12, 2, 12];const [min, max] = t.reduce(([min, max], cur) => { if (min > cur) min = cur; if (max < cur) max = cur; return [min, max];}, [Number.MAX_VALUE, Number.MIN_VALUE]);code

//tableau de pers

const etudiants = [ { nom: "superA", note: 20 }, { nom: "superB", note: 12 }, { nom: "superC", note: 2 }, { nom: "superD", note: 12 },];

//retourne un tableau de valeurs

const [minE, maxE] = etudiants.reduce(([min, max], { note }) => { if (min > note) min = note; if (max < note) max = note; return [min, max];}, [Number.MAX_VALUE, Number.MIN_VALUE]);code

//retourne un tableau de pointeurs

const [dernier, major] = etudiants.reduce(([dernier, premier], etudiant) => { if (dernier.note > etudiant.note) dernier = etudiant; if (premier.note < etudiant.note) premier = etudiant; return [dernier, premier];}, [etudiants[0], etudiants[0]]);code

//retourne un objet

const { dernier, major } = etudiants.reduce(({ dernier, major }, etudiant) => { if (dernier.note > etudiant.note) dernier = etudiant; if (major.note < etudiant.note) major = etudiant; return { dernier, major };}, { dernier: etudiants[0], major: etudiants[0] });code

Un petit tour du côté des méthodes !

Some, every

map

filter

reduce

some

→ Cours

→ Exercice

→ Exercice

Amélioration :

Compléter les codes des fonctions forEach, trans, filter

const t = [20, 12, 2, 12];
const [min, max] = t.reduce(([min, max], cur) => {

if (min > cur) min = cur;
if (max < cur) max = cur;

return [min, max];

}, [Number.MAX_VALUE, Number.MIN_VALUE]);

code

const etudiants = [
{ nom: "superA", note: 20 },
{ nom: "superB", note: 12 },
{ nom: "superC", note: 2 },
{ nom: "superD", note: 12 },
];

const [minE, maxE] = etudiants.reduce(([min, max], { note }) => {

if (min > note) min = note;
if (max < note) max = note;

return [min, max];

}, [Number.MAX_VALUE, Number.MIN_VALUE]);

code

const [dernier, major] = etudiants.reduce(([dernier, premier], etudiant) => {

if (dernier.note > etudiant.note) dernier = etudiant;
if (premier.note < etudiant.note) premier = etudiant;

return [dernier, premier];

}, [etudiants[0], etudiants[0]]);

code

const { dernier, major } = etudiants.reduce(({ dernier, major }, etudiant) => {

if (dernier.note > etudiant.note) dernier = etudiant;
if (major.note < etudiant.note) major = etudiant;

return { dernier, major };

}, { dernier: etudiants[0], major: etudiants[0] });

code