{"canonical_url":"https://engineer.company/sv/glossary/go/","content_markdown":"# Go\n\n## Vad det är\n\nGo är ett allmänt programspråk som föddes hos Google, utformat med systemprogrammering i åtanke och\nmed samtidighet inbyggd i själva språket i stället för tillagd som ett bibliotek. Det kallas ofta\ngolang, efter projektets första webbadress, golang.org, men projektets FAQ är bestämd: språket heter\nbara Go, skrivs Go och aldrig GO.\n\nRobert Griesemer, Rob Pike och Ken Thompson började skissa på målen för språket på en\nwhiteboardtavla den 21 september 2007, och Go blev ett offentligt projekt med öppen källkod den 10\nnovember 2009. Go 1 följde den 28 mars 2012, med ett löfte om att program skrivna för den versionen\nskulle fortsätta att kompilera och köra, oförändrade, under varje senare utgåva av Go 1. Löftet\nhåller fortfarande: specifikationen beskriver nu språkversionen go1.27, och Go 1.27.0 släpptes den\n19 augusti 2026. Generiska typer kom i Go 1.18, och språkets konstruktörer kallade dem den största\nförändringen sedan den första utgåvan med öppen källkod.\n\nEnligt FAQ:n växte språket fram ur ett val som upphovsmännen hade tröttnat på att göra, mellan\neffektiv kompilering, effektiv körning och enkel programmering. Go tar sikte på att ge alla tre. Ett\nprogram byggs av paket, och verktygskedjan är ett enda kommando, `go`, som bygger, testar,\nformaterar och hämtar beroenden. Nyckelordet `go` framför ett funktionsanrop startar en goroutine,\nen funktion som körs vid sidan av resten av programmet, och goroutiner är så billiga att\nhundratusentals, enligt FAQ:n, kan dela ett och samma adressrum. Kanaler förmedlar värden mellan\ndem, och [Effective Go](https://go.dev/doc/effective_go) sammanfattar den avsedda stilen i en\nslogan: ”Do not communicate by sharing memory; instead, share memory by communicating.”\n\nTvå vanor känns igen i Go-kod var den än finns. Programmet `gofmt` skriver ut varje källfil i en och\nsamma standardlayout, så formateringen blir aldrig en fråga i kodgranskningen. Kompilatorn vägrar\ndessutom att bygga ett program med en oanvänd variabel eller en oanvänd import, eftersom den första\nkan dölja en bugg och den andra gör varje senare bygge långsammare.\n\n## Varför det spelar roll\n\nFrågan som Go besvarar gäller oftast vad en nätverkstjänst, ett kommandoradsverktyg eller en bit\ninfrastruktur ska skrivas i, och alternativen finns på var sin sida om det: ett skriptspråk på den\nena, C, C++ eller Rust på den andra.\n\nJämfört med ett skriptspråk erbjuder Go enkel driftsättning och tidiga fel. Länkaren bygger statiskt\nlänkade binärer som standard, så resultatet av ett bygge är en enda fil som bär sin egen körmiljö\noch kör på en server där inget annat är installerat. FAQ:n anger priset till ett par megabyte för\nett program som skriver ut ”hello, world”, mot ungefär 750 kB för samma program i C. Kompilatorn\nvisar typfel när programmet byggs och inte när en sällan använd gren körs i produktion, och ett av\nde ursprungliga målen var att även en stor körbar fil skulle byggas på några sekunder på en enda\ndator.\n\nJämfört med C, C++ eller Rust erbjuder Go enkelhet och minnessäkerhet till priset av kontroll. En\nskräpsamlare återtar minnet, så vanlig kod slipper en hel klass av misstag av typen use-after-free,\nmen programmet bestämmer inte exakt när minnet släpps, och varje binär levereras med den körmiljö\nsom gör jobbet. För de flesta servrar är det rätt avvägning. För en systemkärna, en liten inbyggd\nenhet eller en het loop som inte tål en skräpsamlare är det fel avvägning.\n\nDet tystare argumentet är tid. År 2023 skrev Russ Cox att ett Go 2 som bryter gamla program ”is\nnever going to happen” och att projektet i stället skulle ”double down on compatibility”. Löftet\nbetalas med uppgraderingar snarare än omskrivningar. En ny huvudversion släpps var sjätte månad, i\nfebruari och augusti, och var och en får stöd tills två nyare finns, så ett team som vill ha\nsäkerhetsrättningar går vidare ungefär en gång om året.\n\nDet lilla språket kräver också att en del saker skrivs ut i sin helhet. I Go är fel vanliga värden,\nsom returneras och kontrolleras där de uppstår, vilket är lika delar tydligt och upprepande.\n\n## Så ser det ut i praktiken\n\nEn goroutine är billig att starta och lika billig att förlora. Sidan om att flytta långsamt arbete\ntill [en jobbkö i River](/sv/portfolio/moved-slow-work-onto-a-river-job-queue/) säger det rakt\nut: lägger du långsamt arbete i en goroutine försvinner det ”i samma stund som processen startas om,\nvilket den kommer att göra, mitt under en driftsättning, utan några spår av att det någonsin var\ntänkt att ske”. Företaget flyttade arbetet till River, som håller sin kö i PostgreSQL, så att ett\njobb och ”raderna det berör committas eller rullas tillbaka tillsammans”. Bakom kön finns 15\nworkermoduler och 8 schemalagda uppgifter, med 20 jobb i pg_cron under dem. En goroutine ger\nsamtidighet; beständigheten måste komma från något annat håll.\n\nTester ingår i verktygskedjan, och den\n[skiktade testsviten](/sv/portfolio/built-a-test-suite-across-go-sql-and-browser/)\nvisar vad det kan bli. Dess Go-API har 981 testfunktioner fördelade på 310 filer, ett av fyra lager\nvid sidan av frontendens testspecifikationer och databasens egna tester i SQL. Sidan formulerar\nuppgiften så här: ”Varje lager behövde få sitt beteende verifierat där beteendet faktiskt finns, i\nstället för att allt verifierades utifrån genom en webbläsare.”\n\nDet\n[kontinuerliga säkerhetsprogrammet](/sv/portfolio/ran-a-continuous-security-scanning-programme/)\nlutar sig också mot språkets verktyg. Go-beroenden skannas med govulncheck, och en sårbarhet som\nkänns igen av de konfigurerade kontrollerna kan få bygget att misslyckas. Samma sida kallar mängden fynd för den verkliga kostnaden med skanning, och govulncheck är\nkonstruerat mot just den kostnaden: verktyget rapporterar en sårbarhet bara när kodens egna\nfunktioner anropar den berörda funktionen, direkt eller via andra.\n\n## Var det går fel\n\n**En funktion rapporterar ett fel fast allt gick bra.** Ett gränssnittsvärde i Go håller en typ och\nett värde, och det är lika med nil bara när båda saknas. En funktion som returnerar en nil-pekare av\nen konkret feltyp genom gränssnittet `error` ger anroparen ett gränssnitt som håller en typ, och det\ngränssnittet är inte nil:\n\n```go\nfunc save() error {\n    var err *ValidationError // en nil-pekare\n    if invalid() {\n        err = \u0026ValidationError{}\n    }\n    return err // aldrig lika med nil: gränssnittet håller en typ\n}\n```\n\nReturnera ett bokstavligt `nil` när allt gick bra, och deklarera varje felresultat som `error` och\ninte som en konkret typ.\n\n**En tjänst som klarade alla tester kraschar under verklig trafik.** Operationer på en map är\nmedvetet osynkroniserade, eftersom låsning vid varje åtkomst skulle göra de flesta program\nlångsammare, och FAQ:n varnar för att okontrollerad åtkomst till en map kan krascha programmet.\nOrsaken är att en goroutine skriver till en map medan en annan läser eller skriver i den; enbart\nläsningar är säkra. Skydda mapen med en mutex, låt en enda goroutine äga den och de andra nå den via\nen kanal, eller använd `sync.Map` i de fall den är gjord för. Kör sedan testerna med `go test\n-race`. För ett typiskt program kan race-detektorn öka minnesanvändningen fem till tio gånger och\nkörtiden två till tjugo gånger, och den hittar bara datakapplöpningar på kodvägar som faktiskt körs,\nså en binär som byggts med `-race` och körs under realistisk last hittar fler.\n\n**Goroutiner som startas i en loop arbetar alla på det sista elementet.** Före Go 1.22 hade en\n`for`-loop en enda variabel som delades av alla iterationer, så en closure som fångade den såg det\nvärde variabeln råkade ha när goroutinen till slut kördes. Go 1.22 ger varje iteration en egen\nvariabel, men bara i moduler vars go.mod anger `go 1.22` eller senare, och äldre kod behåller sin\ngamla betydelse även när en nyare verktygskedja bygger den. Höj `go`-raden och kör `go vet` och\ntesterna. Ett test som börjar fallera efter ändringen har ofta kontrollerat fel värde hela tiden.\n\n**Ett bygge på en ny maskin stannar för att ladda ned en annan Go.** Sedan Go 1.21 är `go`-raden ett\nkrav, och när den installerade verktygskedjan är äldre än vad en modul begär hämtar kommandot `go`\nden nyare som en modul och kör den från modulcachen. På en laptop är det bekvämt; i ett bygge utan\nnätåtkomst eller med en låst containeravbild är det en överraskning. Installera den verktygskedja\nsom go.mod anger, och sätt miljövariabeln `GOTOOLCHAIN` när ett bygge måste använda en exakt\nversion.\n\n## Läs mer\n\n- [The Go Programming Language Specification](https://go.dev/ref/spec) — referensmanualen för varje\n  konstruktion i språket, versionerad med varje utgåva.\n- [Frequently Asked Questions (FAQ)](https://go.dev/doc/faq) — varför språket skapades,\n  designbesluten bakom det och gåtorna om nil-fel och maps ovan.\n- [Go 1 and the Future of Go Programs](https://go.dev/doc/go1compat) — kompatibilitetslöftet och de\n  undantag det tillåter.\n- [Release History](https://go.dev/doc/devel/release) — varje utgåva sedan Go 1, med stödpolicyn\n  överst.\n- [Data Race Detector](https://go.dev/doc/articles/race_detector) — hur du kör den, vad den fångar\n  och vad den kostar.\n- [Fixing For Loops in Go 1.22](https://go.dev/blog/loopvar-preview) — ändringen av loopvariabeln,\n  varför den är knuten till go.mod och hur du testar gammal kod mot den.\n\n\u003chttps://engineer.company/sv/glossary/go/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad programspråket Go är, när kompatibilitetslöftet och binärer i en enda fil lönar sig och vilka fällor i samtidighet och versioner som drabbar nya team.","formats":{"gemtext":"https://engineer.company/sv/glossary/go/index.gmi","gopher":"https://engineer.company/sv/glossary/go/gophermap","html":"https://engineer.company/sv/glossary/go/","json":"https://engineer.company/sv/glossary/go/index.json","markdown":"https://engineer.company/sv/glossary/go/index.md","pdf":"https://engineer.company/sv/glossary/go/index.pdf"},"kind":"page","language":"sv","title":"Vad är Go?","url":"https://engineer.company/sv/glossary/go/","version":1}