Dans l'article pr?c?dent tutoriel JavaScript - Certaines fonctions JavaScript Prototype essentielles pour am?liorer vos applications JavaScript - ACC @ nk qui vous sont pr?sent?es d'une fonction JavaScript prototype de copier/clone d'un objet JavaScript , mais dans ce post , il n'y a qu'une Code source JavaScript de le faire sans des instructions d?taill?es et comments.
- Demo
- Agrandir
- Recharger
- New window
Gratuit iPage hébergement Web pour la première année MOMENT
Si vous êtes toujours à la recherche d'un fournisseur d'hébergement Web fiable avec des tarifs abordables, pourquoi vous ne prenez pas un peu de temps pour essayer iPage, seulement avec $1.89/month, inclus $500+ Crédits supplémentaires gratuites pour le paiement de 24 mois ($45)?
Plus de 1.000.000 de clients + existisng peuvent pas avoir tort, vraiment vous n'êtes pas aussi! Plus important encore, lorsque vous enregistrez l'hébergement web à iPage grâce à notre lien, nous allons être heureux de renvoyer un plein remboursement. C'est génial! Vous devriez essayer iPage hébergement web GRATUITEMENT maintenant! Et contactez-nous pour tout ce que vous devez savoir sur iPage.
Everyone knows Javascript doesn’t have classes. Thankfully most Javascript programmers are very good at playing pretend.
Because so many people attempt to introduce a classical structure to their Javscript code, I figure I’ll share some of my findings. Below is one way of allowing a base class function to copy an instance of a subclass while maintaining proper type.
Let’s say we have an Animal class and we subclass it to create a Cat class. We also want the Animal class to have a clone() method that will return work with its subclasses. That is, if I clone a Cat, I want “instanceof Cat” and “instanceof Animal” to both be true.
Let’s make the classes real quick. Here’s an Animal:
function Animal() { // animal stuff } // All of Animal's methods will go into its prototype Animal.prototype = { saySomething: function() { return "I am an animal!"; }, copy: function() { var newcopy; if (this.subConstructor) { newcopy = new this.subConstructor; } else { newcopy = new Animal(); } // maybe copy over other values return newcopy; } };
And then the Cat. Typically the easiest way to make a Javascript function be a “subclass” of another function is to set the prototype of the subclass equal to “new baseclass.” With cat we’ll go a little further and also save the constructor.
Cat:
function Cat() { this.constructor(); // call animal's constructor // cat stuff } // Save the cat's constructor, replace Cat's prototype and constructor // Then restore cat's constructor as subConstructor var con = Cat.prototype.constructor; Cat.prototype = new Animal(); Cat.prototype.constructor = Animal; Cat.prototype.subConstructor = con // override the saySomething function Cat.prototype.saySomething = function() { return "Meow!"; };
There you have it. Cats created this way will be “instanceof Cat” and “instanceof Animal”, and so will their clones. We should of course make tests to see, and lucky for us all of them check out OK:
// some tests and their results in the comment var c = new Cat(); console.log(c instanceof Animal); // true console.log(c instanceof Cat); // true console.log(c.saySomething()); // "Meow!" var a = new Animal(); console.log(a instanceof Animal); // true console.log(a instanceof Cat); // false console.log(a.saySomething()); // "I am an animal!" var copyCat = c.copy(); console.log(copyCat instanceof Animal); // true console.log(copyCat instanceof Cat); // true console.log(copyCat.saySomething()); // "Meow!" var copyAnimal = a.copy(); console.log(copyAnimal instanceof Animal); // true console.log(copyAnimal instanceof Cat); // false console.log(copyAnimal.saySomething()); // "I am an animal!"
You might want to use the four lines needed for subclassing elsewhere so its a good idea to stuff them into a function that you’d put in a utility class/var somewhere. So we could make:
function derive(base, sub) { var con = sub.prototype.constructor; sub.prototype = new base(); sub.prototype.constructor = base; sub.prototype.subConstructor = con }
And then making a clone-able subclass would be as easy as calling derive after each constructor:
function Cat() { this.constructor(); // call animal's constructor // cat stuff } derive(Animal, Cat); // override the saySomething function Cat.prototype.saySomething = function() { return "Meow!"; };
- Sent (0)
- Nouveau
Save up to 630$ when buy new iPhone 15
GateIO.gomymobi.com
Free Airdrops to Claim, Share Up to $150,000 per Project
https://tooly.win
Open tool hub for free to use by any one for every one with hundreds of tools
chatGPTaz.com, chatGPT4.win, chatGPT2.fun, re-chatGPT.com
Talk to ChatGPT by your mother language
Dall-E-OpenAI.com
Generate creative images automatically with AI
AIVideo-App.com
Render creative video automatically with AI
Réponse