JavaScript: Fundamentet under TypeScript — og hva du bør forstå

TypeScript er det jeg skriver til daglig. Men TypeScript er JavaScript — med typer. Og de delene av JavaScript som TypeScript ikke abstraherer bort, er ofte de som forårsaker de vanskeligste bugsene. Closures, prototype-kjeden, event loopen — dette er ting du må forstå, ikke bare vite om.

Hvorfor JavaScript fremdeles er viktig

TypeScript kompilerer til JavaScript. Koden som kjører i browseren eller i Node.js er JavaScript. Når noe feiler i produksjon, er det JavaScript du debugger. Når du leser en stack trace, er det JavaScript du leser.

Closures. En closure er en funksjon som husker variablene fra scopet der den ble opprettet — selv etter at det ytre scopet er ferdig. Det er grunnlaget for callbacks, React hooks, og det meste av asynkron programmering i JavaScript.

Event loopen. JavaScript er single-threaded. All asynkron kode — setTimeout, fetch, Promise — kjøres via event loopen. Å forstå at en Promise ikke kjører parallelt med resten av koden, men planlegges til neste mikrotask, er essensielt for å unngå subtile race conditions.

Prototype-kjeden. Selv med ES6-klasser er JavaScript prototype-basert under panseret. class er syntaktisk sukker. Å forstå dette hjelper deg å debugge arv-problemer og forstå hvorfor this oppfører seg som det gjør.

Closure og asynkronitet i praksis

Et klassisk eksempel som avslører hvordan closures og event loopen samspiller:

function createTrackers(items) {
  const trackers = [];

  for (const item of items) {
    trackers.push({
      track: () => {
        console.log(`Processing: ${item.name}`);
        return fetch(`/api/track/${item.id}`)
          .then(res => res.json())
          .then(data => ({ ...item, tracked: true, result: data }));
      },
    });
  }

  return trackers;
}

const items = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
const trackers = createTrackers(items);

Promise.all(trackers.map(t => t.track()))
  .then(results => console.log('Done:', results));

Hver track-funksjon er en closure som fanger sin egen item via const i for...of-løkken. Hadde vi brukt var i stedet, ville alle closures delt samme variabel — en klassisk JavaScript-felle. Promise.all kjører alle fetch-kall samtidig via event loopen, men JavaScript-tråden er fremdeles single-threaded. Det er event loopen som håndterer paralleliteten, ikke språket selv.

Oppsummering

Du trenger ikke skrive JavaScript i stedet for TypeScript. Men du trenger å forstå JavaScript for å skrive god TypeScript. Closures, event loopen og prototype-kjeden er ikke historiske kuriositeter — de er mekanismene som kjører koden din hver dag.

Del av en serie: Denne guiden er en del av en samling tekniske innlegg om verktøyene og språkene jeg bruker.