ockley · Feb 27, 2026 · Feb 27, 2026
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -1,20 +1,20 @@
 
-Answers:
+Svarene er:
 
 1. `true`. 
 
-    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.
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Changing "prototype"
+# Ændring af "prototype"
 
-In the code below we create `new Rabbit`, and then try to modify its prototype.
+I koden nedenfor opretter vi `new Rabbit`, og forsøger derefter at ændre dens prototype.
 
-In the start, we have this code:
+I starten har vi følgende kode:
 
 ```js run
 function Rabbit() {}
@@ -20,7 +20,7 @@ alert( rabbit.eats ); // true
 ```
 
 
-1. We added one more string (emphasized). What will `alert` show now?
+1. Vi har tilføjet endnu en streng (fremhævet). Hvad viser `alert` nu?
 
     ```js
     function Rabbit() {}
@@ -37,7 +37,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-2. ...And if the code is like this (replaced one line)?
+2. ...Og hvis koden ser således ud (har erstattet en linje)?
 
     ```js
     function Rabbit() {}
@@ -54,7 +54,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-3. And like this (replaced one line)?
+3. Og, hvad med denne her (har erstattet en linje)?
 
     ```js
     function Rabbit() {}
@@ -71,7 +71,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-4. The last variant:
+4. Sidste variant?
 
     ```js
     function Rabbit() {}

diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -1,23 +1,23 @@
-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) {
@@ -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).
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# Create an object with the same constructor
+# Opret et objekt med samme konstruktør
 
-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.
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,18 +1,19 @@
 # F.prototype
 
-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 = {
@@ -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:
 
 ![](proto-constructor-animal-rabbit.svg)
 
-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 };
 */
 ```
 
 ![](function-prototype-constructor.svg)
 
-We can check it:
+Det kan vi tjekke ved at se på `constructor` egenskaben:
 
 ```js run
 function Rabbit() {}
-// by default:
+// som standard:
 // Rabbit.prototype = { constructor: Rabbit }
 
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Naturally, if we do nothing, the `constructor` property is available to all rabbits through  `[[Prototype]]`:
+Hvis vi ikke gør noget andet vil egenskaben `constructor` være tilgængelig for alle kaniner gennem `[[Prototype]]`:
 
 ```js run
 function Rabbit() {}
-// by default:
+// som standard:
 // Rabbit.prototype = { constructor: Rabbit }
 
-let rabbit = new Rabbit(); // inherits from {constructor: Rabbit}
+let rabbit = new Rabbit(); // nedarver fra {constructor: Rabbit}
 
-alert(rabbit.constructor == Rabbit); // true (from prototype)
+alert(rabbit.constructor == Rabbit); // true (fra prototype)
 ```
 
 ![](rabbit-prototype-constructor.svg)
 
-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.
 
-For instance:
+For eksempel:
 
 ```js run
 function Rabbit() {}
@@ -129,18 +130,18 @@ alert(rabbit.constructor === Rabbit); // false
 */!*
 ```
 
-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 = {
@@ -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.