


Apprentissage du modèle de conception JavaScript 'Héritage de classe'_compétences javascript
Avant de faire quelque chose, vous devez d'abord comprendre les avantages de le faire. Je crois que personne n'est prêt à faire quelque chose sans raison. D'une manière générale, lorsque nous concevons une classe, nous espérons en fait réduire le code répétitif. L'utilisation de l'héritage peut parfaitement le faire. Avec le mécanisme d'héritage, vous pouvez concevoir à nouveau sur la base de la classe existante et les modifications complètes de la conception sont facilitées en en tirant parti. des méthodes dont ils disposent déjà. Sans plus attendre, voici quelques exemples :
fonction Personne(nom){
This.name = nom;
>
Personne.prototype.getname = function(){
Renvoie this.name;
>
function Bloger(nom,blog){
Personne.appel(ce,nom);
This.blog = blog;
>
var blogger = new Bloger("zhenn","http://www.jb51.net");
alert(bloger.name=="zhenn"); /*return true*/
alerte(bloger.blog) /*Alerte http://www.jb51.net*/
alert(bloger.getname()=="zhenn"); /*Invite "bloger.getname n'est pas une fonction"*/
Comme vous pouvez le voir dans l'exemple ci-dessus, Blogger appelle dynamiquement les propriétés et méthodes natives de sa classe parent Person via un appel interne (pour une explication de l'appel, veuillez vous référer à http://www.jb51.net/article/ 62086.htm ), ce qui peut être compris comme Bloger hérite de Person et en devient une sous-classe, mais les étudiants attentifs découvriront que les méthodes de l'objet prototype Person ne peuvent pas être héritées simplement en s'appuyant sur call, ce qui signifie "bloger. getname n'est pas une fonction" en est la raison. Mais ne vous inquiétez pas, vous pouvez résoudre ce problème avec un petit traitement du code ci-dessus !
fonction Personne(nom){
This.name = nom;
>
Personne.prototype.getname = function(){
Renvoie this.name;
>
function Bloger(nom,blog){
Personne.appel(ce,nom);
This.blog = blog;
>
/*Veuillez faire attention aux deux lignes de code suivantes*/
Bloger.prototype = new Person();
Bloger.prototype.constructor = Bloger;
var blogger = new Bloger("zhenn","http://www.jb51.net");
alert(bloger.name=="zhenn"); /*return true*/
alerte(bloger.blog) /*Alerte http://www.jb51.net*/
alert(bloger.getname()=="zhenn"); /*Prompt true*/
Ici, nous devons expliquer ces deux lignes de code. Nous savons que chaque constructeur a un attribut prototype, qui pointe vers l'objet prototype du constructeur. En fait, l'objet prototype est aussi un objet instance, mais dans le prototype. object Les propriétés et méthodes définies peuvent être partagées par tous les objets d'instance.On peut en conclure que le but de l'ajout de deux lignes de code est de définir l'objet prototype de la sous-classe pour qu'il pointe vers un objet instancié de la classe parent, et l'objet instancié de la classe parent. objet de la classe parent Toutes les méthodes d'attribut du prototype de la classe parent seront héritées, atteignant ainsi notre objectif. Le prototype de la sous-classe hérite de toutes les propriétés et méthodes de l'objet instance de la classe parent.
Mais vous devez également faire attention à la ligne de code Bloger.prototype.constructor = Bloger; car lorsque vous définissez le prototype de la sous-classe sur une instance de la classe parent, son attribut constructeur pointera vers la classe parent, donc vous devez à nouveau définir le constructeur du prototype de sous-classe. À ce stade, l'héritage de classe JavaScript a été parfaitement implémenté !
Afin de simplifier la déclaration des sous-classes, l'ensemble du processus d'extension d'une sous-classe peut être écrit dans une fonction appelée extend. La fonction consiste à créer une nouvelle classe basée sur une structure de classe donnée :
fonction extend(childClass,parentClass){
var F = nouvelle fonction();
F.prototype = parentClass.prototype;
childClass.prototype = new F();
childClass.prototype.constructor = childClass;
>
Avec cette fonction d'extension, vous pouvez facilement étendre les sous-classes.Appelez simplement cette fonction.Les deux lignes de code ajoutées ci-dessus peuvent être modifiées en extend(Bloger,Person), et un héritage complet peut également être obtenu !

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Dans le framework Java, la différence entre les modèles de conception et les modèles architecturaux réside dans le fait que les modèles de conception définissent des solutions abstraites aux problèmes courants de conception de logiciels, en se concentrant sur l'interaction entre les classes et les objets, tels que les modèles d'usine. Les modèles architecturaux définissent la relation entre les structures et les modules du système, en se concentrant sur l'organisation et l'interaction des composants du système, tels que l'architecture en couches.

Le modèle Adaptateur est un modèle de conception structurelle qui permet à des objets incompatibles de fonctionner ensemble. Il convertit une interface en une autre afin que les objets puissent interagir de manière fluide. L'adaptateur d'objet implémente le modèle d'adaptateur en créant un objet adaptateur contenant l'objet adapté et en implémentant l'interface cible. Dans un cas pratique, grâce au mode adaptateur, le client (tel que MediaPlayer) peut lire des médias au format avancé (tels que VLC), bien qu'il ne prenne lui-même en charge que les formats multimédias ordinaires (tels que MP3).

Le modèle décorateur est un modèle de conception structurelle qui permet l’ajout dynamique de fonctionnalités d’objet sans modifier la classe d’origine. Il est mis en œuvre grâce à la collaboration de composants abstraits, de composants concrets, de décorateurs abstraits et de décorateurs concrets, et peut étendre de manière flexible les fonctions de classe pour répondre aux besoins changeants. Dans cet exemple, des décorateurs de lait et de moka sont ajoutés à Espresso pour un prix total de 2,29 $, démontrant la puissance du modèle de décorateur pour modifier dynamiquement le comportement des objets.

1. Modèle d'usine : séparez la création d'objets et la logique métier, et créez des objets des types spécifiés via des classes d'usine. 2. Modèle d'observateur : permet aux objets sujets d'informer les objets observateurs de leurs changements d'état, obtenant ainsi un couplage lâche et un modèle d'observateur.

Les avantages de l'utilisation de modèles de conception dans les frameworks Java incluent : une lisibilité, une maintenabilité et une évolutivité améliorées du code. Les inconvénients incluent la complexité, la surcharge de performances et la courbe d'apprentissage abrupte due à une utilisation excessive. Cas pratique : Le mode proxy permet de charger des objets paresseusement. Utilisez les modèles de conception à bon escient pour tirer parti de leurs avantages et minimiser leurs inconvénients.

Les modèles de conception résolvent les problèmes de maintenance du code en fournissant des solutions réutilisables et extensibles : Modèle d'observateur : permet aux objets de s'abonner aux événements et de recevoir des notifications lorsqu'ils se produisent. Factory Pattern : fournit un moyen centralisé de créer des objets sans recourir à des classes concrètes. Modèle Singleton : garantit qu'une classe n'a qu'une seule instance, qui est utilisée pour créer des objets accessibles globalement.

Le framework Guice applique un certain nombre de modèles de conception, notamment : Modèle Singleton : garantir qu'une classe n'a qu'une seule instance via l'annotation @Singleton. Modèle de méthode d'usine : créez une méthode d'usine via l'annotation @Provides et obtenez l'instance d'objet lors de l'injection de dépendances. Mode stratégie : encapsulez l'algorithme dans différentes classes de stratégie et spécifiez la stratégie spécifique via l'annotation @Named.

TDD est utilisé pour écrire du code PHP de haute qualité. Les étapes comprennent : l'écriture de cas de test, la description des fonctionnalités attendues et leur échec. Écrivez du code de manière à ce que seuls les cas de test réussissent sans optimisation excessive ni conception détaillée. Une fois les cas de test réussis, optimisez et refactorisez le code pour améliorer la lisibilité, la maintenabilité et l’évolutivité.
