<langage de script="javascript">
fonctioncircel(rayon)
{//Cette fonction définit la classe elle-même. Le r suivant est une variable d'instance définie et initialisée par le constructeur.
this.r=radius;
}
//Cet attribut est une variable de classe, qui est un attribut du constructeur
cercle.PI=3,14159 ;
zone de fonction()
{//C'est bien sûr la formule pour calculer l'aire d'un cercle.
retourner ceci.PI * ceci.r * ceci.r;
}
// Ci-dessous, nous en faisons une méthode d'instance en attribuant la fonction à l'objet circulaire du constructeur.
//Afin d'être compatible avec Navigator3, nous devons créer et supprimer un objet avant que l'objet prototype ne soit généré
nouveaucercle(0);
cercle.prototype.area=zone;
//Ce qui suit est une autre fonction qui compare deux paramètres et renvoie le plus grand
fonctioncircel_max(a,b)
{
si(ar > br)
renvoyer un ;
autre
retourner b ;
}
//Puisque cette fonction compare deux objets, cela n'a aucun sens de la traiter comme une opération sur une seule méthode d'instance Circel.
//Mais nous ne voulons pas devenir une fonction indépendante, nous lui attribuons donc un constructeur et en faisons une méthode de classe.
cercle.max=circel_max;
//Le code suivant utilise différents champs de cercle
var c=new circel(1.0); //Créer une instance de la classe circel
cr=2.2; //Définit une variable r de l'instance
var a=c.area(); //Appelle la méthode zone de l'instance
var x=Math.exp(circel.PI); //Utiliser la variable PI dans nos propres calculs
var d=new circel(1.2); //Créer une autre instance de circel
var plus grand=circel.max(c,d);//Utiliser la méthode de classe circel.max
</script>
Fichier JScript.js
/**//* Fichier JScript Un nombre complexe est la somme d'un nombre imaginaire et d'un nombre imaginaire Le nombre imaginaire i est la racine carrée de -1.
*/
/**//*La première étape de la définition d'une classe consiste à définir le constructeur de la classe. Le constructeur qualifié initialise toutes les fonctions d'instance de l'objet. Ces attributs sont les "variables d'état" principales qui activent chaque instance de l'objet. classe pour interagir les uns avec les autres.
*/
fonction JScript(réel,img)
{
this.x=real;//partie réelle
this.y=img;//Partie imaginaire
}
/**//*La deuxième étape dans la définition d'une classe de fonctions consiste à définir sa méthode d'instance (ou d'autres attributs) dans l'objet prototype du constructeur
Toutes les propriétés définies par cet objet seront héritées par toutes les instances de cette classe. Notez que les méthodes d'instance fonctionnent implicitement sur le mot-clé this. De nombreuses méthodes ne nécessitent pas d'autres paramètres.
*/
//Renvoie la taille du nombre complexe, qui est définie comme la distance entre l'origine (0,0) et le plan complexe
JScript.prototype.magnitude=fonction()
{
return Math.sqrt(this.x * this.x + this.y * this.y);
} ;
//Renvoie l'opposé d'un nombre complexe
JScript.prototype.negative=fonction()
{
return new JScript(-this.x,-this.y);
} ;
// Convertit l'objet JScript en chaîne de manière efficace. Ce sera la fonction appelée lors de l'utilisation de l'objet JScript comme chaîne.
JScript.prototype.toString=fonction()
{
return "{"+ this.x +","+ this.y +"}";
} ;
//Renvoie la partie réelle d'un nombre complexe. Cette fonction est appelée lors du traitement d'un objet JScript en tant que valeur primitive.
JScript.prototype.valueOf=function() {return this.x;};
/**//*La troisième étape dans la définition d'une classe consiste à définir les méthodes de classe.
Les constantes et autres variables de classe sont des propriétés du constructeur de fonction lui-même (plutôt que des propriétés de l'objet prototype du constructeur)
Notez que les méthodes statiques n'utilisent pas le mot-clé this car elles n'opèrent que sur les paramètres.
*/
//Calculer la somme de deux nombres complexes et renvoyer le résultat
JScript.add()=fonction(a,b)
{
renvoie un nouveau JScript (ax + bx, ay + by);
} ;
// Soustraire un nombre complexe d'un autre nombre complexe et renvoyer le résultat
JScript.subtract()=fonction(a,b)
{
return new JScript(ax - bx, ay - by);
} ;
//Calculer le produit de deux nombres complexes et renvoyer le résultat
JScript.multiply()=fonction(a,b)
{
return new JScript(ax * bx - ay * by , ax * bx + xy * by);
};
/**//*Voici quelques pluriels prédéfinis utiles. Ils sont définis comme des variables de classe afin qu'ils puissent être utilisés comme constantes (notez qu'ils ne sont pas réellement en lecture seule).
*/
JScript.zero=new JScript(0,0);
JScript.one=nouveau JScript(1.0);
JScript.i=nouveau JScript(0.1);