Merge pull request #248 from ockley/master

The old "var"

Author: ockley

1-js/06-advanced-functions/04-var/article.md

@@ -1,62 +1,62 @@
 
-# The old "var"
+# Den gamle "var"
 
-```smart header="This article is for understanding old scripts"
-The information in this article is useful for understanding old scripts.
+```smart header="Den artikel er primært for at forstå ældre scripts"
+Informationen i denne artikel er brugbar for at forstå ældre scripts.
 
-That's not how we write new code.
+Det er ikke noget man normalt bruger i moderne JavaScript.
 ```
 
-In the very first chapter about [variables](info:variables), we mentioned three ways of variable declaration:
+I det første kapitel omkring [variable](info:variables), nævnte vi tre måder at deklarere variable:
 
 1. `let`
 2. `const`
 3. `var`
 
-The `var` declaration is similar to `let`. Most of the time we can replace `let` by `var` or vice-versa and expect things to work:
+Deklerationen `var` minder meget om `let`. I langt de fleste tilfælde kan vi erstatte `let` med `var` eller omvendt og forvente, at tingene virker som de skal:
 
 ```js run
-var message = "Hi";
-alert(message); // Hi
+var message = "Hej";
+alert(message); // Hej
 ```
 
-But internally `var` is a very different beast, that originates from very old times. It's generally not used in modern scripts, but still lurks in the old ones.
+Men internt er `var` en helt anden størrelse, der har sin oprindelse i JavaScript tidlige år. Det bruges normalt ikke i moderne JavaScript, men vil stadig ofte findes i ældre scripts.
 
-If you don't plan on meeting such scripts you may even skip this chapter or postpone it.
+Hvis du ikke planlægger at møde sådanne scripts, kan du måske springe dette kapitel over eller udsætte det.
 
-On the other hand, it's important to understand differences when migrating old scripts from `var` to `let`, to avoid odd errors.
+På den anden side er det vigtigt at forstå forskellene, når man migrerer gamle scripts fra `var` til `let`, for at undgå sjældne fejl.
 
-## "var" has no block scope
+## "var" har ingen block scope
 
-Variables, declared with `var`, are either function-scoped or global-scoped. They are visible through blocks.
+Variable deklareret med `var` er enten function-scoped eller global-scoped. De er synlige gennem kodeblokke.
 
-For instance:
+For eksempel:
 
 ```js run
 if (true) {
-  var test = true; // use "var" instead of "let"
+  var test = true; // bruger "var" i stedet for "let"
 }
 
 *!*
-alert(test); // true, the variable lives after if
+alert(test); // true, variablen lever efter if er afsluttet
 */!*
 ```
 
-As `var` ignores code blocks, we've got a global variable `test`.
+Da `var` ignorerer kodeblokke får vi her en global variabel `test`.
 
-If we used `let test` instead of `var test`, then the variable would only be visible inside `if`:
+Hvis vi bruger `let test` i stedet for `var test`, så vil variablen kun være synlig inden for `if`:
 
 ```js run
 if (true) {
-  let test = true; // use "let"
+  let test = true; // bruger "let"
 }
 
 *!*
 alert(test); // ReferenceError: test is not defined
 */!*
 ```
 
-The same thing for loops: `var` cannot be block- or loop-local:
+Den samme ting gælder for løkker: `var` kan ikke være lokal for løkken:
 
 ```js run
 for (var i = 0; i < 10; i++) {
@@ -65,59 +65,59 @@ for (var i = 0; i < 10; i++) {
 }
 
 *!*
-alert(i);   // 10, "i" is visible after loop, it's a global variable
-alert(one); // 1, "one" is visible after loop, it's a global variable
+alert(i);   // 10, "i" er synlig efter loopet da det (med var) er blevet en global variabel
+alert(one); // 1, "one" er synlig efter loopet da det (med var) er blevet en global variabel
 */!*
 ```
 
-If a code block is inside a function, then `var` becomes a function-level variable:
+Hvis en kodeblok er inde i en funktion så bliver `var` en variabel med et scope til funktionen. Den er synlig i hele funktionen, uanset hvor den er deklareret:
 
 ```js run
 function sayHi() {
   if (true) {
-    var phrase = "Hello";
+    var phrase = "Hej";
   }
 
-  alert(phrase); // works
+  alert(phrase); // virker
 }
 
 sayHi();
 alert(phrase); // ReferenceError: phrase is not defined
 ```
 
-As we can see, `var` pierces through `if`, `for` or other code blocks. That's because a long time ago in JavaScript, blocks had no Lexical Environments, and `var` is a remnant of that.
+Som vi kan se så skærer `var` sig gennem `if`, `for` og andre kodeblokke. Det er fordi JavaScript i gamle dage ikke havde leksikale miljøer for kodeblokke og `var` er et barn af den tid.
 
-## "var" tolerates redeclarations
+## "var" tolererer redeklerationer
 
-If we declare the same variable with `let` twice in the same scope, that's an error:
+Hvis vi deklarerer den samme variabel med `let` to gange i samme scope, får vi en fejl:
 
 ```js run
 let user;
 let user; // SyntaxError: 'user' has already been declared
 ```
 
-With `var`, we can redeclare a variable any number of times. If we use `var` with an already-declared variable, it's just ignored:
+Med `var` kan vi redeklarere en variabel så meget vi har lyst. Hvis vi bruger `var` med en allerede deklareret variabel, ignoreres det bare:
 
 ```js run
 var user = "Pete";
 
-var user = "John"; // this "var" does nothing (already declared)
-// ...it doesn't trigger an error
+var user = "John"; // denne "var" gør intet (er allerede deklareret), så den ignoreres
+// ...derfor melder JavaScript ikke en fejl
 
 alert(user); // John
 ```
 
-## "var" variables can be declared below their use
+## "var" variable kan deklareres efter de bruges
 
-`var` declarations are processed when the function starts (or script starts for globals).
+`var` deklaration processeres først når funktionen kaldes (eller scriptet starter for globale variable).
 
-In other words, `var` variables are defined from the beginning of the function, no matter where the definition is (assuming that the definition is not in the nested function).
+Sagt på en anden måde. Variable skabt med `var` er defineret fra begyndelsen af funktionen, lige meget hvor i funktionen definitionen er (med mindre definitionen er i en indlejret funktion selvfølgelig).
 
-So this code:
+Så denne kode:
 
 ```js run
 function sayHi() {
-  phrase = "Hello";
+  phrase = "Hej";
 
   alert(phrase);
 
@@ -128,26 +128,26 @@ function sayHi() {
 sayHi();
 ```
 
-...Is technically the same as this (moved `var phrase` above):
+...er teksnisk set det samme som denne (flyttet `var phrase` over):
 
 ```js run
 function sayHi() {
 *!*
   var phrase;
 */!*
 
-  phrase = "Hello";
+  phrase = "Hej";
 
   alert(phrase);
 }
 sayHi();
 ```
 
-...Or even as this (remember, code blocks are ignored):
+...eller endda denne her (husk, at kodeblokke ignoreres af `var`):
 
 ```js run
 function sayHi() {
-  phrase = "Hello"; // (*)
+  phrase = "Hej"; // (*)
 
   *!*
   if (false) {
@@ -160,128 +160,128 @@ function sayHi() {
 sayHi();
 ```
 
-People also call such behavior "hoisting" (raising), because all `var` are "hoisted" (raised) to the top of the function.
+Denne adfærd kaldes "hoisting" (hejsning eller opløftning), fordi alle `var` bliver "hoisted" (løftet) op til toppen af funktionen.
 
-So in the example above, `if (false)` branch never executes, but that doesn't matter. The `var` inside it is processed in the beginning of the function, so at the moment of `(*)` the variable exists.
+Så i eksemplet ovenfor, `if (false)` branch bliver egentlig aldrig eksekveret, men det spiller ingen rolle. Den `var` der er inde i den bliver behandlet i begyndelsen af funktionen, så ved tidspunktet for `(*)` eksisterer variablen.
 
-**Declarations are hoisted, but assignments are not.**
+**Deklarationer bliver hoisted men tildelinger bliver ikke.**
 
-That's best demonstrated with an example:
+Det er nok bedst demonstreret med et eksempel, hvor vi prøver at bruge en variabel før den er deklareret:
 
 ```js run
 function sayHi() {
   alert(phrase);
 
 *!*
-  var phrase = "Hello";
+  var phrase = "Hej";
 */!*
 }
 
 sayHi();
 ```
 
-The line `var phrase = "Hello"` has two actions in it:
+Linjen `var phrase = "Hej"` har to handlinger knyttet til sig:
 
-1. Variable declaration `var`
-2. Variable assignment `=`.
+1. Deklaration af variablen `var`
+2. Tildeling af værdi `=`.
 
-The declaration is processed at the start of function execution ("hoisted"), but the assignment always works at the place where it appears. So the code works essentially like this:
+Deklarationen processeres i starten af funktionens eksekvering ("hoisted"), men tildelingen virker altid på den sted hvor den optræder. Så koden virker faktisk som dette:
 
 ```js run
 function sayHi() {
 *!*
-  var phrase; // declaration works at the start...
+  var phrase; // deklaration virker fra starten...
 */!*
 
   alert(phrase); // undefined
 
 *!*
-  phrase = "Hello"; // ...assignment - when the execution reaches it.
+  phrase = "Hej"; // ...tildeling - når afviklingen rammer dette sted.
 */!*
 }
 
 sayHi();
 ```
 
-Because all `var` declarations are processed at the function start, we can reference them at any place. But variables are undefined until the assignments.
+Fordi alle `var` deklarationer behandles i starten af funktionens eksekvering, kan vi referere til dem hvor som helst. Men variabler er undefined indtil tildelingen.
 
-In both examples above, `alert` runs without an error, because the variable `phrase` exists. But its value is not yet assigned, so it shows `undefined`.
+I begge eksempler ovenfor, kører `alert` uden en fejl, fordi variablen `phrase` eksisterer. Men dens værdi er ikke endnu tildelt, så den viser `undefined`.
 
 ## IIFE
 
-In the past, as there was only `var`, and it has no block-level visibility, programmers invented a way to emulate it. What they did was called "immediately-invoked function expressions" (abbreviated as IIFE).
+I begyndelsen, da der kun var `var`, og det ikke havde synlighed på blokniveau, opfandt programmører en måde at emulere det. Det de gjorde, kaldtes "immediately-invoked function expressions" (forkortet som IIFE).
 
-That's not something we should use nowadays, but you can find them in old scripts.
+Det er ikke noget der er udbredt mere, men du vil stadig kunne finde det i kode fra tid til anden.
 
-An IIFE looks like this:
+En IIFE ser således ud:
 
 ```js run
 (function() {
 
-  var message = "Hello";
+  var message = "Hej";
 
-  alert(message); // Hello
+  alert(message); // Hej
 
 })();
 ```
 
-Here, a Function Expression is created and immediately called. So the code executes right away and has its own private variables.
+Her bliver et funktionsudtryk skabt og kaldt med det samme. På den måde bliver koden afviklet med sine egne private variable.
 
-The Function Expression is wrapped with parenthesis `(function {...})`, because when JavaScript engine encounters `"function"` in the main code, it understands it as the start of a Function Declaration. But a Function Declaration must have a name, so this kind of code will give an error:
+Funktionsudtrykket er pakket ind i parentes `(function {...})`, fordi når JavaScript-motoren støder på `"function"` i hovedkoden, så forstår den det som starten af en funktionsdeklaration. Men en funktionsdeklaration skal have et navn, så denne type kode vil give en fejl:
 
 ```js run
-// Tries to declare and immediately call a function
+// Prøver at oprette og kalde en funktion med det samme
 function() { // <-- SyntaxError: Function statements require a function name
 
-  var message = "Hello";
+  var message = "Hej";
 
-  alert(message); // Hello
+  alert(message); // Hej
 
 }();
 ```
 
-Even if we say: "okay, let's add a name", that won't work, as JavaScript does not allow Function Declarations to be called immediately:
+Selv hvis vi siger: "Okay, lad os give den et navn!", vil det ikke virke da JavaScript ikke tillader at funktionsudtryk kaldes med det samme de er skabt:
 
 ```js run
-// syntax error because of parentheses below
+// syntaksfejl på grund af parenteser til sidst
 function go() {
 
-}(); // <-- can't call Function Declaration immediately
+}(); // <-- du kan ikke kalde den med det samme
 ```
 
-So, the parentheses around the function is a trick to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression: it needs no name and can be called immediately.
+Så parenteser rundt om funktionensudtrykket er et trick, for at vise JavaScript at funktionen er skabt i konteksten af et andet udtryk, og derfor er den et funktionsudtryk: det behøver ikke et navn og kan kaldes med det samme.
 
-There exist other ways besides parentheses to tell JavaScript that we mean a Function Expression:
+Der findes andre måder end parenteser til at fortælle JavaScript at vi mener et funktionsudtryk:
 
 ```js run
 // Ways to create IIFE
 
 *!*(*/!*function() {
-  alert("Parentheses around the function");
+  alert("Parenteser omkring funktionen");
 }*!*)*/!*();
 
 *!*(*/!*function() {
-  alert("Parentheses around the whole thing");
+  alert("Parenteser omkring hele udtrykket");
 }()*!*)*/!*;
 
 *!*!*/!*function() {
-  alert("Bitwise NOT operator starts the expression");
+  alert("Bitwise NOT operator starter udtrykket");
 }();
 
 *!*+*/!*function() {
-  alert("Unary plus starts the expression");
+  alert("Unært plus starter udtrykket");
 }();
 ```
 
-In all the above cases we declare a Function Expression and run it immediately. Let's note again: nowadays there's no reason to write such code.
+I alle tilfælde ovenfor deklareres et funktionsudtryk og kaldes med det samme. Men, i dag er der sjældent grund til at skrive sådan kode efter vi har fået `let` og `const`.
 
-## Summary
+## Opsummering
 
-There are two main differences of `var` compared to `let/const`:
+Der er to hovedforskelle mellem `var` og `let/const`:
 
-1. `var` variables have no block scope, their visibility is scoped to current function, or global, if declared outside function.
-2. `var` declarations are processed at function start (script start for globals).
+1. `var` variabler har ingen blok-scope, deres synlighed er scoped til den aktuelle funktion, eller globalt, hvis de er deklareret uden for en funktion.
+2. `var` deklarationer behandles i starten af funktionens eksekvering (script start for globale variabler).
 
-There's one more very minor difference related to the global object, that we'll cover in the next chapter.
+Der er yderligere en lille ekstra forskel relateret til det globale objekt, som vi vil dække i næste kapitel.
 
-These differences make `var` worse than `let` most of the time. Block-level variables is such a great thing. That's why `let` was introduced in the standard long ago, and is now a major way (along with `const`) to declare a variable.
+Det er disse forskelle der gør `var` værre end `let` de fleste gange. Blok-niveau variabler er sådan en god ting. Det er derfor `let` blev introduceret i standarden for længe siden, og er nu en vigtig måde (sammen med `const`) at deklarere en variabel på.