From 500f444d23a7a758da229ebe6b9691cc5d4fe731 Mon Sep 17 00:00:00 2001 From: SphinxKnight Date: Wed, 16 Mar 2022 17:52:18 +0100 Subject: Fix #4269 - Removes empty/special characters (#4270) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Remove ufeff * Remove u2064 * Remove u2062 * Replace u202f followed by : with  : * Replace u202f next to « or » with   and « or » * Replace u202f followed by ; with  ; * Replace u202f followed by ! with   * Replace u202f followed by ? with  ? * Replace remaining u202f with classical space * Replace u200b surrounded by space with classical space * Replace u200b surrounded by space with classical space - again (repeated) * Remove remaining u200b * Remove u200a * Replace u2009 with   * Remove u00ad * Replace u00a0 followed by : ! or ? with   and punctuation * Replace u00a0 surrounded « or » with   and punctuation * Replace u00a0 followed by whitespaces * Replace u00a0 preceded by whitespaces * Replace u00a0 followed by a newline with a newline * Replace u00a0 followed by a newline with a newline - Take2 * Replace u00a0 followed by a ;   and punctuation * Remove u00a0 followed by , * Remove u00a0 in indentation spaces with \n([ ]*)([\u00a0])([ ]*) * Manual replacement of ([\u00a0])([ ]+) * Replace remaining ([\u00a0]+) by a space * cleaning empty elements * remove ufe0f * Remove u00a0 and u202f after merging against updated main * remove double whitespace using (\w)( )(\w) --- files/fr/web/javascript/reference/classes/index.md | 2 +- .../classes/private_class_fields/index.md | 110 ++++++++++----------- .../reference/classes/public_class_fields/index.md | 74 +++++++------- .../javascript/reference/classes/static/index.md | 6 +- 4 files changed, 96 insertions(+), 96 deletions(-) (limited to 'files/fr/web/javascript/reference/classes') diff --git a/files/fr/web/javascript/reference/classes/index.md b/files/fr/web/javascript/reference/classes/index.md index 2808bc1d39..8fbdf65b9e 100644 --- a/files/fr/web/javascript/reference/classes/index.md +++ b/files/fr/web/javascript/reference/classes/index.md @@ -19,7 +19,7 @@ En réalité, les classes sont juste des [fonctions](/fr/docs/Web/JavaScript/Ref ### Les déclarations de classes -Pour utiliser une déclaration de classe simple, on utilisera le mot-clé `class`, suivi par le nom de la classe que l'on déclare (ici « Rectangle »). +Pour utiliser une déclaration de classe simple, on utilisera le mot-clé `class`, suivi par le nom de la classe que l'on déclare (ici « Rectangle »). ```js class Rectangle { 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 45ad084074..7b6a0b1d73 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 @@ -35,12 +35,12 @@ La limitation des variables statiques ne pouvant être appelées que par des mé ```js class ClassWithPrivateStaticField { -  static #PRIVATE_STATIC_FIELD + static #PRIVATE_STATIC_FIELD -  static publicStaticMethod() { -    ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42 -    return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD -  } + static publicStaticMethod() { + ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42 + return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD + } } console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42) @@ -54,12 +54,12 @@ Ceci peut conduire à un comportement inattendu lors de l'utilisation de **`this ```js class BaseClassWithPrivateStaticField { -  static #PRIVATE_STATIC_FIELD + static #PRIVATE_STATIC_FIELD -  static basePublicStaticMethod() { -    this.#PRIVATE_STATIC_FIELD = 42 -    return this.#PRIVATE_STATIC_FIELD -  } + static basePublicStaticMethod() { + this.#PRIVATE_STATIC_FIELD = 42 + return this.#PRIVATE_STATIC_FIELD + } } class SubClass extends BaseClassWithPrivateStaticField { } @@ -75,18 +75,18 @@ console.assert(error instanceof TypeError) ### 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. ```js class ClassWithPrivateField { -  #privateField + #privateField -  constructor() { -    this.#privateField = 42 -    this.#randomField = 666 // Erreur de syntaxe -  } + constructor() { + this.#privateField = 42 + this.#randomField = 666 // Erreur de syntaxe + } } const instance = new ClassWithPrivateField() @@ -103,17 +103,17 @@ Les méthodes statiques privées peuvent être des fonctions génératrices, asy ```js class ClassWithPrivateStaticMethod { -    static #privateStaticMethod() { -        return 42 -    } + static #privateStaticMethod() { + return 42 + } -    static publicStaticMethod1() { -        return ClassWithPrivateStaticMethod.#privateStaticMethod(); -    } + static publicStaticMethod1() { + return ClassWithPrivateStaticMethod.#privateStaticMethod(); + } -    static publicStaticMethod2() { -       return this.#privateStaticMethod(); -  } + static publicStaticMethod2() { + return this.#privateStaticMethod(); + } } console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42); @@ -124,15 +124,15 @@ Cela peut conduire à un comportement inattendu lors de l'utilisation de **`this ```js class Base { -    static #privateStaticMethod() { -        return 42; -    } -    static publicStaticMethod1() { -        return Base.#privateStaticMethod(); -    } -    static publicStaticMethod2() { -        return this.#privateStaticMethod(); -    } + static #privateStaticMethod() { + return 42; + } + static publicStaticMethod1() { + return Base.#privateStaticMethod(); + } + static publicStaticMethod2() { + return this.#privateStaticMethod(); + } } class Derived extends Base {} @@ -147,41 +147,41 @@ Les méthodes d'instance privées sont des méthodes disponibles dans les instan ```js class ClassWithPrivateMethod { -  #privateMethod() { -    return 'hello world' -  } + #privateMethod() { + return 'hello world' + } -  getPrivateMessage() { -      return this.#privateMethod() -  } + getPrivateMessage() { + return this.#privateMethod() + } } const instance = new ClassWithPrivateMethod() console.log(instance.getPrivateMessage()) -// expected output: "hello worl​d" +// expected output: "hello world" ``` 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 : ```js class ClassWithPrivateAccessor { -  #message - -  get #decoratedMessage() { -    return `✨${this.#message}✨` -  } -  set #decoratedMessage(msg) { -    this.#message = msg -  } - -  constructor() { -    this.#decoratedMessage = 'hello world' -    console.log(this.#decoratedMessage) -  } + #message + + get #decoratedMessage() { + return `✨${this.#message}✨` + } + set #decoratedMessage(msg) { + this.#message = msg + } + + constructor() { + this.#decoratedMessage = 'hello world' + console.log(this.#decoratedMessage) + } } new ClassWithPrivateAccessor(); -// expected output: "✨hello worl​d✨" +// expected output: "✨hello world✨" ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/classes/public_class_fields/index.md b/files/fr/web/javascript/reference/classes/public_class_fields/index.md index 8630e5e473..9cf3f20d20 100644 --- a/files/fr/web/javascript/reference/classes/public_class_fields/index.md +++ b/files/fr/web/javascript/reference/classes/public_class_fields/index.md @@ -14,14 +14,14 @@ original_slug: Web/JavaScript/Reference/Classes/Class_fields > > Les déclarations de champs, tant publics que privés, sont [une fonctionnalité expérimentale (étape 3)](https://github.com/tc39/proposal-class-fields) proposée au [TC39](https://tc39.github.io/beta/), le comité des standards JavaScript. > -> La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que [Babel](https://babeljs.io/). Voir [l'information de compatibilité](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility) ci-dessous. +> La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que [Babel](https://babeljs.io/). Voir [l'information de compatibilité](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility) ci-dessous. Les champs publics, tant statiques que d'instance, sont des propriétés qui peuvent être écrites, et qui sont énumérables et configurables. En tant que telles, à la différence de leurs contreparties privées, elles participent à l'héritage du prototype. ## Syntaxe class ClasseAvecChampDInstance { -   champDInstance = 'champ d\'instance' + champDInstance = 'champ d\'instance' } class ClasseAvecChampStatique { @@ -29,9 +29,9 @@ Les champs publics, tant statiques que d'instance, sont des propriétés qui peu } class ClasseAvecMethodeDInstancePublique { -   methodePublique() { -     return 'hello world' -   } + methodePublique() { + return 'hello world' + } } ## Exemples @@ -44,18 +44,18 @@ Les champs statiques publics sont déclarés en utilisant le mot-clé `static`. ```js class ClasseAvecChampStatique { -  static champStatique = 'champ statique' + static champStatique = 'champ statique' } console.log(ClasseAvecChampStatique.champStatique) -// affichage attendu : "champ statique"​ +// affichage attendu : "champ statique" ``` Les champs sans initialiseur sont initialisés à `undefined`. ```js class ClasseAvecChampStatique { -  static champStatique + static champStatique } console.assert(ClasseAvecChampStatique.hasOwnProperty('champStatique')) @@ -67,11 +67,11 @@ Les champs statiques publics ne sont pas réinitialisés dans les sous-classes, ```js class ClasseAvecChampStatique { -  static champStatiqueDeBase = 'champ de base' + static champStatiqueDeBase = 'champ de base' } class SousClasseAvecChampStatique extends ClasseAvecChampStatique { -  static sousChampStatique = 'champ de la sous-classe' + static sousChampStatique = 'champ de la sous-classe' } console.log(SousClasseAvecChampStatique.sousChampStatique) @@ -85,14 +85,14 @@ Lors de l'initialisation des champs, `this` fait référence au constructeur de ```js class ClasseAvecChampStatique { -  static champStatiqueDeBase = 'champ statique de base' -  static autreChampStatiqueDeBase = this.champStatiqueDeBase + static champStatiqueDeBase = 'champ statique de base' + static autreChampStatiqueDeBase = this.champStatiqueDeBase -  static methodeStatiqueDeBase() { return 'affichage de la méthode statique de base' } + static methodeStatiqueDeBase() { return 'affichage de la méthode statique de base' } } class SousClasseAvecChampStatique extends ClasseAvecChampStatique { -  static sousChampStatique = super.methodeStatiqueDeBase() + static sousChampStatique = super.methodeStatiqueDeBase() } console.log(ClasseAvecChampStatique.autreChampStatiqueDeBase) @@ -122,7 +122,7 @@ Les champs sans initialiseur sont initialisés à `undefined`. ```js class ClasseAvecChampDInstance { -  champdDInstance + champdDInstance } const instance = new ClasseAvecChampDInstance() @@ -137,7 +137,7 @@ console.log(instance.champDInstance); const PREFIXE = 'prefixe'; class ClasseAvecNomDeChampCalcule { -    [`${PREFIXE}Champ`] = 'champ préfixé' + [`${PREFIXE}Champ`] = 'champ préfixé' } const instance = new ClasseAvecNomDeChampCalcule() @@ -149,13 +149,13 @@ Lors de l'initialisation des champs, `this` fait référence à l'instance en co ```js class ClasseAvecChampDInstance { -  champDInstanceDeBase = 'champ de base' -  autreChampDInstanceDeBase = this.champDInstanceDeBase -  methodeDInstanceDeBase() { return 'affichage de la méthode de base' } + champDInstanceDeBase = 'champ de base' + autreChampDInstanceDeBase = this.champDInstanceDeBase + methodeDInstanceDeBase() { return 'affichage de la méthode de base' } } class SousClasseAvecChampDInstance extends ClasseAvecChampDInstance { -  sousChampDInstance = super.methodeDInstanceDeBase() + sousChampDInstance = super.methodeDInstanceDeBase() } const base = new ClasseAvecChampDInstance() @@ -200,7 +200,7 @@ class ClasseAvecMethodeDInstancePublique { const instance = new ClasseAvecMethodeDInstancePublique() console.log(instance.methodePublique()) -// affichage attendu : "hello worl​d" +// affichage attendu : "hello world" ``` Les méthodes d'instance publiques sont ajoutées au prototype au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Elles peuvent être écrites, ne sont pas énumérables et sont configurables. @@ -219,39 +219,39 @@ A l'intérieur des méthodes d'instance, `this` fait référence à l'instance e ```js class ClasseDeBase { -  msg = 'hello world' -  methodePubliqueDeBase() { -    return this.msg -  } + msg = 'hello world' + methodePubliqueDeBase() { + return this.msg + } } class SousClasse extends ClasseDeBase { -  sousMethodePublique() { -    return super.methodePubliqueDeBase() -  } + sousMethodePublique() { + return super.methodePubliqueDeBase() + } } const instance = new SousClasse() console.log(instance.sousMethodePublique()) -// affichage attendu : "hello worl​d" +// affichage attendu : "hello world" ``` Les accesseurs et les mutateurs sont des méthodes spéciales qui sont liées à une propriété de classe, et sont appelées lorsqu'on accède à cette propriété ou qu'on la définit. Utilisez la syntaxe [get](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/get) et [set](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/set) pour déclarer un accesseur ou un mutateur publique d'une instance. ```js class ClasseAvecGetSet { -  #msg = 'hello world' -  get msg() { -    return this.#msg -  } -  set msg(x) { -    this.#msg = `hello ${x}` -  } + #msg = 'hello world' + get msg() { + return this.#msg + } + set msg(x) { + this.#msg = `hello ${x}` + } } const instance = new ClasseAvecGetSet(); console.log(instance.msg); -// affichage attendu : "hello worl​d" +// affichage attendu : "hello world" instance.msg = 'gâteau'; console.log(instance.msg); diff --git a/files/fr/web/javascript/reference/classes/static/index.md b/files/fr/web/javascript/reference/classes/static/index.md index f08b2b5a94..7637ced784 100644 --- a/files/fr/web/javascript/reference/classes/static/index.md +++ b/files/fr/web/javascript/reference/classes/static/index.md @@ -77,7 +77,7 @@ StaticMethodCall.anotherStaticMethod(); ### Depuis les constructeurs de classes et les autres méthodes -Les méthodes statiques ne sont pas directement accessibles via le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this). Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique `NomDeClasse.MéthodeStatique()` (comme pour les autres appels en dehors de la classe) ou avec la propriété `constructor`  : `this.constructor.MéthodeStatique()`. +Les méthodes statiques ne sont pas directement accessibles via le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this). Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique `NomDeClasse.MéthodeStatique()` (comme pour les autres appels en dehors de la classe) ou avec la propriété `constructor` : `this.constructor.MéthodeStatique()`. ```js class StaticMethodCall{ @@ -89,7 +89,7 @@ class StaticMethodCall{ // 'appel de la méthode statique' } - static staticMethod(){ + static staticMethod(){ return 'appel de la méthode statique.'; } } @@ -100,7 +100,7 @@ class StaticMethodCall{ | Spécification | État | Commentaires | | -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | | {{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2015')}} | Définition initiale. | -| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} |   | +| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} | | ## Compatibilité des navigateurs -- cgit v1.2.3-54-g00ecf