{"canonical_url":"https://engineer.company/da/glossary/go/","content_markdown":"# Go\n\n## Hvad det er\n\nGo er et generelt programmeringssprog, der begyndte hos Google, udformet med systemprogrammering for\nøje og med samtidighed bygget ind i selve sproget i stedet for lagt ovenpå som et bibliotek. Det\nkaldes ofte golang efter projektets første webadresse, golang.org, men projektets FAQ holder fast i,\nat sproget bare hedder Go, skrevet Go og aldrig GO.\n\nRobert Griesemer, Rob Pike og Ken Thompson begyndte at skitsere målene på et whiteboard den 21.\nseptember 2007, og Go blev et offentligt open source-projekt den 10. november 2009. Go 1 kom den 28.\nmarts 2012 med et løfte om, at programmer skrevet til den ville blive ved med at kompilere og køre,\nuændret, under hver senere Go 1-udgave. Løftet holder stadig: specifikationen beskriver i dag\nsprogversion go1.27, og Go 1.27.0 udkom den 19. august 2026. Generics landede i Go 1.18, og sprogets\ndesignere kaldte dem den største ændring siden den første open source-udgave.\n\nIfølge FAQ'en voksede sproget ud af et valg, forfatterne var trætte af at skulle træffe: mellem\neffektiv kompilering, effektiv afvikling og nem programmering. Go vil give alle tre. Et program\nbygges af pakker, og værktøjskæden er én kommando, `go`, som bygger, tester, formaterer og henter\nafhængigheder. Nøgleordet `go` foran et funktionskald starter en goroutine, en funktion, der kører\nside om side med resten af programmet, og goroutiner er så billige, at der ifølge FAQ'en kan være\nhundredtusinder af dem i ét adresserum. Kanaler bærer værdier mellem dem, og\n[Effective Go](https://go.dev/doc/effective_go) samler den tilsigtede stil i et slogan, der på dansk\nlyder: »Kommunikér ikke ved at dele hukommelse; del i stedet hukommelse ved at kommunikere.«\n\nTo vaner kendetegner Go-kode, uanset hvor man møder den. Programmet `gofmt` skriver hver kildefil i\nét standardlayout, så formatering aldrig bliver et emne i review. Og compileren afviser et program\nmed en ubrugt variabel eller en ubrugt import, fordi den første kan skjule en fejl, og den anden gør\nhvert senere build langsommere.\n\n## Hvorfor det betyder noget\n\nDet valg, Go besvarer, er som regel, hvad en netværkstjeneste, et kommandolinjeværktøj eller et\nstykke infrastruktur skal skrives i, og alternativerne ligger på hver sin side af det: et\nscriptsprog på den ene, C, C++ eller Rust på den anden.\n\nOver for et scriptsprog tilbyder Go enkel udrulning og tidlige fejl. Linkeren laver som standard\nstatisk linkede binærfiler, så resultatet af et build er én fil, der har sin egen runtime med og\nkører på en server, hvor intet andet er installeret. FAQ'en sætter prisen til et par megabyte for et\nprogram, der skriver »hello, world«, mod omkring 750 kB for det samme program i C. Typefejl viser\nsig, når programmet kompileres, og ikke når en sjældent brugt gren kører i produktion, og et af de\noprindelige mål var, at selv en stor eksekverbar fil skulle kunne bygges på få sekunder på én\ncomputer.\n\nOver for C, C++ eller Rust tilbyder Go enkelhed og hukommelsessikkerhed for prisen af kontrol. En\ngarbage collector frigør hukommelse, så almindelig kode slipper for en hel klasse af\nuse-after-free-fejl, men programmet bestemmer ikke selv, præcis hvornår hukommelsen frigives, og\nhver binærfil har den runtime med, der gør det. For de fleste servere er det den rigtige\nbyttehandel. For en kerne, en lille indlejret enhed eller en ydelseskritisk løkke, der ikke tåler en\ncollector, er det den forkerte.\n\nDet stillere argument er tid. I 2023 skrev Russ Cox, at et Go 2, der bryder gamle programmer, aldrig\nkommer til at ske, og at projektet i stedet ville satse dobbelt på kompatibilitet. Løftet betales\nmed opgraderinger frem for omskrivninger. En ny hovedudgave kommer hver sjette måned, i februar og\naugust, og hver af dem understøttes, indtil der findes to nyere, så et team, der vil have\nsikkerhedsrettelser, rykker frem omtrent én gang om året.\n\nDet lille sprog skriver også nogle ting ud i fuld længde. Fejl er almindelige værdier, der\nreturneres og tjekkes dér, hvor de opstår, hvilket er lige dele eksplicit og gentagende.\n\n## Sådan ser det ud i praksis\n\nEn goroutine er billig at starte og lige så billig at miste. Siden om at flytte\n[langsomt arbejde over på en River-jobkø](/da/portfolio/moved-slow-work-onto-a-river-job-queue/)\nsiger det ligeud: lægger man langsomt arbejde i en goroutine, forsvinder det i det øjeblik,\nprocessen genstarter, midt i en udrulning, uden spor af, at det nogensinde skulle være sket.\nVirksomheden flyttede det arbejde over på River, som har sin kø i PostgreSQL, så et job og de\nrækker, det rører, committer eller ruller tilbage sammen. Bag den ligger 15 worker-moduler og 8\nplanlagte opgaver, med 20 pg_cron-jobs nedenunder. En goroutine giver samtidighed; holdbarheden må\nkomme et andet sted fra.\n\nTest følger med værktøjskæden, og den\n[lagdelte testsuite](/da/portfolio/built-a-test-suite-across-go-sql-and-browser/)\nviser, hvad det kan blive til. Go-API'et har 981 testfunktioner fordelt på 310 filer, ét af fire\nlag, der hver bliver testet dér, hvor deres adfærd hører hjemme, ved siden af frontendens specs og\ndatabasens egne SQL-test.\n\nDet [løbende sikkerhedsprogram](/da/portfolio/ran-a-continuous-security-scanning-programme/)\nlæner sig også op ad sprogets værktøjer. Go-afhængigheder tjekkes med govulncheck, og en sårbarhed,\nder genkendes af de konfigurerede tjek, kan få buildet til at fejle. Siden\nkalder mængden af fund den reelle pris ved scanningen, og govulncheck er bygget mod netop den pris:\nden melder kun en sårbarhed, når kodens egne funktioner kalder den berørte funktion, direkte eller\ngennem andre.\n\n## Hvor det går galt\n\n**En funktion melder en fejl, hvor der ingen fejl er.** En interfaceværdi i Go rummer en type og en\nværdi, og den er kun lig med nil, når begge mangler. En funktion, der returnerer en nil-pointer af\nen konkret fejltype gennem interfacet `error`, giver kalderen et interface, der rummer en type, og\ndet interface er ikke nil:\n\n```go\nfunc save() error {\n    var err *ValidationError // en nil-pointer\n    if invalid() {\n        err = \u0026ValidationError{}\n    }\n    return err // aldrig lig med nil: interfacet rummer en type\n}\n```\n\nReturnér et bogstaveligt `nil` ved succes, og erklær hvert fejlresultat som `error` frem for som en\nkonkret type.\n\n**En tjeneste, der bestod alle test, går ned under rigtig trafik.** Operationer på maps er bevidst\nikke synkroniserede, fordi låsning af hver adgang ville gøre de fleste programmer langsommere, og\nFAQ'en advarer om, at ukontrolleret adgang til et map kan få programmet til at gå ned. Årsagen er,\nat én goroutine skriver til et map, mens en anden læser eller skriver i det; rene læsninger er\nsikre. Beskyt mappet med en mutex, giv det til én goroutine, som de andre når gennem en kanal, eller\nbrug `sync.Map` i de tilfælde, den er lavet til. Kør derefter testene med `go test -race`. For et\ntypisk program kan race-detektoren øge hukommelsesforbruget fem til ti gange og køretiden to til\ntyve gange, og den finder kun races på kodestier, der faktisk kører, så en binærfil bygget med\n`-race` og sat under realistisk belastning finder flere.\n\n**Goroutiner startet i en løkke arbejder alle på det sidste element.** Før Go 1.22 havde en\n`for`-løkke én variabel, som alle iterationer delte, så en closure, der fangede den, så den værdi,\nvariablen havde, da goroutinen endelig kørte. Go 1.22 giver hver iteration sin egen variabel, men\nkun i moduler, hvis go.mod angiver `go 1.22` eller nyere, og ældre kode beholder sin gamle\nbetydning, selv når en nyere værktøjskæde bygger den. Hæv `go`-linjen, og kør `go vet` og testene.\nEn test, der begynder at fejle efter ændringen, tjekkede ofte den forkerte værdi hele tiden.\n\n**Et build på en ny maskine stopper op for at hente en anden Go.** Siden Go 1.21 er `go`-linjen et\nkrav, og når den installerede værktøjskæde er ældre, end et modul beder om, henter kommandoen `go`\nden nyere som et modul og kører den fra modulcachen. På en bærbar er det praktisk; i et air-gapped\nbuild eller et fastlåst containerimage er det en overraskelse. Installér den værktøjskæde, som\ngo.mod nævner, og sæt miljøvariablen `GOTOOLCHAIN`, når et build skal bruge én bestemt version.\n\n## Læs mere\n\n- [The Go Programming Language Specification](https://go.dev/ref/spec) — referencemanualen for hver\n  konstruktion i sproget, versioneret med hver udgave.\n- [Frequently Asked Questions (FAQ)](https://go.dev/doc/faq) — hvorfor sproget blev lavet,\n  designvalgene bag det og gåderne om nil-fejl og maps ovenfor.\n- [Go 1 and the Future of Go Programs](https://go.dev/doc/go1compat) — kompatibilitetsløftet og de\n  undtagelser, det tillader.\n- [Release History](https://go.dev/doc/devel/release) — hver udgave siden Go 1, med\n  supportpolitikken øverst.\n- [Data Race Detector](https://go.dev/doc/articles/race_detector) — hvordan den køres, hvad den\n  fanger, og hvad den koster.\n- [Fixing For Loops in Go 1.22](https://go.dev/blog/loopvar-preview) — ændringen af løkkevariabler,\n  hvorfor den er bundet til go.mod, og hvordan gammel kode testes mod den.\n\n\u003chttps://engineer.company/da/glossary/go/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad Go-sproget er, hvornår kompatibilitetsløftet og binærfiler i én fil betaler sig, og de faldgruber i samtidighed og versioner, der fanger nye teams.","formats":{"gemtext":"https://engineer.company/da/glossary/go/index.gmi","gopher":"https://engineer.company/da/glossary/go/gophermap","html":"https://engineer.company/da/glossary/go/","json":"https://engineer.company/da/glossary/go/index.json","markdown":"https://engineer.company/da/glossary/go/index.md","pdf":"https://engineer.company/da/glossary/go/index.pdf"},"kind":"page","language":"da","title":"Hvad er Go?","url":"https://engineer.company/da/glossary/go/","version":1}