From 3cdb21cdb4427f7e9d2ed740eb74fb0c503b64fb Mon Sep 17 00:00:00 2001
From: ockley <vestergaard.karsten@gmail.com>
Date: Sun, 8 Feb 2026 08:02:40 +0100
Subject: [PATCH] Oversat til dansk

---
 .../10-ifelse/1-if-zero-string/solution.md    |   7 +-
 .../10-ifelse/1-if-zero-string/task.md        |   4 +-
 .../2-check-standard/ifelse_task2/index.html  |   6 +-
 .../10-ifelse/2-check-standard/task.md        |   6 +-
 .../10-ifelse/3-sign/if_sign/index.html       |   2 +-
 1-js/02-first-steps/10-ifelse/3-sign/task.md  |  12 +-
 .../5-rewrite-if-question/solution.md         |   2 +-
 .../10-ifelse/5-rewrite-if-question/task.md   |   6 +-
 .../6-rewrite-if-else-question/solution.md    |   6 +-
 .../6-rewrite-if-else-question/task.md        |  16 +-
 1-js/02-first-steps/10-ifelse/article.md      | 144 +++++++++---------
 11 files changed, 105 insertions(+), 106 deletions(-)

diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
index 51f1d4680..613b576e0 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
@@ -1,9 +1,8 @@
-**Yes, it will.**
+**Ja, det vil den.**
 
-Any string except an empty one (and `"0"` is not empty) becomes `true` in the logical context.
-
-We can run and check:
+Enhver streng undtagen en tom (og `"0"` er ikke tom) bliver til `true` i en logisk kontekst.
 
+Vi kan køre og tjekke:
 ```js run
 if ("0") {
   alert( 'Hello' );
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
index 5f16cda85..2dba599d0 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# if (a string with zero)
+# if (en tekststreng med nul)
 
-Will `alert` be shown?
+Vil `alert` blive vist?
 
 ```js
 if ("0") {
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
index ea9966653..14065abf2 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
@@ -5,12 +5,12 @@
   <script>
     'use strict';
 
-    let value = prompt('What is the "official" name of JavaScript?', '');
+    let value = prompt('Hvad er det "officielle" navn på JavaScript?', '');
 
     if (value == 'ECMAScript') {
-      alert('Right!');
+      alert('Rigtigt!');
     } else {
-      alert("You don't know? ECMAScript!");
+      alert("Ved du det ikke? ECMAScript!");
     }
   </script>
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index 4305584fa..5b006fd7e 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -2,11 +2,11 @@ importance: 2
 
 ---
 
-# The name of JavaScript
+# Navnet på JavaScript
 
-Using the `if..else` construct, write the code which asks: 'What is the "official" name of JavaScript?'
+Brug `if..else`-konstruktionen til at skrive koden, som spørger: 'Hvad er det "officielle" navn på JavaScript?'
 
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "You don't know? ECMAScript!"
+Hvis brugeren indtaster "ECMAScript", skal der vises "Rigtigt!", ellers -- vises: "Ved du det ikke? ECMAScript!"
 
 ![](ifelse_task2.svg)
 
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
index f168360dd..39600bfe9 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
+++ b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
@@ -6,7 +6,7 @@
   <script>
     'use strict';
 
-    let value = prompt('Type a number', 0);
+    let value = prompt('Indtast et tal', 0);
 
     if (value > 0) {
       alert(1);
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/task.md b/1-js/02-first-steps/10-ifelse/3-sign/task.md
index 0c5d0e008..7d406a8d3 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/task.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/task.md
@@ -2,14 +2,14 @@ importance: 2
 
 ---
 
-# Show the sign
+# Vis tegnet
 
-Using `if..else`, write the code which gets a number via `prompt` and then shows in `alert`:
+Brug `if..else`-konstruktionen til at skrive en kode, som modtager et tal via `prompt` og derefter, i en `alert` viser:
 
-- `1`, if the value is greater than zero,
-- `-1`, if less than zero,
-- `0`, if equals zero.
+- `1`, hvis værdien er større end nul,
+- `-1`, hvis mindre end nul,
+- `0`, er lig med nul.
 
-In this task we assume that the input is always a number.
+I denne opgave antager vi, at inputtet altid er et tal.
 
 [demo src="if_sign"]
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
index ff32354fa..8f0615818 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
@@ -1,6 +1,6 @@
 
 
 ```js
-let result = (a + b < 4) ? 'Below' : 'Over';
+let result = (a + b < 4) ? 'Under' : 'Over';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
index 6bdf8453e..286ed13a1 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
@@ -2,15 +2,15 @@ importance: 5
 
 ---
 
-# Rewrite 'if' into '?'
+# Omskriv 'if' til '?'
 
-Rewrite this `if` using the conditional operator `'?'`:
+Omskriv denne `if` ved hjælp af den betingede operator `'?'`:
 
 ```js
 let result;
 
 if (a + b < 4) {
-  result = 'Below';
+  result = 'Under';
 } else {
   result = 'Over';
 }
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
index 6d68e29d7..15b46e113 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
@@ -1,9 +1,9 @@
 
 
 ```js
-let message = (login == 'Employee') ? 'Hello' :
-  (login == 'Director') ? 'Greetings' :
-  (login == '') ? 'No login' :
+let message = (login == 'Ansat') ? 'Hej' :
+  (login == 'Direktør') ? 'Goddag' :
+  (login == '') ? 'Ingen login' :
   '';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
index 4f7d994a2..c08d90d69 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
@@ -2,21 +2,21 @@ importance: 5
 
 ---
 
-# Rewrite 'if..else' into '?'
+# Omskriv 'if..else' til '?'
 
-Rewrite `if..else` using multiple ternary operators `'?'`.
+Omskriv `if..else` ved hjælp af flere betingede operatorer `'?'`.
 
-For readability, it's recommended to split the code into multiple lines.
+For læsbarhed anbefales det at opdele koden i flere linjer.
 
 ```js
 let message;
 
-if (login == 'Employee') {
-  message = 'Hello';
-} else if (login == 'Director') {
-  message = 'Greetings';
+if (login == 'Ansat') {
+  message = 'Hej';
+} else if (login == 'Direktør') {
+  message = 'Goddag';
 } else if (login == '') {
-  message = 'No login';
+  message = 'Ingen login';
 } else {
   message = '';
 }
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 82e8800b9..e9407c033 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,46 +1,46 @@
-# Conditional branching: if, '?'
+# Betinget forgrening: if, '?'
 
-Sometimes, we need to perform different actions based on different conditions.
+Nogle gange har vi brug for at udføre forskellige handlinger baseret på forskellige betingelser.
 
-To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
+For at gøre det kan vi bruge `if`-udtrykket og den betingede operator `?`, som også kaldes "spørgsmålstegn"-operatoren.
 
-## The "if" statement
+## "if"-udtrykket
 
-The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
+`if(...)`-udtrykket evaluerer en betingelse i parenteserne, og hvis resultatet er `true`, udfører det en kodeblok.
 
-For example:
+For eksempel:
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('I hvilket år blev ECMAScript-2015-specifikationen udgivet?', '');
 
 *!*
-if (year == 2015) alert( 'You are right!' );
+if (year == 2015) alert( 'Du har ret!' );
 */!*
 ```
 
-In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+I eksemplet ovenfor er betingelsen en simpel lighedstest (`year == 2015`), men den kan være meget mere kompleks.
 
-If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+Hvis vi vil udføre mere end én sætning, skal vi pakke vores kodeblok ind i krøllede parenteser:
 
 ```js
 if (year == 2015) {
-  alert( "That's correct!" );
-  alert( "You're so smart!" );
+  alert( "Det er korrekt!" );
+  alert( "Du er så klog!" );
 }
 ```
 
-We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+Vi anbefaler at pakke din kodeblok ind i krøllede parenteser `{}` hver gang du bruger en `if`-sætning, selvom der kun er én sætning at udføre. Det forbedrer læsbarheden.
 
-## Boolean conversion
+## Boolean-konvertering
 
-The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+`if (…)`-sætningen evaluerer udtrykket i sine parenteser og konverterer resultatet til en boolean.
 
-Let's recall the conversion rules from the chapter <info:type-conversions>:
+Lad os huske konverteringsreglerne fra kapitlet <info:type-conversions>:
 
-- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
-- Other values become `true`, so they are called "truthy".
+- Et tal `0`, en tom streng `""`, `null`, `undefined` og `NaN` bliver alle til `false`. Derfor kaldes de "falsy" værdier.
+- Andre værdier bliver til `true`, så de kaldes "truthy".
 
-So, the code under this condition would never execute:
+Så koden under denne betingelse vil aldrig blive udført:
 
 ```js
 if (0) { // 0 is falsy
@@ -48,7 +48,7 @@ if (0) { // 0 is falsy
 }
 ```
 
-...and inside this condition -- it always will:
+...og inde i denne betingelse -- det vil den altid gøre:
 
 ```js
 if (1) { // 1 is truthy
@@ -56,7 +56,7 @@ if (1) { // 1 is truthy
 }
 ```
 
-We can also pass a pre-evaluated boolean value to `if`, like this:
+Vi kan også give en forud-evalueret boolean værdi til `if`, sådan her:
 
 ```js
 let cond = (year == 2015); // equality evaluates to true or false
@@ -66,52 +66,52 @@ if (cond) {
 }
 ```
 
-## The "else" clause
+## "else"-ledet
 
-The `if` statement may contain an optional `else` block. It executes when the condition is falsy.
+Et `if`-udtryk kan indeholde et valgfrit `else`-led. Det udføres, når betingelsen er falsk.
 
-For example:
+For eksempel:
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('I hvilket år blev ECMAScript-2015-specifikationen udgivet?', '');
 
 if (year == 2015) {
-  alert( 'You guessed it right!' );
+  alert( 'Du har ret!' );
 } else {
-  alert( 'How can you be so wrong?' ); // any value except 2015
+  alert( 'Hvordan kan du tage så fejl?' ); // any value except 2015
 }
 ```
 
-## Several conditions: "else if"
+## Flere betingelser: "else if"
 
-Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+Nogle gange vil vi gerne teste flere varianter af en betingelse. `else if`-leddet lader os gøre det.
 
-For example:
+For eksempel:
 
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('I hvilket år blev ECMAScript-2015-specifikationen udgivet?', '');
 
 if (year < 2015) {
-  alert( 'Too early...' );
+  alert( 'For tidligt...' );
 } else if (year > 2015) {
-  alert( 'Too late' );
+  alert( 'For sent' );
 } else {
-  alert( 'Exactly!' );
+  alert( 'Præcis!' );
 }
 ```
 
-In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+I koden ovenfor tjekker JavaScript først `year < 2015`. Hvis det er falsk, går det videre til den næste betingelse `year > 2015`. Hvis det også er falsk, viser det den sidste `alert`.
 
-There can be more `else if` blocks. The final `else` is optional.
+Der kan være flere `else if`-blokke. Det sidste `else` er valgfrit.
 
-## Conditional operator '?'
+## Den betingede operator '?'
 
-Sometimes, we need to assign a variable depending on a condition.
+Nogle gange har vi brug for at tildele en variabel afhængigt af en betingelse.
 
-For instance:
+For eksempel:
 
 ```js run no-beautify
 let accessAllowed;
-let age = prompt('How old are you?', '');
+let age = prompt('Hvor gammel er du?', '');
 
 *!*
 if (age > 18) {
@@ -124,26 +124,26 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
+Den såkaldte "betingede" eller "spørgsmålstegn" operator lader os gøre det på en kortere og enklere måde.
 
-The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+Operatoren repræsenteres af et spørgsmålstegn `?`. Nogle gange kaldes det "ternary", fordi operatoren har tre operander. Det er faktisk den eneste operator i JavaScript, der har så mange.
 
-The syntax is:
+Syntaksen er:
 ```js
 let result = condition ? value1 : value2;
 ```
 
-The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+Betingelsen `condition` evalueres: hvis den er sand, returneres `value1`, ellers returneres `value2`.
 
-For example:
+For eksempel:
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`.
+Teknisk set kan vi udelade parenteserne omkring `age > 18`. Spørgsmålstegn-operatoren har en lav præcedens, så den udføres efter sammenligningen `>`.
 
-This example will do the same thing as the previous one:
+Dette eksempel vil gøre det samme som det forrige:
 
 ```js
 // the comparison operator "age > 18" executes first anyway
@@ -151,20 +151,20 @@ This example will do the same thing as the previous one:
 let accessAllowed = age > 18 ? true : false;
 ```
 
-But parentheses make the code more readable, so we recommend using them.
+Men parenteser gør koden mere læsbar, så vi anbefaler at bruge dem.
 
 ````smart
-In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
+I eksemplet ovenfor kan du undgå at bruge spørgsmålstegn-operatoren, fordi sammenligningen i sig selv returnerer `true/false`:
 
 ```js
-// the same
+// det samme
 let accessAllowed = age > 18;
 ```
 ````
 
-## Multiple '?'
+## Flere '?'
 
-A sequence of question mark operators `?` can return a value that depends on more than one condition.
+En sekvens af spørgsmålstegn-operatorer `?` kan returnere en værdi, der afhænger af mere end én betingelse.
 
 For instance:
 ```js run
@@ -178,14 +178,14 @@ let message = (age < 3) ? 'Hi, baby!' :
 alert( message );
 ```
 
-It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+Det kan være svært i starten at forstå, hvad der foregår. Men efter et nærmere kig kan vi se, at det blot er en almindelig sekvens af tests:
 
-1. The first question mark checks whether `age < 3`.
-2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon ":", checking `age < 18`.
-3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon ":", checking `age < 100`.
-4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon ":", returning `'What an unusual age!'`.
+1. Det første spørgsmålstegn tjekker, om `age < 3`.
+2. Hvis det er sandt -- returnerer det `'Hi, baby!'`. Ellers fortsætter det til udtrykket efter kolon ":", hvor det tjekker `age < 18`.
+3. Hvis det er sandt -- returnerer det `'Hello!'`. Ellers fortsætter det til udtrykket efter det næste kolon ":", hvor det tjekker `age < 100`.
+4. Hvis det er sandt -- returnerer det `'Greetings!'`. Ellers fortsætter det til udtrykket efter det sidste kolon ":", hvor det returnerer `'What an unusual age!'`.
 
-Here's how this looks using `if..else`:
+Sådan ser det ud ved brug af `if..else`:
 
 ```js
 if (age < 3) {
@@ -199,41 +199,41 @@ if (age < 3) {
 }
 ```
 
-## Non-traditional use of '?'
+## Ikke-traditionel brug af '?'
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+Nogle gange bruges spørgsmålstegnet `?` som en erstatning for `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Hvilket firma skabte JavaScript?', '');
 
 *!*
 (company == 'Netscape') ?
-   alert('Right!') : alert('Wrong.');
+   alert('Rigtigt!') : alert('Forkert.');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+Afhængigt af betingelsen `company == 'Netscape'` bliver enten det første eller det andet udtryk efter `?` udført og viser en alert.
 
-We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+Vi tildeler ikke et resultat til en variabel her. I stedet udfører vi forskellig kode afhængigt af betingelsen.
 
-**It's not recommended to use the question mark operator in this way.**
+**Det anbefales ikke at bruge spørgsmålstegn-operatoren på denne måde.**
 
-The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+Notationen er kortere end den tilsvarende `if`-sætning, hvilket tiltaler nogle programmører. Men den er mindre læsbar.
 
-Here is the same code using `if` for comparison:
+Her er den samme kode ved brug af `if` til sammenligning:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Hvilket firma skabte JavaScript?', '');
 
 *!*
 if (company == 'Netscape') {
-  alert('Right!');
+  alert('Rigtigt!');
 } else {
-  alert('Wrong.');
+  alert('Forkert.');
 }
 */!*
 ```
 
-Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
+Vores øjne scanner koden lodret. Kodeblokke, der spænder over flere linjer, er lettere at forstå end en lang, horisontal instruktionssætning.
 
-The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+Formålet med spørgsmålstegn-operatoren `?` er at returnere en værdi eller en anden afhængigt af dens betingelse. Brug den præcis til det. Brug `if`, når du har brug for at udføre forskellige kodegrene.