5.2 Variabler, datatyper og operatorer i JavaScript

Variablar, datatypar og operatorar i JavaScript

I førre kapittel blei du kjend med variablar og enkel bruk av JavaScript. No skal vi gå djupare inn i datatypane som JavaScript tilbyr, forstå korleis typesystemet fungerer, og meistre dei ulike operatorane for utrekningar, samanlikningar og logikk.

Ei solid forståing av datatypar er avgjerande for å skrive korrekt og forutsigbar kode. JavaScript er eit dynamisk typa språk, noko som tyder at du ikkje deklarerer kva type ein variabel skal innehalde – typen blir avgjord automatisk av verdien du tildeler. Dette gjev fleksibilitet, men kan også føre til overraskande resultat dersom du ikkje forstår korleis typesystemet fungerer.

JavaScript har sju primitive datatypar. Dei tre viktigaste for dagleg programmering er:

Number – tal

Alle tal i JavaScript er av typen number, anten det er heiltal eller desimaltal:

const heltall = 42;
const desimaltall = 3.14;
const negativt = -7;
const vitenskapelig = 2.5e6;    // 2 500 000

console.log(typeof heltall);     // "number"
console.log(typeof desimaltall); // "number"

JavaScript har nokre spesielle talverdiar:

console.log(1 / 0);          // Infinity
console.log(-1 / 0);         // -Infinity
console.log("hei" * 2);      // NaN (Not a Number)
console.log(0.1 + 0.2);      // 0.30000000000000004 (flytepunktsfeil!)

String – tekst

Strengar representerer tekst og blir omslutta av hermeteikn:

const enkle = 'Hei på deg';
const doble = "Hei på deg";
const backticks = `Hei på deg`;  // Template literal

console.log(typeof enkle);  // "string"

Template literals (med backticks) er spesielt nyttige fordi dei støttar innebygde uttrykk:

const navn = "Sara";
const alder = 17;
const melding = `${navn} er ${alder} år gammel.`;
console.log(melding);  // "Sara er 17 år gammel."

Boolean – sann/usann

Boolske verdiar er anten true eller false:

const erMyndig = true;
const harRegnet = false;
const erStorre = 10 > 5;   // true

console.log(typeof erMyndig);  // "boolean"

JavaScript har to spesielle verdiar for «ingenting»:

undefined

undefined tyder at ein variabel er deklarert men ikkje har fått ein verdi:

let noe;
console.log(noe);         // undefined
console.log(typeof noe);  // "undefined"

null

null representerer eit medvite fråvær av verdi – du bruker det for å seie «denne variabelen har ingen verdi med vilje»:

let bruker = null;  // Brukeren er ikke logget inn ennå
console.log(bruker);         // null
console.log(typeof bruker);  // "object" (en velkjent bug i JavaScript!)

Skilnaden i praksis er at undefined tyder «verdien er ikkje sett enno», medan null tyder «verdien er medvite sett til ingenting».

JavaScript har dei vanlege rekneoperatorane:

const a = 10;
const b = 3;

console.log(a + b);   // 13
console.log(a - b);   // 7
console.log(a * b);   // 30
console.log(a / b);   // 3.3333...
console.log(a % b);   // 1 (resten ved 10 delt på 3)
console.log(a ** b);  // 1000 (10 opphøyd i 3)

Forkorta tildeling

let tall = 10;
tall += 5;    // tall = tall + 5 → 15
tall -= 3;    // tall = tall - 3 → 12
tall *= 2;    // tall = tall * 2 → 24
tall /= 4;    // tall = tall / 4 → 6
tall++;       // tall = tall + 1 → 7
tall--;       // tall = tall - 1 → 6

Samanlikningsoperatorar

Samanlikningsoperatorar returnerer true eller false:

console.log(5 === 5);     // true (streng likhet)
console.log(5 === "5");   // false (ulike typer)
console.log(5 == "5");    // true (løs likhet – unngå denne!)
console.log(5 !== 3);     // true (streng ulikhet)
console.log(10 > 5);      // true
console.log(3 <= 3);      // true

Bruk alltid === (trippel likskapsteikn) for samanlikning, aldri == (dobbel likskapsteikn). Dobbel likskap utfører automatisk typekonvertering som kan gje uventa resultat:

console.log(0 == "");      // true  (begge konverteres til 0)
console.log(0 === "");     // false (number !== string)
console.log(null == undefined);  // true  (spesiell regel)
console.log(null === undefined); // false (ulike typer)

Logiske operatorar

const a = true;
const b = false;

console.log(a && b);   // false (OG – begge må være sanne)
console.log(a || b);   // true  (ELLER – minst én må være sann)
console.log(!a);        // false (IKKE – snur verdien)

JavaScript konverterer automatisk mellom typar i nokre situasjonar, noko som blir kalla implisitt typekonvertering (coercion). Dette kan gje overraskande resultat:

console.log("5" + 3);      // "53" (tallet konverteres til streng)
console.log("5" - 3);      // 2   (strengen konverteres til tall)
console.log("5" * "3");    // 15  (begge konverteres til tall)
console.log(true + 1);     // 2   (true konverteres til 1)
console.log(false + 1);    // 1   (false konverteres til 0)

Plussoperatoren (+) er spesiell: når éi side er ein streng, konverterer han den andre sida til streng og set dei saman. For andre operatorar prøver JavaScript å konvertere til tal.

For å unngå forvirring kan du eksplisitt konvertere mellom typar:

// Streng til tall
const tall = Number("42");        // 42
const tall2 = parseInt("42px");   // 42 (ignorerer ikke-numeriske tegn)
const tall3 = parseFloat("3.14"); // 3.14

// Tall til streng
const tekst = String(42);        // "42"
const tekst2 = (42).toString();  // "42"

// Til boolean
const bool = Boolean(0);         // false
const bool2 = Boolean("hei");    // true

Ein array (liste) er ei ordna samling av verdiar. Arrays er ein av dei mest brukte datastrukturane i JavaScript:

const frukter = ["eple", "banan", "appelsin"];
const tall = [1, 2, 3, 4, 5];
const blandet = ["tekst", 42, true, null];

// Hente elementer (indeks starter på 0!)
console.log(frukter[0]);   // "eple"
console.log(frukter[1]);   // "banan"
console.log(frukter[2]);   // "appelsin"
console.log(frukter.length); // 3

// Endre elementer
frukter[1] = "mango";
console.log(frukter);  // ["eple", "mango", "appelsin"]

Nyttige array-metodar

const tall = [3, 1, 4, 1, 5, 9];

// Legge til og fjerne
tall.push(2);            // Legger til 2 bakerst → [3,1,4,1,5,9,2]
tall.pop();              // Fjerner siste element → [3,1,4,1,5,9]
tall.unshift(0);         // Legger til 0 forrest → [0,3,1,4,1,5,9]

// Søke
console.log(tall.includes(4));   // true
console.log(tall.indexOf(1));    // 2 (første forekomst)

// Transformere
const doble = tall.map(t => t * 2);      // Dobler hvert element
const store = tall.filter(t => t > 3);   // Filtrerer ut tall > 3
const sum = tall.reduce((a, b) => a + b, 0); // Summerer alle

// Sortere
tall.sort((a, b) => a - b);  // Sorterer stigende

Eit objekt er ei samling av nøkkel-verdi-par (også kalla eigenskapar). Objekt blir brukte til å gruppere relaterte data:

const elev = {
  fornavn: "Sara",
  etternavn: "Hansen",
  alder: 17,
  klasse: "2ITA",
  erAktiv: true,
};

// Hente verdier
console.log(elev.fornavn);        // "Sara"
console.log(elev["etternavn"]);   // "Hansen"

// Endre verdier
elev.alder = 18;

// Legge til nye egenskaper
elev.epost = "sara@skole.no";

// Slette egenskaper
delete elev.erAktiv;

Objekt kan også innehalde arrays og andre objekt:

const skole = {
  navn: "Nordberg videregående",
  adresse: {
    gate: "Skolegata 1",
    poststed: "Oslo",
  },
  fag: ["IT1", "Matematikk", "Norsk"],
  antallElever: 850,
};

console.log(skole.adresse.gate);   // "Skolegata 1"
console.log(skole.fag[0]);         // "IT1"

Objekt og arrays er fundamentale i JavaScript og blir brukte overalt – frå enkel datalagring til JSON-formatet som blir brukt i nesten all datautveksling på webben.

Oppsummering

I dette kapittelet har du lært:

- Datatypar i JavaScript: number, string, boolean, undefined og null.
- Primitive vs. objekt: enkle verdiar mot samansette strukturar.
- Operatorar: aritmetiske, samanlikning og logiske.
- Forkorta tildeling: +=, -= osv.
- Array- og strengmetodar: nyttige innebygde funksjonar.

Nøkkelomgrep