{"canonical_url":"https://engineer.company/da/glossary/refactoring/","content_markdown":"# Refaktorering\n\n## Hvad det er\n\nRefaktorering ændrer kodens struktur, mens dens observerbare adfærd bevares. Man kan for\neksempel flytte beregningen af en ordretotal til en navngiven funktion og kontrollere, at\nkvitteringen stadig viser det samme beløb. Koden bliver lettere at forstå og nemmere at ændre\nved næste opgave. De samme input giver stadig de samme svar og sideeffekter. Udsagnsordet er\nat refaktorere, og en enkelt sådan ændring kaldes også en refaktorering. På engelsk hedder\ndet refactoring.\n\nMartin Fowler definerer begrebet i sin bog Refactoring og gentog definitionen på\nsit websted i 2004. Som navneord er en refaktorering en ændring af softwarens\nindre struktur, der gør den lettere at forstå og billigere at ændre, uden at\ndens observerbare adfærd ændres. Som udsagnsord betyder at refaktorere at\nomstrukturere software ved at anvende en række af den slags ændringer, igen uden\nat ændre den observerbare adfærd. Begge halvdele tæller. Formålet er en\nbilligere næste ændring, og betingelsen er, at ingen uden for koden kan se, at\nder er sket noget.\n\nFowler trækker grænsen skarpt: »Refactoring isn't another word for cleaning up\ncode,« skriver han på refactoring.com. Ordet betegner én bestemt teknik. Han\nbruger omstrukturering (restructuring) som det bredere ord for at omorganisere\nkode med alle midler, også nogle, der ikke bevarer adfærden ved hvert skridt.\nDet, der gør refaktorering til en teknik, er størrelsen. Hvert skridt er en\nlille transformation, der ikke gør meget i sig selv og sjældent går galt, og\nsystemet holdes fuldt fungerende efter hvert eneste. En lang række af dem kan\nalligevel samlet blive til en stor ændring af strukturen.\n\nSkridtene har navne. Kataloget på refactoring.com, der hører til bogens anden\nudgave, opregner dem sammen med de ældre navne, de afløser: Extract Function,\ntidligere kaldt Extract Method, og dens modstykke Inline Function; Inline\nVariable; Rename Variable; Move Function; Split Phase og snesevis flere. Et\nfælles navn lader en udvikler sige med to ord, hvad en ændring var, og lader\nden, der gennemgår koden, holde den op mod en kendt opskrift.\n\n## Hvorfor det betyder noget\n\nSoftware, der får succes, bliver ved med at ændre sig. Ny funktionalitet og\nrettelser lægges oven på hinanden, og hver af dem gør typisk den næste lidt\nsværere, indtil nyt arbejde, som Fowler beskriver det, næsten går i stå.\nRefaktorering er modvægten: den omformer koden, så hver tilføjelse ikke bringer\nkompleksitet med sig, som den ikke har brug for. Udbyttet måles i prisen på den\nnæste ændring, ikke i, hvordan koden ser ud.\n\nDerfor behandler Fowler det som en del af almindelig programmering og ikke som\nen opgave, der står i en projektplan. Han nævner tre øjeblikke. Før han tilføjer\nny funktionalitet, tjekker han, om koden har en form, der gør den let at\ntilføje, og hvis ikke, refaktorerer han først, hvilket han som regel finder\nhurtigere end at tvinge funktionaliteten ind. Når funktionaliteten virker,\nrefaktorerer han resultatet til en form, som en, der vender tilbage om et par\nuger, kan følge uden at gruble. Og når han skal læse ukendt kode for at forstå\nden, refaktorerer han, så den næste læser ikke kæmper på samme sted. Det første\naf de tre har sit eget navn, forberedende refaktorering (preparatory\nrefactoring), og Fowler tilskriver Kent Beck reglen bag det: ved hver ændring\nskal man først omforme koden, indtil ændringen er let, hvilket kan være den\nsvære del, og først derefter foretage den.\n\nRefaktorering holder også risikoen nede på en måde, som arbejde på ny\nfunktionalitet ikke kan. Fowler giver endnu en af Becks metaforer videre, de to\nhatte. Med refaktoreringshatten på bevarer hver ændring adfærden, og testene\nforbliver grønne hele vejen. Når man tilføjer funktionalitet, kommer der nye\ntests til, og eksisterende tests går i stykker, hvilket er mere stressende og\nmere risikabelt. En udvikler, der ved, hvilken hat der sidder på hovedet, ved\nogså, hvad en fejlende test betyder: under en refaktorering betyder den, at det\nsidste skridt var forkert.\n\nDet er også sådan, det meste af den tekniske gæld bliver betalt tilbage. Googles\nartikel om skjult gæld i maskinlæringssystemer nævner refaktorering af kode\nførst blandt måderne at afdrage gæld på. Værktøjer hjælper: mange sprog har nu\neditorer, der automatiserer almindelige refaktoreringer. Fowler regner sådanne\nværktøjer for værdifulde, men ikke nødvendige, og hvor de mangler, holder han\nsig til små skridt og hyppige tests.\n\n## Sådan ser det ud i praksis\n\nTag en funktion, skrevet til denne artikel, der lægger en ordre sammen og\nudskriver en kvittering samme sted:\n\n```javascript\nfunction printReceipt(order) {\n  let total = 0;\n  for (const line of order.lines) {\n    total += line.price * line.quantity;\n  }\n\n  // print the receipt lines\n  console.log(`Order ${order.id}`);\n  console.log(`Total: ${total}`);\n}\n```\n\nEt nyt krav kommer ind: den samme total skal stå på en faktura. I stedet for at\nkopiere løkken refaktorerer udvikleren først. Første skridt er Extract Function:\nløkken flyttes ind i sin egen funktion, opkaldt efter det, den beregner, og\ntestene køres. Andet skridt trækker udskrivningen ud på samme måde, så et\nfunktionsnavn erstatter kommentaren, og testene køres igen. Tredje skridt er\nInline Variable: variablen `total` bruges nu kun ét sted, så kaldet sættes ind i\nstedet for den. Efter hvert skridt gør programmet præcis det samme som før og\nkunne committes for sig:\n\n```javascript\nfunction printReceipt(order) {\n  printLines(order.id, orderTotal(order));\n}\n\nfunction orderTotal(order) {\n  let total = 0;\n  for (const line of order.lines) {\n    total += line.price * line.quantity;\n  }\n  return total;\n}\n\nfunction printLines(id, total) {\n  console.log(`Order ${id}`);\n  console.log(`Total: ${total}`);\n}\n```\n\nFørst nu kommer totalen på fakturaen til, og det kræver én linje i fakturakoden,\nder kalder `orderTotal`. Intet i de tre refaktoreringsskridt krævede en ny test,\nfor intet observerbart ændrede sig; det er de tests, der allerede dækkede\nkvitteringen, som beviser det.\n\nInfrastrukturkode bliver også refaktoreret, og der er indsatsen højere, fordi\nnavnene henviser til kørende ressourcer. Terraforms dokumentation advarer om, at\nen ændret adresse på en ressource i konfigurationen som standard er en instruks\nom at slette den eksisterende ressource og oprette en ny. Omdøber man\n`aws_instance.a` til `aws_instance.web` for læsbarhedens skyld, bliver en server\naltså erstattet. Siden Terraform v1.1 registrerer en `moved`-blok i stedet den\ngamle adresse, og den næste plan opdaterer adressen uden at slette noget:\n\n```hcl\nresource \"aws_instance\" \"web\" {\n  # (configuration unchanged)\n}\n\nmoved {\n  from = aws_instance.a\n  to   = aws_instance.web\n}\n```\n\nI tidligere versioner henviser dokumentationen til kommandoen `terraform state\nmv` til den samme flytning. Uanset hvad er refaktoreringen først sikker, når\nplanen er læst og viser en flytning og ikke en sletning og en oprettelse.\n\nDet er lettere at holde den slags ændringer adskilt fra arbejde på ny\nfunktionalitet, når historikken siger, hvad der er hvad. Commit-standarden, som\nsidens porteføljepost om at\n[holde fire repositories på én historikstandard](/da/portfolio/held-4-repositories-to-one-history-standard/)\nbeskriver, lader hver commit-besked begynde med et konventionelt præfiks, der\nangiver ændringens art, og en hook på commit-beskeden håndhæver det.\nPorteføljeposten, der handler om arbejde udført i juli 2026, tæller 26\nrefaktoreringer i historikken for det største repository ved siden af 156\nfunktions-commits og 133 rettelser. Den siger også ærligt, at hooken tjekker\nformatet og ikke indholdet. En commit, der er mærket som refaktorering, skal\nstadig gennem sine tests og en kodegennemgang vise, at den har ladet adfærden\nvære i fred.\n\n## Hvor det går galt\n\n**Adfærdsændringer sniger sig med i refaktoreringen.** En udvikler rydder op i\nen funktion og retter en fejl i den i samme commit. Når en test fejler, kan\ningen se, hvilken af de to der var årsagen, og den, der gennemgår koden, må læse\nhver linje som en mulig ændring af adfærden. Hav én hat på ad gangen: refaktorér\ni én commit, ændr adfærden i den næste, og hvis en test fejler under\nrefaktoreringen, så fortryd det sidste skridt i stedet for at lappe videre på\ndet.\n\n**En stor omstrukturering bliver kaldt refaktorering.** En branch står i ugevis\nmed et build, der ikke virker, mens koden angiveligt »bliver refaktoreret«. Det\ner omstrukturering i Fowlers forstand, og den bærer netop den risiko, som\nrefaktorering er skabt til at undgå. Del arbejdet op i skridt, der hver især\nefterlader systemet i fungerende stand og kan merges for sig; hvor det ikke kan\nlade sig gøre, så kald det en omskrivning og planlæg det som en.\n\n**Der er ingen tests, der viser, at intet har ændret sig.** Bevaret adfærd er en\npåstand, og uden tests er den et gæt. Før du rører kode uden tests, så skriv\ntests, der fastholder, hvad den gør i dag, også hvor det ser forkert ud, og ret\nmærkværdighederne i separate ændringer bagefter. Fowlers tommelfingerregel fra\nhans eksempel på forberedende refaktorering gælder her: hver gang trangen melder\nsig til at køre koden og kigge på outputtet med egne øjne, så skriv en test i\nstedet.\n\n**En omdøbning i infrastrukturkode erstatter ressourcen.** Et pænt nyt navn i\nTerraform ligner en refaktorering i kodegennemgangen, og planen foreslår i al\nstilhed at slette en database og oprette en tom. Registrér hver omdøbning og\nhver flytning ind i eller ud af et modul med en `moved`-blok, og betragt enhver\nsletning i planen for en ændring, der var tænkt som refaktorering, som et\nmislykket skridt.\n\n**En gammel `moved`-blok bliver slettet.** Moved-blokke hober sig op, og at\nfjerne dem ligner almindelig oprydning. Terraforms dokumentation kalder det en\nændring, der bryder kompatibiliteten: enhver konfiguration, der stadig står på\nden gamle adresse, vil så planlægge at slette det eksisterende objekt i stedet\nfor at flytte det. Behold de historiske blokke, kæd dem sammen, når et objekt\nomdøbes to gange, og fjern dem kun fra et privat modul, når alle, der bruger\ndet, har kørt apply med den version, der indeholder dem.\n\n**Refaktoreringen venter på en særlig fase.** Et team, der udskyder\nrefaktoreringen til et særligt forløb senere, bliver ved med at tilføje\nfunktionalitet til kode, der stritter imod, og et forløb, der er planlagt til\nsenere, er let at skære væk, når en deadline flytter sig. Fowlers råd går den\nanden vej: refaktorér som en del af hver ændring, først for at gøre ændringen\nlet og bagefter for at efterlade resultatet klart, så arbejdet aldrig har brug\nfor sin egen plads i planen.\n\n## Læs mere\n\n- [Definition Of Refactoring](https://martinfowler.com/bliki/DefinitionOfRefactoring.html)\n  — Martin Fowlers definitioner som navneord og udsagnsord, sådan som han giver\n  dem i sin bog.\n- [Refactoring](https://refactoring.com/) — Fowlers websted for bogen, om\n  hvorfor refaktorering hører til den daglige programmering, og med hele\n  kataloget.\n- [Extract Function](https://refactoring.com/catalog/extractFunction.html)\n  — katalogets opslag om en af de mest almindelige refaktoreringer, med dens\n  modstykke og navnet fra første udgave.\n- [An example of preparatory refactoring](https://martinfowler.com/articles/preparatory-refactoring-example.html)\n  — Fowler omformer sin egen kode i små skridt, før han tilføjer ny\n  funktionalitet, og forklarer de to hatte.\n- [Refactor modules](https://developer.hashicorp.com/terraform/language/modules/develop/refactoring)\n  — Terraforms dokumentation om `moved`-blokke, omdøbninger, opdeling af\n  moduler, og hvorfor gamle blokke skal blive stående.\n\n\u003chttps://engineer.company/da/glossary/refactoring/\u003e\n","date_modified":"2026-11-19T06:00:51Z","description":"Refaktorering gør kode lettere at forstå og ændre, mens adfærden bevares. Se, hvordan den samme idé bruges i en funktion og ved en flytning i Terraform.","formats":{"gemtext":"https://engineer.company/da/glossary/refactoring/index.gmi","gopher":"https://engineer.company/da/glossary/refactoring/gophermap","html":"https://engineer.company/da/glossary/refactoring/","json":"https://engineer.company/da/glossary/refactoring/index.json","markdown":"https://engineer.company/da/glossary/refactoring/index.md","pdf":"https://engineer.company/da/glossary/refactoring/index.pdf"},"kind":"page","language":"da","title":"Hvad er refaktorering?","url":"https://engineer.company/da/glossary/refactoring/","version":1}