{"canonical_url":"https://engineer.company/nb/glossary/refactoring/","content_markdown":"# Refaktorering\n\n## Hva det er\n\nRefaktorering er å endre den indre strukturen i kode uten å endre det koden gjør\nfor dem som bruker den. Navn, grensene mellom funksjoner og inndelingen i\nmoduler endres; input, output og sideeffekter blir nøyaktig som de var. Verbet\ner å refaktorere, og én slik endring kalles også en refaktorering. På engelsk\nheter det refactoring.\n\nMartin Fowler definerer begrepet i boken sin Refactoring og gjentok definisjonen\npå nettstedet sitt i 2004. Som substantiv er en refaktorering en endring i\nprogramvarens indre struktur som gjør den lettere å forstå og billigere å endre,\nuten at den observerbare atferden endres. Som verb betyr å refaktorere å\nomstrukturere programvare ved å bruke en rekke slike endringer, igjen uten å\nendre den observerbare atferden. Begge halvdelene teller. Formålet er en\nbilligere neste endring, og betingelsen er at ingen utenfor koden kan se at noe\nhar skjedd.\n\nFowler trekker grensen skarpt: «Refactoring isn't another word for cleaning up\ncode,» skriver han på refactoring.com. Ordet betegner én bestemt teknikk. Han\nbruker omstrukturering (restructuring) som det bredere ordet for å omorganisere\nkode med alle midler, også slike som ikke bevarer atferden i hvert steg. Det som\ngjør refaktorering til en teknikk, er størrelsen. Hvert steg er en liten\ntransformasjon som gjør lite i seg selv og sjelden går galt, og systemet holdes\nfullt fungerende etter hvert eneste ett. En lang rekke av dem kan likevel til\nsammen bli en stor endring i strukturen.\n\nStegene har navn. Katalogen på refactoring.com, som hører til bokens andre\nutgave, lister dem opp sammen med de eldre navnene de erstatter: Extract\nFunction, tidligere kalt Extract Method, og det motsatte grepet Inline Function;\nInline Variable; Rename Variable; Move Function; Split Phase og dusinvis flere.\nEt felles navn lar en utvikler si med to ord hva en endring var, og lar den som\ngår gjennom koden, holde den opp mot en kjent oppskrift.\n\n## Hvorfor det er viktig\n\nProgramvare som lykkes, fortsetter å endre seg. Ny funksjonalitet og rettinger\nlegges oppå hverandre, og hver av dem gjør gjerne den neste litt vanskeligere,\ntil nytt arbeid, slik Fowler beskriver det, nesten stopper opp. Refaktorering er\nmotvekten: den former om koden slik at hvert tillegg ikke tar med seg\nkompleksitet det ikke trenger. Gevinsten måles i prisen på neste endring, ikke i\nhvordan koden ser ut.\n\nDerfor behandler Fowler det som en del av vanlig programmering og ikke som en\noppgave som står i en prosjektplan. Han nevner tre øyeblikk. Før han legger til\nny funksjonalitet, sjekker han om koden har en form som gjør den lett å legge\ntil, og hvis ikke refaktorerer han først, noe han som regel finner raskere enn å\ntvinge funksjonaliteten inn. Når funksjonaliteten virker, refaktorerer han\nresultatet til en form som en som kommer tilbake om noen uker, kan følge uten å\ngruble. Og når han må lese ukjent kode for å forstå den, refaktorerer han slik\nat neste leser ikke sliter på samme sted. Det første av de tre har sitt eget\nnavn, forberedende refaktorering (preparatory refactoring), og Fowler gir Kent\nBeck æren for regelen bak det: ved hver endring skal man først forme om koden\ntil endringen er lett, noe som kan være den vanskelige delen, og først deretter\ngjøre den.\n\nRefaktorering holder også risikoen lav på en måte som arbeid med ny\nfunksjonalitet ikke kan. Fowler gir videre enda en av Becks metaforer, de to\nhattene. Med refaktoreringshatten på bevarer hver endring atferden, og testene\nforblir grønne hele veien. Når man legger til funksjonalitet, kommer det nye\ntester til, og eksisterende tester brekker, noe som er mer stressende og mer\nrisikabelt. En utvikler som vet hvilken hatt som sitter på, vet også hva en\nfeilende test betyr: under en refaktorering betyr den at det siste steget var\nfeil.\n\nDet er også slik det meste av den tekniske gjelden blir betalt ned. Artikkelen\nfra Google om skjult gjeld i maskinlæringssystemer nevner refaktorering av kode\nførst blant måtene å betale ned gjeld på. Verktøy hjelper: mange språk har nå\neditorer som automatiserer vanlige refaktoreringer. Fowler regner slike verktøy\nsom verdifulle, men ikke nødvendige, og der de mangler, holder han seg til små\nsteg og hyppige tester.\n\n## Slik ser det ut i praksis\n\nTa en funksjon, skrevet for denne artikkelen, som summerer en ordre og skriver\nut en kvittering på 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 nytt krav kommer: den samme totalsummen skal stå på en faktura. I stedet for\nå kopiere løkken refaktorerer utvikleren først. Første steg er Extract Function:\nløkken flyttes inn i en egen funksjon, oppkalt etter det den beregner, og\ntestene kjøres. Andre steg trekker ut utskriften på samme måte, slik at et\nfunksjonsnavn erstatter kommentaren, og testene kjøres igjen. Tredje steg er\nInline Variable: variabelen `total` brukes nå bare ett sted, så kallet settes\ninn i stedet for den. Etter hvert steg gjør programmet nøyaktig det samme som\nfør og kunne vært committet for seg:\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 nå kommer totalsummen på fakturaen til, og det krever én linje i\nfakturakoden som kaller `orderTotal`. Ingenting i de tre refaktoreringsstegene\ntrengte en ny test, fordi ingenting observerbart endret seg; det er testene som\nallerede dekket kvitteringen, som beviser det.\n\nInfrastrukturkode refaktoreres også, og der står mer på spill, fordi navnene\nviser til ressurser som kjører. Dokumentasjonen til Terraform advarer om at det\nå endre adressen til en ressurs i konfigurasjonen som standard er en instruks om\nå slette den eksisterende ressursen og opprette en ny. Å gi `aws_instance.a` det\nnye navnet `aws_instance.web` for lesbarhetens skyld ville derfor erstatte en\nserver. Siden Terraform v1.1 registrerer en `moved`-blokk i stedet den gamle\nadressen, og neste plan oppdaterer adressen uten å slette noe:\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 versjoner viser dokumentasjonen til kommandoen `terraform state mv`\nfor den samme flyttingen. Uansett er refaktoreringen først trygg når planen er\nlest og viser en flytting, ikke en sletting og en oppretting.\n\nDet er lettere å holde slike endringer adskilt fra arbeid med ny funksjonalitet\nnår historikken sier hva som er hva. Commitstandarden som porteføljeoppføringen\nher på nettstedet om å\n[samle fire repoer under én historikkstandard](/nb/portfolio/held-4-repositories-to-one-history-standard/)\nbeskriver, lar hver commitmelding begynne med et konvensjonelt prefiks som angir\ntypen endring, og en hook for commitmeldinger håndhever det. Oppføringen, som\ngjelder arbeid utført i juli 2026, teller 26 refaktoreringer i historikken til\ndet største repoet, ved siden av 156 commits med funksjoner og 133 rettinger.\nDen sier også ærlig at hooken sjekker formatet og ikke innholdet. En commit som\ner merket som refaktorering, må fortsatt vise gjennom testene sine og en\nkodegjennomgang at den har latt atferden være i fred.\n\n## Hvor det går galt\n\n**Atferdsendringer sniker seg med i refaktoreringen.** En utvikler rydder i en\nfunksjon og retter en feil i den i samme commit. Når en test feiler, kan ingen\nse hvilken av de to som var årsaken, og den som går gjennom koden, må lese hver\nlinje som en mulig endring i atferden. Ha på én hatt om gangen: refaktorer i én\ncommit, endre atferden i den neste, og hvis en test feiler under\nrefaktoreringen, så angre det siste steget i stedet for å lappe videre på det.\n\n**En stor omstrukturering blir kalt refaktorering.** En gren står i ukevis med\net bygg som ikke virker, mens koden angivelig «refaktoreres». Det er\nomstrukturering i Fowlers forstand, og den bærer akkurat den risikoen\nrefaktorering er laget for å unngå. Del opp arbeidet i steg som hvert for seg\netterlater systemet i fungerende stand og kan flettes inn alene; der det ikke\nlar seg gjøre, kall det en omskriving og planlegg det som en.\n\n**Det finnes ingen tester som viser at ingenting er endret.** Bevart atferd er\nen påstand, og uten tester er den en gjetning. Før du rører kode uten tester,\nskriv tester som låser fast hva den gjør i dag, også der det ser feil ut, og\nrett særhetene i egne endringer etterpå. Fowlers tommelfingerregel fra\neksempelet hans på forberedende refaktorering gjelder her: hver gang lysten\nmelder seg til å kjøre koden og se på utdataene med egne øyne, skriv en test i\nstedet.\n\n**Et nytt navn i infrastrukturkode erstatter ressursen.** Et ryddig nytt navn i\nTerraform ser ut som en refaktorering i kodegjennomgangen, og planen foreslår i\ndet stille å slette en database og opprette en tom. Registrer hvert nytt navn og\nhver flytting inn i eller ut av en modul med en `moved`-blokk, og regn enhver\nsletting i planen for en endring som var ment som refaktorering, som et\nmislykket steg.\n\n**En gammel `moved`-blokk blir slettet.** Moved-blokker hoper seg opp, og å\nfjerne dem ser ut som vanlig rydding. Dokumentasjonen til Terraform kaller det\nen endring som bryter kompatibiliteten: enhver konfigurasjon som fortsatt står\npå den gamle adressen, vil da planlegge å slette det eksisterende objektet i\nstedet for å flytte det. Behold de historiske blokkene, kjed dem sammen når et\nobjekt får nytt navn to ganger, og fjern dem bare fra en privat modul når alle\nsom bruker den, har kjørt apply med versjonen som inneholder dem.\n\n**Refaktoreringen venter på en egen fase.** Et team som skyver refaktoreringen\ntil en egen periode senere, fortsetter å legge funksjonalitet til kode som\nstritter imot, og en periode som er planlagt til senere, er lett å kutte når en\nfrist flytter seg. Fowlers råd går motsatt vei: refaktorer som en del av hver\nendring, først for å gjøre endringen lett og etterpå for å etterlate resultatet\noversiktlig, slik at arbeidet aldri trenger en egen plass i planen.\n\n## Les mer\n\n- [Definition Of Refactoring](https://martinfowler.com/bliki/DefinitionOfRefactoring.html)\n  — Martin Fowlers definisjoner som substantiv og verb, slik han gir dem i boken\n  sin.\n- [Refactoring](https://refactoring.com/) — Fowlers nettsted for boken, om\n  hvorfor refaktorering hører hjemme i den daglige programmeringen, og med hele\n  katalogen.\n- [Extract Function](https://refactoring.com/catalog/extractFunction.html)\n  — katalogoppføringen for en av de vanligste refaktoreringene, med det motsatte\n  grepet og navnet fra første utgave.\n- [An example of preparatory refactoring](https://martinfowler.com/articles/preparatory-refactoring-example.html)\n  — Fowler former om sin egen kode i små steg før han legger til ny\n  funksjonalitet, og forklarer de to hattene.\n- [Refactor modules](https://developer.hashicorp.com/terraform/language/modules/develop/refactoring)\n  — dokumentasjonen til Terraform om `moved`-blokker, nye navn, oppdeling av\n  moduler og hvorfor gamle blokker bør bli stående.\n\n\u003chttps://engineer.company/nb/glossary/refactoring/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Hva som teller som refaktorering, hvordan små steg holder koden i drift, hvordan infrastruktur får nye navn trygt, og hvor refaktorering går galt.","formats":{"gemtext":"https://engineer.company/nb/glossary/refactoring/index.gmi","gopher":"https://engineer.company/nb/glossary/refactoring/gophermap","html":"https://engineer.company/nb/glossary/refactoring/","json":"https://engineer.company/nb/glossary/refactoring/index.json","markdown":"https://engineer.company/nb/glossary/refactoring/index.md","pdf":"https://engineer.company/nb/glossary/refactoring/index.pdf"},"kind":"page","language":"nb","title":"Hva er refaktorering?","url":"https://engineer.company/nb/glossary/refactoring/","version":1}