{"canonical_url":"https://engineer.company/sv/glossary/rust/","content_markdown":"# Rust\n\n## Vad det är\n\nRust är ett programspråk för det arbete som traditionellt görs i C och C++, där ett program sköter\nsitt eget minne och ofta länkas in i mjukvara som är skriven i andra språk. Kompilatorn översätter\nkoden till maskinkod i förväg. Version 1.0 tillkännagavs den 15 maj 2015 som ett språk som förenar\nstyrning av prestanda på låg nivå med garantier för säkerhet, nådda utan skräpsamlare eller\nkörmiljö, och det är just det som låter ett bibliotek i Rust ersätta ett i C.\n\nMinnet hanteras genom ägarskap, en uppsättning regler som kompilatorn kontrollerar. Varje värde har\nen enda ägare i taget, och när ägaren går ur scope släpps värdet och dess minne frigörs, vid en\npunkt som bestäms när programmet kompileras snarare än när en skräpsamlare nästa gång tittar efter.\nKod som behöver ett värde utan att ta över det lånar en referens, och lånereglerna tillåter i varje\nögonblick antingen en enda muterbar referens eller hur många oföränderliga som helst, och kräver att\nvarje referens är giltig. Ett program som bryter mot en regel kompileras inte. Samma regler\nutesluter datakapplöpningar, så två trådar som skriver till samma data utan synkronisering är ett\nkompileringsfel snarare än ett fel som dyker upp då och då.\n\nRust saknar undantag. En funktion som kan misslyckas på ett väntat sätt returnerar ett `Result`, som\nrymmer antingen ett värde eller ett fel, och kompilatorn varnar som standard om anroparen lämnar resultatet oanvänt. En bugg som programmet inte kan återhämta sig från, som att läsa förbi\nslutet av en array, går i stället genom makrot `panic!`.\n\nStatisk analys är försiktig, så kompilatorn avvisar en del program som hade fungerat, och visst\narbete, som att styra hårdvara eller anropa ett annat språk, går inte att kontrollera alls. För de\nfallen finns `unsafe`, som låser upp fem extra förmågor, bl.a. att avreferera en rå pekare och att\nanropa en osäker funktion, vilket som standard omfattar varje funktion som deklareras från C. Det\nstänger inte av lånekontrollen, den så kallade borrow checker. Det markerar de rader där\nprogrammeraren, inte kompilatorn, går i god för minnessäkerheten, så säkerheten i dessa operationer beror på att programmeraren upprätthåller deras kontrakt, även i den omgivande säkra koden. Rust-bokens råd är att hålla de blocken små och kapsla in dem i ett\nsäkert gränssnitt, och det är så delar av standardbiblioteket är byggda.\n\nEn ny kompilator släpps var sjätte vecka. Ändringar som skulle bryta befintlig kod väntar på en\nutgåva, en edition, som kommer ungefär vart tredje år. Det finns fyra utgåvor, 2015, 2018, 2021 och\n2024, och den senaste blev stabil den 20 februari 2025 med Rust 1.85.0. Varje programpaket anger sin\nutgåva i `Cargo.toml`, varje kompilator bygger alla utgåvor som kom före den, och programpaket med\nolika utgåvor länkas ihop, så ett projekt går vidare när det självt väljer. Cargo, språkets\nberoendehanterare och byggverktyg, följer med språket, rustfmt håller kodstilen enhetlig, och\nbibliotek från tredje part kommer som programpaket som kallas crates.\n\n## Varför det spelar roll\n\nI C och C++ kompileras en pekare som används efter att dess minne har frigjorts, eller två trådar\nsom skriver samma data, utan klagomål och fallerar senare, sporadiskt och ofta långt från orsaken.\nRust gör sådana program till kompileringsfel, och eftersom kontrollerna körs när programmet byggs\nbetalar det färdiga programmet ingenting för dem.\n\nEftersom Rust varken bär på en skräpsamlare eller en körmiljö kan kod i Rust ligga under mjukvara i\nandra språk. Allt som kan anropa C kan anropa en kärna i Rust genom ett C-gränssnitt, så en enda\nvältestad implementation kan betjäna klienter på flera plattformar. Rust-boken räknar upp\nkommandoradsverktyg, webbtjänster, inbyggda enheter och stora delar av webbläsaren Firefox bland de\nanvändningar som finns i produktion.\n\nKostnaden betalas i förväg. Koden måste formas så att kompilatorn kan se att den är säker, vilket\nofta innebär att bestämma vem som äger ett värde i stället för att skicka runt referenser fritt, och\nboken säger själv att ägarskap tar tid att vänja sig vid. När kompilatorn vägrar ett program som den\ninte kan verifiera är svaret oftast en annan struktur snarare än en väg runt kontrollen.\n\nStabiliteten är den andra halvan av överenskommelsen. Sedan 1.0 är ändringar som bryter befintlig\nkod i stort sett uteslutna, så en ändring som skulle kunna bryta gammal kod kommer bara genom en\nutgåva som ett programpaket självt väljer att gå över till.\n\n## Så ser det ut i praktiken\n\nI portföljen är Rust kärnan under\n[en native meddelandeklient för macOS](/sv/portfolio/built-a-native-macos-client-in-swift-6/):\nden vältestade kärnan i protokollet är skriven i Rust och exponerar ett C-gränssnitt, och klienten,\n11 141 rader Swift i 53 filer, länkar in den som ett statiskt arkiv kompilerat från en fastlåst\nuppströmsrevision. Låsningen spelar roll eftersom C-gränssnittet är kontraktet: en kärna i rörelse\nändrar kontraktet utan att en enda rad Swift ändras. Allt som C-gränssnittet returnerar har en\nägarskapsregel, och ett misstag i någon av dem ger en läcka eller en krasch utan en enda\nkompilatorvarning på vägen, så en tunn wrapper äger varje pekare och varje sträng som korsar\ngränsen, och inget lager ovanför den ser en rå pekare.\n\nAtt länka in den kärnan i en applikation innebär att leverera allt som den är beroende av, och det\när ämnet för\n[en licensgranskning av 644 Rust-crates](/sv/portfolio/know-the-licence-of-everything-you-ship/).\nVarje crate deklarerar sin licens som ett uttryck, och granskningen kontrollerar varje uttryck i\nhela beroendegrafen mot en tillåtelselista vid varje bygge, där OR läses som ett val mellan licenser\noch AND som en skyldighet att följa båda. Allt som inte matchar får bygget att fallera. Eftersom en\nkontroll som aldrig har fallerat ser likadan ut som en som inte kan fallera, fick den fallera med\nflit, två gånger: en gång genom att en crates licens skrevs om till ett villkor som listan avvisar,\noch en gång genom att den fastlåsta kärnrevisionen flyttades utan att granskningen genererades om.\nDen läser bara deklarerade metadata och är ingen juridisk rådgivning.\n\nDen här webbplatsen har ingen egen källkod i Rust. Den möter språket på avstånd, genom Ruff, som är\nskrivet i Rust och kontrollerar varje Python-skript som en commit rör.\n\n## Var det går fel\n\nDet mesta besväret med Rust sitter vid kanterna av det som kompilatorn kontrollerar: aritmetik i ett\noptimerat bygge, gränsen mot ett annat språk och kod som kommer in med ett beroende.\n\n**Aritmetik slår runt i ett releasebygge.** En räknare som fick panik vid ett överspill under\ntestningen blir i tysthet ett litet tal i produktion. I debugbyggen kontrollerar Rust\nheltalsaritmetik efter överspill och får panik. Ett bygge med `--release` utelämnar kontrollen och\nslår runt, så 256 i en `u8` blir 0, och boken betraktar det som ett fel att förlita sig på det\nomslaget. Där ett värde kan spilla över ska beteendet väljas uttryckligen: `checked_*` returnerar\n`None`, `saturating_*` stannar vid gränsen och `wrapping_*` slår runt med avsikt.\n\n```rust\nfn add_stock(on_hand: u8, delivered: u8) -\u003e Option\u003cu8\u003e {\n    // None när summan inte får plats, i debug- och releasebyggen lika\n    on_hand.checked_add(delivered)\n}\n```\n\n**Minnesbuggar kommer tillbaka vid gränsen mot C.** Ett program vars Rust-sida byggs utan en enda\nvarning läcker minne eller kraschar inne i ett främmande anrop. Funktioner som deklareras i ett\nblock med `extern` är osäkra att anropa eftersom det andra språket inte upprätthåller någon av Rusts\nregler, så vem som frigör varje pekare är en konvention som kompilatorn inte kan se. Ge en enda\nwrapper ansvaret för varje pekare och sträng som korsar gränsen, skriv ned varje ägarskapsregel\nbredvid anropet och exponera bara ett säkert gränssnitt ovanför det.\n\n**En panik når C och processen avbryts.** En Rust-funktion som anropas från C får panik, och i\nstället för ett fel stannar hela programmet. Sedan Rust 1.81, som släpptes den 5 september 2024,\navbryter en panik som försöker lämna en funktion deklarerad med det vanliga gränssnittet `\"C\"` hela\nprocessen. Gör fel till returvärden innan de når gränsen, och deklarera en funktion med `\"C-unwind\"`\nbara där koden på andra sidan förväntar sig att stacken rullas upp.\n\n**En rutinmässig uppdatering ändrar licensen för hela bygget.** En versionshöjning tre nivåer ned\ndrar in en crate vars licens produkten inte kan godta, och ingenting i bygget säger ifrån. Varje\ncrate deklarerar sin egen licens, och skyldigheterna läggs ihop över hela grafen. Kontrollera varje\ncrates uttryck mot en tillåtelselista vid varje bygge, låt allt som inte matchar få bygget att\nfallera och bryt kontrollen med flit en gång för att bevisa att den slår till.\n\n## Läs mer\n\n- [The Rust Programming Language](https://doc.rust-lang.org/book/)\n  — den officiella boken, från installation via ägarskap och felhantering till osäker kod.\n- [What Is Ownership?](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html)\n  — de tre reglerna för ägarskap och hur minnet frigörs utan en skräpsamlare.\n- [Unsafe Rust](https://doc.rust-lang.org/book/ch20-01-unsafe-rust.html)\n  — de fem osäkra förmågorna, råa pekare och att anropa C genom `extern`.\n- [The Manifest Format](https://doc.rust-lang.org/cargo/reference/manifest.html)\n  — fälten `edition`, `rust-version` och `license` i `Cargo.toml`.\n- [Announcing Rust 1.0](https://blog.rust-lang.org/2015/05/15/Rust-1.0/)\n  — de ursprungliga målen och det stabilitetslöfte som började med 1.0.\n\n\u003chttps://engineer.company/sv/glossary/rust/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Rust för dig som skriver systemnära kod: ägarskap i stället för skräpsamlare, utgåvor som låter språket ändras säkert och var garantierna tar slut vid C.","formats":{"gemtext":"https://engineer.company/sv/glossary/rust/index.gmi","gopher":"https://engineer.company/sv/glossary/rust/gophermap","html":"https://engineer.company/sv/glossary/rust/","json":"https://engineer.company/sv/glossary/rust/index.json","markdown":"https://engineer.company/sv/glossary/rust/index.md","pdf":"https://engineer.company/sv/glossary/rust/index.pdf"},"kind":"page","language":"sv","title":"Vad är Rust?","url":"https://engineer.company/sv/glossary/rust/","version":1}