{"canonical_url":"https://engineer.company/sv/glossary/semantic-versioning/","content_markdown":"# Semantisk versionering\n\n## Vad det är\n\nSemantisk versionering, på engelska semantic versioning och oftast förkortat\nSemVer, är en uppsättning regler för hur releaser numreras, så att själva numret\nberättar vilken sorts ändring en release innehåller. I specifikationens svenska\növersättning kallas det semantisk versionshantering. Specifikationen, som nu är\ni version 2.0.0 och ursprungligen skrevs av Tom Preston-Werner, använder tre tal\npå formen MAJOR.MINOR.PATCH. En release som bryter det publika API:t höjer\nmajor-versionen, en som lägger till funktionalitet på ett bakåtkompatibelt sätt\nhöjer minor-versionen, och en som bara rättar buggar utan att röra API:t höjer\npatch-versionen. När ett tal höjs, nollställs talen till höger om det, och varje\ntal jämförs som ett tal och inte som text, så `1.10.0` kommer efter `1.9.0`.\n\nAllt vilar på ett krav: projektet måste deklarera ett publikt API, i koden eller\ni dokumentationen, eftersom talen beskriver ändringar i just det API:t och inget\nannat. När en version väl är släppt, får dess innehåll inte ändras; en rättelse\när en ny version. Major-version noll, `0.y.z`, är till för den inledande\nutvecklingen, där vad som helst kan ändras när som helst och API:t inte ska\nbetraktas som stabilt. Version `1.0.0` är den punkt där det publika API:t\ndefinieras, och därifrån följer talen hur det ändras.\n\nTvå valfria tillägg utökar formatet. En förhandsversion (pre-release) skrivs\nefter ett bindestreck och sorteras före den release den leder fram till, så\n`1.0.0-alpha` kommer före `1.0.0-alpha.1`, som i sin tur kommer före\n`1.0.0-beta`, `1.0.0-rc.1` och till sist `1.0.0`. Byggmetadata skrivs efter ett\nplustecken, som i `1.0.0+20130313144700`, och ignoreras när versioner sorteras,\nså två versioner som bara skiljer sig där har samma prioritet. Ett inledande v,\nsom i Git-taggen `v1.2.3`, är inte en del av den semantiska versionen;\nspecifikationen kallar det ett vanligt sätt att visa att det rör sig om ett\nversionsnummer. Go gör det till ett krav: en kanonisk version av en Go-modul är\nbokstaven v följd av en semantisk version.\n\n## Varför det spelar roll\n\nSpecifikationen utgår från det den kallar beroendeträsket (dependency hell).\nAnger du beroenden för snävt, hamnar du i versionslås, där en uppgradering av\nett paket kräver nya versioner av allt som är beroende av det. Anger du dem för\nlöst, hamnar du i versionsnaivitet: du antar kompatibilitet med fler framtida\nversioner än vad som är rimligt. Ett versionsnummer med en överenskommen\nbetydelse låter ett projekt säga vad det accepterar: ett bibliotek som behöver\nen funktion som tillkom i 3.1.0 kan acceptera allt från 3.1.0 upp till, men inte\nmed, 4.0.0, och få senare rättelser och tillägg utan att någon redigerar kravet.\n\nPakethanterare agerar på det löftet utan att fråga. I Cargo, pakethanteraren för\nRust, är ett vanligt krav som `\"1.2.3\"` ett caret-krav och betyder minst 1.2.3\nmen under 2.0.0. När Cargo skriver `Cargo.lock`, väljer det den högsta versionen\ninom det intervallet, och det stannar på 1.x även efter att 2.0.0 har\npublicerats, eftersom det betraktar 2.0.0 som inkompatibel. I node-semver, som\nbeskriver sig som verktyget för semantisk versionering i npm, betyder `^1.2.3`\ndetsamma som `\u003e=1.2.3 \u003c2.0.0-0`, och `~1.2.3` tillåter bara ändringar på\npatch-nivå, `\u003e=1.2.3 \u003c1.3.0-0`. Go bygger in regeln i importsökvägarna: från\nmajor-version 2 och uppåt måste en moduls sökväg sluta med ett suffix som `/v2`,\nså två inkompatibla major-versioner blir två olika importsökvägar. Minimal\nversion selection i Go tar sedan, för varje modul, den högsta version som något\nkrav begär, och det är den lägsta version som uppfyller alla krav. Resultatet\nsparas inte i någon låsfil; varje kommando som arbetar med moduler räknar fram\ndet på nytt.\n\nInget av detta gör numret till en garanti. Det är ett löfte från dem som\npublicerar paketet, och det är aldrig bättre än deras bedömning av vad som\nräknas som brytande. Därför publicerar Cargo en lång kompatibilitetsguide som\nsorterar ändringar i major, minor och möjligen brytande (possibly-breaking). Det\nmesta i guiden handlar om ändringar som gör att kod som kompilerade i går inte\nkompilerar i dag. Guiden påpekar själv att nästan varje ändring medför en viss\nrisk för beteendet vid körning och att frågan om en sådan ändring är\ninkompatibel oftast avgörs efter underhållarnas eget omdöme.\n\n## Så ser det ut i praktiken\n\nFölj ett påhittat Rust-bibliotek, tally, genom dess releaser. Version 0.4.2 är\nfortfarande inledande utveckling. Version 1.0.0 förklarar det publika API:t\nstabilt. Version 1.0.1 rättar ett avrundningsfel och är en patch. Version 1.1.0\nlägger till en funktion, `parse_strict`, och markerar den gamla `parse` som\nföråldrad (deprecated): specifikationen kräver en minor-release för det och ber\nom minst en sådan release innan funktionen tas bort. Version 2.0.0 tar bort\n`parse` och är en major-release. Version 2.1.0-rc.1 är en förhandsversion av\nnästa minor-version.\n\nEn applikation som är beroende av tally och tre andra påhittade crates anger\nsina krav i `Cargo.toml`. Kommentarerna visar det intervall som Cargo läser ut\nur varje rad:\n\n```toml\n[dependencies]\ntally = \"1.0.1\"         # \u003e=1.0.1, \u003c2.0.0: takes 1.1.0, never 2.0.0\nledger = \"0.4.2\"        # \u003e=0.4.2, \u003c0.5.0: 0.5.0 counts as breaking\nstamp = \"~1.2.3\"        # \u003e=1.2.3, \u003c1.3.0: patch releases only\nquill = \"=2.1.0-rc.1\"   # exactly this pre-release\n```\n\nRaden för `ledger` visar en konvention i verktygen och inte i specifikationen:\nför Cargo är det första talet från vänster som inte är noll det som signalerar\nbrott, medan specifikationen säger att allt under 1.0.0 kan ändras när som\nhelst. Cargo håller förhandsversioner utanför ett krav om inte kravet nämner en,\nså ett krav på `\"2.0\"` skulle aldrig plocka upp releasekandidaten för tally. Den\nexakta `=`-formen på sista raden är det fall där Cargos dokumentation säger att\nett fullständigt angivet krav kan vara motiverat: att vara beroende av en\nförhandsversion och samtidigt undvika brytande ändringar mellan\nförhandsversioner. När versionerna har valts, registreras de i `Cargo.lock`,\noch `cargo update` flyttar dem inom de här intervallen. Med `--locked`\nreturnerar ett bygge som skulle behöva ändra låsfilen ett fel i stället.\n\nDet numret inte täcker är allt utanför API:t.\n[Licensgranskningen av 644 Rust-crates](/sv/portfolio/know-the-licence-of-everything-you-ship/),\nutförd i september 2026, kontrollerar licensen för varje crate vid varje bygge\nmot en lista över villkor som projektet godtar, eftersom en rutinmässig\nversionshöjning djupt ned i beroendegrafen i tysthet kan ändra under vilka\nvillkor en applikation får distribueras, i en låsfil som ingen läser rad för\nrad. För att bevisa att kontrollen fungerar, fick den fallera med flit, två\ngånger. Den ena gången skrevs en crates licensuttryck om, så som det ser ut när\nen crate ändrar sina villkor uppströms mellan versioner, något som ingen\nmänsklig granskning fångar, eftersom craten i sig inte är ny. Den andra gången\nflyttades den fastlåsta kärnrevisionen utan att licensgranskningen genererades\nom. En semantisk version kan berätta att 1.4.0 är tänkt att fungera med kod\nskriven mot 1.0.0. Den kan inte berätta om du fortfarande får leverera den.\n\n## Var det går fel\n\n**En brytande ändring i en minor-release.** Det händer av misstag eller för att\nman ser olika på vad som är brytande. Cargos guide räknar upp ändringar som ser\nharmlösa ut men inte är det: att lägga till en variant i en publik enum bryter\nkod som matchar uttömmande på den, om inte enumen märktes `#[non_exhaustive]`\nfrån början, och i sällsynta fall med glob-importer orsakar till och med ett\nnytt publikt element ett kompileringsfel. Specifikationens svar, när misstaget\nväl har upptäckts, är att släppa en ny minor-version som återställer\nkompatibiliteten, aldrig att ändra den redan publicerade releasen, och att tala\nom för användarna vilken version som var fel. På den konsumerande sidan är det\nen låsfil som är incheckad i repot och tester som körs vid varje uppdatering som\nfångar felet innan det når produktion.\n\n**Att bli kvar på 0.x i åratal.** Enligt specifikationen har major-version noll\ninget stabilt API alls. Dess FAQ säger det rakt ut: används mjukvaran redan i\nproduktion, borde den med största sannolikhet redan ha version 1.0.0. Verktygen\nfyller tomrummet med en egen konvention: Cargo och node-semver behandlar det\nförsta talet från vänster som inte är noll som det brytande, så `^0.2.3`\naccepterar bara fler 0.2.x-releaser och `^0.0.3` accepterar inga uppdateringar\nalls. Ett bibliotek som har stått på 0.x i åratal har användare som är beroende\nav det men inget definierat löfte till dem. Släpp 1.0.0 när folk väl förlitar\nsig på API:t; det ändrar ett nummer, inte koden.\n\n**Att läsa in mer i numret än det säger.** Kompatibilitet enligt specifikationen\nhandlar om det publika API:t. Cargos guide klassar en höjning av den lägsta\nRust-version som en crate kräver som möjligen brytande och rekommenderar i\nallmänhet att den behandlas som en minor-ändring, så en minor-uppdatering kan\nstoppa bygget på en äldre verktygskedja. När `package.rust-version` är satt, kan\nCargos beroendeupplösare pröva äldre versioner av craten vid behov.\nLicensvillkor, prestanda och beteende som API:t aldrig har dokumenterat ligger\nhelt utanför numret. Kontrollera dem separat, med en licensgranskning och\ntester, i stället för att sluta dig till dem utifrån en minor-release.\n\n**Två major-versioner i ett bygge.** När två beroenden behöver inkompatibla\nversioner av samma crate, till exempel 0.6 och 0.7, bygger Cargo båda.\nKompilatorn behandlar deras typer som olika, även när namnen är desamma. Oftast\nvisar det sig som ett kompileringsfel och ibland först vid körning: Cargos\ndokumentation beskriver en downcast som misslyckas eftersom objektet skapades av\nett bibliotek som använde version 1.0.0, medan den anropande koden försöker göra\nen downcast till typen från 2.0.0. Kommandot `cargo tree -d` listar dubblerade\nversioner och var de kommer ifrån. En biblioteksförfattare kan mildra en\nmajor-release med det som Cargos dokumentation kallar ”the semver trick”:\npublicera den nya major-versionen och sedan en punktrelease av den gamla som\nåterexporterar typerna från den nya.\n\n## Läs mer\n\n- [Semantic Versioning 2.0.0](https://semver.org/) — specifikationen och dess\n  FAQ, bland annat om vad man gör efter att av misstag ha släppt en brytande\n  ändring. Finns även i svensk översättning.\n- [SemVer Compatibility](https://doc.rust-lang.org/cargo/reference/semver.html)\n  — Cargo-bokens guide till vilka ändringar i ett Rust-bibliotek som är major,\n  minor eller möjligen brytande, var och en med ett exempel.\n- [Specifying Dependencies](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html)\n  — Cargos kravsyntax: standard-, caret-, tilde- och jämförelsekrav, och hur\n  förhandsversioner matchas.\n- [Dependency Resolution](https://doc.rust-lang.org/cargo/reference/resolver.html)\n  — hur Cargo väljer versioner, vad låsfilen innehåller och riskerna med två\n  inkompatibla versioner i en graf.\n- [node-semver](https://github.com/npm/node-semver) — npm:s verktyg för\n  semantisk versionering, med reglerna för caret, tilde och intervall med\n  förhandsversioner.\n- [Go Modules Reference](https://go.dev/ref/mod) — suffix för major-versioner,\n  regeln för importkompatibilitet och minimal version selection.\n\n\u003chttps://engineer.company/sv/glossary/semantic-versioning/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad MAJOR.MINOR.PATCH lovar, hur Cargo, npm och Go agerar på det och vad ett versionsnummer inte kan berätta.","formats":{"gemtext":"https://engineer.company/sv/glossary/semantic-versioning/index.gmi","gopher":"https://engineer.company/sv/glossary/semantic-versioning/gophermap","html":"https://engineer.company/sv/glossary/semantic-versioning/","json":"https://engineer.company/sv/glossary/semantic-versioning/index.json","markdown":"https://engineer.company/sv/glossary/semantic-versioning/index.md","pdf":"https://engineer.company/sv/glossary/semantic-versioning/index.pdf"},"kind":"page","language":"sv","title":"Vad är semantisk versionering?","url":"https://engineer.company/sv/glossary/semantic-versioning/","version":1}