Outils pour utilisateurs

Outils du site


cours2012:programmation:td:fonctions_bases

Les fonctions (bases)

C'est quoi une fonction

Une Fonction (informatique) reçoit des paramètres et retourne un résultat.

Fonctions pures

Idéalement une fonction reçoit des paramètres et retourne un résultat

Exemples
  • Définition : “valeur absolue” prend un nombre en paramètre et retourne sa valeur absolue (c.-à-d. s’il est négatif, on retourne son opposé).
    • code : (“signature”)
function valeurAbsolue(nbr) {}
  • Exemples :
print(valeurAbsolue(-10)); /* affiche 10 */
print(valeurAbsolue( 12)); /* affiche 12 */
  • Définition : “maximum” prend deux nombres en paramètre et retourne le plus grand des deux.
    • code : (“signature”)
function maximum(nbr1,nbr2) {}
  • Exemples :
print(maximum(10,12)); /* affiche 12 */
print(maximum(15,-18)); /* affiche 15 */
Exercises
  • Définition :
    • code : (“signature”)
function minimum(nbr1,nbr2) {}
  • Exemples :
 
  • Définition : “bornes” prend trois nombres en paramètre. Les deux premiers désignent la valeur minimum et maximum acceptable. Le troisième, la valeur à tester.
    • Si la valeur à tester est comprise entre le minium et le maximum : c'est elle qui est retournée.
    • Si la valeur à tester est inférieure au minimum : alors, on retourne la valeur minimum.
    • Si la valeur à tester est supérieure au maximum : alors, on retourne la valeur maximum.
    • code : (“signature”)
 
  • Exemples :
 
Prolongement

Écrire le code complet des fonctions précédentes.

Solution pour “valeur absolue” :

/* “valeur absolue” prend un nombre en paramètre 
    et retourne sa valeur absolue (c.-à-d. s’il est négatif, on retourne son opposé). */
function valeurAbsolue(nbr) {
  var resultat;
  if (nbr<0) {
     /* si négatif, retourne l'opposé */
     resultat = -nbr;
  } else {
     /* sinon (positif), retourne le nbr lui-même */
     resultat = nbr;
  }
  return resultat;
}
 
/* tests */
print("la valeur absolue de -10 est : ",valeurAbsolue(-10));
print("la valeur absolue de  12 est : ",valeurAbsolue( 12));

Faire de même pour : “maximum”, “minimum” et “bornes”

Fonction qui n'est pas "pure"

Notion d'effet de bords :

  • Modifie l'environnement (navigateur) Eg. print(nsg)
    • Ne retourne “rien” : undefined
    • Sert à afficher un message (“modifie” le navigateur)
  • Modifie une variable “globale” (à éviter, voir plus loin)
  • Modifie une structure de données (objet, tableau) passée en paramètre (à éviter)

Syntaxe d'une fonction

Fonctions nommées
function nomDeLaFonction(paramUn, paramDeux,) {
  /* traitement */;
  /* … */;
  return /*résultat*/;
}
 
/* appel de la fonction : */
var result = nomDeLaFonction("un","deux");
show(result);
Fonctions anonymes

En JavaScript, une fonction anonyme est une expression qui retourne comme valeur une fonction !

Affectation d'une fonction à une variable :

nomDeLaVariableQuiReferenceLaFonction = function (paramUn, paramDeux,) {
  /* traitement */;
  /* … */;
  return /*résultat*/;
}
 
/* appel de la fonction : */
var result = nomDeLaVariableQuiReferenceLaFonction("un","deux");
show(result);
/* on peut "transférer" la valeur (affection à une autre variable) */
var nomCourt = nomDeLaVariableQuiReferenceLaFonction; /* pas de parenthèses ! */
result = nomCourt("un","deux");
show(result);

On peut aussi passer une fonction anonyme comme paramètre lors de l'appel d'une autre fonction. Cela sera vu lorsqu'on abordera la programmation fonctionnelle.

Retenir : En JavaScript, une fonction est une valeur. On appelle une fonction associé à un identifiant/nom de variable en le faisant suivre de parenthèses.

Décomposition d'un programme en fonctions

On utilise les fonctions pour :

  • Formaliser et structurer un programme (le décomposer en tâches élémentaires)
  • Éviter les répétitions en “factorisant” un comportement commun à plusieurs parties du programme.

Exemple

var rendre = 7.35;
 
var nbrP2 = Math.floor(rendre / 2);
print("je vous donne ", nbrP2, " pièce(s) de 2");
rendre = rendre - nbrP2 * 2;
print("il reste : ",rendre);
 
var nbrP1 = Math.floor(rendre / 1);
print("je vous donne ", nbrP1, " pièce(s) de 1");
rendre = rendre - nbrP1 * 1;
print("il reste : ",rendre);
 
var nbrP05 = Math.floor(rendre / 0.5);
print("je vous donne ", nbrP05, " pièce(s) de 0.5");
rendre = rendre - nbrP05 * 0.5;
print("il reste : ",rendre);
Identifier ce qui se répète

Écrire le code pour les pièces de ”0.2

Extraire les paramètres

Écrire le code pour les pièces de ”0.1” en plaçant cette valeur dans une variable (et employer la variable, ne pas répéter la valeur).

Pour la variable stockant le nombre de pièces : on choisit un nom générique (nbrP)

var valeurPiece = 0.1;
var nbrP =
Écrire le corps de la fonction et substituer les appels

Écrire une fonction (rendrePieceDeValeur)

  • Qui prend en paramètre :
    • resteARendre la somme totale restant à rendre.
    • valeurPiece la valeur des pièces à rendre.
  • Qui fait le travail suivant :
    • Affiche le nombre de pièces à rendre (de la valeur donnée).
    • Affiche la valeur restant à rendre après avoir rendu les pièces.
    • Retourne la valeur restant à rendre après avoir rendu les pièces.

On l'utilise de la façon suivante :

function rendrePieceDeValeur(resteARendre, valeurPiece) {
  /* code à écrire */
}
var rendre = 7.36
rendre = rendrePieceDeValeur(rendre, 2);
rendre = rendrePieceDeValeur(rendre, 1);
rendre = rendrePieceDeValeur(rendre, 0.5);
rendre = rendrePieceDeValeur(rendre, 0.2);
rendre = rendrePieceDeValeur(rendre, 0.1);
rendre = rendrePieceDeValeur(rendre, 0.05);
rendre = rendrePieceDeValeur(rendre, 0.01);
Pour les bons

Et en avances des tableaux.

Compléter le code :

function rendrePieceDeValeur(resteARendre, valeurPiece) {
	/* code écrit précédemment */
}
 
var rendre = 7.36;
 
var listePieces = [2, 1, 0.5, 0.1, 0.05, 0.01];
for (var i =0; i<listePieces.length; i++) {
	/* code à écrire : une ligne !
	indice, tester :
	print(listePieces[i]); //*/
}
Pour faire mal à la tête

Et en avance de la programmation fonctionnelle.

Tester le code suivant :

function rendrePieceDeValeur(resteARendre, valeurPiece) {
	/* code écrit précédemment */
}
 
var rendre = 7.36;
 
var listePieces = [2, 1, 0.5, 0.1, 0.05, 0.01];
listePieces.reduce(rendrePieceDeValeur, rendre);

Explication : Array reduce - Javascript MDN

C'est identique à écrire :

rendrePieceDeValeur(rendrePieceDeValeur(rendrePieceDeValeur(rendrePieceDeValeur(rendrePieceDeValeur(rendrePieceDeValeur(rendre,2),1),0.5),0.1),0.05),0.01);

Si vous grattez la tête, c'est normal !
Cela vous montre l'intérêt de bien suivre le cours (éloquent JavaScript) : il peut vous apprendre à écrire pareil “magie”.
« Toute technologie suffisamment avancée est indiscernable de la magie. »

cours2012/programmation/td/fonctions_bases.txt · Dernière modification: 2013/03/27 08:11 (modification externe)