JS CLASS Flashcards
Comment expliquez-vous le concept d’encapsulation et pourquoi est-il important?
L’encapsulation est le principe qui consiste à regrouper les données (propriétés) et les comportements (méthodes) dans une unité cohérente (la classe) tout en contrôlant l’accès à ces données.
En JavaScript, nous utilisons des propriétés privées (avec le préfixe #) et des méthodes publiques pour y accéder (getters/setters):
class CompteBancaire {
#solde; // Propriété privée
constructor(soldeInitial) {
this.#solde = soldeInitial;
}
getSolde() {
return this.#solde;
}
deposer(montant) {
if (montant > 0) {
this.#solde += montant;
return true;
}
return false;
}
}
L’encapsulation est importante car elle:
* Protège les données contre les modifications accidentelles
* Permet de valider les entrées (ex: vérifier qu’un montant est positif)
* Offre la flexibilité de changer l’implémentation interne sans affecter le code utilisateur
* Garantit la cohérence des données (ex: un solde ne peut pas devenir négatif si on l’empêche)
En quoi la POO facilite-t-elle le développement d’applications web complexes?
La POO facilite le développement d’applications web complexes de plusieurs façons:
1. Organisation modulaire: Chaque classe peut représenter un composant ou une fonctionnalité spécifique (utilisateur, produit, panier…), ce qui rend le code plus organisé.
2. Réutilisabilité: Les classes peuvent être réutilisées dans différentes parties de l’application ou même dans d’autres projets.
3. Maintenance simplifiée: Les modifications sont localisées à des classes spécifiques, limitant les effets de bord.
4. Évolutivité: L’héritage et la composition permettent d’étendre facilement les fonctionnalités existantes.
5. Collaboration facilitée: Dans une équipe, chaque développeur peut travailler sur des classes différentes avec des interfaces bien définies.
6. Alignement avec les frameworks modernes: React, Angular, Vue.js et autres frameworks utilisent des concepts orientés objet (composants, services…).
7. Analogie avec le monde réel: Les modèles de données correspondent souvent à des entités réelles, facilitant la conception.
Par exemple, dans une application e-commerce, vous pourriez avoir des classes pour Utilisateur, Produit, Panier, Commande, etc., chacune gérant ses propres données et comportements.
Qu’est-ce qu’une classe en JavaScript et à quoi sert-elle?
Une classe JavaScript est un modèle pour créer des objets similaires. Elle permet de définir un type d’objet avec ses propriétés et méthodes, facilitant ainsi la création d’instances multiples partageant la même structure mais avec des données différentes.
Expliquez l’utilisation du mot-clé this dans une classe JavaScript.
Le mot-clé this fait référence à l’instance de l’objet en cours d’utilisation. Dans une méthode, this permet d’accéder aux propriétés et méthodes de l’objet courant. Par exemple, dans this.name, on accède à la propriété name de l’objet actuel.
Comment utiliseriez-vous l’héritage dans un projet web ou web mobile?
Dans un projet web ou web mobile, l’héritage peut être utilisé pour:
1. Hiérarchie de composants UI: class Composant { constructor(id, parent) {
this.id = id;
this.parent = parent;
this.visible = true; }
afficher() { /* Code commun / } cacher() { / Code commun / }} class Bouton extends Composant { constructor(id, parent, texte) { super(id, parent);
this.texte = texte; }
onClick(callback) { / Spécifique aux boutons / }}
class Modal extends Composant { constructor(id, parent, titre) { super(id, parent);
this.titre = titre;
this.visible = false; // Par défaut invisible }
ouvrir() { / Spécifique aux modales / }
fermer() { / Spécifique aux modales / }
2. Modèles de données avec validation:
class ModeleDonnees { valider() { / Validation générique / } sauvegarder() { / Logique de sauvegarde commune / }}
class Utilisateur extends ModeleDonnees {
constructor(nom, email, motDePasse) {
super();
this.nom = nom;
this.email = email;
this.motDePasse = motDePasse; } valider() {
super.valider();
// Validation spécifique aux utilisateurs
if (!this.email.includes(‘@’)) throw new
Error(“Email invalide”); }}
3. Hiérarchie d’API ou de services: class ServiceAPI { constructor(baseURL) { this.baseURL = baseURL; this.headers = { ‘Content-Type’: ‘application/json’ }; }
async fetch(endpoint, options = {}) { / Logique commune de requête */ }}
class ServiceUtilisateurs extends ServiceAPI {
constructor() {
super(‘/api/users’); }
async obtenir(id) {
return this.fetch(/${id}); }
async creer(userData) {
return this.fetch(‘’, {
method: ‘POST’,
body: JSON.stringify(userData) }); }}
L’héritage permet de réduire la duplication de code tout en spécialisant chaque composant selon ses besoins spécifiques.
Comment protéger les données d’une classe contre les modifications non contrôlées?
On utilise des propriétés privées préfixées par # (ex: #age). Ces propriétés ne sont pas accessibles directement depuis l’extérieur de la classe. Pour les manipuler, on implémente des méthodes publiques getter et setter qui peuvent inclure des contrôles de validation.
Expliquez le concept d’héritage en JavaScript et ses avantages pour le développement.
L’héritage permet à une classe d’étendre une autre classe avec le mot-clé extends. La classe enfant hérite des propriétés et méthodes de la classe parent, ce qui favorise la réutilisation du code et l’organisation hiérarchique des objets. Le mot-clé super permet d’appeler le constructeur de la classe parent.
Qu’est-ce que le mot-clé constructor dans une classe et quel est son rôle?
Le constructor est une méthode spéciale qui s’exécute automatiquement lors de la création d’une instance avec new. Il permet d’initialiser les propriétés de l’objet avec les valeurs passées en paramètres. C’est là qu’on définit généralement l’état initial de l’objet.
Comment créer des méthodes dans une classe JavaScript et quelle est leur utilité?
Les méthodes sont des fonctions définies à l’intérieur d’une classe. Elles sont créées simplement en déclarant une fonction sans le mot-clé function. Elles permettent d’encapsuler des comportements spécifiques à la classe et d’interagir avec les propriétés de l’objet.
Expliquez la différence entre le pattern Factory et l’utilisation de classes en JavaScript.
Le pattern Factory utilise une fonction qui crée et retourne des objets, tandis que les classes offrent une syntaxe plus structurée avec l’héritage intégré. Les classes sont plus adaptées pour modéliser des hiérarchies complexes d’objets, alors que les factories sont plus simples et peuvent être utilisées pour créer différents types d’objets selon des conditions.
Quelle est l’utilité des getters et setters dans la programmation orientée objet?
Les getters et setters permettent un accès contrôlé aux propriétés, notamment privées. Ils offrent une couche d’abstraction qui permet de valider les données avant modification (setters) et de formater les données avant de les renvoyer (getters). Cela renforce l’encapsulation et la cohérence des données.
Comment s’assurer qu’une propriété respecte certaines contraintes lors de sa modification?
On utilise une propriété privée (avec #) et on implémente une méthode setter qui vérifie les contraintes avant d’effectuer la modification. Par exemple, pour s’assurer qu’un âge est valide, on vérifie dans setAge() que la valeur est comprise entre des bornes acceptables avant d’affecter la valeur à #age.
En quoi la POO peut-elle améliorer la qualité et la maintenabilité du code dans un projet web?
La POO permet une meilleure organisation du code en regroupant logiquement les données et les comportements, facilitant la compréhension et l’extension du code. Elle favorise la réutilisation via l’héritage, réduit la duplication par l’encapsulation, et améliore la robustesse par le contrôle d’accès aux données.
Comment les classes JavaScript s’intègrent-elles dans le développement d’applications web ou web mobile?
Les classes JavaScript sont utilisées pour structurer la logique métier, gérer l’état de l’application et créer des composants réutilisables. Dans les frameworks modernes (React, Vue, Angular), elles peuvent servir à définir des composants, des services, ou des modèles de données qui facilitent le développement d’interfaces dynamiques et la gestion de l’état.
