# Variabler

{% hint style="info" %}
**Dokumentasjon fra MDN**

* [`let`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)
* [`const`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)
  {% endhint %}

JavaScript er dynamisk typet, det vil si at vi ikke definerer hvilken type (int, boolean, string) en variabel er, slik man gjør i språk som Java og C#. Typer bestemmes underveis når et program kjøres, noe som også betyr at den samme variabelen kan bli satt til flere forskjellige verdier og dermed ha hatt flere typer i løpet av kjøringen.

Det er tre måter å deklarere en variabel på i JavaScript, vist under, og av disse anbefaler vi at du bruker enten `let` eller `const`.

```javascript
var a = 1;
let b = 1;
const c = 1;
```

`const` brukes om alle konstanter som ikke skal endre seg senere. Resten av variablene burde deklareres med `let`, som indikerer at innholdet kan endre seg over tid.

**OBS!** Glemmer du å deklarere en variabel med `var`, `let` eller `const`, vil variabelen være global.

{% hint style="info" %}
Du finner flere gode grunner til å velge `let` og `const` over `var` i avsnittene under. Men en annen fordel med `let` og `const` er at du kommuniserer til andre som leser koden hva som er meningen med en variabel. Skal den kunne endres eller ikke?
{% endhint %}

## Var

Før 2015 ble alle variabler i JavaScript deklarert som `var`, og er det vi kaller function scoped. Function scoped betyr at uavhengig av hvor variabelen blir deklarert, vil det være ekvivalent med å deklarere den på toppen. Dette fenomenet er kjent som [var hoisting](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var#var_hoisting), og har gjennom JavaScript sin historie forårsaket en del [uventet oppførsel](http://ignaciothayer.com/post/a-dangerous-example-of-javascript-hoisting/), særlig når looper har vært involvert. Dette er også bakgrunnen for at `let` og `const` er anbefalt å bruke til variabeldeklarasjon etter at det ble del av JavaScript-standarden i 2015.

Her er noen eksempler på hvordan `var` fungerer:

```javascript
var n = 1;

if (true) {
    n; // 1
}

n; // 1
```

```javascript
if (true) {
    var n = 1;
}

n; // 1
```

```javascript
if (false) {
    var n = 1;
}

n; // undefined
```

## Let

`let` oppfører seg nesten som `var`, og gir oss en variabel vi kan sette flere ganger. Forskjellen ligger i at `let` er block scoped. Det vil si at vi får en kjørefeil hvis vi forsøker å aksessere variabelen utenfor blokken den ble deklarert i, og slipper å forholde oss til at variabelen er tilgjengelig i hele funksjonen.

```javascript
if (true) {
    var x = true;
}

x; // true

if (true) {
    let y = true;
}

y; // ReferenceError: y is not defined
```

Let kan også brukes i konstruerte (fake) scopes, med samme oppførsel:

```javascript
{
    let x = true;
}

x; // ReferenceError: x is not defined
```

## Const

På samme måte som `let`, er `const` også block scoped:

```javascript
if (true) {
    const x = true;
}

x; // ReferenceError: x is not defined
```

Men hvis vi deklarerer en variabel med `const`, er det ikke mulig å tildele den noen ny verdi etter initiering, eller redeklarere den:

```javascript
const x = 'I am a const';
x = 'Can not change you?'; // TypeError: Assignment to constant variable.
```

Innholdet kan forøvrig fortsatt endres, siden det kun er referansen som er uforanderlig - en liste kan ikke plutselig bli satt til å være et tall eller en annen liste, men man kan fortsatt legge til elementer i den:

```javascript
const arr = [1, 2];
arr[0] = 0;

arr[0]; // 0
```

## Oppgaver

* [let](https://jsbin.com/tehakud/edit?html,js,output)
* [const](https://jsbin.com/punetoxase/1/edit?js,output)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://bekk.gitbook.io/web-intro/grunnleggende-webutvikling/cover-3/01-variabler.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.