This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
The assignment to `Rabbit.prototype` sets up `[[Prototype]]` for new objects, but it does not affect the existing ones.
Tildelingen til `Rabbit.prototype` sætter `[[Prototype]]` for nye objekter, men påvirker ikke eksisterende objekter. Så `rabbit` har stadig den gamle prototype, hvor `eats` er `true`.
2. `false`.
Objects are assigned by reference. The object from `Rabbit.prototype` is not duplicated, it's still a single object referenced both by `Rabbit.prototype` and by the `[[Prototype]]` of `rabbit`.
Objekter bliver tildelt med reference til det oprindelige objekt. Objektet fra `Rabbit.prototype` er ikke kopieret, det er stadig et enkelt objekt refereret både af `Rabbit.prototype` og af `[[Prototype]]` på `rabbit`.
So when we change its content through one reference, it is visible through the other one.
Så når vi ændrer dets indhold via én reference, er det synligt via den anden reference.
3. `true`.
All `delete` operations are applied directly to the object. Here `delete rabbit.eats` tries to remove `eats` property from `rabbit`, but it doesn't have it. So the operation won't have any effect.
Alle `delete` operationer udføres direkte på objektet. Her forsøger `delete rabbit.eats` at fjerne `eats` egenskaben fra `rabbit`, men det har ikke den egenskab. Så operationen har ingen effekt.
4. `undefined`.
The property `eats` is deleted from the prototype, it doesn't exist any more.
Egenskaben `eats` er slettet fra prototypen, den eksisterer ikke længere.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
We can use such approach if we are sure that `"constructor"` property has the correct value.
Vi kan bruge denne tilgang hvis vi er sikre på at `"constructor"` egenskaben har den korrekte værdi.
For instance, if we don't touch the default `"prototype"`, then this code works for sure:
For eksempel, hvis vi ikke rører ved standard `"prototype"`, så virker denne kode altid:
```js run
function User(name) {
this.name = name;
}
let user = new User('John');
let user2 = new user.constructor('Pete');
let user = new User('Jan');
let user2 = new user.constructor('Helene');
alert( user2.name ); // Pete (worked!)
alert( user2.name ); // Helene (virker!)
```
It worked, because `User.prototype.constructor == User`.
Det virker fordi `User.prototype.constructor == User`.
..But if someone, so to speak, overwrites `User.prototype` and forgets to recreate `constructor` to reference `User`, then it would fail.
..Men hvis en overskriver `User.prototype` uden at genskabe `constructor` som reference til `User`, så vil det fejle.
For instance:
For eksempel:
```js run
function User(name) {
Expand All
@@ -27,23 +27,23 @@ function User(name) {
User.prototype = {}; // (*)
*/!*
let user = new User('John');
let user2 = new user.constructor('Pete');
let user = new User('Jan');
let user2 = new user.constructor('Helene');
alert( user2.name ); // undefined
```
Why `user2.name` is `undefined`?
Hvorfor er `user2.name` `undefined`?
Here's how `new user.constructor('Pete')` works:
Sådan her virker `new user.constructor('Helene')`:
1. First, it looks for `constructor` in `user`. Nothing.
2. Then it follows the prototype chain. The prototype of `user` is `User.prototype`, and it also has no `constructor` (because we "forgot" to set it right!).
3. Going further up the chain, `User.prototype` is a plain object, its prototype is the built-in `Object.prototype`.
4. Finally, for the built-in `Object.prototype`, there's a built-in `Object.prototype.constructor == Object`. So it is used.
1. Først kigger den efter `constructor` i `user`. Intet fundet.
2. Derefter følger den prototypen. Prototypen af `user` er `User.prototype`, og den har også ingen `constructor` (fordi vi "glemte" at genskabe den!).
3. Går videre op i kæden, `User.prototype` er et almindeligt objekt, og dens prototype er den indbyggede `Object.prototype`.
4. Til sidst, for den indbyggede `Object.prototype`, findes der en indbygget `Object.prototype.constructor == Object`. Så bruges denne.
Finally, at the end, we have `let user2 = new Object('Pete')`.
Til sidst har vi altså noget der oversat ser ud som `let user2 = new Object('Helene')`.
Probably, that's not what we want. We'd like to create `new User`, not `new Object`. That's the outcome of the missing `constructor`.
Helt sikkert ikke det vi vil. Vi ønsker at skabe `new User`, ikke `new Object`. Det er resultatet af den manglende `constructor`.
(Just in case you're curious, the `new Object(...)` call converts its argument to an object. That's a theoretical thing, in practice no one calls `new Object` with a value, and generally we don't use `new Object` to make objects at all).
(Bare, i det tilfælde, at du er nysgerrig: Kaldet til `new Object(...)` konverterer dets argument til et objekt. Det er en teoretisk ting, i praksis kalder ingen `new Object` med en værdi, og generelt bruger vi ikke `new Object` til at lave objekter).
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Imagine, we have an arbitrary object `obj`, created by a constructor function -- we don't know which one, but we'd like to create a new object using it.
Forestil dig, vi har et vilkårligt objekt `obj`, skabt af en konstruktør funktion -- vi ved ikke hvilken, men vi vil gerne skabe et nyt objekt med samme konstruktør.
Can we do it like that?
Kan vi gøre det sådan?
```js
let obj2 = new obj.constructor();
```
Give an example of a constructor function for `obj` which lets such code work right. And an example that makes it work wrong.
Giv et eksempel på en konstruktør funktion for `obj` som lader sådan kode virke korrekt. Og et eksempel som gør det forkert.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Remember, new objects can be created with a constructor function, like `new F()`.
Du husker nok at nye objekter kan oprettes med en konstruktør funktion, som f.eks. `new F()`.
If `F.prototype` is an object, then the `new` operator uses it to set `[[Prototype]]` for the new object.
Hvis `F.prototype` er et objekt, så bruger `new`-operatoren det til at sætte `[[Prototype]]` for det nye objekt.
```smart
JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.
JavaScript har haft nedarvning fra prototype fra begyndelsen. Det er en af sprogets kernetræk.
But in the old times, there was no direct access to it. The only thing that worked reliably was a `"prototype"` property of the constructor function, described in this chapter. So there are many scripts that still use it.
Men i gamle dage var der ikke nogen direkte adgang til det. Den eneste ting der virkede pålideligt var en `"prototype"` egenskab i konstruktør funktioner som vi beskriver i dette kapitel. Så der er mange scripts der stadig bruger denne tilgang.
```
Please note that `F.prototype` here means a regular property named `"prototype"` on `F`. It sounds something similar to the term "prototype", but here we really mean a regular property with this name.
Bemærk at udtrykket `F.prototype` her betyder en regulær egenskab kaldet `"prototype"` på objektet `F`. Det lyder som noget tæt på selve begrebet "prototype", men her mener vi faktisk bare en regulær egenskab med det navn.
Here's the example:
Her er et eksempel:
```js run
let animal = {
Expand All
@@ -27,95 +28,95 @@ function Rabbit(name) {
Rabbit.prototype = animal;
*/!*
let rabbit = new Rabbit("White Rabbit"); // rabbit.__proto__ == animal
let rabbit = new Rabbit("Hvid kanin"); // rabbit.__proto__ == animal
alert( rabbit.eats ); // true
```
Setting `Rabbit.prototype = animal` literally states the following: "When a `new Rabbit` is created, assign its `[[Prototype]]` to `animal`".
Når vi skriver `Rabbit.prototype = animal` betyder det bogstaveligt talt: "Når en `ny Rabbit` skabes, så sørg for at dens `[[Prototype]]` sættes til `animal`".
That's the resulting picture:
Det resulterer i følgende:
On the picture, `"prototype"` is a horizontal arrow, meaning a regular property, and `[[Prototype]]` is vertical, meaning the inheritance of `rabbit` from `animal`.
På billedet er `"prototype"` en horisontal pil, hvilket betyder en regulær egenskab, og `[[Prototype]]` er en lodret pil, betyder nedarvning af `rabbit` fra `animal`.
```smart header="`F.prototype` only used at `new F` time"
`F.prototype` property is only used when `new F` is called, it assigns `[[Prototype]]` of the new object.
```smart header="`F.prototype` bruges kun ved `new F`"
Egenskaben `F.prototype` bruges kun når `new F` kaldes, og den sætter `[[Prototype]]` på det nye objekt.
If, after the creation, `F.prototype` property changes (`F.prototype = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
Hvis `F.prototype`-egenskaben ændres efter objektet er skabt (`F.prototype = <another object>`), så vil nye objekter skabt med `new F` have et andet objekt som `[[Prototype]]`, mens eksisterende objekter beholder det gamle.
```
## Default F.prototype, constructor property
## Standard F.prototype, konstruktør egenskab
Every function has the `"prototype"` property even if we don't supply it.
Alle funktioner har egenskaben `"prototype"` selvom vi ikke angiver den.
The default `"prototype"` is an object with the only property `constructor` that points back to the function itself.
Den standard `"prototype"` er et objekt med den ene egenskab `constructor` som peger tilbage på funktionen selv.
Like this:
Som dette:
```js
function Rabbit() {}
/* default prototype
/* standard prototype
Rabbit.prototype = { constructor: Rabbit };
*/
```
We can check it:
Det kan vi tjekke ved at se på `constructor` egenskaben:
We can use `constructor` property to create a new object using the same constructor as the existing one.
Vi kan bruge `constructor` egenskaben til at skabe et nyt objekt med samme konstruktør som det eksisterende objekt.
Like here:
Som her:
```js run
function Rabbit(name) {
this.name = name;
alert(name);
}
let rabbit = new Rabbit("White Rabbit");
let rabbit = new Rabbit("Hvid kanin");
*!*
let rabbit2 = new rabbit.constructor("Black Rabbit");
let rabbit2 = new rabbit.constructor("Sort kanin");
*/!*
```
That's handy when we have an object, don't know which constructor was used for it (e.g. it comes from a 3rd party library), and we need to create another one of the same kind.
Det er praktisk når vi har et objekt og ikke ved hvilken konstruktør det blev skabt med (f.eks. hvis det kommer fra en 3rd party bibliotek), og vi skal skabe et andet objekt af samme type.
But probably the most important thing about `"constructor"` is that...
Men den vigtigste ting at huske på om `"constructor"` er at...
**...JavaScript itself does not ensure the right `"constructor"` value.**
**...JavaScript sikrer ikke selv at værdien i `"constructor"` er korrekt.**
Yes, it exists in the default `"prototype"` for functions, but that's all. What happens with it later -- is totally on us.
Ja, den eksisterer i standard `"prototype"` for funktioner, men det er det. Hvad der sker senere -- det er helt op til os.
In particular, if we replace the default prototype as a whole, then there will be no `"constructor"` in it.
Det gælder særligt, hvis vi erstatter standard prototypen i sin helhed, så vil der ikke længere være nogen `"constructor"` i den.
So, to keep the right `"constructor"` we can choose to add/remove properties to the default `"prototype"` instead of overwriting it as a whole:
Så for at beholde den korrekte `"constructor"` kan vi vælge at tilføje/fjerne egenskaber til standard `"prototype"` i stedet for at overskrive hele prototypen:
```js
function Rabbit() {}
// Not overwrite Rabbit.prototype totally
// just add to it
// Overskriver ikke Rabbit.prototype helt
// vi tilføjer bare noget til den
Rabbit.prototype.jumps = true
// the default Rabbit.prototype.constructor is preserved
// standard Rabbit.prototype.constructor er bevaret
```
Or, alternatively, recreate the `constructor` property manually:
Alternativt kan du genskabe egenskaben `constructor` manuelt, hvis du erstatter hele prototypen:
```js
Rabbit.prototype = {
Expand All
@@ -150,26 +151,26 @@ Rabbit.prototype = {
*/!*
};
// now constructor is also correct, because we added it
// nu er constructor rigtig igen, fordi vi tilføjede den tilbage til objektet
```
## Summary
## Opsummering
In this chapter we briefly described the way of setting a `[[Prototype]]` for objects created via a constructor function. Later we'll see more advanced programming patterns that rely on it.
I dette kapitel beskrev vi kort måden at sætte en `[[Prototype]]` for objekter skabt via en konstruktør funktion. Senere vil vi se mere avancerede programmeringsmønstre, der bygger på det.
Everything is quite simple, just a few notes to make things clear:
Alt er egentlig ganske enkelt. Her er nogle få bemærkninger for at gøre tingene helt klart:
- The `F.prototype` property (don't mistake it for `[[Prototype]]`) sets `[[Prototype]]` of new objects when `new F()` is called.
- The value of `F.prototype` should be either an object or `null`: other values won't work.
- The `"prototype"` property only has such a special effect when set on a constructor function, and invoked with `new`.
- Egenskaben `F.prototype` (ikke at forveksle med `[[Prototype]]`) sætter `[[Prototype]]` på nye objekter når `new F()` kaldes.
- Værdien af `F.prototype` bør enten være et objekt eller `null`: andre værdier virker ikke.
- Egenskaben `"prototype"` har kun denne specielle effekt når den er sat på en konstruktør funktion, og kaldes med `new`.
On regular objects the `prototype` is nothing special:
På regulære objekter er `prototype` ikke noget specielt:
```js
let user = {
name: "John",
prototype: "Bla-bla" // no magic at all
prototype: "Bla-bla" // magien er væk!
};
```
By default all functions have `F.prototype = { constructor: F }`, so we can get the constructor of an object by accessing its `"constructor"` property.
Som standard har alle funktioner `F.prototype = { constructor: F }`, så vi kan få konstruktøren af et objekt ved at tilgå dets `"constructor"` egenskab.
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
F.prototype #261
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Uh oh!
There was an error while loading. Please reload this page.
F.prototype #261
Filter by extension
Viewed files
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
There are no files selected for viewing
Uh oh!
There was an error while loading. Please reload this page.