M03 BASES DU JAVASCRIPT

EXERCICE 1
// Dans les exercices suivants, vous devrez remplacer la
valeur null
// pour le correspondant.

// Créer une variable de type chaîne de caractères.

const newString = 'hello' ;

// Créer une variable de type nombre.

const newNumber = 18 ;

// Créer une variable booléenne.

const newBoolean = false ;

// Résoudre le problème mathématique suivant.

const newResta = 10 - 7 === 3 ;

// Résoudre le problème mathématique suivant.

const newMultiplication = 10 * 4 === 40 ;

// Résoudre le problème mathématique suivant.

const newModule = 21 % 5 === 1 ;

EXERCICE 2

function returnString(string) {
// Doit renvoyer une chaîne de caractères.
// Votre code :
retour (chaîne) ;
}

// 0 " X" et "Y" sont des nombres.

function sum(x, y) {
// Renvoie le résultat de leur somme.
// Votre code :
retour x + y ;
}

function subtract(x, y) {
// Renvoie le résultat de la soustraction.
// Votre code :
retourner x - y ;
}
function divide(x, y) {
// Renvoie le résultat de sa division.
// Votre code :
retourner x / y ;
}

function multiply(x, y) {
// Renvoie le résultat de leur multiplication.
// Votre code :
retourner x * y ;
}

function getResto(x, y) {
// Obtenir le reste de la division de "x" par "y".
// Votre code :
retour x % y ;
}

EXERCICE 3

function areAlike(x, y) {
// Retourne vrai si "x" et "y" sont égaux.
// Sinon, il faut renvoyer false.
// Votre code :
if (x === y) {
retourner vrai ;
} else {
retourner faux ;
}
}

function haveSameLength(str1, str2) {

// Retourne vrai si les deux chaînes ont la même longueur.
// Sinon, il faut renvoyer false.
// Votre code :
if (str1.length === str2.length) {
retourner vrai ;
} else {
retourner faux ;
}

}
function minusNinety(num) {
// Retourne vrai si l'argument "num" est inférieur à quatre-
vingt-dix.
// Sinon, il faut renvoyer false.
// Votre code :
if (num < 90) {
retourner vrai ;
} else {
retourner faux ;
}
}

function greaterThanFifty(num) {
// Retourne vrai si l'argument "num" est supérieur à cinquante.
// Sinon, il faut renvoyer false.
// Votre code :
if (num > 50) {
retourner vrai ;
} else {
retourner faux ;
}
}

function esPar(num) {
// Retourne vrai si "num" est pair.
// Sinon, il faut renvoyer false.
// Votre code :
if (num % 2 === 0) {
retourner vrai ;
} else {
retourner faux ;
}
}

function isImpar(num) {
// Retourne vrai si "num" est impair.
// Sinon, il faut renvoyer false.
// Votre code :
if (num % 2 === 0) {
retourner faux ;
} else {
retourner vrai ;
}
}
EXERCICE 4

function raiseSquare(num) {
// Retourne la valeur de "num" au carré.
// Votre code :
return Math.pow(num, 2) ;
}

function elevateBucket(num) {
// Retourne la valeur de "num" cubée.
// Votre code :
return Math.pow(num, 3) ;
}

function raise(num, exponent) {

// Retourne la valeur de "num" élevée à l'exposant "exponent".
// Votre code :
return Math.pow(num, exponent) ;
}

function roundNumber(num) {
// Arrondir "num" à l'entier le plus proche et le renvoyer.
// Votre code :
return Math.round(num) ;
}

function roundUp(num) {
// Arrondir "num" à la hausse et l'arrondir à la baisse.
// Votre code :
return Math.ceil(num) ;
}

function numeroRandom() {
// Génère un nombre aléatoire entre 0 et 1 et le renvoie.
// Votre code :
return Math.random() ;
}
EXERCICE 5

function isPositive(num) {
// La fonction reçoit un entier. Renvoie comme résultat une chaîne de caractères indiquant
si le nombre
// est positive ou négative.
// Si le nombre est positif ---> "Est positif".
// Si le nombre est négatif ---> "Est négatif".
// Si le nombre est 0, renvoie false.
// Votre code :
if (num > 0) {
retourner "Il est positif" ;
} else if (num < 0) {
retourner "Il est négatif" ;
} else {
retourner faux ;
}
}

function addSymbolExclamation(str) {
// Ajoute un point d'exclamation à la fin de la chaîne "str" et la renvoie.
// Exemple : "hello world" ---> "hello world !"
// Votre code :
return str + " !";
}

function combineNames(firstname, lastname) {

// Retourne "first name" et "last name" combinés en une seule chaîne mais séparés par un
espace.
// Exemple : ("Je suis", "Henry") ---> "Je suis Henry".
// Votre code :
retourner le prénom + " " + le nom ;
}

function getGreeting(name) {
// Prendre la chaîne "nom" et y concaténer une autre chaîne de manière à ce qu'elle
prenne la forme suivante :
// Exemple : "Martin" ---> "Bonjour Martin !"
// Votre code :
return "Bonjour " + nom + " !";
}

function getRectangleArea(height, width) {

// Retourne la surface d'un rectangle en prenant sa hauteur et sa largeur.
// Votre code :
renvoie la hauteur * la largeur ;
}
function returnPerimeter(side) {
// La fonction prend comme argument la mesure d'un côté d'un carré.
// Vous devez renvoyer son périmètre.
// Votre code :
côté retour * 4 ;
}

function areaOfTriangle(base, height) {

// Calculer la surface d'un triangle et renvoyer le résultat.
// Votre code :
retour base * hauteur / 2 ;
}

function deEuroAdolar(euro) {
// Supposons que 1 euro soit égal à 1,20 dollar.
// Vous devez calculer la valeur reçue en argument en la passant à dollars.
// Votre code :
retour euro * 1,2 ;
}

function esVocal(letter) {
// Écrire une fonction qui reçoit une lettre et, si c'est une voyelle, affiche le message "C'est
une voyelle".
// Si l'utilisateur saisit une chaîne de caractères comportant plus d'un caractère, vous
devez renvoyer le message suivant : "Données incorrectes".
// Si ce n'est pas une voyelle, il doit également renvoyer "Données incorrectes".
// Votre code :
if (letter === "a" || letter === "e" || letter === "i" || letter === "o" || letter === "u") { return
"C'est une voyelle" ;
else if (letra.length > 1) {
retourner "Données incorrectes" ;
} else {
retourner "Données incorrectes" ;
}
}
M04 BOUCLES
JAVASCRIPT
function getMajor(x, y) {
// x" et "y" sont des nombres entiers.
// Retourne le plus grand nombre.
// S'ils sont égaux, renvoyer l'un ou l'autre.
// Votre code :
if (x > y) {
retourner x ;
} else if (x < y) {
retourner y ;
} else {
return x || y ;
}
}

function majorityOfAge(age) {
// Déterminer si la personne peut participer à l'événement en fonction de son âge.
// Si vous avez 18 ans ou plus, vous devez renvoyer la chaîne : "Allowed".
// Sinon : "Non autorisé".
// Votre code :
if(age >= 18) {
retourner "Autorisé" ;
}
else {
retourner "Non autorisé" ;
}
}

function conection(status) {
// L'argument "status" représente l'état de la connexion d'un utilisateur.
// Si le statut est égal à 1, l'utilisateur est "en ligne".
// Si le statut est égal à 2, l'utilisateur est "Absent".
// Sinon, nous supposons que l'utilisateur est "hors ligne".
// Renvoie l'état de la connexion de l'utilisateur.
// Votre code :
if (status === 1) {
retourner "Online" ;
else if (status === 2) {
retour "Away" ;
} else {
retourner "Offline" ;
}
}
function greeting(language) {
// Renvoyer un message d'accueil dans trois langues différentes :
// Si "language" est "German", renvoie "Guten Tag !
// Si "language" est "Mandarin", renvoyer "Ni Hao !
// Si "language" est "english", retourner "Hello !
// Si "language" ne correspond à aucun des éléments ci-dessus ou est `undefined`, il
renvoie "Hello !
// Votre code :
if (language === "German") {
return "Guten Tag !
} else if (language === "Mandarin") {
retour "Ni Hao !
} else if (language === "English") {
return "Bonjour !
} else {
return "Bonjour !
}
}

function colours(colour) {
// La fonction reçoit une couleur. Renvoie la chaîne de caractères correspondante :
// Si la couleur reçue est "blue" --> "This is blue".
// Si la couleur reçue est "rouge" --> "Ceci est rouge".
// Si la couleur reçue est "verte" --> "Ceci est vert".
// Si la couleur reçue est "orange" --> "Ceci est orange".
// Si aucune de ces couleurs --> "Couleur non trouvée".
// IMPORTANT : utiliser la mention SWITCH.
// Votre code :
switch (couleur) {
cas "bleu" :
return "Ceci est bleu" ;
cas "rouge" :
return "Ceci est rouge" ;
cas "vert" :
return "Ceci est vert" ;
cas "orange" :
return "Ceci est orange" ;
par défaut :
retourner "Couleur non trouvée" ;
}
function isTenFive(num) {
// Retourne vrai si "num" est 10 ou 5.
// Sinon, il faut renvoyer false.
// Votre code :
if (num === 10 || num === 5) {

}
 retourner vrai ;
} else {
retourner faux ;
}
}

function thisInRange(num) {
// Retourne vrai si "num" est inférieur à 50 et supérieur à 20.
// Sinon, il faut renvoyer false.
// Votre code :
if (num < 50 && num > 20) {
retourner vrai ;
} else {
retourner faux ;
}
}

function esEntero(num) {
// Retourne true si "num" est un entier, positif, négatif ou nul.
// Exemple : 0.8 ---> false
// Exemple : 1 ---> vrai
// Exemple : (-10) ---> true
// Sinon, il faut renvoyer false.
// Votre code :
if (num % 1 === 0) {
retourner vrai ;
} else {
retourner faux ;
}
}
function fizzBuzz(num) {
// Si "num" est divisible par 3, il renvoie "fizz".
// Si "num" est divisible par 5, il renvoie "buzz".
// Si "num" est divisible par 3 et 5 (les deux), il renvoie "fizzbuzz".
// Sinon, il faut renvoyer false.
// Votre code :
if (num % 3 === 0 && num % 5 === 0) {
retourner "fizzbuzz" ;
else if (num % 5 === 0) {
retourner "buzz" ;
else if (num % 3 === 0) {
retourner "fizz" ;
} else {
retourner faux ;
}

function operatorsLogic(num1, num2, num3) {

// La fonction reçoit trois nombres différents.
// Si num1 est plus grand que num2 et num3, et également positif, retourner ---> "Num1
est plus grand et positif".
// Si l'un des trois nombres est négatif, retourner ---> "Il y a des négatifs".
// Si num3 est plus grand que num1 et num2, incrémenter sa valeur de 1 et renvoyer la
nouvelle valeur.
// Si tous les arguments sont nuls, retourner ---> "Erreur".
// Si aucune des conditions ci-dessus n'est remplie, il faut renvoyer false.
// Votre code :
if (num1 > num2 && num1 > num3 && num1 > 0) {
return "Le numéro 1 est plus grand et positif" ;
else if (num1 < 0 || num2 < 0 || num3 < 0) {
return "Il y a des négatifs" ;
else if (num3 > num1 && num3 > num2) {
retourner num3 + 1 ;
} else if (num1 === 0 && num2 === 0 && num3 ===0) {
retourner "Erreur" ;
} else {
retourner faux ;
}
}
function esPrimo(num) {
// Retourne vrai si "num" est premier.
// Sinon, il renvoie un message faux.
// [Indice 1] : un nombre premier n'est divisible que par lui-même et par 1.
// [Indice 2] : vous pouvez résoudre ce problème en utilisant une boucle `for`.
// Note] : Les nombres négatifs, 0 et 1, ne sont PAS des nombres premiers.
// Votre code :
si (num < 2) retournez faux ;
si (num === 2) retourner vrai ;
for (var i = 2 ; i < num ; i++) {
if (num % i === 0) {
retourner faux ;
}
}
retourner vrai ;
}

function isTrue(value) {
// Si "valeur" est vrai, retournez "Je suis vrai".
// Sinon, renvoyer "Je suis faux".
// Votre code :
if (value === true) {
retourner "Je suis vrai" ;
} else {
return "Je suis un faux" ;
}
}

function hasThreeDigits(num) {
// Si le numéro reçu comporte trois chiffres, renvoyer true.
// Sinon, il faut renvoyer false.
// Votre code :
if (num >= 100 && num <= 999) {
retourner vrai ;
} else {
retourner faux ;
}
}
function doWhile(num) {
fois.
// Implémenter une fonction qui augmente la valeur reçue de 5 jusqu'à une limite de 8
// Renvoie la valeur finale.
// Utiliser la boucle Do-While.
// Votre code :
var i = 0
var a = num
faire {
i=i+1;
a=a+5;
} while (i < 8) ;
retourner a ;
}
M05 JAVASCRIPT ARRAYS

function returnFirstElement(array) {
// Retourne le premier élément du tableau reçu en paramètre.
// Votre code :
return array[0] ;
}

function returnLastElement(array) {
// Retourne le dernier élément du tableau reçu en paramètre.
// Votre code :
return array [array.length - 1] ;
}

function getArrayLength(array) {
// Retourne la longueur du tableau reçu en paramètre.
// Votre code :
return array.length ;
}

function incrementForOne(array) {
// Le tableau reçu en paramètre contient des nombres.
// Retourne un tableau dont les éléments sont incrémentés de +1.
// Votre code :
var masUno = [] ;
for(var i = 0 ; i < array.length ; i++) {
moreOne[i] = array[i] + 1 ;
}
return moreOne ;

function addItemToEndOfArray(array, element) {

// Ajouter l'"élément" à la fin du tableau reçu.
// Retourner l'arrangement.
// Votre code :
array.push(element) ;
retourner le tableau ;
}

function addItemToArrayStart(array, element) {

// Ajouter l'"élément" au début du tableau reçu.
// Retourner l'arrangement.
// Votre code :
array.unshift(element) ;
retourner le tableau ;
}
function dePalabrasAFrase(words) {
// L'argument "words" est un tableau de chaînes de caractères.
// Retourne une chaîne où tous les mots sont concaténés
// avec un espace entre chaque mot.
// Exemple : ['Hello', 'world!'] -> 'Hello world !
// Votre code :
return words.join(' ') ;
}

function arrayContains(array, element) {

// Vérifie si l'élément existe dans le tableau reçu.
// Retourne true si c'est le cas, ou false si ce n'est pas le cas.
// Votre code :
for(var i = 0 ; i < array.length ; i++) {
if (array[i] === element) {
retourner vrai ;
}
}
retourner faux ;
}

function addNumbers(arrayOfNums) {
// Le paramètre "arrayOfNums" doit être un tableau de nombres.
// Additionner tous les éléments et renvoyer le résultat.
// Votre code :
var sum = 0 ;
arrayOfNums.forEach (function(num){
sum += num ;
});
retourner la somme ;
}

function averageTestResults(testResults) {
// Le paramètre "testresults" est un tableau de nombres.
// Interroger (en boucle) les éléments du tableau et renvoyer la moyenne des notes.
// Votre code :
var accumulator = 0 ;
for(var i = 0 ; i < resultsTest.length ; i++){
accumulateur = accumulateur + résultatsTest[i] ;
}
var average = accumulator / resultsTest.length ;
moyenne de retour ;
}
function numeroMasGrande(arrayOfNums) {
// Le paramètre "arrayOfNums" est un tableau de nombres.
// Retourne le plus grand nombre.
// Votre code :
var masGrande = arrayOfNums[0] ;
for (var i = 0 ; i < arrayOfNums.length ; i++) {
if(arrayOfNums[i] > masGrande) {
masLarge = arrayOfNums[i] ;
}
}
return masGrande ;
}

function multiplyArguments() {
// Utiliser le mot clé `arguments` pour multiplier tous les arguments et retourner le produit.
// Si aucun argument n'est transmis, renvoie 0. Si un argument est transmis, il suffit de le
renvoyer.
// [INDICE] : "arguments" est un tableau.
// Votre code :
var total = 1 ;
if(arguments.length === 0) return 0 ;
else if (arguments.length === 1) return arguments[0] ;
else {
for (var i = 0 ; i < arguments.length ; i++){
total = total * arguments[i] ;
}
le total des retours ;
}
}

function storyElements(array) {
// Développez une fonction qui renvoie le nombre d'éléments du tableau dont la valeur est
supérieure à 18.
// Votre code :
var counter = 0 ;
for (var i = 0 ; i < array.length ; i++) {
if (array[i] > 18){ counter++
}
}
retourner le compteur ;
}
function dayOfWeek(dayNumber) {
// Supposons que les jours de la semaine soient codés comme suit : 1 = dimanche, 2 =
lundi, etc.
// Exécute une fonction qui, étant donné le numéro du jour de la semaine, renvoie : "C'est
le week-end".
// si le jour est "samedi" ou "dimanche", et "C'est un jour ouvrable" dans le cas contraire.
// Votre code :
if (numberDayNumber === 1 || numberDayNumber === 7) {
retourner "C'est le week-end" ;
} else {
return "C'est un jour ouvrable" ;
}
}

function startsWithNine(num) {
// Cette fonction prend un nombre comme paramètre.
// Doit retourner true si l'entier commence par 9 et false sinon.
// Votre code :
var str = num.toString() ;
if (str[0] === '9'){
retourner vrai ;
} else {
 retourner faux ;
}
}

function allEqual(array) {
// Si tous les éléments du tableau sont égaux, il faut renvoyer true.
// Sinon, elle renvoie un message faux.
// Votre code :

for (var i = 1 ; i < array.length ; i++) {

if (array[0] !== array[i]){
retourner faux ;
}
}
retourner vrai ;
}

function monthsYear(array) {
// L'arrangement contient certains mois de l'année dans le désordre. Il faut le parcourir,
chercher les mois "janvier",
// Mars" et "Novembre", les stocker dans un nouveau tableau et le renvoyer.
// Si l'un des mois est manquant, la chaîne suivante est renvoyée : "Les mois demandés
n'ont pas été trouvés".
// Votre code :
var newArray = [] ;

for (var i = 0 ; i < array.length ; i++) {

if (array[i] === 'January' || array[i] === 'March' || array[i] === 'November')
{ newArray.push(array[i])
}
}
if (newArray.length < 3){
return 'Les mois demandés n'ont pas été trouvés' ;
} else {
return newArray ;
}

function tablaDelSeis() {
// Écrire une fonction qui affiche la table de multiplication de 6 (de 0 à 60).
// La fonction renvoie un tableau contenant les résultats de la table de multiplication de 6
dans l'ordre croissant.
// Votre code :
var table = [] ;
for (i = 0 ; i < 11 ; i++) {
table.push(6*i) ;
}
tableau de retour ;
}

function greaterACien(array) {
// La fonction reçoit un tableau d'entiers compris entre 0 et 200.
// Le parcourir et renvoyer un tableau contenant toutes les valeurs supérieures à 100 (sans
compter 100).
// Votre code :
var newArray = [] ;

for(var i = 0 ; i < array.length ; i++) {

if (array[i] > 100) {
newArray.push(array[i])}
}
return newArray ;
}

function breakStatement(num) {
// Itérer dans une boucle en augmentant le nombre reçu par 2 jusqu'à une limite de 10 fois.
// Stocker chaque nouvelle valeur dans un tableau et la renvoyer.
// Si, à un moment donné, la valeur de la somme et le nombre d'itérations coïncident, il faut
l'interrompre.
// l'exécution et renvoie la chaîne : "L'exécution a été interrompue".
// [CONSEIL] : utilisez l'instruction "break".
// Votre code :
var array = [] ;

var sum = num ;

for (var i = 0 ; i < 10 ; i++) {

somme = somme + 2 ;

si (sum === i) break ;

else {
array.push(sum) ;
}
}

if(i < 10) {

return 'L'exécution a été interrompue' ;
} else {
retourner le tableau ;
}
}

function continueStatement(num) {
// Itérer dans une boucle en augmentant le nombre reçu par 2 jusqu'à une limite de 10 fois.
// Stocker chaque nouvelle valeur dans un tableau et la renvoyer.
// Lorsque le nombre d'itérations atteint la valeur 5, ce cas n'est pas ajouté et
 // passe à l'itération suivante.
// [CONSEIL] : utilisez l'instruction "continue".
// Votre code :
var array = [] ;
var sum = num ;

for (i = 0 ; i < 10 ; i++) {

if (i === 5){
continuer ;
} else {
somme = somme + 2 ;
array.push(sum) ;
}
}
return array ; }

M06 OBJETS JAVASCRIPT

function createCat(name, age) {

// Vous devez créer un nouvel objet avec les propriétés "name" et "age".
// Les deux propriétés doivent avoir la valeur correspondante reçue par le paramètre.
// Ajoutez également une propriété nommée "meow".
// La propriété "meow" sera une fonction qui renvoie la chaîne : "Meow !
// Retourne l'objet.
// Votre code :
var cat = {name : name,
âge : âge,
meow : function() {
return 'Miaou !
}
};
retour cat ;
}

function newUser(name, email, password) {

// Vous devez créer un nouvel objet.
// Il doit avoir les propriétés : "name", "email" et "password" avec leurs valeurs respectives.
// Retourne l'objet.
// Votre code :
var newUser = {
nom : nom,
email : email,
mot de passe : mot de passe,
}
return newUser ;
}

function addProperty(object, property) {

 // Vous recevrez un objet par paramètre.
// Vous devez ajouter une propriété avec le nom reçu en paramètre.
// Cette propriété doit être égale à la valeur `null`.
// Retourne l'objet.
// Votre code :
objet[propriété] = null ;
retourner l'objet ;
}

function invokeMethod(object, method) {

// Le paramètre "method" est une chaîne de caractères qui correspond au nom d'une
propriété de l'objet reçu.
// Cette propriété contient une fonction. Vous devez l'invoquer/exécuter.
// NOTE] : il n'est pas nécessaire de renvoyer quoi que ce soit.
// Votre code :
objet[méthode]() ;
}

function multiplyUnknownNumberByFive(MysteriousObject) {
// Le paramètre "MysteriousObject" possède une propriété nommée "MysteriousNumber".
// Vous devez multiplier ce nombre par 5 et renvoyer le résultat.
// Votre code :
var result = objectMysterioso.numeroMisterioso * 5 ;
retourner le résultat ;
}

function deleteProperty(object, property) {

// Le paramètre "property" est une propriété de l'objet que vous recevez.
// Vous devez le retirer de l'objet et le renvoyer finalement.
// Votre code :
supprimer l'objet [propriété] ;
return object ; }
function hasEmail(objectUser) {
// Vérifie si l'objet "userobject", dans sa propriété "email", a une valeur définie.
// Dans ce cas, renvoyer vrai. Sinon, c'est faux.
// Votre code :
if (objectUser['email']){
retourner vrai ;
} else {
retourner faux ;
}
}

function hasProperty(object, property) {

// Vérifie si l'objet reçu possède une propriété portant le même nom que le paramètre
"property".
// Dans ce cas, renvoyer vrai. Sinon, c'est faux.
// Votre code :
if (object[property]) {
 retourner vrai ;
} else {
retourner faux ;
}
}

function verifyPassword(objectUser, password) {

// Vérifie si la propriété "password" du "userobject" correspond au paramètre "password".
// Dans ce cas, renvoyer vrai. Sinon, c'est faux.
// Votre code :
return objectUser['password'] === password ;
}

function updatePassword(objectUser, newPassword) {

// Remplacer le mot de passe stocké dans la propriété "password" du "userobject".
// Vous recevez le nouveau mot de passe par paramètre.
// Retourne l'objet.
// Votre code :
objectUser.password = newPassword ;
return objectUser ;
}

function addFriend(objectUser, newFriend) {

// Le paramètre "userobject" a une propriété appelée "friends" égale à un tableau.
// Vous devez ajouter le "newFriend" à la fin de ce tableau.
// Retourne l'objet.
// Votre code :
objectUser.friends.push(newFriend) ;
return objectUser ;
}

function passUserAPremium(objectManyUsers) {
// Le paramètre "objectManyUsers" est un tableau d'objets (utilisateurs).
// Chaque utilisateur possède une propriété appelée "enPremium".
// Fixer cette propriété à true pour tous les utilisateurs.
// Retourner l'arrangement.
// Votre code :
for(var i = 0 ; i < objectManyUsers.length ; i++) { objectManyUsers[i].isPremium = true ;
}
return objectManyUsers ;
}

function addLikesFromUser(userobject) {
// Le paramètre "userobject" a une propriété appelée "posts" qui est un tableau.
// Ce tableau contient des objets (post).
// Chaque article a une propriété appelée "likes". Ce bien est un numéro.
// Vous devez additionner les likes de tous les posts et renvoyer le résultat.
// Votre code :
var sum = 0 ;
 for(var i = 0 ; i < objectUser.posts.length ; i++){
sum = sum + objectUser.posts[i].likes ;
}
retourner la somme ;
}

function addDiscountCalculationMethod(Product object) {

// Ajouter une propriété à l'objet "Produit" avec le nom "calculateDiscountPrice".
// Cette propriété doit être une fonction qui multiplie le prix du produit par le
DiscountPercentage.
// L'objet "Produit" possède une propriété "prix" et une propriété "pourcentage de
réduction".
// Vous devez ensuite soustraire la valeur escomptée du prix total du produit.
// Retourner le prix final.
// Exemple :
// Prix ---> 10
// PercentageDiscount ---> 0.2
// Prix final ---> 8
// Votre code :
objectProduct.calculatePriceDiscount = function(){
return this.price - (this.price * this.percentageDiscount) ;
}
return objectProduct ;
}
M07 COURS DE JAVASCRIPT
EXERCICE 1
function createUser() {
// Créer une classe ES6 ou une fonction de construction appelée "User".
// Le constructeur de cette classe doit avoir les propriétés : "user", "name", "email" et
"password".
// La valeur de chaque propriété sera reçue par paramètre.
// En outre, cette classe doit avoir une méthode appelée "greet".
// Cette méthode doit renvoyer la chaîne : "Hello, my name is {{name}}".
// La valeur {{name}} doit être le nom défini pour l'instance de classe.
// Retour à la classe.
// Votre code :
function User(user, name, name, email, password) {
this.user = user ;
this.name = name ;
this.email = email ;
this.password = password ;
}

User.prototype.greet = function() {
return 'Bonjour, mon nom est ' + this.name ;
};
return User ;
}

function addMethodPrototype(User) {
// Ajouter une méthode au prototype "User".
// La méthode doit s'appeler "greet" et doit renvoyer la chaîne "Hello World !".
// Votre code :
User.prototype.greet = function() {
return "Hello World !
};
}

function addStringInvert() {
// Ajouter une méthode au prototype "String" qui renvoie la même chaîne, mais inversée.
// La méthode doit être appelée "reverse".
// [HINT] : vous devrez utiliser l'objet "this".
String.prototype.reverse = function() {
var stringInvested = '' ;
for(var i = this.length - 1 ; i>=0 ; i--) {
stringInverted = stringInverted + this.charAt(i) ;
}
return stringInvested ;
};
}
EXERCICE 2
class Person {
 // Créer le constructeur de la classe "Person".
// Il doit avoir les propriétés suivantes : "nom", "prénom", "âge" et "adresse".
// Vous devez avoir une méthode appelée "detail" qui renvoie un objet avec les propriétés
de la personne, et
// leurs valeurs.

constructor(first name, last name, age, address) {

this.name = name,
this.surname = surname,
this.age = age,
this.domicile = domicile
this.detail = function() {
return {
name : this.name,
nom de famille : ce.nom de famille,
age : this.age,
adresse : this.address
}
}
}
}

function createInstancePerson(first name, last name, age, address) {

// Dans cet exercice, vous devez créer une instance de la classe construite dans l'exercice
précédent.
// Vous recevrez les propriétés par paramètre.
// Retourne l'instance créée.
// Votre code :
var person = new Person (first name, last name, age, address) ;
personne de retour ;
}

function addMethod() {
// La fonction ajoute une méthode "data" à la classe "Person".
// Cette méthode prend les propriétés "name" et "age" et renvoie la chaîne :
// Exemple : "Jean, 22 ans".
// Votre code :
Person.prototype.data = function(){
return this.name + ', ' + this.age + ' years' ;
}
}

M08 JAVASCRIPT CALLBACKS

function uppercase(name) {
// Cette fonction reçoit un nom (chaîne de caractères).
// Il doit renvoyer le même nom, mais avec la première lettre en majuscule.
// [Exemple] : "mario" --> "Mario".
// Votre code :
 return nom[0].toUpperCase() + nom.slice(1) ;
}

function invokeCallback(cb) {
// Invoquer/exécuter le callback `cb`.
// NOTE] : Vous ne devez rien retransmettre.
// Votre code :
cb() ;
}

function operacionMatematica(num1, num2, cb) {

// Dans cet exercice, vous recevrez deux numéros et un rappel.
// Le callback effectue une opération mathématique, il a donc besoin des deux nombres.
// Renvoyer le résultat du callback en passant les nombres comme paramètres.
// Votre code :
return cb(num1, num2) ;
}

function sumArray(arrayOfNumbers, cb) {

// Vous recevez un tableau de nombres et un rappel.
// Additionner tous les nombres du tableau.
// Ce résultat doit être transmis en tant qu'argument au callback reçu.
// NOTE] : Vous ne devez rien retransmettre.
// Votre code :
var arrayOfNumbers = [1, 2, 3, 4, 5] ;
var sum = 0 ;
for (var i = 0 ; i < arrayOfNumbers.length ; i++) { sum = sum + arrayOfNumbers[i] ;
}
cb(sum) ;
}

function forEach(array, cb) {

// Vous obtenez un correctif et un rappel.
// Vous devez itérer sur le tableau, et pour chaque élément exécuter le callback.
// Vous devez transmettre l'élément en tant qu'argument au callback.
// Votre code :
for(var i = 0 ; i < array.length ; i++) { cb(array[i]) ;
}
}

function map(array, cb) {

// Vous devez itérer sur le tableau et passer chaque élément comme argument au
callback.
// Vous devez stocker le résultat retourné par le callback dans chaque élément d'un
nouveau tableau.
// Renvoie le nouvel arrangement.
// Votre code :
var newArray = array.map(function(el) {
return cb(el) ;
});
 return newArray ;
}

function filter(arrayOfStrings) {
// Vous devez identifier tous les éléments du tableau qui commencent par la lettre "a".
// Puis renvoyer un nouveau tableau avec ces éléments.
// Votre code :
var newArray = [] ;
for (let i = 0 ; i<arrayOfStrings.length ; i++) {
if (arrayOfStrings[i][0] === 'a') {
newArray.push(arrayOfStrings[i])
}
}
return newArray ;
}