From 24aeaadee0aaf2f7e7ac0832c5cef485891c7adc Mon Sep 17 00:00:00 2001 From: Mercier Mike Date: Wed, 16 Jun 2021 21:33:20 +0200 Subject: Supprimer les accents des nom de classe (#1214) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Supprimer les accents des nom de classe Je suis peut être dans l'erreur mais il me semble que c'est deconseillé de mettre des accents dans les variables/classes * UPDT: Refrensh from en-US * FIX: Wrong removed line Co-authored-by: tristantheb --- .../reference/classes/constructor/index.html | 202 ++++++++++++++------- 1 file changed, 135 insertions(+), 67 deletions(-) (limited to 'files/fr/web/javascript/reference/classes') diff --git a/files/fr/web/javascript/reference/classes/constructor/index.html b/files/fr/web/javascript/reference/classes/constructor/index.html index 0fd5c8941a..f488f06dc5 100644 --- a/files/fr/web/javascript/reference/classes/constructor/index.html +++ b/files/fr/web/javascript/reference/classes/constructor/index.html @@ -2,103 +2,171 @@ title: constructor slug: Web/JavaScript/Reference/Classes/constructor tags: + - Classes - ECMAScript 2015 - JavaScript - - Reference + - Language feature translation_of: Web/JavaScript/Reference/Classes/constructor +browser-compat: javascript.classes.constructor --- -
{{jsSidebar}}
+
{{jsSidebar("Classes")}}
-

La méthode constructor est une méthode qui est utilisée pour créer et initialiser un objet lorsqu'on utilise le mot clé {{jsxref("Opérateurs/class","class")}}.

+

La méthode constructor est une méthode qui est utilisée pour créer et initialiser un objet lorsqu'on utilise le mot clé class.

{{EmbedInteractiveExample("pages/js/classes-constructor.html")}}
- +

Syntaxe

-

Syntaxe

+
constructor() { ... }
+constructor(argument0) { ... }
+constructor(argument0, argument1) { ... }
+constructor(argument0, argument1, ... , argumentN) { ... }
-
constructor([arguments]) { ... }
+

Description

-

Description

+

Un constructeur vous permet de fournir toute initialisation personnalisée qui doit être effectuée avant que toute autre méthode puisse être appelée sur un objet instancié.

-

Il ne peut y avoir qu'une seule méthode utilisant le mot-clé constructor au sein d'une classe. Une exception {{jsxref("SyntaxError")}} sera levée si la classe contient plusieurs méthodes constructor.

+
class Person {
+  constructor(name) {
+    this.name = name;
+  }
+
+  introduce() {
+    console.log(`Hello, my name is ${this.name}`);
+  }
+}
+
+const otto = new Person('Otto');
 
-
Le constructeur peut utiliser le mot-clé {{jsxref("Opérateurs/super","super")}} afin d'appeler le constructeur de la classe parente.

+otto.introduce();
-

Si on ne définit pas une méthode constructor, un constructeur par défaut sera utilisé.

+

Si vous ne fournissez pas votre propre constructeur, alors un constructeur par défaut sera fourni pour vous. Si votre classe est une classe de base, le constructeur par défaut est vide :

-

Exemples

+
constructor() {}
-

Utiliser la méthode constructor

+

Si votre classe est une classe dérivée, le constructeur par défaut appelle le constructeur parent, en transmettant tous les arguments qui ont été fournis :

-

Ce fragment de code est tiré de cet exemple :

+
constructor(...args) {
+  super(...args);
+}
+ +

Cela permet à un code comme celui-ci de fonctionner :

-
class Carré extends Polygone {
-  constructor(longueur) {
-    // On utilise le constructeur de la classe parente
-    // avec le mot-clé super
-    super(longueur, longueur);
-    // Pour les classes dérivées, super() doit être appelé avant de
-    // pouvoir utiliser 'this' sinon cela provoque une exception
-    // ReferenceError
-    this.nom = 'Carré';
+
class ValidationError extends Error {
+  printCustomerMessage() {
+    return `La validation a échoué :-( (détails : ${this.message})`;
   }
+}
 
-  get aire() {
-    return this.hauteur * this.largeur;
+try {
+  throw new ValidationError("Numéro de téléphone invalide");
+} catch (error) {
+   if (error instanceof ValidationError) {
+    console.log(error.name); // Il s'agit d'une erreur au lieu de ValidationError !
+    console.log(error.printCustomerMessage());
+  } else {
+    console.log('Erreur inconnue', error);
+    throw error;
   }
+}

 
-  set aire(valeur) {
-    this.aire = valeur;
+
La classe ValidationError n'a pas besoin d'un constructeur explicite, car elle n'a pas besoin de faire d'initialisation personnalisée. Le constructeur par défaut se charge alors d'initialiser le parent Error à partir de l'argument qui lui est fourni.

+
+
Cependant, si vous fournissez votre propre constructeur, et que votre classe dérive d'une certaine classe parente, alors vous devez appeler explicitement le constructeur de la classe parente en utilisant super. Par exemple :

+
+
class ValidationError extends Error {
+  constructor(message) {
+    super(message);  // appelle le constructeur de la classe parent
+    this.name = 'ValidationError';
+    this.code = '42';
+  }
+
+  printCustomerMessage() {
+     return `La validation a échoué :-( (détails : ${this.message}, code : ${this.code})`;
+  }
+}
+
+try {
+  throw new ValidationError("Numéro de téléphone invalide");
+} catch (error) {
+   if (error instanceof ValidationError) {
+    console.log(error.name); // Maintenant, c'est une ValidationError !
+    console.log(error.printCustomerMessage());
+  } else {
+    console.log('Unknown error', error);
+    throw error;
   }
 }

 
-
Utiliser un constructeur par défaut

+
Il ne peut y avoir qu'une seule méthode spéciale portant le nom « constructor » dans une classe. Avoir plus d'une occurrence d'une méthode constructor dans une classe lancera une erreur SyntaxError.

 
-
Si vous ne définissez pas de méthode constructor, un constructeur par défaut sera utilisé. Pour les classes de base, le constructeur par défaut sera :

+
Exemples

 
-
constructor() {}

+
Utilisation de la méthode du constructor

 
-
Pour les classes dérivées, le constructeur par défaut sera :

+
Cet extrait de code est tiré de l'échantillon de classes (démo en direct).

 
-
constructor(...args) {
-  super(...args);
+
class Square extends Polygon {
+  constructor(length) {
+    // Ici, on appelle le constructeur de la classe parente avec des longueurs
+    // fournies pour la largeur et la hauteur du polygone.
+    super(length, length);
+    // NOTE : Dans les classes dérivées, `super()` doit être appelé avant de pouvoir
+    // utiliser `this`. Si vous ne le faites pas, cela provoquera une ReferenceError.
+    this.name = 'Carré';
+  }
+
+  get area() {
+    return this.height * this.width;
+  }
+
+  set area(value) {
+    this.height = value**0.5;
+    this.width = value**0.5;
+  }
+}

+
+
Un autre exemple

+
+
Ici, le prototype de la classe Square est modifié — mais le constructeur de sa classe de base Polygon est toujours appelé lorsqu'une nouvelle instance d'un carré est créée.

+
+
class Polygon {
+    constructor() {
+        this.name = "Polygone";
+    }
+}
+
+class Square extends Polygon {
+    constructor() {
+        super();
+    }
 }
-

-
-
Spécifications

-
-
- 
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
-  
-   
-   
-   
-  
- 
-
SpécificationStatutCommentaires
{{SpecName('ES2015', '#sec-constructor', 'constructor')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-static-semantics-constructormethod', 'Constructor Method')}}{{Spec2('ESDraft')}}

-
-
Compatibilité des navigateurs

-
-
-
-
{{Compat("javascript.classes.constructor")}}

-
-
Voir aussi

+
+class Rectangle {}
+
+Object.setPrototypeOf(Square.prototype, Rectangle.prototype);
+
+console.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //false
+console.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true
+
+let newInstance = new Square();
+console.log(newInstance.name); // Polygone

+
+
Spécifications

+
+
{{Specifications}}

+
+
Compatibilité des navigateurs

+
+
{{Compat}}

+
+
Voir aussi

 
 
-- 
cgit v1.2.3-54-g00ecf