5.2 Variabler, datatyper og operatorer i JavaScript

Variabler, datatyper og operatorer i JavaScript

I forrige kapittel ble du kjent med variabler og enkel bruk av JavaScript. Nå skal vi gå dypere inn i datatypene som JavaScript tilbyr, forstå hvordan typesystemet fungerer, og mestre de ulike operatorene for beregninger, sammenligninger og logikk.

En solid forståelse av datatyper er avgjørende for å skrive korrekt og forutsigbar kode. JavaScript er et dynamisk typet språk, noe som betyr at du ikke deklarerer hvilken type en variabel skal inneholde – typen bestemmes automatisk av verdien du tilordner. Dette gir fleksibilitet, men kan også føre til overraskende resultater hvis du ikke forstår hvordan typesystemet fungerer.

JavaScript har syv primitive datatyper. De tre viktigste for daglig programmering er:

Number – tall

Alle tall i JavaScript er av typen number, enten det er heltall eller desimaltall:

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 noen spesielle tallverdier:

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

Strenger representerer tekst og omsluttes av anførselstegn:

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 de støtter 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 verdier er enten true eller false:

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

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

JavaScript har to spesielle verdier for «ingenting»:

undefined

undefined betyr at en variabel er deklarert men ikke har fått en verdi:

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

null

null representerer et bevisst fravær av verdi – du bruker det for å si «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!)

Forskjellen i praksis er at undefined betyr «verdien er ikke satt ennå», mens null betyr «verdien er bevisst satt til ingenting».

JavaScript har de vanlige regneoperatorene:

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)

Forkortet tilordning

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

Sammenligningsoperatorer

Sammenligningsoperatorer 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 likhetstegn) for sammenligning, aldri == (dobbel likhetstegn). Dobbel likhet utfører automatisk typekonvertering som kan gi uventede resultater:

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 operatorer

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 typer i noen situasjoner, noe som kalles implisitt typekonvertering (coercion). Dette kan gi overraskende resultater:

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 én side er en streng, konverterer den den andre siden til streng og setter dem sammen. For andre operatorer prøver JavaScript å konvertere til tall.

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

// 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

En array (liste) er en ordnet samling av verdier. Arrays er en av de mest brukte datastrukturene 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-metoder

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

Et objekt er en samling av nøkkel-verdi-par (også kalt egenskaper). Objekter brukes 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;

Objekter kan også inneholde arrays og andre objekter:

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"

Objekter og arrays er fundamentale i JavaScript og brukes overalt – fra enkel datalagring til JSON-formatet som brukes i nesten all datautveksling på webben.

Oppsummering

I dette kapittelet har du lært:

- Datatyper i JavaScript: number, string, boolean, undefined og null.
- Primitive vs. objekter: enkle verdier mot sammensatte strukturer.
- Operatorer: aritmetiske, sammenligning og logiske.
- Forkortet tilordning: +=, -= osv.
- Array- og strengmetoder: nyttige innebygde funksjoner.

Noekkelbegreper