JavaScript

Ce cours ne nécessite aucune connaissance informatique préalable, excepté celle du HTML. Le JavaScript est un langage de programmation appliqué au objet d'un document HTML.

Les objets en JavaScript

En vrac

String.prototype.reverse = function() {return this.split("").reverse().join("")}

Instance de fonction

En Javascript, les nombres et les chaînes sont des objets. Une variable est donc une instance d'objet numérique, de chaîne, ou d'autre objet plus compliqué.

Mais une variable peut aussi être une instance de fonction. Dans ce cas, nous pouvons aussi voir la fonction soit comme une chaîne de caractère interprétable, soit comme un objet parent (d'où le terme d'instance).

Syntaxe : [var] id_var = id_fonction;

Où id_var représent le nom de l'instance (variable) et id_fonction le nom de la fonction.
<HTML><body><script><!--

function Max(a,b)
{return (a>b)?a:b;}

a = Max(1,2);
b = Max;
c = b(2,3);

with (document)
{
write(a,'<br>');
write(b,'<br>');
write(c,'<br>');
}

//--></script></body></HTML>

Méthode d'objet

Grâce aux instances de fonction, nous pouvons créer des méthodes à nos objets personnels.

 
<HTML><body><script><!--

function Max(a,b)
{return (a>b)?a:b;};

a = new Object;
a.Max = Max;

with (document)
{
write(a,'<br>');
write(a.Max(1,2),'<br>');

for (t in a)
  write('<br>',t,'=',a[t]);
}

//--></script></body></HTML>

Objet personnel

Grâce aux instances de fonction et aux affectations de méthodes, nous pouvons complétement créer nos objets personnels.

Il faut savoir, qu'un objet est toujours une instance d'un autre ; c'est-à-dire, que chaque objet possède un parent. Dans notre cas, pour définir un nouvel objet, nous déclarerons une instance de l'objet vide "Object".

Syntaxe : [var] id = new Object;

Où id est le nom de notre nouvel objet (instance).

Une fois déclaré, nous pouvons affecter les méthodes et les propriétés de notre objet.
<HTML><body><script><!--

function Aire(a)
{return this.Dx*this.Dy};

a = new Object;
a.Dx = 800;
a.Dy = 600;
a.Aire = Aire;

with (document)
{
write(a.Aire());

for (t in a)
  write('<br>',t,'=',a[t]);
}

//--></script></body></HTML>

Objet - Constructeur

Un construction est une méthode générateur de l'objet.

Il faut savoir, qu'un objet est toujours une instance d'un autre ; c'est-à-dire, que chaque objet possède un parent. Dans notre cas, pour définir un nouvel objet, nous déclarerons une instance de l'objet vide constructeur".

Syntaxe : [var] id = new id_const;

Où id est le nom de notre nouvel objet (instance), et id_const le nom du constructeur.

Cette exemple obtient le même résultat que dans l'exemple précédent, mais d'une façon plus proche (et plus propre) de la notion d'héritage d'objet.
<HTML><body><script><!--

function Aire(a)
{return this.Dx*this.Dy};

function My_Obj(Dx,Dy)
{this.Dx = Dx;
this.Dy = Dy;
this.Aire = Aire;};

a = new My_Obj(800,600);

with (document)
{
write(a.Aire());

for (t in a)
  write('<br>',t,'=',a[t]);
}

//--></script></body></HTML>

Objet - Class d'instance

Il est possible de rajouter des méthodes et des propriétés à l'ensemble des instances d'un même objet.

Syntaxe : id_const.prototype.id = affectation;

Où id_const est le nom de notre objet constructeur, id est le nom d'une nouvelle propriété ou méthode, et affectation la valeur ou le nom de la méthode à ajouter.

Cette exemple obtient le même résultat que dans l'exemple précédent.
Remarquez que l'instance "a" de l'objet est déclaré avant l'ajout de la méthode "Aire".
<HTML><body><script><!--

function Aire(a)
{return this.Dx*this.Dy};

function My_Obj(Dx,Dy)
{this.Dx = Dx;
this.Dy = Dy;};

a = new My_Obj(800,600);

My_Obj.prototype.Aire= Aire;

with (document)
{
write(a.Aire());

for (t in a)
  write('<br>',t,'=',a[t]);
}

//--></script></body></HTML>

Objet - Classe de l'objet

L'objet peut contenir des données utile qu'a lui même (pour son fonctionnement) et qui n'ont pas besoin d'être recopié dans les instances donc il sera le générateur.

Syntaxe : id_const.id = affectation;

Où id_const est le nom de notre objet constructeur, id est le nom d'une nouvelle propriété ou méthode, et affectation la valeur ou le nom de la méthode à ajouter.

Cette exemple nous montre la différent de contenue entre l'objet et son instance.

Nous voyons bien que la propriété PI appartient à l'objet, et la méthode "Aire" à l'instance. L'instance peut donc modifier cette méthode à son grés.
<HTML><body><script><!--

function C(R) //Cercle
{this.R = R};

C.PI = 3.1415;

function C_Aire()
{return C.PI*this.R*this.R};

C.prototype.Aire=C_Aire;

a = new C(3);

with (document)
{
for (t in C)
  write(t,'=',C[t],'<br>');
write('<hr>');
for (t in a)
  write(t,'=',a[t],'<br>');

write('<hr>',a.Aire());
}

//--></script></body></HTML>

Objet - assing()

Cette méthode permet de redéfinir l'assignation de l'objet.

Lors d'une affectation (obj1 = obj2), l'objet est copié par référence ; ainsi, toutes modifications effectuées sur obj1 et aussi fait sur obj2, car ils partagent les même données.

Le but de la méthode assign() est de définir (par soit même) un copie par valeur.

Cette propriété est défini dans le langage Javascript, mais ne semble pas être fonctionnelle. Si vous avez un exemple fonctionnel, informez moi SVP.

Cette exemple montre l'affectation par référence.
<HTML><body><script><!--

function Pt(x,y)
{this.x=x; this.y=y;}

var p1 = new Pt(1,2);
var p2 = p1;

p2.x = 3;


with(document)
{write(p1==p2,'<br>');

for(t in p1)write('<br>'
    ,t,'=',p1[t]);}

//--></script></body></HTML>

Objet - toString()

Un objet se connaît lui même ; dans cette idée, il serait normal qu'il puisse retourner un chaîne de caractère lorsque l'on désire connaître son état.

La méthode toString() permet de retourner une donnée (une chaîne de préférence) représentant l'objet.

Cette méthode n'est valable que pour l'instance.

Cette exemple nous affiche l'objet et son instance.
<HTML><body><script><!--

function Carre(c)
{this.c = c};

function C_toString()
{return "[Carre de côté "
  + this.c + "]";}

Carre.prototype.toString
  = C_toString;

a = new Carre(3);

with (document)
{
  write(Carre,'<hr>');
  write(a);
}

//--></script></body></HTML>

Objet - valueOf()

Permet à l'objet de retourner une valeur numérique lorsqu'il est intégré dans une expression.
<HTML><body><script><!--

function Masse(m) {this.m = m};

function M_toString() {return "[Objet Masse]"};
function M_valueOf() {return this.m;};

Masse.prototype.toString = M_toString;
Masse.prototype.valueOf = M_valueOf;

a = new Masse(2);
with (document)
{
  write(a,'<br>');
  write(a-0);
}

//--></script></body></HTML>

L'Objet fonction

Dans l'idée qu'une fonction est un objet, le Javascript nous propose un constructeur de fonction nommé "Function()".

Syntaxe : id = new Function("code");

Où id représente le nom de l'instance de fonction (variable) et code le code de la fonction.
<HTML><body><script><!--

function Carre(c)
{this.c = c};

var a = new Carre(2);
Carre.prototype.toString
  = new Function("return this.c");

document.write(a);

//--></script></body></HTML>

 

 

Page précédente Dernière mise à jour : dimanche 06 janvier 2008 Haut de page Première page du site