From f4faadf9e9a8e7b0817a28816d5b9c70dad62702 Mon Sep 17 00:00:00 2001 From: ockley Date: Tue, 10 Feb 2026 17:41:38 +0100 Subject: [PATCH] Oversat til dansk --- .../1-two-functions-one-object/solution.md | 6 +- .../1-two-functions-one-object/task.md | 6 +- .../2-calculator-constructor/_js.view/test.js | 14 +- .../2-calculator-constructor/task.md | 12 +- .../3-accumulator/_js.view/solution.js | 2 +- .../3-accumulator/_js.view/test.js | 12 +- .../3-accumulator/solution.md | 2 +- .../06-constructor-new/3-accumulator/task.md | 22 +-- .../06-constructor-new/article.md | 141 +++++++++--------- 9 files changed, 108 insertions(+), 109 deletions(-) diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md index 7d8edd7ca..6a7a57d10 100644 --- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md +++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md @@ -1,8 +1,8 @@ -Yes, it's possible. +Ja, det er muligt. -If a function returns an object then `new` returns it instead of `this`. +Hvis en funktion returnerer et objekt, så returnerer `new` det i stedet for `this`. -So they can, for instance, return the same externally defined object `obj`: +Så de kan for eksempel returnere det samme eksternt definerede objekt `obj`: ```js run no-beautify let obj = {}; diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md index e932a201a..21f2fda04 100644 --- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md +++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md @@ -2,9 +2,9 @@ importance: 2 --- -# Two functions – one object +# To funktioner – ét objekt -Is it possible to create functions `A` and `B` so that `new A() == new B()`? +Er det muligt at skabe funktionerne `A` og `B`, så `new A() == new B()`? ```js no-beautify function A() { ... } @@ -16,4 +16,4 @@ let b = new B(); alert( a == b ); // true ``` -If it is, then provide an example of their code. +Hvis det er tilfældet, så giv et eksempel på deres kode. diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js index bba80e5c2..81b14762f 100644 --- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js +++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js @@ -1,7 +1,7 @@ -describe("calculator", function() { +describe("lommeregner", function () { let calculator; - before(function() { + before(function () { sinon.stub(window, "prompt") prompt.onCall(0).returns("2"); @@ -10,21 +10,21 @@ describe("calculator", function() { calculator = new Calculator(); calculator.read(); }); - - it("the read method asks for two values using prompt and remembers them in object properties", function() { + + it("read-metoden spørger efter to værdier ved hjælp af prompt og husker dem i objektets egenskaber", function () { assert.equal(calculator.a, 2); assert.equal(calculator.b, 3); }); - it("when 2 and 3 are entered, the sum is 5", function() { + it("når 2 og 3 indtastes, er summen 5", function () { assert.equal(calculator.sum(), 5); }); - it("when 2 and 3 are entered, the product is 6", function() { + it("når 2 og 3 indtastes, er produktet 6", function () { assert.equal(calculator.mul(), 6); }); - after(function() { + after(function () { prompt.restore(); }); }); diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md index c862bec40..328ae3e44 100644 --- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md +++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md @@ -2,15 +2,15 @@ importance: 5 --- -# Create new Calculator +# Opret en ny lommeregner -Create a constructor function `Calculator` that creates objects with 3 methods: +Opret en konstruktørfunktion `Calculator`, der skaber objekter med 3 metoder: -- `read()` prompts for two values and saves them as object properties with names `a` and `b` respectively. -- `sum()` returns the sum of these properties. -- `mul()` returns the multiplication product of these properties. +- `read()` spørger efter to værdier og gemmer dem som egenskaber med navnene `a` og `b`. +- `sum()` returnerer summen af disse egenskaber. +- `mul()` returnerer produktet af disse egenskaber. -For instance: +For eksempel: ```js let calculator = new Calculator(); diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js index 585287c54..43b6ea5b4 100644 --- a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js +++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js @@ -2,7 +2,7 @@ function Accumulator(startingValue) { this.value = startingValue; this.read = function() { - this.value += +prompt('How much to add?', 0); + this.value += +prompt('Hvor meget vil du tilføje?', 0); }; } diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js index a719cf45c..0990615bf 100644 --- a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js +++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js @@ -1,27 +1,27 @@ -describe("Accumulator", function() { +describe("Accumulator", function () { - beforeEach(function() { + beforeEach(function () { sinon.stub(window, "prompt") }); - afterEach(function() { + afterEach(function () { prompt.restore(); }); - it("initial value is the argument of the constructor", function() { + it("initialiseret værdi er argumentet for konstruktøren", function () { let accumulator = new Accumulator(1); assert.equal(accumulator.value, 1); }); - it("after reading 0, the value is 1", function() { + it("efter at have læst 0, er værdien 1", function () { let accumulator = new Accumulator(1); prompt.returns("0"); accumulator.read(); assert.equal(accumulator.value, 1); }); - it("after reading 1, the value is 2", function() { + it("efter at have læst 1, er værdien 2", function () { let accumulator = new Accumulator(1); prompt.returns("1"); accumulator.read(); diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md index eb145e79d..1439c287a 100644 --- a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md +++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md @@ -5,7 +5,7 @@ function Accumulator(startingValue) { this.value = startingValue; this.read = function() { - this.value += +prompt('How much to add?', 0); + this.value += +prompt('Hvor meget vil du tilføje?', 0); }; } diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md index c2c44881e..d9750324a 100644 --- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md +++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md @@ -2,26 +2,26 @@ importance: 5 --- -# Create new Accumulator +# Opret en akkumulator -Create a constructor function `Accumulator(startingValue)`. +Opret en konstruktørfunktion `Accumulator(startingValue)`. -Object that it creates should: +Objektet det opretter skal: -- Store the "current value" in the property `value`. The starting value is set to the argument of the constructor `startingValue`. -- The `read()` method should use `prompt` to read a new number and add it to `value`. +- Gemme den "nuværende værdi" i egenskaben `value`. Startværdien sættes til argumentet for konstruktøren `startingValue`. +- `read()`-metoden skal bruge `prompt` til at læse et nyt tal og lægge det til `value`. -In other words, the `value` property is the sum of all user-entered values with the initial value `startingValue`. +Med andre ord er `value`-egenskaben summen af alle brugerindtastede værdier med startværdien `startingValue`. -Here's the demo of the code: +Her er et eksempel på koden, der bruger `Accumulator`: ```js -let accumulator = new Accumulator(1); // initial value 1 +let accumulator = new Accumulator(1); // Initialiser med værdien 1 -accumulator.read(); // adds the user-entered value -accumulator.read(); // adds the user-entered value +accumulator.read(); // tilføjer den brugerindtastede værdi +accumulator.read(); // tilføjer den brugerindtastede værdi -alert(accumulator.value); // shows the sum of these values +alert(accumulator.value); // viser summen af disse værdier ``` [demo] diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md index a335464f1..ee2cc2492 100644 --- a/1-js/04-object-basics/06-constructor-new/article.md +++ b/1-js/04-object-basics/06-constructor-new/article.md @@ -1,17 +1,17 @@ -# Constructor, operator "new" +# Constructor, operatoren "new" -The regular `{...}` syntax allows us to create one object. But often we need to create many similar objects, like multiple users or menu items and so on. +Den almindelige `{...}` syntaks tillader os at skabe et enkelt objekt. Men ofte har vi brug for at skabe mange lignende objekter, som flere brugere eller menupunkter og så videre. -That can be done using constructor functions and the `"new"` operator. +Det kan gøres ved hjælp af konstruktørfunktioner og `"new"` operatoren. -## Constructor function +## Constructor funktion (konstruktør) -Constructor functions technically are regular functions. There are two conventions though: +Konstruktørfunktioner er teknisk set almindelige funktioner. Der er dog to konventioner: -1. They are named with capital letter first. -2. They should be executed only with `"new"` operator. +1. De navngives med stort begyndelsesbogstav. +2. De bør kun køres med `"new"` operatoren. -For instance: +For eksempel: ```js run function User(name) { @@ -27,31 +27,31 @@ alert(user.name); // Jack alert(user.isAdmin); // false ``` -When a function is executed with `new`, it does the following steps: +Når en funktion køres med `new`, udfører den følgende trin: -1. A new empty object is created and assigned to `this`. -2. The function body executes. Usually it modifies `this`, adds new properties to it. -3. The value of `this` is returned. +1. Et nyt tomt objekt oprettes og tildeles til `this`. +2. Funktionskroppen udføres. Normalt ændrer den `this`, tilføjer nye egenskaber til det. +3. Værdien af `this` returneres. -In other words, `new User(...)` does something like: +Med andre ord gør `new User(...)` noget i retning af: ```js function User(name) { *!* - // this = {}; (implicitly) + // this = {}; (implicit) */!* - // add properties to this + // tilføj egenskaber til this this.name = name; this.isAdmin = false; *!* - // return this; (implicitly) + // returner this; (implicit) */!* } ``` -So `let user = new User("Jack")` gives the same result as: +Så `let user = new User("Jack")` giver det samme resultat som: ```js let user = { @@ -60,149 +60,148 @@ let user = { }; ``` -Now if we want to create other users, we can call `new User("Ann")`, `new User("Alice")` and so on. Much shorter than using literals every time, and also easy to read. +Nu, hvis vi vil skabe andre brugere, kan vi kalde `new User("Ann")`, `new User("Alice")` og så videre. Meget kortere end at bruge litteraler hver gang, og også nemt at læse. -That's the main purpose of constructors -- to implement reusable object creation code. +Det er hovedformålet med konstruktører -- at implementere genanvendelig kode til objektoprettelse. -Let's note once again -- technically, any function (except arrow functions, as they don't have `this`) can be used as a constructor. It can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`. +Lad os igen bemærke -- teknisk set kan enhver funktion (undtagen arrow-funktioner, da de ikke har `this`) bruges som en konstruktør. Den kan køres med `new`, og den vil udføre algoritmen ovenfor. "Stort begyndelsesbogstav" er en almindelig aftale for at gøre det klart, at en funktion skal køres med `new`. ````smart header="new function() { ... }" -If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this: +Hvis vi har mange linjer kode, der handler om oprettelse af et enkelt komplekst objekt, kan vi pakke dem ind i en straks kaldt konstruktørfunktion, sådan her: ```js -// create a function and immediately call it with new +// opret en funktion og kald den straks med new let user = new function() { this.name = "John"; this.isAdmin = false; - // ...other code for user creation - // maybe complex logic and statements - // local variables etc + // ...anden kode til oprettelse af bruger + // måske kompleks logik og udsagn + // lokale variabler osv }; ``` -This constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse. +Denne konstruktør kan ikke kaldes igen, fordi den ikke er gemt nogen steder, bare oprettet og kaldt. Så dette trick sigter mod at indkapsle koden, der konstruerer det enkelte objekt, uden fremtidig genbrug. ```` ## Constructor mode test: new.target -```smart header="Advanced stuff" -The syntax from this section is rarely used, skip it unless you want to know everything. +```smart header="Avanceret stuff" +Syntaxen fra denne sektion bruges sjældent, spring den over medmindre du vil vide alt. ``` -Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property. +Inde i en funktion kan vi tjekke, om den blev kaldt med `new` eller uden, ved hjælp af en speciel `new.target` egenskab. -It is undefined for regular calls and equals the function if called with `new`: +Den er `undefined` for almindelige kald og er lig med funktionen, hvis den kaldes med `new`: ```js run function User() { alert(new.target); } -// without "new": +// uden "new": *!* User(); // undefined */!* -// with "new": +// med "new": *!* new User(); // function User { ... } */!* ``` -That can be used inside the function to know whether it was called with `new`, "in constructor mode", or without it, "in regular mode". +Det kan bruges inde i funktionen til at vide, om den blev kaldt med `new`, "i konstruktørtilstand", eller uden, "i almindelig tilstand". -We can also make both `new` and regular calls to do the same, like this: +Vi kan også få både `new` og almindelige kald til at gøre det samme, sådan her: ```js run function User(name) { - if (!new.target) { // if you run me without new - return new User(name); // ...I will add new for you + if (!new.target) { // hvis du kører mig uden new + return new User(name); // ...jeg vil tilføje new for dig } this.name = name; } -let john = User("John"); // redirects call to new User +let john = User("John"); // omdirigerer kald til new User alert(john.name); // John ``` -This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works. +Denne tilgang bruges nogle gange i biblioteker for at gøre syntaksen mere fleksibel. Så folk kan kalde funktionen med eller uden `new`, og det fungerer stadig. +Det er nok ikke en god idé at bruge det overalt, fordi udeladelse af `new` gør det lidt mindre tydeligt, hvad der foregår. Med `new` ved vi alle, at det nye objekt bliver oprettet. -Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created. +## Returnering fra konstruktører -## Return from constructors +Normalt har konstruktører ikke en `return`-sætning. Deres opgave er at skrive alt nødvendigt ind i `this`, og det bliver automatisk resultatet. -Usually, constructors do not have a `return` statement. Their task is to write all necessary stuff into `this`, and it automatically becomes the result. +Men hvis der er en `return`-sætning, så er reglen simpel: -But if there is a `return` statement, then the rule is simple: +- Hvis `return` kaldes med et objekt, så returneres objektet i stedet for `this`. +- Hvis `return` kaldes med en primitiv, ignoreres primitivværdien. -- If `return` is called with an object, then the object is returned instead of `this`. -- If `return` is called with a primitive, it's ignored. +Med andre ord, `return` med et objekt returnerer det objekt, i alle andre tilfælde returneres `this`. -In other words, `return` with an object returns that object, in all other cases `this` is returned. - -For instance, here `return` overrides `this` by returning an object: +For eksempel, her overskriver `return` `this` ved at returnere et objekt: ```js run function BigUser() { this.name = "John"; - return { name: "Godzilla" }; // <-- returns this object + return { name: "Godzilla" }; // <-- returnerer dette objekt } -alert( new BigUser().name ); // Godzilla, got that object +alert( new BigUser().name ); // Godzilla, modtog objektet ``` -And here's an example with an empty `return` (or we could place a primitive after it, doesn't matter): +Her er et eksempel med en tom `return` (eller vi kunne placere en primitiv efter det, det er ligegyldigt): ```js run function SmallUser() { this.name = "John"; - return; // <-- returns this + return; // <-- returnerer this } alert( new SmallUser().name ); // John ``` -Usually constructors don't have a `return` statement. Here we mention the special behavior with returning objects mainly for the sake of completeness. +Normalt har konstruktører ikke en `return`-sætning. Her nævner vi den specielle opførsel med at returnere objekter primært for fuldstændighedens skyld. -````smart header="Omitting parentheses" -By the way, we can omit parentheses after `new`: +````smart header="Udeladelse af parenteser" +Forresten, vi kan udelade parenteser efter `new`: ```js -let user = new User; // <-- no parentheses +let user = new User; // <-- ingen parenteser // same as let user = new User(); ``` -Omitting parentheses here is not considered a "good style", but the syntax is permitted by specification. +At udelade parenteser her betragtes ikke som en "god stil", men syntaksen er tilladt ifølge specifikationen. ```` -## Methods in constructor +## Metoder i konstruktør -Using constructor functions to create objects gives a great deal of flexibility. The constructor function may have parameters that define how to construct the object, and what to put in it. +At bruge konstruktørfunktioner til at oprette objekter giver en stor grad af fleksibilitet. Konstruktørfunktionen kan have parametre, der definerer, hvordan objektet skal konstrueres, og hvad der skal puttes i det. -Of course, we can add to `this` not only properties, but methods as well. +Selvfølgelig kan vi tilføje til `this` ikke kun egenskaber, men også metoder. -For instance, `new User(name)` below creates an object with the given `name` and the method `sayHi`: +For eksempel opretter `new User(name)` nedenfor et objekt med det givne `name` og metoden `sayHi`: ```js run function User(name) { this.name = name; this.sayHi = function() { - alert( "My name is: " + this.name ); + alert( "Mit navn er: " + this.name ); }; } *!* let john = new User("John"); -john.sayHi(); // My name is: John +john.sayHi(); // Mit navn er: John */!* /* @@ -213,19 +212,19 @@ john = { */ ``` -To create complex objects, there's a more advanced syntax, [classes](info:classes), that we'll cover later. +Til oprettelse af komplekse objekter er der en mere avanceret syntaks, [klasser](info:classes), som vi vil dække senere. -## Summary +## Opsummering -- Constructor functions or, briefly, constructors, are regular functions, but there's a common agreement to name them with capital letter first. -- Constructor functions should only be called using `new`. Such a call implies a creation of empty `this` at the start and returning the populated one at the end. +- Konstruktørfunktioner, eller kort sagt konstruktører (constructors på engelsk), er almindelige funktioner, men der er en fælles aftale om at navngive dem med stort begyndelsesbogstav. +- Konstruktørfunktioner bør kun kaldes ved hjælp af `new`. Et sådant kald indebærer oprettelsen af et tomt `this` i starten og returneringen af det udfyldte objekt til sidst. -We can use constructor functions to make multiple similar objects. +Vi kan bruge konstruktørfunktioner til at lave flere lignende objekter. -JavaScript provides constructor functions for many built-in language objects: like `Date` for dates, `Set` for sets and others that we plan to study. +JavaScript leverer konstruktørfunktioner til mange indbyggede sproglige objekter: som `Date` til datoer, `Set` til mængder og andre, som vi planlægger at studere. -```smart header="Objects, we'll be back!" -In this chapter we only cover the basics about objects and constructors. They are essential for learning more about data types and functions in the next chapters. +```smart header="Objekter, vi kommer tilbage!" +I dette kapitel dækker vi kun det grundlæggende om objekter og konstruktører. De er essentielle for at lære mere om datatyper og funktioner i de næste kapitler. -After we learn that, we return to objects and cover them in-depth in the chapters and . +Efter vi har lært det, vender vi tilbage til objekter og dækker dem grundigt i kapitlerne og . ```