Fonctions

En plus de l'opérateur + rencontré, le type String définit d'autres opérations qu'il est possible d'appliquer sur ses valeurs. Il s'agit de fonctions. Une fonction est une entité qui accepte des données en entrée, réalise un traitement puis fournit un résultat.

Les données (en entrée) d'une fonction sont appelées paramètres. Il peut y avoir plusieurs paramètres à une fonction et ce nombre est fixé à la définition de la fonction. Il ne peut cependant y avoir qu'un résultat. Lorsque l'on utilise une fonction, on parle d'appel de fonction, il faut fournir des valeurs pour les paramètres. Le traitement réalisé par la fonction, et en conséquence son résultat, dépend des valeurs des paramètres.

Par habitude, on dit qu'une fonction renvoie ou retourne un résultat, on parlera donc de valeur retournée ou renvoyée par une fonction.

Dans certain cas particuliers, une fonction n'a pas besoin de retourner un résultat, seul le traitement réalisé compte. C'est par exemple le cas de la fonction writeln de document que nous avons déjà rencontrée.

Les types des paramètres ne sont pas quelconques. A nouveau ils sont fixés à la définition de la fonction. Lorsque l'on appelle une fonction, il faut fournir des valeurs dont le type correspond à celui attendu. Mais il faut bien évidemment également connaiître la nature de la valeur attendue, savoir qu'il faut un nombre ne suffit pas, il faut savoir si ce nombre correspond à une température, à une somme d'argent, à la durée en secondes d'un morceau de musique, etc.

Pour pouvoir appeler une fonction il faut donc connaître les informations concernant les paramètres : leur nombre, leurs types, et à quoi ils correspondent. Pour pouvoir l'utiliser il faut également savoir à quoi correspond son résultat et quel traitement est réalisé. Toutes ces informations sont décrites dans la spécification de la fonction (qui correspond à ce que nous avons vu pour l'opérateur d'addition en renommant simplement opérande en paramètre). La donnée de la spécification doit suffire à l'utilisation d'une fonction.

Lorsqu'une fonction est définie pour un type de donnée particulier, l'utilisation de cette fonction, son appel, sur une donnée de ce type s'écrit en utilisant la notation pointée. Nous l'avons déjà rencontrée avec document.writeln qui est en fait un appel de la fonction writeln sur une donnée de type Document, ce type de données correspondant à une page chargée dans le navigateur. Evidemment le résultat dépend de la donnée sur laquelle s'utilise ou s'applique la fonction, on utilisera aussi par la suite l'expression "donnée concernée".

Nous verrons qu'il existe également des fonctions dites globales qui ne sont pas définies par un type particulier. Dans ce cas leur appel se fait simplement en utilisant le nom de la fonction, sans utiliser la notation pointée.

Exemple

Il existe une fonction getHours sur le type Date. De même que l'opérateur + existe pour les nombres et pour les chaines de caractères, on peut imaginer qu'une fonction de nom getHours puisse être définie pour un autre type de donnée. Par exemple une donnée Spectacle qui permetrait de gérer des spectacles, la fonction getHours fournirait alors peut-être l'heure de début du spectacle. Il est donc indispensable de préciser dans la spécification pour quel type la fonction est spécifiée.

Voici une spécification de getHours du type Date :

Cette spécification nous suffit pour savoir comment utiliser cette fonction sur une donnée de type Date :

var maintenant = new Date();                                  // date a pour la valeur la date courante
var nbHeures = maintenant.getHours();                         // heures a pour valeur le nombre d'heures de Date
document.writeln("le nombre d'heures est " + nbHeures);       // on affiche ce nombre d'heures (on note l'utilisation de la concaténation)
document.writeln("ou encore :" + maintenant.getHours());      // il n'est pas obligatoire de définir une variable pour utiliser le résultat
document.writeln("ou encore :" + new Date().getHours());      // ni même pour la date

Il existe de nombreuses autres méthodes similaires qui s'appliquent sur et permettent la manipulation des données de type Date : getFullYear, getMinutes, getMonth, getSeconds et getMilliseconds.

Conversion de types

Cette conversion se fait à l'aide de fonctions. Ainsi il existe la fonction parseInt qui prend en paramètre une chaîne de caractères et dont le résultat est l'entier correspondant au contenu de cette chaîne de caractères, lorsque cela est possible. De manière similaire il existe une fonction parseFloat qui permet la conversion d'une chaîne en un nombre "à virgule flottante" lorsque cela est possible.

Quelques précisions sont nécessaires quant au fonctionnement des ces fonctions :

• seul le premier nombre dans la chaîne est retourné, les autres caractères (y compris correspondant à des nombres) sont ignorés,
• si le premier caractère ne peut être converti en un nombre, le résultat sera NaN,
• les espaces en tête sont ignorés,
• avec parseInt il est possible de préciser un second paramètre qui sera la base (8, 10, 16) à utiliser pour analyser la chaîne.

Exemples :

parseFloat("1.24");                ==>   1.24
parseInt("42");                    ==>   42
parseInt("42 est la réponse");     ==>   42
parseInt("    42 est la réponse"); ==>   42
parseInt("1.24");                  ==>   1
parseInt("42estlaréponse");        ==>   42
parseInt("42 43 44");              ==>   42
parseInt("réponse = 42");          ==>   NaN
parseInt("10",16);                 ==>   16
parseInt("AA",16)                  ==>   170

La fonction parseInt peut donc être appliquée au résultat d'un appel à la fonction prompt pour produire un nombre, lorsque cela a un sens :

var texteSaisi = prompt("Donnez une valeur entière");
var unEntier = parseInt(texteSaisi);

Mais dans la mesure ou la fonction parseInt prend pour paramètre une chaîne de caractères et que la fonction prompt a pour résultat une chaîne de caractères, on peut également "enchainer" les appels de fonction sans passer par une variable intermédiaire :

var unEntier = parseInt(prompt("Donnez une valeur entière"));

On obtient ainsi le moyen d'obtenir une valeur entière saisie par l'utilisateur.

On réalise dans ce cas une composition d'appels de fonction.

 Le résultat de la somme de xx et yy est res.

Certaines conversions de type sont réalisées "automatiquement" par le langage : le langage applique implicitement une conversion, c'est-à-dire sans que le programmeur ait à "demander" cette manipulation. C'est ce qui se passe par exemple avec la fonction writeln que nous avons déjà beaucoup utilisée. Le paramètre de cette fonction doit être de type String or nous avons pu écrire :

var x = 12;
document.writeln(x);

Cela est possible car Javascript réalise automatiquement l'appel d'un traitement qui convertit la donnée numérique 12 en la chaîne "12" avant d'exécuter le traitement du writeln. Si le langage ne réalisait pas à notre place cette conversion il faudrait écrire : document.writeln(x.toString()); Ce qui alourdit le code pour une fonction assez souvent utilisée. Les concepteurs du langage ont ici voulu faciliter le travail des programmeurs.