0Pricing
JavaScript Academy · Leçon

Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends

Découvrez en douceur la syntaxe des classes : constructeur, méthodes d’instance, fonctions utilitaires static et héritage simple avec extends

Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 2. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 2 leçons au total.

Introduction à la syntaxe des classes

Objectif : comprendre comment la syntaxe des classes correspond aux prototypes.

  • constructor pour l’initialisation
  • methods sur le prototype
  • Fonctions auxiliaires static sur la classe
  • extends pour un héritage simple
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 1

Constructeur et méthode

Le constructor s’exécute avec new. Les méthodes du corps de la classe sont partagées par toutes les instances (prototype).

// Class with a constructor and an instance method
class Counter {
  constructor(start = 0) {
    // Initialize fields
    this.value = start;
  }

  // Instance method (lives on the prototype)
  inc() {
    this.value = this.value + 1;
    console.log("Now:", this.value);
  }
}

const c = new Counter(1);
c.inc();
c.inc();
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 2

Partage du prototype

Les méthodes d’instance de la syntaxe des classes sont des méthodes du prototype : la même fonction est donc réutilisée.

// Prototype sharing demo
class Greeter {
  say(name) {
    console.log("Hello,", name);
  }
}

const g1 = new Greeter();
const g2 = new Greeter();

// Same function reference for both instances
console.log("Same method?", g1.say === g2.say);
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 3

Bases des méthodes statiques

Les méthodes static sont appelées sur la classe elle-même, et non sur les instances.

// Static method: lives on the class, not instances
class MathBox {
  static double(n) {
    return n * 2;
  }
}

console.log("Static call:", MathBox.double(4));

const m = new MathBox();
// @ts-ignore (conceptually): next line would be undefined in JS
console.log("Instance has static?", typeof m.double);
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 4

Héritage simple

extends configure la chaîne des prototypes ; utilisez super pour appeler la méthode parente.

// Inheritance with extends and super
class Animal {
  speak() {
    console.log("...");
  }
}

class Dog extends Animal {
  speak() {
    // Optionally call parent method
    super.speak();
    console.log("Woof");
  }
}

const d = new Dog();
d.speak();
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 5

Conseils sur les classes

Conseils :

  • Gardez les classes petites : quelques champs et méthodes.
  • Préférez les méthodes d’instance dans le corps de la classe (partagées via le prototype).
  • Utilisez static pour les fonctions auxiliaires pures qui ne dépendent pas d’une instance.
Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 6

Quiz sur l’emplacement des méthodes de classe

Vérification rapide : emplacement d’une méthode partagée.

Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 7

Récapitulatif

Récapitulatif : vous avez créé une classe avec un constructeur, écrit des méthodes d’instance partagées, ajouté une fonction auxiliaire statique et étendu une classe de base avec super.

Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends — illustration 8

Questions Fréquemment Posées

La leçon « Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends » est-elle gratuite ?

Oui — le texte complet de « Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 2 leçons au total.

Qu'est-ce que j'apprendrai dans « Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends » ?

Découvrez en douceur la syntaxe des classes : constructeur, méthodes d’instance, fonctions utilitaires static et héritage simple avec extends Tu pratiques JavaScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 2.

Combien de temps prend la leçon « Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon JavaScript Academy ?

Oui. Chaque leçon JavaScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Chaîne des prototypes et notions de base des propriétés propres
  2. Syntaxe des classes (aperçu) : constructeur, méthodes, static, extends
← Retour à JavaScript Academy