diff --git a/1-js/11-async/08-async-await/01-rewrite-async/solution.md b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
index 3337ef3c4..c429b310b 100644
--- a/1-js/11-async/08-async-await/01-rewrite-async/solution.md
+++ b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
@@ -1,5 +1,5 @@
 
-The notes are below the code:
+Noterne er under koden:
 
 ```js run
 async function loadJson(url) { // (1)
@@ -17,11 +17,11 @@ loadJson('https://javascript.info/no-such-user.json')
   .catch(alert); // Error: 404 (4)
 ```
 
-Notes:
+Noter:
 
-1. The function `loadJson` becomes `async`.
-2. All `.then` inside are replaced with `await`.
-3. We can `return response.json()` instead of awaiting for it, like this:
+1. Funktionen `loadJson` bliver `async`.
+2. Alle `.then` indeni erstattes med `await`.
+3. Vi kan bruge `return response.json()` i stedet for at vente på det, som dette:
 
     ```js
     if (response.status == 200) {
@@ -29,5 +29,5 @@ Notes:
     }
     ```
 
-    Then the outer code would have to `await` for that promise to resolve. In our case it doesn't matter.
-4. The error thrown from `loadJson` is handled by `.catch`. We can't use `await loadJson(…)` there, because we're not in an `async` function.
+    Den ydre kode vil være nødt til at vente med `await` på at det promise løses. I vores tilfælde spiller det ikke en rolle.
+4. Fejlen kastet fra `loadJson` håndteres af `.catch`. Vi kan ikke bruge `await loadJson(…)` der, fordi vi ikke er i en `async` funktion.
diff --git a/1-js/11-async/08-async-await/01-rewrite-async/task.md b/1-js/11-async/08-async-await/01-rewrite-async/task.md
index 0c31737da..5d057483d 100644
--- a/1-js/11-async/08-async-await/01-rewrite-async/task.md
+++ b/1-js/11-async/08-async-await/01-rewrite-async/task.md
@@ -1,7 +1,7 @@
 
-# Rewrite using async/await
+# Omskriv ved brug af async/await
 
-Rewrite this example code from the chapter <info:promise-chaining> using `async/await` instead of `.then/catch`:
+Omskriv dette eksempelkode fra kapitlet <info:promise-chaining> ved hjælp af `async/await` i stedet for `.then/catch`:
 
 ```js run
 function loadJson(url) {
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
index aa462dbf7..8826237d4 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
@@ -1,5 +1,5 @@
 
-There are no tricks here. Just replace `.catch` with `try..catch` inside `demoGithubUser` and add `async/await` where needed:
+Der er ikke nogen tricks her. Bare erstat `.catch` med `try..catch` inde i `demoGithubUser` og tilføj `async/await` hvor det er nødvendigt:
 
 ```js run
 class HttpError extends Error {
@@ -19,29 +19,29 @@ async function loadJson(url) {
   }
 }
 
-// Ask for a user name until github returns a valid user
+// Spørg efter et brugernavn indtil github returnerer en gyldig bruger
 async function demoGithubUser() {
 
   let user;
   while(true) {
-    let name = prompt("Enter a name?", "iliakan");
+    let name = prompt("Skriv et brugernavn?", "iliakan");
 
     try {
       user = await loadJson(`https://api.github.com/users/${name}`);
-      break; // no error, exit loop
+      break; // ingen fejl, hop ud af loopet
     } catch(err) {
       if (err instanceof HttpError && err.response.status == 404) {
-        // loop continues after the alert
-        alert("No such user, please reenter.");
+        // loop fortsætter efter alert
+        alert("Brugeren findes ikke. Indtast et nyt brugernavn.");
       } else {
-        // unknown error, rethrow
+        // ukendt fejl, rethrow
         throw err;
       }
     }      
   }
 
 
-  alert(`Full name: ${user.name}.`);
+  alert(`Fulde navn: ${user.name}.`);
   return user;
 }
 
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
index 13d625d2a..39708ee30 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
@@ -1,9 +1,9 @@
 
-# Rewrite "rethrow" with async/await
+# Omskriv "rethrow" med async/await
 
-Below you can find the "rethrow" example. Rewrite it using `async/await` instead of `.then/catch`.
+Nedenfor ser du "rethrow" eksemplet. Omskriv det ved hjælp af `async/await` i stedet for `.then/catch`.
 
-And get rid of the recursion in favour of a loop in `demoGithubUser`: with `async/await` that becomes easy to do.
+Og erstat rekursionen med et loop i `demoGithubUser`: med `async/await` bliver det nemt at gøre.
 
 ```js run
 class HttpError extends Error {
@@ -25,18 +25,18 @@ function loadJson(url) {
     });
 }
 
-// Ask for a user name until github returns a valid user
+// Spørg efter et brugernavn indtil github returnerer en gyldig bruger
 function demoGithubUser() {
-  let name = prompt("Enter a name?", "iliakan");
+  let name = prompt("Skriv et brugernavn?", "iliakan");
 
   return loadJson(`https://api.github.com/users/${name}`)
     .then(user => {
-      alert(`Full name: ${user.name}.`);
+      alert(`Fulde navn: ${user.name}.`);
       return user;
     })
     .catch(err => {
       if (err instanceof HttpError && err.response.status == 404) {
-        alert("No such user, please reenter.");
+        alert("Brugeren findes ikke. Indtast et nyt brugernavn.");
         return demoGithubUser();
       } else {
         throw err;
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/solution.md b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
index 7e2ab597e..ce5151d42 100644
--- a/1-js/11-async/08-async-await/03-async-from-regular/solution.md
+++ b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
@@ -1,7 +1,8 @@
 
-That's the case when knowing how it works inside is helpful.
+Det er her hvor det er godt at vide hvordan det virker inde i motorrummet.
+
+Du kan bare behandle `async` kald som et promise og tilføje `.then` til det:
 
-Just treat `async` call as promise and attach `.then` to it:
 ```js run
 async function wait() {
   await new Promise(resolve => setTimeout(resolve, 1000));
@@ -10,7 +11,7 @@ async function wait() {
 }
 
 function f() {
-  // shows 10 after 1 second
+  // viser 10 efter 1 sekund
 *!*
   wait().then(result => alert(result));
 */!*
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/task.md b/1-js/11-async/08-async-await/03-async-from-regular/task.md
index ca7c186ff..e6f97e303 100644
--- a/1-js/11-async/08-async-await/03-async-from-regular/task.md
+++ b/1-js/11-async/08-async-await/03-async-from-regular/task.md
@@ -1,7 +1,7 @@
 
-# Call async from non-async
+# Kald async fra ikke-async
 
-We have a "regular" function called `f`. How can you call the `async` function `wait()` and use its result inside of `f`?
+Vi har en "normal" function kaldet `f`. Hvordan kan du kalde den `async` function `wait()` og bruge dens resultat inde i `f`?
 
 ```js
 async function wait() {
@@ -11,10 +11,10 @@ async function wait() {
 }
 
 function f() {
-  // ...what should you write here?
-  // we need to call async wait() and wait to get 10
-  // remember, we can't use "await"
+  // ... hvad skal vi skrive her?
+  // vi har brug for at kalde den asynkrone wait() og vente på at få 10
+  // husk, vi kan ikke bruge "await"
 }
 ```
 
-P.S. The task is technically very simple, but the question is quite common for developers new to async/await.
+P.S. Opgaven er teknisk set meget simpel, men spørgsmålet er ganske almindeligt for udviklere, der er nye i async/await.
diff --git a/1-js/11-async/08-async-await/04-promise-all-failure/solution.md b/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
index 9fda8e000..134d1adc9 100644
--- a/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
+++ b/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
@@ -1,52 +1,52 @@
 
-The root of the problem is that `Promise.all` immediately rejects when one of its promises rejects, but it do nothing to cancel the other promises.
+Roden til problemet er, at `Promise.all` umiddelbart afviser, når en af dens promises afviser, men den gør intet for at annullere de andre promises.
 
-In our case, the second query fails, so `Promise.all` rejects, and the `try...catch` block catches this error.Meanwhile, other promises are *not affected* - they independently continue their execution. In our case, the third query throws an error of its own after a bit of time. And that error is never caught, we can see it in the console.
+I vores tilfælde fejler den anden forespørgsel, så `Promise.all` afviser, og `try...catch` blokken fanger denne fejl. Mens de andre promises ikke er påvirket - de fortsætter uafhængigt deres eksekvering. I vores tilfælde kaster den tredje forespørgsel en fejl selv efter et stykke tid. Og den fejl bliver aldrig fanget, vi kan se den i konsollen.
 
-The problem is especially dangerous in server-side environments, such as Node.js, when an uncaught error may cause the process to crash.
+Problemet er især farligt i server-side miljøer, såsom Node.js, hvor en ikke-fanget fejl kan forårsage, at processen går ned.
 
-How to fix it?
+Hvordan fikser vi det?
 
-An ideal solution would be to cancel all unfinished queries when one of them fails. This way we avoid any potential errors.
+En idéel løsning ville være at annullere alle uafsluttede forespørgsler, når en af dem fejler. På denne måde undgår vi eventuelle fejl.
 
-However, the bad news is that service calls (such as `database.query`) are often implemented by a 3rd-party library which doesn't support cancellation. Then there's no way to cancel a call.
+Men den dårlige nyheder er, at servicekald (såsom `database.query`) ofte er implementeret af en 3rd-parts bibliotek, som ikke understøtter annullering. Så der er ingen måde at annullere et kald.
 
-As an alternative, we can write our own wrapper function around `Promise.all` which adds a custom `then/catch` handler to each promise to track them: results are gathered and, if an error occurs, all subsequent promises are ignored.
+Som et alternativ kan vi skrive vores egen wrapper omkring `Promise.all` som tilføjer en custom `then/catch` handler til hver promise for at spore dem: resultaterne samles og, hvis en fejl opstår, ignoreres alle efterfølgende promises.
 
 ```js
 function customPromiseAll(promises) {
   return new Promise((resolve, reject) => {
     const results = [];
     let resultsCount = 0;
-    let hasError = false; // we'll set it to true upon first error
+    let hasError = false; // vi sætter den til true ved første fejl vi møder
 
     promises.forEach((promise, index) => {
       promise
         .then(result => {
-          if (hasError) return; // ignore the promise if already errored
+          if (hasError) return; // ignorer promise hvis den allerede er fejlet
           results[index] = result;
           resultsCount++;
           if (resultsCount === promises.length) {
-            resolve(results); // when all results are ready - successs
+            resolve(results); // når alle resultater er klar - succes
           }
         })
         .catch(error => {
-          if (hasError) return; // ignore the promise if already errored
-          hasError = true; // wops, error!
-          reject(error); // fail with rejection
+          if (hasError) return; // ignorer promise hvis den allerede er fejlet
+          hasError = true; // ups, fejl!
+          reject(error); // fejl med reject
         });
     });
   });
 }
 ```
 
-This approach has an issue of its own - it's often undesirable to `disconnect()` when queries are still in the process.
+Denne tilgang har sine egne udfordringer - det er ofte uønsket at kalde `disconnect()` når der stadig er forespørgsler i processen.
 
-It may be important that all queries complete, especially if some of them make important updates.
+Det kan være vigtigt at alle forespørgsler gennemføres, især hvis nogle af dem indeholder vigtige opdateringer.
 
-So we should wait until all promises are settled before going further with the execution and eventually disconnecting.
+Så vi bør vente indtil alle promise er afsluttet, før vi går videre med eksekveringen og til sidst frakobler.
 
-Here's another implementation. It behaves similar to `Promise.all` - also resolves with the first error, but waits until all promises are settled.
+Her er en anden implementering. Den opfører sig i stil med `Promise.all` - den resolver også ved den første fejl, men venter indtil alle promise er afsluttet.
 
 ```js
 function customPromiseAllWait(promises) {
@@ -80,16 +80,16 @@ function customPromiseAllWait(promises) {
 }
 ```
 
-Now `await customPromiseAllWait(...)` will stall the execution until all queries are processed.
+Nu vil `await customPromiseAllWait(...)` tilbageholde udførelsen indtil alle forespørgsler er behandlet. Hvis der opstår en fejl, vil den blive fanget i `try...catch` blokken, og vi kan være sikre på, at alle forespørgsler er afsluttet, før vi går videre.
 
-This is a more reliable approach, as it guarantees a predictable execution flow.
+Dette er en mere pålidelig tilgang, da den garanterer et forudsigeligt eksekveringsflow.
 
-Lastly, if we'd like to process all errors, we can use either use `Promise.allSettled` or write a wrapper around it to gathers all errors in a single [AggregateError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError) object and rejects with it.
+Til sidst, hvis vi vil behandle alle fejl, kan vi bruge enten `Promise.allSettled` eller skrive en wrapper omkring for at samle alle fejl i et enkelt [AggregateError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError) objekt og afvise med det.
 
 ```js
-// wait for all promises to settle
-// return results if no errors
-// throw AggregateError with all errors if any
+// vent på at alle promise er afsluttet
+// returner resultater hvis ingen fejl
+// kast AggregateError med alle fejl hvis nogen
 function allOrAggregateError(promises) {
   return Promise.allSettled(promises).then(results => {
     const errors = [];
@@ -104,7 +104,7 @@ function allOrAggregateError(promises) {
     });
 
     if (errors.length > 0) {
-      throw new AggregateError(errors, 'One or more promises failed');
+      throw new AggregateError(errors, 'En eller flere promises fejlede');
     }
 
     return values;
diff --git a/1-js/11-async/08-async-await/04-promise-all-failure/task.md b/1-js/11-async/08-async-await/04-promise-all-failure/task.md
index 74571c43e..6b6b4773d 100644
--- a/1-js/11-async/08-async-await/04-promise-all-failure/task.md
+++ b/1-js/11-async/08-async-await/04-promise-all-failure/task.md
@@ -1,17 +1,17 @@
 
-# Dangerous Promise.all
+# Farlig Promise.all
 
-`Promise.all` is a great way to parallelize multiple operations. It's especially useful when we need to make parallel requests to multiple services.
+`Promise.all` er en fantastisk måde at køre flere operationer parallelt. Det er især nyttigt når vi har brug for at lave flere forespørgsler til forskellige services samtidigt.
 
-However, there's a hidden danger. We'll see an example in this task and explore how to avoid it.
+Men, der er en skjult fare. Vi vil se et eksempel i denne opgave og udforske, hvordan man undgår den.
 
-Let's say we have a connection to a remote service, such as a database.
+Lad os sige, vi har en forbindelse til en ekstern service, såsom en database.
 
-There're two functions: `connect()` and `disconnect()`.
+Der er to funktioner: `connect()` og `disconnect()`.
 
-When connected, we can send requests using `database.query(...)` - an async function which usually returns the result but also may throw an error.
+Når den er forbundet, kan vi sende forespørgsler ved hjælp af `database.query(...)` - en async function, som normalt returnerer resultatet, men også kan kaste en fejl.
 
-Here's a simple implementation:
+Her er en simpel implementering af det:
 
 ```js
 let database;
@@ -28,21 +28,21 @@ function disconnect() {
   database = null;
 }
 
-// intended usage:
+// beregnet brug:
 // connect()
 // ...
-// database.query(true) to emulate a successful call
-// database.query(false) to emulate a failed call
+// database.query(true) for at emulere et succesfuldt kald
+// database.query(false) for at emulere et mislykket kald
 // ...
 // disconnect()
 ```
 
-Now here's the problem.
+Se her er problemet.
 
-We wrote the code to connect and send 3 queries in parallel (all of them take different time, e.g. 100, 200 and 300ms), then disconnect:
+Vi skrev koden til at forbinde og sende 3 forespørgsler parallelt (alle tager forskellig tid, f.eks. 100, 200 og 300 ms), for derefter at frakoble igen:
 
 ```js
-// Helper function to call async function `fn` after `ms` milliseconds
+// Hjælperfunktion til at kalde async funktion `fn` efter `ms` millisekunder
 function delay(fn, ms) {
   return new Promise((resolve, reject) => {
     setTimeout(() => fn().then(resolve, reject), ms);
@@ -54,8 +54,8 @@ async function run() {
 
   try {
     await Promise.all([
-      // these 3 parallel jobs take different time: 100, 200 and 300 ms
-      // we use the `delay` helper to achieve this effect
+      // disse 3 paralelle jobs tager forskellig tid: 100, 200 og 300 ms
+      // vi bruger `delay` hjælperen for at opnå denne effekt
 *!*
       delay(() => database.query(true), 100),
       delay(() => database.query(false), 200),
@@ -63,7 +63,7 @@ async function run() {
 */!*
     ]);
   } catch(error) {
-    console.log('Error handled (or was it?)');
+    console.log('Fejl håndteret (eller er den?)');
   }
 
   disconnect();
@@ -72,8 +72,8 @@ async function run() {
 run();
 ```
 
-Two of these queries happen to be unsuccessful, but we're smart enough to wrap the `Promise.all` call into a `try..catch` block.
+To af disse forespørgsler viser sig at fejle, men vi var smarte nok til at wrappe `Promise.all` kaldet i en `try..catch` block.
 
-However, this doesn't help! This script actually leads to an uncaught error in console!
+Men lige meget hvad, så hjælper det ikke! Dette script fører faktisk til en ikke-fanget fejl i konsollen!
 
-Why? How to avoid it?
\ No newline at end of file
+Hvorfor? Hvordan undgår man det?
\ No newline at end of file
diff --git a/1-js/11-async/08-async-await/article.md b/1-js/11-async/08-async-await/article.md
index e679b1c4c..c83b794ac 100644
--- a/1-js/11-async/08-async-await/article.md
+++ b/1-js/11-async/08-async-await/article.md
@@ -1,10 +1,10 @@
 # Async/await
 
-There's a special syntax to work with promises in a more comfortable fashion, called "async/await". It's surprisingly easy to understand and use.
+Der er en speciel syntaks der bruges til at arbejde med promises på en mere komfortabel måde, kaldet "async/await". Den er overraskende let at forstå og bruge.
 
 ## Async functions
 
-Let's start with the `async` keyword. It can be placed before a function, like this:
+Lad os starte med nøgleordet `async`. Det kan placeres før en function, sådan her:
 
 ```js
 async function f() {
@@ -12,9 +12,9 @@ async function f() {
 }
 ```
 
-The word "async" before a function means one simple thing: a function always returns a promise. Other values are wrapped in a resolved promise automatically.
+Ordet "async" før en function betyder en simpel ting: en function returnerer altid en promise. Andre værdier er automatisk pakket ind i en løst (resolved) promise.
 
-For instance, this function returns a resolved promise with the result of `1`; let's test it:
+For eksempel, denne funktion returnerer et løst promise med resultatet `1`; lad os teste den:
 
 ```js run
 async function f() {
@@ -24,7 +24,7 @@ async function f() {
 f().then(alert); // 1
 ```
 
-...We could explicitly return a promise, which would be the same:
+... vi kunne også eksplicit returnere et promise, hvilket ville være det samme:
 
 ```js run
 async function f() {
@@ -34,20 +34,20 @@ async function f() {
 f().then(alert); // 1
 ```
 
-So, `async` ensures that the function returns a promise, and wraps non-promises in it. Simple enough, right? But not only that. There's another keyword, `await`, that works only inside `async` functions, and it's pretty cool.
+Så `async` sikrer at funktionen returnerer et promise, og pakker ikke-promise værdier ind i et løst promise. Enkelt nok, ikke? Men ikke kun det. Der er endnu et nøgleord, `await`, som kun virker inde i `async` funktioner, og det er ret sejt.
 
 ## Await
 
-The syntax:
+Syntaksen er:
 
 ```js
-// works only inside async functions
+// virker kun inde i async funktioner
 let value = await promise;
 ```
 
-The keyword `await` makes JavaScript wait until that promise settles and returns its result.
+Nøgleordet `await` gør at JavaScript venter indtil det promise er løst og returnerer dets resultat.
 
-Here's an example with a promise that resolves in 1 second:
+Her er et eksempel med et promise, der løses om 1 sekund:
 ```js run
 async function f() {
 
@@ -56,23 +56,23 @@ async function f() {
   });
 
 *!*
-  let result = await promise; // wait until the promise resolves (*)
+  let result = await promise; // vent indtil promise løses (*)
 */!*
 
-  alert(result); // "done!"
+  alert(result); // "færdig!"
 }
 
 f();
 ```
 
-The function execution "pauses" at the line `(*)` and resumes when the promise settles, with `result` becoming its result. So the code above shows "done!" in one second.
+Udførelsen af funktionen "sættes på pause" ved linjen `(*)` og fortsætter når promise løses, med `result` som dens resultat. Koden ovenfor vil vise "færdig!" efter 1 sekund.
 
-Let's emphasize: `await` literally suspends the function execution until the promise settles, and then resumes it with the promise result. That doesn't cost any CPU resources, because the JavaScript engine can do other jobs in the meantime: execute other scripts, handle events, etc.
+Lad os understrege: `await` udsætter eksekvering af funktionen indtil promise løses og fortsætter med det modtagne resultat. Det koster ikke nogen CPU ressourcer, fordi JavaScript motoren kan udføre andre job i mellemtiden: udføre andre scripts, håndtere events etc.
 
-It's just a more elegant syntax of getting the promise result than `promise.then`. And, it's easier to read and write.
+Det er bare en mere elegant syntaks for at få resultatet af et promise end `promise.then`. Og det er lettere at læse og skrive.
 
-````warn header="Can't use `await` in regular functions"
-If we try to use `await` in a non-async function, there would be a syntax error:
+````warn header="Du kan ikke bruge `await` i regulære funktioner"
+HVis vi prøver at bruge `await` i en ikke-async funktion, vil der være en syntaxfejl:
 
 ```js run
 function f() {
@@ -83,32 +83,32 @@ function f() {
 }
 ```
 
-We may get this error if we forget to put `async` before a function. As stated earlier, `await` only works inside an `async` function.
+Vi får den fejl hvis vi glemmer at tilføje `async` før en funktion. Som nævnt tidligere, virker `await` kun inde i en `async` funktion.
 ````
 
-Let's take the `showAvatar()` example from the chapter <info:promise-chaining> and rewrite it using `async/await`:
+Lad os tage `showAvatar()` eksemplet fra kapitlet <info:promise-chaining> og omskrive det ved hjælp af `async/await`:
 
-1. We'll need to replace `.then` calls with `await`.
-2. Also we should make the function `async` for them to work.
+1. Vi vil skulle erstatte `.then` kald med `await`.
+2. Desuden bør vi gøre funktionen `async` for at de kan fungere.
 
 ```js run
 async function showAvatar() {
 
-  // read our JSON
+  // læs JSON filen
   let response = await fetch('/article/promise-chaining/user.json');
   let user = await response.json();
 
-  // read github user
+  // læs github bruger
   let githubResponse = await fetch(`https://api.github.com/users/${user.name}`);
   let githubUser = await githubResponse.json();
 
-  // show the avatar
+  // vis avatar
   let img = document.createElement('img');
   img.src = githubUser.avatar_url;
   img.className = "promise-avatar-example";
   document.body.append(img);
 
-  // wait 3 seconds
+  // vent 3 sekunder
   await new Promise((resolve, reject) => setTimeout(resolve, 3000));
 
   img.remove();
@@ -119,24 +119,24 @@ async function showAvatar() {
 showAvatar();
 ```
 
-Pretty clean and easy to read, right? Much better than before.
+Ret rent og nemt at læse, ikke? Meget bedre end før.
 
-````smart header="Modern browsers allow top-level `await` in modules"
-In modern browsers, `await` on top level works just fine, when we're inside a module. We'll cover modules in article <info:modules-intro>.
+````smart header="Moderne browsere tillader top-level `await` i moduler"
+I moderne browsere vil `await` på top level fungere helt fint, når vi er inde i et modul. Vi vil dække moduler i artiklen <info:modules-intro>.
 
-For instance:
+For eksempel:
 
 ```js run module
-// we assume this code runs at top level, inside a module
+// vi tager udgangspunkt i, at denne kode kører på top level, inde i et modul
 let response = await fetch('/article/promise-chaining/user.json');
 let user = await response.json();
 
 console.log(user);
 ```
 
-If we're not using modules, or [older browsers](https://caniuse.com/mdn-javascript_operators_await_top_level) must be supported, there's a universal recipe: wrapping into an anonymous async function.
+Hvis vi ikke bruger moduler, eller [ældre browsere](https://caniuse.com/mdn-javascript_operators_await_top_level) skal understøttes, er der en universel opskrift: pak det hele ind i en anonym async funktion.
 
-Like this:
+Sådan her:
 
 ```js
 (async () => {
@@ -148,10 +148,10 @@ Like this:
 
 ````
 
-````smart header="`await` accepts \"thenables\""
-Like `promise.then`, `await` allows us to use thenable objects (those with a callable `then` method). The idea is that a third-party object may not be a promise, but promise-compatible: if it supports `.then`, that's enough to use it with `await`.
+````smart header="`await` accepterer \"thenables\""
+Ligesom `promise.then` vil `await` tillade os at bruge *thenable* objekter (dem med en meode `then` der kan kaldes). Idéen med dette er at 3de-parts objekter ikke nødvendigvis er et promise, men promise-kompatible: hvis det understøtter `.then`, er det godt nok til at bruge sammen med `await`.
 
-Here's a demo `Thenable` class; the `await` below accepts its instances:
+Her er en demo `Thenable` klasse; `await` nedenfor accepterer udgaver af den:
 
 ```js run
 class Thenable {
@@ -160,13 +160,13 @@ class Thenable {
   }
   then(resolve, reject) {
     alert(resolve);
-    // resolve with this.num*2 after 1000ms
+    // resolve med this.num*2 efter 1000ms
     setTimeout(() => resolve(this.num * 2), 1000); // (*)
   }
 }
 
 async function f() {
-  // waits for 1 second, then result becomes 2
+  // venter i 1 sekund, hvorefter resultatet bliver 2
   let result = await new Thenable(1);
   alert(result);
 }
@@ -174,11 +174,11 @@ async function f() {
 f();
 ```
 
-If `await` gets a non-promise object with `.then`, it calls that method providing the built-in functions `resolve` and `reject` as arguments (just as it does for a regular `Promise` executor). Then `await` waits until one of them is called (in the example above it happens in the line `(*)`) and then proceeds with the result.
+Hvis `await` får et ikke-promise object med `.then`, det kalder den metode og giver de indbyggede funktioner `resolve` og `reject` som argumenter (ligesom det gør for en almindelig `Promise` executor). Derefter venter `await` indtil en af dem bliver kaldt (i eksemplet ovenfor sker det i linjen `(*)`) og fortsætter derefter med resultatet.
 ````
 
-````smart header="Async class methods"
-To declare an async class method, just prepend it with `async`:
+````smart header="Async klasse metoder"
+For at deklarere en async klasse metode, tilføj `async` før metoden:
 
 ```js run
 class Waiter {
@@ -191,38 +191,38 @@ class Waiter {
 
 new Waiter()
   .wait()
-  .then(alert); // 1 (this is the same as (result => alert(result)))
+  .then(alert); // 1 (det er det samme som (result => alert(result)))
 ```
-The meaning is the same: it ensures that the returned value is a promise and enables `await`.
+Meningen er den samme: det sikrer at den returnerede værdi er et promise og aktiverer `await`.
 
 ````
-## Error handling
+## Håndtering af fejl
 
-If a promise resolves normally, then `await promise` returns the result. But in the case of a rejection, it throws the error, just as if there were a `throw` statement at that line.
+Hvis et promise løses normalt, så returnerer `await promise` resultatet. Men i tilfældet af en afvisning, kaster det en fejl, som om der var en `throw`-sætning på linjen.
 
-This code:
+Denne kode:
 
 ```js
 async function f() {
 *!*
-  await Promise.reject(new Error("Whoops!"));
+  await Promise.reject(new Error("Ups!"));
 */!*
 }
 ```
 
-...is the same as this:
+... er det samme som:
 
 ```js
 async function f() {
 *!*
-  throw new Error("Whoops!");
+  throw new Error("Ups!");
 */!*
 }
 ```
 
-In real situations, the promise may take some time before it rejects. In that case there will be a delay before `await` throws an error.
+I virkelige situationer vil et promise tage noget tid før det afvises. I det tilfælde vil der være en forsinkelse før `await` kaster en fejl.
 
-We can catch that error using `try..catch`, the same way as a regular `throw`:
+Vi kan opsnappe den fejl ved hjælp af `try..catch`, på samme måde som en almindelig `throw`:
 
 ```js run
 async function f() {
@@ -239,7 +239,7 @@ async function f() {
 f();
 ```
 
-In the case of an error, the control jumps to the `catch` block. We can also wrap multiple lines:
+I tilfælde af en fejl, springer kontrollen over til `catch`-blokken. Vi kan også wrappe flere linjer i `try..catch` for at fange fejl i flere `await`:
 
 ```js run
 async function f() {
@@ -248,7 +248,7 @@ async function f() {
     let response = await fetch('/no-user-here');
     let user = await response.json();
   } catch(err) {
-    // catches errors both in fetch and response.json
+    // fanger fejler i både fetch og response.json
     alert(err);
   }
 }
@@ -256,33 +256,33 @@ async function f() {
 f();
 ```
 
-If we don't have `try..catch`, then the promise generated by the call of the async function `f()` becomes rejected. We can append `.catch` to handle it:
+Hvis vi ikke har `try..catch`, så vil promise genreret ved kaldet af den asynkrone funktion `f()` blive afvist. Vi kan tilføje `.catch` for at håndtere det:
 
 ```js run
 async function f() {
   let response = await fetch('http://no-such-url');
 }
 
-// f() becomes a rejected promise
+// f() bliver et afvist promise
 *!*
-f().catch(alert); // TypeError: failed to fetch // (*)
+f().catch(alert); // TypeError: fejlede ved fetch // (*)
 */!*
 ```
 
-If we forget to add `.catch` there, then we get an unhandled promise error (viewable in the console). We can catch such errors using a global `unhandledrejection` event handler as described in the chapter <info:promise-error-handling>.
+Hvis vi glemmer at tilføje `.catch`, så får vi en ikke-håndteret promise-fejl (synlig i konsollen). Vi kan fange sådanne fejl ved hjælp af en global `unhandledrejection`-begivenhedshåndtering som beskrevet i kapitlet <info:promise-error-handling>.
 
 
-```smart header="`async/await` and `promise.then/catch`"
-When we use `async/await`, we rarely need `.then`, because `await` handles the waiting for us. And we can use a regular `try..catch` instead of `.catch`. That's usually (but not always) more convenient.
+```smart header="`async/await` og `promise.then/catch`"
+Når vi bruger `async/await`, bruger vi sjældent `.then`, fordi `await` håndterer ventningen for os. Og vi kan bruge en almindelig `try..catch` i stedet for `.catch`. Det er ofte (men ikke altid) mere praktisk.
 
-But at the top level of the code, when we're outside any `async` function, we're syntactically unable to use `await`, so it's a normal practice to add `.then/catch` to handle the final result or falling-through error, like in the line `(*)` of the example above.
+Men på den øverste niveau af koden, når vi er uden for enhver `async` funktion, er vi syntaktisk ude af stand til at bruge `await`, så det er en normal praksis at tilføje `.then/catch` for at håndtere det endelige resultat eller fejlen, som i linjen `(*)` i eksemplet ovenfor.
 ```
 
-````smart header="`async/await` works well with `Promise.all`"
-When we need to wait for multiple promises, we can wrap them in `Promise.all` and then `await`:
+````smart header="`async/await` virker godt med `Promise.all`"
+Når vi har brug for at vente på flere promises, kan vi pakke dem ind i `Promise.all` og derefter `await`:
 
 ```js
-// wait for the array of results
+// vent på arrayet af resultater
 let results = await Promise.all([
   fetch(url1),
   fetch(url2),
@@ -290,22 +290,22 @@ let results = await Promise.all([
 ]);
 ```
 
-In the case of an error, it propagates as usual, from the failed promise to `Promise.all`, and then becomes an exception that we can catch using `try..catch` around the call.
+I tilfælde af en fejl, propagerer den som sædvanligt, fra det mislykkede promise til `Promise.all`, og så bliver det til en exception, som vi kan fange ved hjælp af `try..catch` omkring kaldet.
 
 ````
 
-## Summary
+## Opsummering
 
-The `async` keyword before a function has two effects:
+Nøgleordet `async` før en funktion har to effekter:
 
-1. Makes it always return a promise.
-2. Allows `await` to be used in it.
+1. Gør det til en funktion, der altid returnerer et promise.
+2. Tillader `await` at blive brugt i den.
 
-The `await` keyword before a promise makes JavaScript wait until that promise settles, and then:
+Nøgleordet `await` før et promise gør JavaScript til at vente indtil det promise løses, og derefter:
 
-1. If it's an error, an exception is generated — same as if `throw error` were called at that very place.
-2. Otherwise, it returns the result.
+1. Hvis det er en fejl, genereres en exception — samme som hvis `throw error` blev kaldt på det sted.
+2. Ellers returnerer det resultatet.
 
-Together they provide a great framework to write asynchronous code that is easy to both read and write.
+Sammen udgør de en fremragende framework til at skrive asynkron kode, som er let at læse og skrive.
 
-With `async/await` we rarely need to write `promise.then/catch`, but we still shouldn't forget that they are based on promises, because sometimes (e.g. in the outermost scope) we have to use these methods. Also `Promise.all` is nice when we are waiting for many tasks simultaneously.
+Med `async/await` behøver vi sjældent at skrive `promise.then/catch`, men vi bør stadig ikke glemme, at de er baseret på promises, fordi nogle gange (f.eks. i den yderste scope) er vi nødt til at bruge dem. Derudover er `Promise.all` ret smart når vi venter på mange opgaver samtidigt.