Exercices NodeJS pour apprendre le JavaScript côté serveur

Nombre d'auteurs : 5 - Nombre d'exercices : 8 - Dernière mise à jour : 23 avril 2016

Une sélection des meilleurs exercices, accessibles aux débutants, avec des énoncés clairs et complets suivis de solutions détaillées.

Grâce à l'entraide bénévole, les membres du club répondent à vos questions directement sur le forum et vous aident lors de l'apprentissage du langage.

SommaireLe langage JavaScriptLes fonctions et les scopes

[Facile][Indispensable] Exercice 1.3.1 : Les fonctions et la factorisation

[Facile][Indispensable] Exercice 1.3.1 : Les fonctions et la factorisation

Mis à jour le 8 mars 2016 par ABCIWEB, Gnuum

Objectif
Créer et utiliser une fonction.

Compétences

Utilisation des fonctions.
Comprendre les enjeux de la factorisation.
Utilisation des valeurs par défaut.
Recherche d'une information dans la documentation.

Cours
Factorisation
La factorisation est le fait de réutiliser un même code plusieurs fois sans le réécrire, sans le dupliquer. Cette notion est primordiale en programmation, car un code dupliqué induit plusieurs gros problèmes :

Correction nécessaire à plusieurs endroits si un bug existe dans ce code (ce qu'on oublie généralement de faire).
Diminution de la lisibilité (une fonction correctement nommée permet de comprendre ce que fait fonctionnellement cette brique de code).
Augmentation de la taille du code inutile.

Fonction
Comme dans la plupart des langages de programmation, en JavaScript, l'outil principal de la factorisation est la fonction.

Une fonction peut ainsi être définie de cette manière :

Code JavaScript :

Sélectionner tout

1
2
3
function displayName(firstName, lastName) { 
  console.log(`My name is ${firstName} ${lastName}`); // équivalent préférable à: 'My name is ' + firstName + ' ' + lastName 
}

displayName est le nom de la fonction.
firstName est le nom du premier argument passé à la fonction et s'utilise comme une variable.
lastName est le nom du second argument passé à la fonction et s'utilise comme une variable.
{ ... } ce qui se trouve entre les accolades est appelé le corps de la fonction et contient le code qui sera exécuté à chaque appel de la fonction.

On peut ensuite utiliser la fonction de cette manière (on parle d'appel à la fonction) :

Code JavaScript :

Sélectionner tout

1
2
displayName('John', 'Doe'); // affiche "My name is John Doe" dans la console 
displayName('Foo', 'Bar'); // affiche "My name is Foo Bar" dans la console

'John' est la valeur passée en premier argument à la fonction (c.-à-d. firstName).
'Doe' est la valeur passée en deuxième argument à la fonction (c.-à-d. lastName).

À noter qu'on peut affecter une fonction à une variable :

Code JavaScript :

Sélectionner tout

1
2
3
4
5
6
var displayName = function displayFullName(firstName, lastName) { 
  console.log(`My name is ${firstName} ${lastName}`); 
} 
  
// On peut alors l'utiliser exactement comme précédemment: 
displayName('John', 'Doe');

On verra ultérieurement la différence entre ces 2 déclarations.

Références

Exercice
Dans l'exercice Les particularités du switch et l'utilisation de la bibliothèque standard, nous avons créé un code qui permet de transformer une chaîne formatée représentant le poids d'un fichier, ex. '100M', '2G', '500k', en nombre d'octets.
L'objectif de cet exercice est d'améliorer ce code en utilisant des fonctions pour le découper en petites unités fonctionnelles réutilisables.

1/ Créer une fonction, à partir de ce code, prenant en argument la chaîne de caractères du nombre d'octets abrégé et qui affiche sur la console la valeur non abrégée correspondante.
La tester avec les valeurs '100M', '2G' et '500k'.

2/ Créer une nouvelle fonction qui prend en premier argument une valeur numérique (p. ex. 200 ou '30') et en second argument une unité (p. ex. 'K') et qui retourne un nombre d'octets non abrégé.
Puis refactoriser le code de la question 1/ en utilisant cette fonction.
Tester avec les mêmes valeurs que dans la question précédente.

3/ [BONUS] Remplacer le code d'extraction du nombre d'octets et de l'unité par une expression rationnelle et définir une valeur par défaut de 'K' si l'unité n'est pas donnée à l'appel de la fonction.
Tester avec la valeur '500' et comparer avec '500k'.

Auteur
Alain Bontemps

Bonne chance !

Posez toutes vos questions à propos de cet exercice sur cette discussion du forum.

Voir une solution

Solution pour la partie 1/:

Code javascript :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'; 
  
function displayFullOctalValue(shortenBytes) { 
    var letter = shortenBytes.substr(shortenBytes.length - 1); 
    var bytes = parseInt(shortenBytes, 10); 
  
    if (isNaN(bytes)) { 
        bytes = false; 
    } else if (isNaN(letter)) { 
        switch (letter.toUpperCase()) { 
            case 'T': 
                bytes *= 1024; 
                //fall through 
            case 'G': 
                bytes *= 1024; 
                //fall through 
            case 'M': 
                bytes *= 1024; 
                //fall through 
            case 'K': 
                bytes *= 1024; 
                break; 
            default: 
                bytes = false; 
        } 
    } 
  
    console.log(bytes); 
} 
  
displayFullOctalValue('100M'); 
displayFullOctalValue('2G'); 
displayFullOctalValue('500k');

Solution pour la partie 2/:

Code javascript :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
'use strict'; 
  
function convert(bytes, letter) { 
    if (isNaN(bytes)) { 
        bytes = false; 
    } else if (isNaN(letter)) { 
        switch (letter.toUpperCase()) { 
            case 'T': 
                bytes *= 1024; 
                //fall through 
            case 'G': 
                bytes *= 1024; 
                //fall through 
            case 'M': 
                bytes *= 1024; 
                //fall through 
            case 'K': 
                bytes *= 1024; 
                break; 
            default: 
                bytes = false; 
        } 
    } 
  
    return bytes; 
} 
  
function displayFullOctalValue(shortenBytes) { 
    var letter = shortenBytes.substr(shortenBytes.length - 1); 
    var bytes = parseInt(shortenBytes, 10); 
  
    console.log(convert(bytes, letter)); 
} 
  
displayFullOctalValue('100M'); 
displayFullOctalValue('2G'); 
displayFullOctalValue('500k');

Solution pour la partie 3/:

Code javascript :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
'use strict'; 
  
function convert(bytes, letter = 'K') { // Ajout d'une valeur par défaut au second argument. 
    if (isNaN(bytes)) { 
        bytes = false; 
    } else if (isNaN(letter)) { 
        switch (letter.toUpperCase()) { 
            case 'T': 
                bytes *= 1024; 
                //fall through 
            case 'G': 
                bytes *= 1024; 
                //fall through 
            case 'M': 
                bytes *= 1024; 
                //fall through 
            case 'K': 
                bytes *= 1024; 
                break; 
            default: 
                bytes = false; 
        } 
    } 
  
    return bytes; 
} 
  
function displayFullOctalValue(shortenBytes) { 
    // Extraction des valeurs grâce à de la décomposition et aux groupes capturant d'une expression rationnelle. 
    var [_, bytes, letter] = shortenBytes.match(/^(\d+)([a-zA-Z]?)$/); 
    var convertedValue = letter 
        ? convert(bytes, letter) 
        : convert(bytes) 
    ; 
  
    console.log(convertedValue); 
} 
  
displayFullOctalValue('500'); 
displayFullOctalValue('500k'); 
console.log(convert('500') === convert('500', 'k')); // Affiche true.

Remarques :

Il est toujours intéressant de correctement nommer sa fonction pour comprendre ce qu'elle fait: l'utilisation d'un verbe décrivant son action est en général fortement recommandé.
Plus le code est découpé, plus il est réutilisable, évolutif et testable.
Plus le code contenu dans le corps d'une fonction est long, plus il est difficile à comprendre.
Si une fonction devient trop grande, il faut refactoriser son code (découpage en plusieurs petites fonctions).

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.