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 --- .../classes/private_class_fields/index.md | 133 ++++++++++----------- 1 file changed, 63 insertions(+), 70 deletions(-) (limited to 'files/fr/web/javascript/reference/classes/private_class_fields') diff --git a/files/fr/web/javascript/reference/classes/private_class_fields/index.md b/files/fr/web/javascript/reference/classes/private_class_fields/index.md index 9d1187b01d..45ad084074 100644 --- a/files/fr/web/javascript/reference/classes/private_class_fields/index.md +++ b/files/fr/web/javascript/reference/classes/private_class_fields/index.md @@ -7,36 +7,34 @@ tags: - JavaScript translation_of: Web/JavaScript/Reference/Classes/Private_class_fields --- -
{{JsSidebar("Classes")}}
+{{JsSidebar("Classes")}}Les propriétés de classe sont publiques par défaut et peuvent être lues et modifiées à l'extérieur de la classe. Cependant, [une proposition expérimentale](https://github.com/tc39/proposal-class-fields), permettant de définir des variables privées dans une classe avec le préfixe `#`, est disponible. -
Les propriétés de classe sont publiques par défaut et peuvent être lues et modifiées à l'extérieur de la classe. Cependant, une proposition expérimentale, permettant de définir des variables privées dans une classe avec le préfixe #, est disponible.
+## Syntaxe -

Syntaxe

+ class ClassWithPrivateField { + #privateField + } -
class ClassWithPrivateField {
-  #privateField
-}
+    class ClassWithPrivateMethod {
+      #privateMethod() {
+        return 'hello world'
+     }
+    }
 
-class ClassWithPrivateMethod {
-  #privateMethod() {
-    return 'hello world'
- }
-}
-
-class ClassWithPrivateStaticField {
-  static #PRIVATE_STATIC_FIELD
-}
-
+ class ClassWithPrivateStaticField { + static #PRIVATE_STATIC_FIELD + } -

Exemples

+## Exemples -

Champs privés statiques

+### Champs privés statiques -

Les champs privés sont accessibles depuis le constructeur et depuis l'intérieur de la déclaration de la classe elle-même.

+Les champs privés sont accessibles depuis le constructeur et depuis l'intérieur de la déclaration de la classe elle-même. -

La limitation des variables statiques ne pouvant être appelées que par des méthodes statiques tient toujours.

+La limitation des variables statiques ne pouvant être appelées que par des méthodes statiques tient toujours. -
class ClassWithPrivateStaticField {
+```js
+class ClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static publicStaticMethod() {
@@ -45,15 +43,17 @@ class ClassWithPrivateStaticField {
   }
 }
 
-console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
+console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42) +``` -

Les champs statiques privés sont ajoutés au constructeur de la classe au moment de l'évaluation de classe..

+Les champs statiques privés sont ajoutés au constructeur de la classe au moment de l'évaluation de classe.. -

Il y a une restriction de provenance sur les champs statiques privés. Seule la classe qui a défini un champ statique privé peut y accéder.

+Il y a une restriction de provenance sur les champs statiques privés. Seule la classe qui a défini un champ statique privé peut y accéder. -

Ceci peut conduire à un comportement inattendu lors de l'utilisation de this.

+Ceci peut conduire à un comportement inattendu lors de l'utilisation de **`this`**. -
class BaseClassWithPrivateStaticField {
+```js
+class BaseClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static basePublicStaticMethod() {
@@ -71,15 +71,16 @@ try {
 } catch(e) { error = e}
 
 console.assert(error instanceof TypeError)
-
+``` -

Champs d'instance privés

+### Champs d'instance privés -

Les champs d'instance privés sont déclarés avec des noms à # (prononcés "noms à hash", "hash names" en anglais), qui sont des identifieurs préfixés par #. Le # fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès.

+Les champs d'instance privés sont déclarés avec des **noms** à **#** (prononcés "_noms à hash_", "_hash names_" en anglais), qui sont des identifieurs préfixés par `#`. Le `#` fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès. -

L'encapsulation est forcée par le langage. C'est une erreur de syntaxe que de faire référence aux noms à # en dehors de leur portée.

+L'encapsulation est forcée par le langage. C'est une erreur de syntaxe que de faire référence aux noms à `#` en dehors de leur portée. -
class ClassWithPrivateField {
+```js
+class ClassWithPrivateField {
   #privateField
 
   constructor() {
@@ -90,17 +91,18 @@ console.assert(error instanceof TypeError)
 
 const instance = new ClassWithPrivateField()
 instance.#privateField === 42 // Erreur de syntaxe
-
+``` -

Méthodes Privées

+### Méthodes Privées -

Méthodes statiques privées

+#### Méthodes statiques privées -

Comme leur équivalents publics, les méthodes statiques privées sont appelées dans la classe elle-même, pas dans les instances de la classe. Comme les champs statiques privés, elles ne sont accessibles que depuis l'intérieur de la déclaration de la classe.

+Comme leur équivalents publics, les méthodes statiques privées sont appelées dans la classe elle-même, pas dans les instances de la classe. Comme les champs statiques privés, elles ne sont accessibles que depuis l'intérieur de la déclaration de la classe. -

Les méthodes statiques privées peuvent être des fonctions génératrices, asynchrones et génératrices asynchrones.

+Les méthodes statiques privées peuvent être des fonctions génératrices, asynchrones et génératrices asynchrones. -
class ClassWithPrivateStaticMethod {
+```js
+class ClassWithPrivateStaticMethod {
     static #privateStaticMethod() {
         return 42
     }
@@ -116,11 +118,12 @@ instance.#privateField === 42 // Erreur de syntaxe
 
 console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42);
 console.assert(ClassWithPrivateStaticMethod.publicStaticMethod2() === 42);
-
+``` -

Cela peut conduire à un comportement inattendu lors de l'utilisation de this. Dans l'exemple suivant, this fait référence à la classe Derived (pas à la classe Base) lorsqu'on essaie d'appeler Derived.publicStaticMethod2(), et fait ainsi apparaître la même "restriction de provenance" que mentionné ci-dessus :

+Cela peut conduire à un comportement inattendu lors de l'utilisation de **`this`**. Dans l'exemple suivant, `this` fait référence à la classe `Derived` (pas à la classe `Base`) lorsqu'on essaie d'appeler `Derived.publicStaticMethod2()`, et fait ainsi apparaître la même "restriction de provenance" que mentionné ci-dessus : -
class Base {
+```js
+class Base {
     static #privateStaticMethod() {
         return 42;
     }
@@ -136,13 +139,14 @@ class Derived extends Base {}
 
 console.log(Derived.publicStaticMethod1()); // 42
 console.log(Derived.publicStaticMethod2()); // TypeError
-
+``` -

Méthodes d'instance privées

+#### Méthodes d'instance privées -

Les méthodes d'instance privées sont des méthodes disponibles dans les instances de classe privées, dont l'accès est restreint de la même manière que les champs d'instance privés.

+Les méthodes d'instance privées sont des méthodes disponibles dans les instances de classe privées, dont l'accès est restreint de la même manière que les champs d'instance privés. -
class ClassWithPrivateMethod {
+```js
+class ClassWithPrivateMethod {
   #privateMethod() {
     return 'hello world'
   }
@@ -154,11 +158,13 @@ console.log(Derived.publicStaticMethod2()); // TypeError
 
 const instance = new ClassWithPrivateMethod()
 console.log(instance.getPrivateMessage())
-// expected output: "hello worl​d"
+// expected output: "hello worl​d" +``` -

Les méthodes d'instance privées peuvent être des fonctions génératrices, asynchones ou génératrices asynchrones. Des accesseurs (getters) et des mutateurs (setters) privés sont aussi posibles :

+Les méthodes d'instance privées peuvent être des fonctions génératrices, asynchones ou génératrices asynchrones. Des accesseurs (getters) et des mutateurs (setters) privés sont aussi posibles : -
class ClassWithPrivateAccessor {
+```js
+class ClassWithPrivateAccessor {
   #message
 
   get #decoratedMessage() {
@@ -176,32 +182,19 @@ console.log(instance.getPrivateMessage())
 
 new ClassWithPrivateAccessor();
 // expected output: "✨hello worl​d✨"
-
- -

Spécifications

- - - - - - - - - - - - -
Spécification
{{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}}
+``` -

Compatibilité des navigateurs

+## Spécifications +| Spécification | +| ---------------------------------------------------------------------------------------------------------------------------- | +| {{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}} | +## Compatibilité des navigateurs -

{{Compat("javascript.classes.private_class_fields")}}

+{{Compat("javascript.classes.private_class_fields")}} -

Voir aussi

+## Voir aussi - +- [Champs de classe publiques](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields) +- [The Semantics of All JS Class Elements](https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html) -- cgit v1.2.3-54-g00ecf