Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Functions/Method_definitions below:

Définir une méthode - JavaScript

Baseline Widely available

Avec ECMAScript 2015 (ES6), il est possible d'utiliser une notation plus courte pour définir des méthodes au sein des littéraux objets. On peut ainsi définir plus rapidement une fonction qui sera utilisée comme méthode.

const obj = {
  foo() {
    return "bar";
  },
};

console.log(obj.foo());
// Expected output: "bar"

var obj = {
  property( parameters… ) {},
  *generator( parameters… ) {},
  async property( parameters… ) {},
  async* generator( parameters… ) {},

  // avec les noms calculés :
  [property]( parameters… ) {},
  *[generator]( parameters… ) {},
  async [property]( parameters… ) {},

  // avec la syntaxe pour les accesseurs
  // mutateurs :
  get property() {},
  set property(value) {}
};

La notation raccourcie est semblable à la syntaxe introduite par ECMAScript 5 pour les accesseurs et mutateurs.

Le code suivant :

var obj = {
  toto: function () {
    /* du code */
  },
  truc: function () {
    /* du code */
  },
};

Peut désormais être raccourci en :

var obj = {
  toto() {
    /* du code */
  },
  truc() {
    /* du code */
  },
};

Les générateurs sont des méthodes et peuvent donc être définis en utilisant la notation raccourci. Lorsqu'on les utilise :

• L'astérisque de la notation raccourcie doit être située avant le nom de la propriété pour le générateur. Autrement dit, * g(){} fonctionnera mais g*(){} ne fonctionnera pas.
• Les définitions des méthodes qui ne sont pas des générateurs ne peuvent pas contenir le mot-clé yield. Cela signifie que l'ancienne syntaxe pour les générateurs ne fonctionnera pas et déclenchera une exception SyntaxError. Il faut toujours utiliser yield avec l'astérisque (*).

// Notation utilisant une propriété nommée (avant-ES2015)
var obj2 = {
  g: function* () {
    var index = 0;
    while (true) yield index++;
  },
};

// La même définition, en utilisant la notation raccourcie
var obj2 = {
  *g() {
    var index = 0;
    while (true) yield index++;
  },
};

var it = obj2.g();
console.log(it.next().value); // 0
console.log(it.next().value); // 1

Les méthodes asynchrones peuvent également être définies grâce à une syntaxe raccourcie.

// On utilise une propriété nommée
var obj3 = {
  f: async function () {
    await une_promesse;
  },
};

// Ici, on obtient le même résultat
// avec la notation raccourcie
var obj3 = {
  async f() {
    await une_promesse;
  },
};

Les méthodes génératrices peuvent également être asynchrones (cf. async) :

var obj4 = {
  f: async function* () {
    yield 1;
    yield 2;
    yield 3;
  },
};

// Le code équivalent avec la
// notation raccourcie
var obj4 = {
  async *f() {
    yield 1;
    yield 2;
    yield 3;
  },
};

Les définitions de méthodes ne sont pas des constructeurs et si on tente de les instancier, cela provoquera une exception TypeError.

var obj = {
  méthode() {},
};
new obj.méthode(); // TypeError: obj.méthode is not a constructor

var obj = {
  *g() {},
};
new obj.g(); // TypeError: obj.g is not a constructuer (changé avec ES2016)

var obj = {
  a: "toto",
  b() {
    return this.a;
  },
};
console.log(obj.b()); // "toto"

Cette notation raccourcie peut également être utilisée avec des noms de propriétés calculés.

var bar = {
  toto0: function () {
    return 0;
  },
  toto1() {
    return 1;
  },
  ["toto" + 2]() {
    return 2;
  },
};

console.log(bar.toto0()); // 0
console.log(bar.toto1()); // 1
console.log(bar.toto2()); // 2

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4