Passionnés d'informatique depuis 1990

Le javascript 4

Par le 30 juin 2004 dans nihil | 0 comments

|  Présentation | Données | Opérateurs | Instructions |

 

Les Instructions conditionnelles

Une instruction conditionnelle permet de spécifier une séquence d’instructions qui ne s’exécute que si une certaine condition est remplie.

if (condition) { instructions;} else {instructions; }

Ex : if ( s % 2 ) { alert("seconde impaire : "+s); } else
{ alert("seconde paire : "+s);}

Il est bien entendu possible de faire directement suivre l’instruction else par une autre instruction if, pour obtenir une construction if - else if – else classique.

 

Les Instruction conditionnelle (2)

La seconde instruction conditionnelle reconnue par JavaScript est l’instruction switch. Cette instruction permet de tester un éventail de valeurs plus important que simplement
true / false.

switch(expression)
{case valeur_1 : instructions; break; case valeur_2 : case valeur_2 :
instructions; break; default : instructions; }

Ex : switch(Math.floor(s/10)) {case 0 : alert("tout petit : "+s
);break;case 1 :alert("petit : " + s );break; case 2 :…}

 

Les Boucles

Une boucle est une séquence d’instructions qui s’exécute de manière répétitive jusqu’à ce qu’une certaine condition soit remplie.

do
{instructions; } while (condition);

Ex : do { time = new Date() ; s = time.getSeconds(); } while ( s % 10
); alert("nouvelle dizaine : "+s);

Cette boucle est parcourue une fois, à la suite de quoi la condition est évaluée. La boucle est alors exécutée à nouveau jusqu’à ce que la condition ne soit plus remplie.
Si la condition est initialement fausse, la boucle est parcourue une fois et une seule.

 

Les Boucles (2)

Une boucle basée sur l’instruction while n’est pas exécutée si la condition est initialement fausse.

while (condition){
instructions; }

Ex : while ( n < 5 ) { alert("n = " + n++); }

La boucle est parcourue tant que la condition est remplie. La condition est évaluée avant toute exécution des instructions de la boucle. Si la condition est initialement fausse, la boucle n’est pas parcourue.

 

Les Boucles (3)

L’instruction for permet de spécifier, en plus de la condition, une instruction d’initialisation et une instruction de boucle. La boucle n’est pas exécutée si la condition est
initialement fausse.

for(init; condition; repeat){instructions;}

Ex : for( n = 1; n < 5; n++ ) {alert("n = " + n);}

L’instruction for ci-dessus est sémantiquement équivalente à la boucle :

init;

while(condition) { instructions;repeat;}

Cette instruction est très souvent utilisée,comme dans l’exemple mentionné, dès lors où l’on gère un compteur de boucle.

 

LesBoucles (4)

L’instruction break permet d’interrompre prématurément l’exécution
d’une boucle.

while(true){ instructions; if (condition) break; instructions; }

Exemple : (quelle est la dernière valeur de affichée ?)

while (true) { alert("n = " + n++);
if ( n == 5 ) break; alert("On continue"); }

ou

for ( n = 0; n < 10; n++ ){ alert("n = " + n++); if ( n % 2 ) continue; alert("n pair"); }

L’instruction continue permet d’interrompre le déroulement du corps d’une boucle, en exécutant directement l’itération suivante.

 

Les Boucles (5)

Dans le cas de boucles imbriquées il est possible de les nommer à l’aide d’un label qui permet de spécifier celle à laquelle s’appliquent les instructions break ou continue.

label:
while(true){ instructions; if (condition) break label; instructions;
}

Ex : loop_i: for (i=1; i < 5; i++) {
loop_j:
for (j=1; j < 5; j++) {
alert("(i,j) = (" + i + "," + j + ")");
if ( j == i ) continue loop_i;
}
}

 

Les Fonctions

En JavaScript la définition d’une fonction se fait à l’aide de l’instruction function. L’appel se fait de manière classique. Depuis le corps d’une fonction il est possible d’accéder
à la liste des arguments à l’aide du tableau arguments[].
Le premier argument a pour indice 0.

Une fonction peut renvoyer une valeur à l’aide de l’instruction return.

JavaScript possède un certain nombre de fonctions prédéfinies :

eval      parseInt, parseFloat
isFinite Number, String      isNaN
escape, unescape

 

Les Tableaux associatifs

Comme dans d’autres langages (cf. perl) il est possible en JavaScript d’indexer des tables non pas avec un entier mais avec une chaîne de caractères (tableaux associatifs).

ascendant[0] = "Raymond";

ascendant[1] = “Marcelle”;

ascendant[2] = “Raymond”;

La séquence précedente gagnerait en lisibilité à être codée :

ascendant["père"]=Raymond";

ascendant["mère"] = “Marcelle”;

ascendant["grand'père paternel"] = “Raymond”;

ascendant["grand'mère paternelle"] = “Ginette”;

ascendant["grand'père maternel"] = “Marcel”;

ascendant["grand'mère maternelle"] = “Raymonde”;

 

Les Objets

Si la valeur de l’index ne comprend que des caractères alphanumériques (cf. nom de variable), la notation précédente peut être simplifiée :

ascendant["p"] = "Raymond";

ascendant["m"] = “Marcelle”;

ascendant["pp"] = “Raymond”;

ascendant["pm"] = “Ginette”;

ascendant["mp"] = “Marcel”;

ascendant["mm"] = “Raymonde”;

donne :

ascendant.p = "Raymond";

ascendant.m = “Marcelle”;

ascendant.pp = “Raymond”;

ascendant.pm = “Ginette”;

ascendant.mp = “Marcel”;

ascendant.mm = “Raymonde”;

En JavaScript, un objet est un tableau associatif :

centralien.prenom = "Raymond";

centralien.nom = “Deubaze”;

centralien.promo = 2000;

Cette séquence crée un objet centralien possédant les trois propriétés prenom, nom et promo.

 

L’Initialisation d’un objet

Une variable du type objet peut être initialisée lors de sa déclaration :

var centralien = {prenom:"Raymond", nom:"Deubaze", promo:2000};

       En général, on définit une fonction appelée constructeur, permettant de créer des instances d’objets similaires.

function Centralien(prenom,nom,promo) {

this.prenom = prenom;

this.nom = nom;

this.promo = promo;

}

var moniteur_H10 = new Centralien(“Raymond”,”Deubaze”,2000);

var moniteur_F7 = new Centralien(“Raymonde”,”Deubaze”,2001);

var centralien = {prenom:”Raymond”, nom:”Deubaze”, promo:2000};

Noter la variable this qui se réfère à l’objet que l’on est en train d’initialiser.

 

Le Prototype

Il est possible d’initialiser ou de modifier une propriété pour l’ensemble des objets d’un type donné (en C++ on dirait pour toutes les instances d’une classe).

function
Centralien(prenom,nom,promo) {

this.prenom = prenom;

this.nom = nom;

this.promo = promo;

}

var moniteur_H10 = new Centralien(“Raymond”,”Deubaze”,2000);

var moniteur_F7 = new Centralien(“Raymonde”,”Deubaze”,2001);

Centralien.prototype.option = “TIC”;

La dernière instruction ajoute et initialise la propriété option aux deux objets du type Centralien : moniteur_H10 et moniteur_F7.

 

Les Méthodes

Lorsqu’une propriété d’un objet est une fonction, on appelle cette fonction une méthode de l’objet considéré. La définition d’une méthode peut être intégrée
au constructeur.

function Centralien(prenom,nom,promo)
{

this.print = list_props;

}

function list_props() {

var str = “”; var prop;

for ( prop in this ) {

str += prop + ” = ” + this[prop] + “\n”;

}

return str;

}

Noter encore la variable this qui se réfère à l’objet appelant.

 

Les Opérateurs objet

JavaScript possède des opérateurs qui s’appliquent plus particulièrement à des objets : new (création d’un objet), this (se réfère à l’objet
appelant dans une méthode), et delete qui permet de supprimer un objet.

L’opérateur delete peut s’appliquer à toutes les variables déclarées implicitement. Ceci recouvre en particulier une propriété ou un élément de
tableau mais aussi une variable ou un objet déclarés implicitement (sans utiliser l’opérateur var).

delete renvoie true si l’opération s’est bien passée, false sinon.

 

Les Instructions objet

Il existe également des instructions qui ne s’appliquent qu’à des objets. La première est for.. in. Elle permet d’effectuer une boucle sur toutes les propriétés
d’un objet.

function list_props(obj) {

var str = “”; var prop;

for ( prop in obj ) {

str += prop + ” = ” + obj[prop] + “\n”;

}

return str;

}

L’instruction with permet de travailler dans le contexte d’un objet particulier (confort d’écriture).

x = r *
Math.sin(Math.PI / 2);
donne: with ( Math ) { x = r * sin(PI / 2); }

 

Les Objets prédéfinis

Boolean

constructeur : Boolean(valeur)

méthode : valueOf( )

Attention : un objet du type Boolean, non null et non undefined sera toujours converti à la valeur true dans une expression logique :

var mybool = new Boolean(false);

if ( mybool ) {

alert(“mybool is true”);

}

alert(“mybool’s value is ” + mybool.ValueOf());

Sauf cas particulier, il vaut mieux utiliser une variable booléenne qu’un objet.

 

Number

Number

constructeur : Number(valeur)

méthodes : valueOf( ), toString( )

Comme dans le cas de l’objet Boolean, il est peu courant de créer des objets du type Number. Toutefois, le prototype de l’objet Number possède des propriétés
intéressantes (en C++ on parlerait de variables de classe) :

Number.MAX_VALUE : le plus grand nombre

Number.MIN_VALUE : le plus petit nombre

Number.NaN : le code NaN (Not a Number)

Number.NEGATIVE_INFINITY : l’infini positif

Number.POSITIVE_INFINITY : l’infini négatif

 

Pour le détail de ces codes, cf. double précision IEEE 754 (64 bits).