From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../reference/classes/constructor/index.md | 103 ++++++++++++--------- 1 file changed, 58 insertions(+), 45 deletions(-) (limited to 'files/fr/web/javascript/reference/classes/constructor') diff --git a/files/fr/web/javascript/reference/classes/constructor/index.md b/files/fr/web/javascript/reference/classes/constructor/index.md index f488f06dc5..ea9682c80d 100644 --- a/files/fr/web/javascript/reference/classes/constructor/index.md +++ b/files/fr/web/javascript/reference/classes/constructor/index.md @@ -9,24 +9,27 @@ tags: translation_of: Web/JavaScript/Reference/Classes/constructor browser-compat: javascript.classes.constructor --- -
{{jsSidebar("Classes")}}
+{{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é 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`](/fr/docs/Web/JavaScript/Reference/Statements/class). -
{{EmbedInteractiveExample("pages/js/classes-constructor.html")}}
+{{EmbedInteractiveExample("pages/js/classes-constructor.html")}} -

Syntaxe

+## Syntaxe -
constructor() { ... }
+```js
+constructor() { ... }
 constructor(argument0) { ... }
 constructor(argument0, argument1) { ... }
-constructor(argument0, argument1, ... , argumentN) { ... }
+constructor(argument0, argument1, ... , argumentN) { ... } +``` -

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é.

+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é. -
class Person {
+```js
+class Person {
   constructor(name) {
     this.name = name;
   }
@@ -38,21 +41,27 @@ constructor(argument0, argument1, ... , argumentN) { ... }
const otto = new Person('Otto'); -otto.introduce(); +otto.introduce(); +``` -

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 :

+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 : -
constructor() {}
+```js +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 :

+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 : -
constructor(...args) {
+```js
+constructor(...args) {
   super(...args);
-}
+} +``` -

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

+Cela permet à un code comme celui-ci de fonctionner : -
class ValidationError extends Error {
+```js
+class ValidationError extends Error {
   printCustomerMessage() {
     return `La validation a échoué :-( (détails : ${this.message})`;
   }
@@ -68,13 +77,15 @@ try {
     console.log('Erreur inconnue', error);
     throw error;
   }
-}
+} +``` -

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.

+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 :

+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 {
+```js
+class ValidationError extends Error {
   constructor(message) {
     super(message);  // appelle le constructeur de la classe parent
     this.name = 'ValidationError';
@@ -96,17 +107,19 @@ try {
     console.log('Unknown error', error);
     throw error;
   }
-}
+} +``` -

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.

+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`](/fr/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError). -

Exemples

+## Exemples -

Utilisation de la méthode du constructor

+### Utilisation de la méthode du `constructor` -

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

+Cet extrait de code est tiré de l'[échantillon de classes](https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html) ([démo en direct](https://googlechrome.github.io/samples/classes-es6/index.html)). -
class Square extends Polygon {
+```js
+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.
@@ -124,13 +137,15 @@ try {
     this.height = value**0.5;
     this.width = value**0.5;
   }
-}
+} +``` -

Un autre exemple

+### 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.

+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 {
+```js
+class Polygon {
     constructor() {
         this.name = "Polygone";
     }
@@ -150,23 +165,21 @@ console.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //fa
 console.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true
 
 let newInstance = new Square();
-console.log(newInstance.name); // Polygone
+console.log(newInstance.name); // Polygone +``` -

Spécifications

+## Spécifications -

{{Specifications}}

+{{Specifications}} -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat}}

+{{Compat}} -

Voir aussi

+## Voir aussi - +- [`super()`](/fr/docs/Web/JavaScript/Reference/Operators/super) +- [Expression `class`](/fr/docs/Web/JavaScript/Reference/Operators/class) +- [Déclaration `class`](/fr/docs/Web/JavaScript/Reference/Statements/class) +- [`Classes`](/fr/docs/Web/JavaScript/Reference/Classes) +- [Object.prototype.constructor](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) -- cgit v1.2.3-54-g00ecf