Dans cet article, JavaScript,. Alex Sexton montrer vous plus sur. JavaScript héritage avec un peu minuscule. Des exemples de codes JavaScript, Facile à comprendre et à maîtriser vos compétences de succession JavaScript.
. Tutoriels héritage JavaScript à maîtriser :
. JavaScript Classique Héritage . Des concepts simples en JavaScript héritage prototypal . 5 Concepts héritage Chef JavaScript
- 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.
So someone shoulder-taps you and asks you to explain the concepts behind JavaScript Inheritance to them. In my eyes you've got a few options.
The Terminology Play
You mention that it's inheritance, not prototypical and pretty much gloss over the rest, comfortable in your superiority in terminology. You may go as far as saying "Objects just come from other Objects because there aren't any classes." Then you just link to Crock's Post on it, and try to seem busy for the next few days.
Many years later you find out that Prototypal and Prototypical are synonyms, but you choose to ignore this.
The Like-Classical-Inheritance-But-Different Play aka the Run-On Sentence Play
"So in Java, like, you have classes or whatever, right? Well so imagine that you don't have those, but you still want to do that same type of thing or whatever, so then you just take another object instead of a class and you just kind of use it like it's a class, but it's not because it can change and it's just a normal object, and if it changes and you don't override the object, oh yea, so you can decide to override the parent object class thing, so if you dont do that and the parent changes the link is live…"
And so forth.
The Animal Play
This is a pretty popular one.
So let's say we want to make an Animal
class in our code. As is often necessary in production JavaScript applications.
First we make a "constructor function", which acts kind of like a constructor method on the inside of a class in a classical
language when it's invoked with the new
operator. Except this one is on the outside.
function Animal (name) { this.name = name; } var myAnimal = new Animal('Annie');
Then we want to have actions that all animals can do.
Animal.prototype.walk = function () { console.log(this.name + ' is walking.'); };
But then you want to define a more specific type of animal. Things start to get weird.
// I think we need to define a new Animal type and extend from it somehow function Dog (name) { this.name = name; } // BUT HOW DO WE EXTEND // WITHOUT AN INSTANCE TO USE? Dog.prototype = Animal.prototype; // ?? I HAVE NO IDEA // Maybe that'll work for some stuff? // ProHint™: probably not much, once you start modifying one of them :D
Then you remember that Prototypal Inheritance doesn't really do 'classes' so much. So you do something like this:
var Dog = new Animal('Annie'); // ??? NO THATS NOT IT >:( // Maybe we can try Object.create? I hear it's prototypal-y var Dog = Object.create(Animal); // Maybe that worked? Let's see... var myDog = new Dog('Sparky'); // TypeError: object is not a function // Shucks
And you eventually simply converge on the…
The Father/Son Analogy Play
Here we go. Finally a real world example of 'instances begetting instances.' It'll be a perfect analogy. It's even an interview question some places. Let's see how we might implement the relationship of a father and son (or a parent to its child) in JavaScript.
We'll start out like we did before, with a Human constructor
function Human( name ) { this.name = name; }
Then we'll add in a common human shared action.
Human.prototype.sayHi = function () { console.log("Hello, I'm " + this.name); };
So we'll create my dad first.
// Instantiate him var myDad = new Human('Bill Sexton'); // Greet him myDad.sayHi(); // "Hello, I'm Bill Sexton"
Score. Now let's create me.
// Let's use ES5 `object.create` in order to be as 'prototypal' as possible. var me = Object.create(myDad); me.sayHi(); // "Hello, I'm Bill Sexton"
It's a start! Seems like I inherited a little too much from my dad, but I inherited, none the less.
Let's try to smooth things out to make the analogy work better. So we'll instantiate objects without a name and have a parent name them after they're created.
// Wrap it all together function makeBaby(parent, name) { // Instantiate a new object based on the parent var baby = Object.create(parent); // Set the name of the baby baby.name = name; // Give the baby away return baby; }
Perfect. Now the baby can sayHi
on its own.
var alex = makeBaby(myDad, 'Alex Sexton'); alex.sayHi(); // "Hello, I'm Alex Sexton"
Err. yipes. Babies can't talk. And what's this deal with a baby being made by one parent. Not to worry, we can fix all of this.
First we'll probably want to try to take two parents into the makeBaby
function (no giggles).
function makeBaby(father, mother, name) { var baby = Object.create(...// fuuu }
Multiple Inheritance! How did you get here? Ugh. Fine. We'll just simply mock the human chromosome pattern into our little inheritance example.
// Let's take a set of 4 genes for ease of // example here. We'll put them in charge // a few things. function Human (name, genes_mom, genes_dad) { this.name = name; // Set the genes this.genes = { darkHair: this._selectGenes(genes_mom.darkHair, genes_dad.darkHair), smart: this._selectGenes(genes_mom.smart, genes_dad.smart), athletic: this._selectGenes(genes_mom.athletic, genes_dad.athletic), tall: this._selectGenes(genes_mom.tall, genes_dad.tall) }; // Since genes affect you since birth we can set these as actual attributes this.attributes = { darkHair: !!(~this.genes.darkHair.indexOf('D')), smart: !!(~this.genes.smart.indexOf('D')), athletic: !!(~this.genes.athletic.indexOf('D')), tall: !!(~this.genes.tall.indexOf('D')) }; } // You don't have access to your own gene selection // so we'll make this private (but in the javascript way) Human.prototype._selectGenes = function (gene1, gene2) { // Assume that a gene is a 2 length array of the following possibilities // DD, Dr, rD, rr -- the latter being the only non "dominant" result // Simple random gene selection return [ gene1[Math.random() > 0.5 ? 1 : 0], gene2[Math.random() > 0.5 ? 1 : 0] ] }; Human.prototype.sayHi = function () { console.log("Hello, I'm " + this.name); }; function makeBaby(name, mother, father) { // Send in the genes of each parent var baby = new Human(name, mother.genes, father.genes); return baby;
Elementary. My only beef is that we no longer are using real prototypal inheritance.
There is no live link between the parents and the child. If there was only one parent,
we could use the __proto__
property to set the parent as the prototype after the
baby was instantiated. However we have two parents…
So we'll need to implement runtime getters that do a lookup for each parent via ES Proxies.
function makeBaby(name, mother, father) { // Send in the genes of each parent var baby = new Human(name, mother.genes, father.genes); // Proxy the baby return new Proxy(baby, { get: function (proxy, prop) { // shortcut the lookup if (baby[prop]) { return baby[prop]; } // Default parent var parent = father; // Spice it up if (Math.random() > 0.5) { parent = mother; } // See if they have it return parent[prop]; } }); }
So now we support live lookups of parents, and, you know, some simplified genetics.
Isn't that just a simple, well-defined, example of how straightforward inheritance can be in JavaScript?
Conclusion
Sometimes these analogies get pretty crazy in my head, and I start to think that maybe instead of trying to apply known examples in the outside world in order to help people understand, it's often better to just let someone know why they might wanna use inheritance in their programs!
I personally find the best Prototypal Inheritance analogy to be:
var defaults = { zero: 0, one: 1 }; var myOptions = Object.create(defaults); var yourOptions = Object.create(defaults); // When I want to change *just* my options myOptions.zero = 1000; // When you wanna change yours yourOptions.one = 42; // When we wanna change the **defaults** even after we've got our options // even **AFTER** we've already created our instances defaults.two = 2; myOptions.two; // 2 yourOptions.two; // 2
So stop making everything so confusing and go program cool stuff, and ignore my old presentations when I used these analogies.
- 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