{"canonical_url":"https://engineer.company/sv/glossary/webassembly/","content_markdown":"# WebAssembly\n\n## Vad det är\n\nWebAssembly, oftast förkortat Wasm, är ett binärt format för körbar kod.\nKärnspecifikationen kallar det ”a safe, portable, low-level code format designed\nfor efficient execution and compact representation” och beskriver det som en\nvirtuell instruktionsuppsättning: instruktionerna för en tänkt processor, som en\nwebbläsare eller en annan värd först kontrollerar och sedan översätter till\nmaskinkod för den verkliga. Kortformen är en sammandragning och inte en akronym,\noch därför skriver specifikationen Wasm och inte WASM.\n\nEn `.wasm`-fil är oftast resultatet av en kompilator för något annat språk.\nHuvudmålet är enligt specifikationen själv snabba program på webben, men\nformatet gör inga antaganden om webben, så det kan också köras som en fristående\nvirtuell maskin eller inuti andra program. Standarden är skiktad därefter:\nkärnspecifikationen definierar instruktionerna, formaten, valideringen och\nexekveringen och ingen särskild miljö. Separata dokument definierar\nJavaScript-API:t, som kompilerar, länkar och anropar moduler, och webb-API:t,\nsom hämtar dem över nätverket.\n\nVersion 1.0 blev en W3C-rekommendation den 5 december 2019. Version 2.0, som i\nallt väsentligt var klar tre år före sin efterföljare, lade till\nvektorinstruktioner, massoperationer på minnet, flera returvärden och enkla\nreferenstyper. Den 17 september 2025 meddelade projektet att version 3.0 nu är\nden gällande standarden och att den redan fanns i de flesta stora webbläsare.\nSamma meddelande nämner Java, OCaml, Scala, Kotlin, Scheme och Dart bland de\nspråk som nu kompileras till Wasm med hjälp av dess skräpsamling.\n\nOrdförrådet är litet. Kodens enhet är en modul: den rymmer funktioner, tabeller,\nminnen och globala variabler, importerar det den behöver, varje import namngiven\nmed ett modulnamn och ett elementnamn, och exporterar det den erbjuder under\negna namn. Det finns fyra taltyper, 32- och 64-bitars heltal och flyttal,\nskrivna `i32`, `i64`, `f32` och `f64`, plus en enda 128-bitars vektortyp och\nogenomskinliga referenser. Heltalen har inget eget tecken; varje operation läser\ndem som antingen med eller utan tecken, och ett 32-bitars heltal fungerar också\nsom booleskt värde. Minnesadresser använder `i32` eller, för ett 64-bitars\nminne, `i64`. Instruktionerna hämtar sina operander\nfrån en implicit stack och lägger tillbaka resultaten på den, och kontrollflödet\när strukturerat: block, loopar och villkor ligger inuti varandra, och ett hopp\nkan bara gå till något av dem.\n\nByteadresserade data ligger i ett linjärt minne, en sammanhängande, skrivbar följd av byte som\nbörjar i en angiven storlek och kan växa medan programmet körs. En läsning eller\nskrivning utanför den aktuella storleken når inget annat. Den utlöser en trap,\nsom stoppar exekveringen omedelbart, och en trap kan inte hanteras inuti Wasm,\nbara rapporteras vidare till värden runt omkring. Exemplet nedan använder det\ntextformat som specifikationen definierar för att människor ska kunna läsa det.\n\n## Varför det spelar roll\n\nHastighet är det första skälet. Designmålen kräver prestanda nära maskinkod\noch ett format som kan avkodas, valideras och kompileras i ett enda snabbt pass,\njust in time eller i förväg. Binärformatet ska vara mindre än typiska text- och\nmaskinkodsformat, och det går att strömma: arbetet kan börja innan den sista\nbyten har kommit fram. Binärformatet håller till och med varje funktions\ntypdeklaration i en annan sektion än dess kropp, så att kropparna kan kompileras\nparallellt och medan de strömmar in. Ett team som redan har ett vältestat\nbibliotek i ett annat språk kan kompilera det för webbläsaren i stället för att\nskriva om det i JavaScript.\n\nPortabilitet är det andra. Samma modul körs på alla moderna arkitekturer, på\ndatorer såväl som mobila enheter, och i varje värd som bäddar in en motor: en\nwebbläsare, en fristående körmiljö eller ett annat program. Specifikationen\ngynnar inget särskilt språk, ingen särskild programmeringsmodell och ingen\nsärskild objektmodell, så formatet är ett gemensamt mål och inte ett enskilt\nspråks privata körmiljö.\n\nAvgränsning är det tredje. En modul har ingen omgivande åtkomst till datorn den\nkörs på. Filer, nätverket, sidan och klockan ligger utom räckhåll om inte värden\nger den en funktion för dem som import, så det är värden som avgör exakt vad\nkoden får röra. På webben påpekar webb-API:t att Wasm kan köras överallt där\nJavaScript kan, har i stort sett samma hotmodell och inte kan exponera mer än\nJavaScript redan kunde. Version 3.0 vidgade vad som ryms innanför den gränsen:\nminnen som adresseras med 64 bitar, på webben begränsade till 16 gigabyte, flera\nminnen i en modul, skräpsamling för språk som förväntar sig det, och undantag\nsom inte längre behöver fly ut till värden, något som meddelandet kallar varken\nportabelt eller effektivt.\n\n## Så ser det ut i praktiken\n\nHär är en modul i textformatet med en enda exporterad funktion som adderar två\n32-bitars heltal:\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 typ säger att den tar två `i32`-värden och returnerar ett. Kroppen\när tre instruktioner på stacken: `local.get 0` lägger på den första parametern,\n`local.get 1` den andra, och `i32.add` tar av båda och lägger på summan, som\nblir liggande som resultatet. `(export \"add\")` ger funktionen det namn som\nomvärlden ser. Översatt till binärformatet börjar filen med de fyra byten\n`0x00 0x61 0x73 0x6D`, en nolla följd av bokstäverna asm, och sedan\nbinärformatets version, som fortfarande är 1.\n\nI en webbläsare läser JavaScript-API:t in den:\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` kompilerar modulen medan svaret fortfarande är på väg och\nlevererar den kompilerade modulen och en instans av den. Instansens exporter är\nvanliga JavaScript-funktioner. Det andra anropet visar vad typerna betyder:\nheltalsaddition i Wasm slår runt modulo 2 upphöjt till 32, och JavaScript-API:t\nläser ett `i32`-resultat som ett tal med tecken, så ett mer än det största\npositiva värdet kommer tillbaka som det mest negativa. Inget kastas. Det gör det\ndäremot vid en trap: läser en funktion utanför sitt minne slutar anropet i ett\n`WebAssembly.RuntimeError`.\n\nEn modul som behöver något från sin värd säger det. Med\n`(import \"env\" \"log\" (func (param i32)))` i modulen behöver instansieringen ett\nandra argument, `{ env: { log: console.log } }`, och modulen kan anropa `log`\nsom en av sina egna funktioner. Utelämna det andra argumentet så misslyckas\ninstansieringen med ett `TypeError`; skicka ett `env`-objekt utan en anropbar\n`log` så misslyckas den med ett `WebAssembly.LinkError`, i båda fallen innan\nnågot av modulens kod har körts. Import och export är hela gränssnittet, med deklarerade typer som omfattar\ntal och referenser; en adress i modulens minne är en `i32`, eller en `i64` för\nett 64-bitars minne.\n\n[En portföljsida om att bygga en native macOS-klient i Swift 6](/sv/portfolio/built-a-native-macos-client-in-swift-6/)\nbeskriver det andra sättet att återanvända kod från ett annat språk. I det\narbetet, som gjordes i augusti 2026, länkades en Rust-kärna in i en Swift-app\nsom ett statiskt arkiv och nåddes genom sitt C-gränssnitt, som sidan behandlar\nsom kontraktet. En tunn wrapper äger varje pekare och varje sträng som korsar\ngränsen, och allt som gränssnittet returnerar har en ägarskapsregel, där ett\nmisstag ger en läcka eller en krasch utan någon kompilatorvarning. Ingen Wasm är\ninblandad där, och det är just det som gör jämförelsen användbar: samma problem\nmed en smal gräns mellan två språk, löst med native-länkning i stället för en\nimportlista och ett minne i en sandlåda.\n\n## Var det går fel\n\n**Promiset avvisas innan något har kompilerats.** En saknad `Content-Type`,\neller något annat värde än `application/wasm` oavsett skiftläge, misslyckas med\nett `TypeError`, och specifikationen påpekar att extra parametrar inte är\ntillåtna, inte ens ett tomt `application/wasm;`. En status som inte är ok\nmisslyckas på samma sätt, och det gör också ett svar från ett annat ursprung när\nCORS inte gör det till samma ursprung. Rätta serverns medietyp och headers.\n`WebAssembly.instantiate` på byte som du själv har hämtat hoppar över kontrollen\nav medietypen men förlorar den strömmade kompileringen.\n\n**En vy av minnet slutar fungera.** JavaScript ser en moduls minne genom\n`memory.buffer` och de arrayer som byggs på den. För minne som inte är delat\nhar bufferten som standard fast längd. När minnet växer kopplar\nJavaScript-API:t loss den bufferten med fast längd och ersätter den med en ny, så\narrayer byggda på den gamla bufferten är avskurna från minnet. Det händer efter\n`memory.grow()` anropat från JavaScript och också efter en\n`memory.grow`-instruktion inuti modulen, under ett anrop som utifrån ser\nharmlöst ut. Skapa vyer från `memory.buffer` på nytt efter varje anrop som kan\nfå minnet att växa, i stället för att behålla en under hela sidans livstid.\n\n**Att vänta sig att Wasm når sidan på egen hand.** En modul har ingen omgivande\nåtkomst till något, så varje effekt på sidan, nätverket eller lagringen går\ngenom en funktion som JavaScript ger den som import. Typerna biter vid samma\ngräns: en `i64` korsar som en `BigInt`, inte som ett tal, och en funktion med en\n`v128`-parameter eller ett `v128`-returvärde kastar ett `TypeError` varje gång\nJavaScript anropar den. Utforma import- och exportlistan som ett gränssnitt med\nenkla tal, och håll vektorerna på Wasm-sidan.\n\n**Att ta sandlådan för ett säkert program.** Sandlådan skyddar värden mot\nmodulen. Den skyddar inte modulen mot sig själv. Specifikationen slår fast att\nden inte kan hindra ett osäkert språk som kompilerats till Wasm från att\nförstöra sin egen minneslayout inuti det linjära minnet: ett\nbuffertöverskridande i kompilerad kod skriver över modulens egna data, och bara\nen åtkomst bortom slutet av hela minnet utlöser en trap. Behåll källspråkets\negna kontroller och tester, och behandla data som modulen tar emot utifrån som\nopålitliga.\n\n**Att skicka ut binärfilen utan att skydda den.** Registreringen av\n`application/wasm` säger att formatet saknar skydd för integritet och sekretess,\noch att sådant skydd, där det behövs, måste komma utifrån, till exempel genom\nHTTPS. Liksom för JavaScript begränsas vissa sätt att läsa in och köra den genom\nsame-origin-policyn eller Content Security Policy. Och eftersom Wasm blir\nmaskinkod på verklig hårdvara varnar kärnspecifikationen för att det kan vara\nsårbart för sidokanalsattacker på hårdvarunivå. Servera moduler över HTTPS, och\nvakta vem som får ändra en modul lika noga som vem som får ändra ett skript.\n\n## Läs mer\n\n- [WebAssembly Specification](https://webassembly.github.io/spec/core/)\n  — kärnspecifikationen för version 3.0: struktur, validering, exekvering och\n  binär- och textformatet.\n- [Introduction](https://webassembly.github.io/spec/core/intro/introduction.html)\n  — definitionen, designmålen, vad varje dokument täcker och\n  säkerhetsövervägandena.\n- [WebAssembly JavaScript Interface](https://webassembly.github.io/spec/js-api/)\n  — kompilering och instansiering från JavaScript, hur värden korsar gränsen,\n  `Memory.grow` och de tre felklasserna.\n- [WebAssembly Web API](https://webassembly.github.io/spec/web-api/)\n  — `instantiateStreaming`, kontrollerna av svaret och registreringen av\n  `application/wasm`.\n- [Wasm 3.0 Completed](https://webassembly.org/news/2025-09-17-wasm-3.0/)\n  — meddelandet från den 17 september 2025 och vad version 3.0 lägger till.\n- [WebAssembly Core Specification 1.0](https://www.w3.org/TR/wasm-core-1/)\n  — W3C-rekommendationen från den 5 december 2019.\n\n\u003chttps://engineer.company/sv/glossary/webassembly/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad Wasm är och hur en modul fungerar: stacken, linjärt minne, import och export, inläsning från JavaScript och var det går fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/webassembly/index.gmi","gopher":"https://engineer.company/sv/glossary/webassembly/gophermap","html":"https://engineer.company/sv/glossary/webassembly/","json":"https://engineer.company/sv/glossary/webassembly/index.json","markdown":"https://engineer.company/sv/glossary/webassembly/index.md","pdf":"https://engineer.company/sv/glossary/webassembly/index.pdf"},"kind":"page","language":"sv","title":"Vad är WebAssembly?","url":"https://engineer.company/sv/glossary/webassembly/","version":1}