javascript-tutorial · ockley · Feb 11, 2026 · Feb 11, 2026
diff --git a/1-js/04-object-basics/index.md b/1-js/04-object-basics/index.md
@@ -1 +1 @@
-# Objects: the basics
+# Objekter: grundlæggende
diff --git a/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md b/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
@@ -1,24 +1,24 @@
 
-Try running it:
+Prøv at køre det:
 
 ```js run
-let str = "Hello";
+let str = "Hej";
 
 str.test = 5; // (*)
 
 alert(str.test);
 ```
 
-Depending on whether you have `use strict` or not, the result may be:
-1. `undefined` (no strict mode)
-2. An error (strict mode).
+Afhængigt af om du har `use strict` eller ej, kan resultatet være:
+1. `undefined` (ingen strict mode)
+2. En fejl (strict mode).
 
-Why? Let's replay what's happening at line `(*)`:
+Hvorfor? Lad os gennemgå, hvad der sker på linje `(*)`:
 
-1. When a property of `str` is accessed, a "wrapper object" is created.
-2. In strict mode, writing into it is an error.
-3. Otherwise, the operation with the property is carried on, the object gets the `test` property, but after that the "wrapper object" disappears, so in the last line `str` has no trace of the property.
+1. Når en egenskab af `str` tilgås, oprettes der et "wrapper-objekt".
+2. I strict mode er det en fejl at skrive til det.
+3. Ellers fortsætter operationen med egenskaben, objektet får `test`-egenskaben, men efterfølgende forsvinder "wrapper-objektet", så i den sidste linje har `str` ingen spor af egenskaben.
 
-**This example clearly shows that primitives are not objects.**
+**Dette eksempel viser tydeligt, at primitivtyper ikke er objekter.**
 
-They can't store additional data.
+De kan ikke gemme yderligere data.
diff --git a/1-js/05-data-types/01-primitives-methods/1-string-new-property/task.md b/1-js/05-data-types/01-primitives-methods/1-string-new-property/task.md
@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Can I add a string property?
+# Kan du tilføje en egenskab til en streng?
 
 
-Consider the following code:
+Forestil dig følgende kode:
 
 ```js
-let str = "Hello";
+let str = "Hej";
 
 str.test = 5;
 
 alert(str.test);
 ```
 
-What do you think, will it work? What will be shown?
+Hvad tror du, vil det virke? Hvad vil blive vist?
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
@@ -1,129 +1,129 @@
-# Methods of primitives
+# Metoder hos primitive typer
 
-JavaScript allows us to work with primitives (strings, numbers, etc.) as if they were objects. They also provide methods to call as such. We will study those soon, but first we'll see how it works because, of course, primitives are not objects (and here we will make it even clearer).
+JavaScript tillader os at arbejde med primitive typer (strenge, tal osv.) som om de var objekter. De giver også metoder, der kan kaldes som sådanne. Vi vil studere dem om lidt, men først vil vi se, hvordan det fungerer, fordi primitive typer selvfølgelig ikke er objekter (og i det følgende vil vi gøre det endnu tydeligere).
 
-Let's look at the key distinctions between primitives and objects.
+Lad os se på de vigtigste forskelle mellem primitive typer og objekter.
 
-A primitive
+En primitiv
 
-- Is a value of a primitive type.
-- There are 7 primitive types: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` and `undefined`.
+- Er en værdi af en primitiv type.
+- Der findes 7 primitive typer: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` og `undefined`.
 
-An object
+Et objekt
 
-- Is capable of storing multiple values as properties.
-- Can be created with `{}`, for instance: `{name: "John", age: 30}`. There are other kinds of objects in JavaScript: functions, for example, are objects.
+- Kan gemme flere værdier som egenskaber.
+- Kan oprettes med `{}`, for eksempel: `{name: "John", age: 30}`. Der findes andre slags objekter i JavaScript: funktioner er for eksempel objekter.
 
-One of the best things about objects is that we can store a function as one of its properties.
+En af de bedste ting ved objekter er, at vi kan gemme en funktion som en af deres egenskaber.
 
 ```js run
 let john = {
   name: "John",
   sayHi: function() {
-    alert("Hi buddy!");
+    alert("Hej med dig!");
   }
 };
 
-john.sayHi(); // Hi buddy!
+john.sayHi(); // Hej med dig!
 ```
 
-So here we've made an object `john` with the method `sayHi`.
+Så her har vi lavet et objekt `john` med metoden `sayHi`.
 
-Many built-in objects already exist, such as those that work with dates, errors, HTML elements, etc. They have different properties and methods.
+Mange indbyggede objekter findes allerede, såsom dem der arbejder med datoer, fejl, HTML-elementer osv. De har forskellige egenskaber og metoder.
 
-But, these features come with a cost!
+Men disse funktioner kommer med en pris!
 
-Objects are "heavier" than primitives. They require additional resources to support the internal machinery.
+Objekter er "tungere" end primitive værdier. De kræver flere ressourcer for at understøtte den interne mekanik.
 
-## A primitive as an object
+## En primitiv som et objekt
 
-Here's the paradox faced by the creator of JavaScript:
+Her er paradokset, som skaberen af JavaScript stod overfor:
 
-- There are many things one would want to do with a primitive, like a string or a number. It would be great to access them using methods.
-- Primitives must be as fast and lightweight as possible.
+- Der er mange ting, man gerne vil gøre med en primitiv, som en streng eller et tal. Det ville være fantastisk at kunne tilgå dem via metoder.
+- Primitive værdier skal være så hurtige og lette som muligt.
 
-The solution looks a little bit awkward, but here it is:
+Løsningen ser lidt akavet ud, men her er den:
 
-1. Primitives are still primitive. A single value, as desired.
-2. The language allows access to methods and properties of strings, numbers, booleans and symbols.
-3. In order for that to work, a special "object wrapper" that provides the extra functionality is created, and then is destroyed.
+1. Primitiver er stadig primitive. En enkelt værdi, som ønsket.
+2. Sproget tillader adgang til metoder og egenskaber for strenge, tal, booleans og symboler.
+3. For at det kan fungere, oprettes der et særligt "objekt-wrapper", der giver den ekstra funktionalitet, og som derefter ødelægges.
 
-The "object wrappers" are different for each primitive type and are called: `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. Thus, they provide different sets of methods.
+"Objekt-wrapperne" er forskellige for hver primitiv type og kaldes: `String`, `Number`, `Boolean`, `Symbol` og `BigInt`. Dermed giver de forskellige sæt af metoder.
 
-For instance, there exists a string method [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) that returns a capitalized `str`.
+For eksempel findes der en strengmetode [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase), der returnerer en kapitaliseret `str`.
 
-Here's how it works:
+Sådan fungerer det:
 
 ```js run
-let str = "Hello";
+let str = "Hej";
 
-alert( str.toUpperCase() ); // HELLO
+alert( str.toUpperCase() ); // HEJ
 ```
 
-Simple, right? Here's what actually happens in `str.toUpperCase()`:
+Simpelt, ikke? Her er hvad der faktisk sker i `str.toUpperCase()`:
 
-1. The string `str` is a primitive. So in the moment of accessing its property, a special object is created that knows the value of the string, and has useful methods, like `toUpperCase()`.
-2. That method runs and returns a new string (shown by `alert`).
-3. The special object is destroyed, leaving the primitive `str` alone.
+1. Strengen `str` er en primitiv. Så i det øjeblik, hvor dens egenskab tilgås, oprettes der et særligt objekt, der kender værdien af strengen og har nyttige metoder, som `toUpperCase()`.
+2. Den metode kører og returnerer en ny streng (vist af `alert`).
+3. Det særlige objekt ødelægges, og den primitive `str` forbliver uændret.
 
-So primitives can provide methods, but they still remain lightweight.
+Så primitive typer kan give metoder, men de forbliver stadig lette.
 
-The JavaScript engine highly optimizes this process. It may even skip the creation of the extra object at all. But it must still adhere to the specification and behave as if it creates one.
+JavaScript-motoren optimerer denne proces kraftigt. Den kan endda helt springe oprettelsen af det ekstra objekt over. Men den skal stadig overholde specifikationen og opføre sig, som om den opretter et.
 
-A number has methods of its own, for instance, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to the given precision:
+Et tal har sine egne metoder, for eksempel runder [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) tallet til den givne præcision:
 
 ```js run
 let n = 1.23456;
 
 alert( n.toFixed(2) ); // 1.23
 ```
 
-We'll see more specific methods in chapters <info:number> and <info:string>.
+Vi vil se flere specifikke metoder i kapitlerne <info:number> og <info:string>.
 
 
-````warn header="Constructors `String/Number/Boolean` are for internal use only"
-Some languages like Java allow us to explicitly create "wrapper objects" for primitives using a syntax like `new Number(1)` or `new Boolean(false)`.
+````warn header="Konstruktører `String/Number/Boolean` er kun til intern brug"
+Nogle sprog som Java tillader os eksplicit at oprette "wrapper-objekter" for primitive værdier ved at bruge en syntaks som `new Number(1)` eller `new Boolean(false)`.
 
-In JavaScript, that's also possible for historical reasons, but highly **unrecommended**. Things will go crazy in several places.
+I JavaScript er det også muligt af historiske årsager, men det er stærkt **ikke anbefalet**. Tingene kan gå galt flere steder.
 
-For instance:
+For eksempel:
 
 ```js run
 alert( typeof 0 ); // "number"
 
 alert( typeof new Number(0) ); // "object"!
 ```
 
-Objects are always truthy in `if`, so here the alert will show up:
+Objekter er altid "truthy" i `if`, så her vil alerten blive vist:
 
 ```js run
 let zero = new Number(0);
 
-if (zero) { // zero is true, because it's an object
-  alert( "zero is truthy!?!" );
+if (zero) { // zero er true, fordi det er et objekt
+  alert( "zero er truthy!?!" );
 }
 ```
 
-On the other hand, using the same functions `String/Number/Boolean` without `new` is totally fine and useful thing. They convert a value to the corresponding type: to a string, a number, or a boolean (primitive).
+På den anden side er det helt fint og nyttigt at bruge de samme funktioner `String/Number/Boolean` uden `new`. De konverterer en værdi til den tilsvarende type: til en streng, et tal eller en boolean (primitiv).
 
-For example, this is entirely valid:
+For eksempel er dette helt gyldigt:
 
 ```js
 let num = Number("123"); // convert a string to number
 ```
 ````
 
 
-````warn header="null/undefined have no methods"
-The special primitives `null` and `undefined` are exceptions. They have no corresponding "wrapper objects" and provide no methods. In a sense, they are "the most primitive".
+````warn header="null/undefined har ingen metoder"
+De specielle primitive værdier `null` og `undefined` er undtagelser. De har ingen tilsvarende "wrapper-objekter" og giver ingen metoder. På en måde er de "de mest primitive".
 
-An attempt to access a property of such value would give the error:
+Et forsøg på at tilgå en egenskab af en sådan værdi vil give en fejl:
 
 ```js run
-alert(null.test); // error
+alert(null.test); // fejl
 ````
 
-## Summary
+## Opsummering
 
-- Primitives except `null` and `undefined` provide many helpful methods. We will study those in the upcoming chapters.
-- Formally, these methods work via temporary objects, but JavaScript engines are well tuned to optimize that internally, so they are not expensive to call.
+- Primitiver undtagen `null` og `undefined` giver mange nyttige metoder. Vi vil studere dem i de kommende kapitler.
+- Formelt set fungerer disse metoder via midlertidige objekter, men JavaScript-motorer er godt optimerede til at håndtere det internt, så de er ikke dyre at kalde.
diff --git a/1-js/05-data-types/index.md b/1-js/05-data-types/index.md
@@ -1,3 +1,3 @@
-# Data types
+# Data typer
 
-More data structures and more in-depth study of the types.
+Mere om datastrukturer og en mere dybdegående undersøgelse af typerne.