{"canonical_url":"https://engineer.company/da/glossary/webassembly/","content_markdown":"# WebAssembly\n\n## Hvad det er\n\nWebAssembly, som regel forkortet til Wasm, er et binært format til kørbar kode.\nKernespecifikationen kalder det »a safe, portable, low-level code format\ndesigned for efficient execution and compact representation« og beskriver det\nsom et virtuelt instruktionssæt: instruktionerne til en tænkt processor, som en\nbrowser eller en anden vært først kontrollerer og derefter oversætter til\nmaskinkode til den rigtige. Den korte form er en sammentrækning og ikke et\nakronym, og derfor skriver specifikationen Wasm og ikke WASM.\n\nEn `.wasm`-fil er som regel resultatet af en oversætter til et andet sprog.\nHovedmålet er ifølge specifikationen selv hurtige programmer på nettet, men\nformatet gør ingen antagelser om nettet, så det kan også køre som en selvstændig\nvirtuel maskine eller inde i andre programmer. Standarden er lagdelt derefter:\nkernespecifikationen definerer instruktionerne, formaterne, valideringen og\nafviklingen og intet bestemt miljø. Særskilte dokumenter definerer\nJavaScript-API'et, der oversætter, sammenkæder og kalder moduler, og web-API'et,\nder henter dem over netværket.\n\nDen første version blev en W3C-anbefaling 5. december 2019. Version 2.0, der i\ndet væsentlige var færdig tre år før sin efterfølger, tilføjede\nvektorinstruktioner, masseoperationer på hukommelsen, flere returværdier og\nenkle referencetyper. Den 17. september 2025 meddelte projektet, at version 3.0\nnu er den gældende standard, og at den allerede var med i de fleste store\nbrowsere. Samme meddelelse nævner Java, OCaml, Scala, Kotlin, Scheme og Dart\nblandt de sprog, der nu oversættes til Wasm ved hjælp af dets garbage collector.\n\nOrdforrådet er lille. Kodens enhed er et modul: det rummer funktioner, tabeller,\nhukommelser og globale variabler, importerer det, det har brug for, hver import\nnavngivet med et modulnavn og et elementnavn, og eksporterer det, det tilbyder,\nunder sine egne navne. Der er fire taltyper, 32- og 64-bit heltal og kommatal,\nskrevet `i32`, `i64`, `f32` og `f64`, plus en enkelt 128-bit vektortype og\nuigennemsigtige referencer. Heltallene har intet fortegn i sig selv; hver\noperation læser dem som enten med eller uden fortegn, og et 32-bit heltal tjener\nogså som boolsk værdi. Hukommelsesadresser bruger `i32` eller, for en\n64-bit hukommelse, `i64`. Instruktionerne tager deres\noperander fra en implicit stak og lægger resultaterne tilbage på den, og\nkontrolflowet er struktureret: blokke, løkker og betingelser ligger inden i\nhinanden, og et spring kan kun gå til en af dem.\n\nByteadresserede data ligger i en lineær hukommelse, et sammenhængende, skrivbart array af bytes,\nsom starter i en erklæret størrelse og kan vokse, mens programmet kører. En\nlæsning eller skrivning uden for den aktuelle størrelse når ikke noget andet.\nDen udløser en trap, der stopper afviklingen med det samme, og en trap kan ikke\nhåndteres inde i Wasm, kun meldes videre til værten omkring det. Eksemplet\nnedenfor bruger det tekstformat, som specifikationen definerer, for at mennesker\nkan læse det.\n\n## Hvorfor det betyder noget\n\nHastighed er den første grund. Designmålene kræver en ydelse tæt på native kode\nog et format, der kan afkodes, valideres og oversættes i ét hurtigt gennemløb,\njust in time eller på forhånd. Binærformatet skal være mindre end typiske tekst-\nog maskinkodeformater, og det kan streames: arbejdet kan begynde, før den sidste\nbyte er ankommet. Binærformatet holder endda hver funktions typeerklæring i en\nanden sektion end dens krop, så kroppene kan oversættes parallelt og mens de\nstrømmer ind. Et team, der allerede har et velafprøvet bibliotek i et andet\nsprog, kan oversætte det til browseren i stedet for at skrive det om i\nJavaScript.\n\nPortabilitet er den anden. Det samme modul kører på alle moderne arkitekturer,\npå computere såvel som mobile enheder, og i enhver vært, der indlejrer en motor:\nen browser, et selvstændigt runtime-miljø eller et andet program.\nSpecifikationen favoriserer intet bestemt sprog, ingen bestemt\nprogrammeringsmodel og ingen bestemt objektmodel, så formatet er et fælles mål\nog ikke ét sprogs private runtime.\n\nAfgrænsning er den tredje. Et modul har ingen omgivende adgang til den computer,\ndet kører på. Filer, netværket, siden og uret er uden for rækkevidde, medmindre\nværten giver det en funktion til dem som import, så det er værten, der bestemmer\npræcis, hvad koden må røre. På nettet bemærker web-API'et, at Wasm kan køre\noveralt, hvor JavaScript kan, har i det væsentlige samme trusselsmodel og ikke\nkan afsløre mere, end JavaScript allerede kunne. Version 3.0 udvidede, hvad der\nkan ligge inden for den grænse: hukommelser, der adresseres med 64 bit, på\nnettet begrænset til 16 gigabyte, flere hukommelser i ét modul, en garbage\ncollector til sprog, der forventer en, og undtagelser, der ikke længere skal\nflygte ud til værten, hvad meddelelsen kalder hverken portabelt eller effektivt.\n\n## Sådan ser det ud i praksis\n\nHer er et modul i tekstformatet med en enkelt eksporteret funktion, der lægger\nto 32-bit heltal sammen:\n\n```wat\n(module\n  (func (export \"add\") (param i32 i32) (result i32)\n    local.get 0\n    local.get 1\n    i32.add))\n```\n\nFunktionens type siger, at den tager to `i32`-værdier og returnerer én. Kroppen\ner tre instruktioner på stakken: `local.get 0` lægger den første parameter på,\n`local.get 1` den anden, og `i32.add` tager begge af og lægger deres sum på,\nhvor den bliver liggende som resultatet. `(export \"add\")` giver funktionen det\nnavn, omverdenen ser. Oversat til binærformatet begynder filen med de fire bytes\n`0x00 0x61 0x73 0x6D`, et nul efterfulgt af bogstaverne asm, og derefter\nbinærformatets version, som stadig er 1.\n\nI en browser indlæser JavaScript-API'et det:\n\n```js\nconst url = \"/add.wasm\";\nconst { instance } = await WebAssembly.instantiateStreaming(fetch(url));\ninstance.exports.add(2, 3); // 5\ninstance.exports.add(2147483647, 1); // -2147483648\n```\n\n`instantiateStreaming` oversætter modulet, mens svaret stadig er på vej, og\nleverer det oversatte modul og en instans af det. Instansens eksporter er\nalmindelige JavaScript-funktioner. Det andet kald viser, hvad typerne betyder:\nheltalsaddition i Wasm løber rundt modulo 2 i 32. potens, og JavaScript-API'et\nlæser et `i32`-resultat som et tal med fortegn, så én mere end den største\npositive værdi kommer tilbage som den mest negative. Der bliver ikke kastet\nnoget. Det gør der til gengæld ved en trap: læser en funktion uden for sin\nhukommelse, ender kaldet i en `WebAssembly.RuntimeError`.\n\nEt modul, der har brug for noget fra sin vært, siger det. Med\n`(import \"env\" \"log\" (func (param i32)))` i modulet skal instansieringen have et\nandet argument, `{ env: { log: console.log } }`, og modulet kan kalde `log` som\nen af sine egne funktioner. Udelad det andet argument, og instansieringen fejler\nmed en `TypeError`; giv et `env`-objekt uden en kaldbar `log`, og den fejler med\nen `WebAssembly.LinkError`, i begge tilfælde før noget af modulets kode har\nkørt. Import og eksport er hele grænsefladen, med erklærede typer, der omfatter tal\nog referencer; en adresse i modulets hukommelse er en `i32` eller en `i64` for\nen 64-bit hukommelse.\n\n[En porteføljeside om at bygge en native macOS-klient i Swift 6](/da/portfolio/built-a-native-macos-client-in-swift-6/)\nbeskriver den anden måde at genbruge kode fra et andet sprog på. I det arbejde,\nder blev udført i august 2026, blev en Rust-kerne linket ind i et Swift-program\nsom et statisk arkiv og nået gennem sin C-grænseflade, som siden behandler som\nkontrakten. En tynd indpakning ejer hver pointer og hver streng, der krydser\ngrænsen, og alt, hvad grænsefladen returnerer, har en ejerskabsregel, hvor en\nfejl giver en lækage eller et nedbrud uden nogen advarsel fra oversætteren. Der\ner ingen Wasm i spil dér, og det er netop det, der gør sammenligningen nyttig:\ndet samme problem med en smal grænse mellem to sprog, løst med native linkning i\nstedet for en importliste og en hukommelse i en sandkasse.\n\n## Hvor det går galt\n\n**Promiset afvises, før noget bliver oversat.** En manglende `Content-Type`\neller en hvilken som helst anden værdi end `application/wasm`, uanset store og\nsmå bogstaver, fejler med en `TypeError`, og specifikationen bemærker, at ekstra\nparametre ikke er tilladt, heller ikke et tomt `application/wasm;`. En status,\nder ikke er ok, fejler på samme måde, og det gør et svar fra en anden oprindelse\nogså, når CORS ikke gør det til samme oprindelse. Ret serverens medietype og\nheaders. `WebAssembly.instantiate` på bytes, man selv har hentet, springer\nkontrollen af medietypen over, men mister den streamede oversættelse.\n\n**En visning af hukommelsen går død.** JavaScript ser et moduls hukommelse\ngennem `memory.buffer` og de arrays, der er bygget oven på den. For ikke-delt\nhukommelse har bufferen som standard fast længde. Når hukommelsen vokser,\nfrakobler JavaScript-API'et den buffer med fast længde og erstatter den\nmed en ny, så arrays bygget på den gamle buffer er skåret fra hukommelsen. Det\nsker efter `memory.grow()` kaldt fra JavaScript og også efter en\n`memory.grow`-instruktion inde i modulet, under et kald, der udefra ser harmløst\nud. Opret visninger fra `memory.buffer` igen efter hvert kald, der kan få\nhukommelsen til at vokse, i stedet for at beholde én, så længe siden lever.\n\n**At forvente, at Wasm selv når ud til siden.** Et modul har ingen omgivende\nadgang til noget, så enhver virkning på siden, netværket eller lageret går\ngennem en funktion, som JavaScript giver det som import. Typerne bider ved den\nsamme grænse: en `i64` krydser som en `BigInt`, ikke som et tal, og en funktion\nmed en `v128`-parameter eller -returværdi kaster en `TypeError`, hver gang\nJavaScript kalder den. Design import- og eksportlisten som en grænseflade med\nenkle tal på, og hold vektorerne på Wasm-siden.\n\n**At tage sandkassen for et sikkert program.** Sandkassen beskytter værten mod\nmodulet. Den beskytter ikke modulet mod sig selv. Specifikationen fastslår, at\nden ikke kan forhindre et usikkert sprog oversat til Wasm i at ødelægge sit eget\nhukommelseslayout inde i den lineære hukommelse: et bufferoverløb i oversat kode\noverskriver modulets egne data, og kun en adgang ud over enden af hele\nhukommelsen udløser en trap. Behold kildesprogets egne kontroller og tests, og\nbehandl data, som modulet modtager udefra, som upålidelige.\n\n**At sende binærfilen ud uden at beskytte den.** Registreringen af\n`application/wasm` siger, at formatet ikke indeholder nogen beskyttelse af\nintegritet eller fortrolighed, og at den, hvor den er nødvendig, må komme\nudefra, for eksempel gennem HTTPS. Som med JavaScript er nogle måder at indlæse\nog køre den på begrænset gennem same-origin-politikken eller Content Security\nPolicy. Og fordi Wasm bliver til maskinkode på rigtig hardware, advarer\nkernespecifikationen om, at det potentielt er sårbart over for sidekanalangreb\npå hardwareniveau. Server moduler over HTTPS, og vogt over, hvem der må ændre et\nmodul, lige så nøje som over, hvem der må ændre et script.\n\n## Læs mere\n\n- [WebAssembly Specification](https://webassembly.github.io/spec/core/)\n  — kernespecifikationen for version 3.0: struktur, validering, afvikling og\n  binær- og tekstformatet.\n- [Introduction](https://webassembly.github.io/spec/core/intro/introduction.html)\n  — definitionen, designmålene, hvad hvert dokument dækker, og\n  sikkerhedsovervejelserne.\n- [WebAssembly JavaScript Interface](https://webassembly.github.io/spec/js-api/)\n  — oversættelse og instansiering fra JavaScript, hvordan værdier krydser\n  grænsen, `Memory.grow` og de tre fejlklasser.\n- [WebAssembly Web API](https://webassembly.github.io/spec/web-api/)\n  — `instantiateStreaming`, kontrollerne af svaret og registreringen af\n  `application/wasm`.\n- [Wasm 3.0 Completed](https://webassembly.org/news/2025-09-17-wasm-3.0/)\n  — meddelelsen fra 17. september 2025 og det, version 3.0 tilføjer.\n- [WebAssembly Core Specification 1.0](https://www.w3.org/TR/wasm-core-1/)\n  — W3C-anbefalingen fra 5. december 2019.\n\n\u003chttps://engineer.company/da/glossary/webassembly/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvad Wasm er, og hvordan et modul fungerer: stakken, lineær hukommelse, import og eksport, indlæsning fra JavaScript, og hvor det går galt.","formats":{"gemtext":"https://engineer.company/da/glossary/webassembly/index.gmi","gopher":"https://engineer.company/da/glossary/webassembly/gophermap","html":"https://engineer.company/da/glossary/webassembly/","json":"https://engineer.company/da/glossary/webassembly/index.json","markdown":"https://engineer.company/da/glossary/webassembly/index.md","pdf":"https://engineer.company/da/glossary/webassembly/index.pdf"},"kind":"page","language":"da","title":"Hvad er WebAssembly?","url":"https://engineer.company/da/glossary/webassembly/","version":1}