{"canonical_url":"https://engineer.company/sv/glossary/refactoring/","content_markdown":"# Refaktorering\n\n## Vad det är\n\nRefaktorering är att ändra den inre strukturen i kod utan att ändra vad koden\ngör för den som använder den. Namn, gränserna mellan funktioner och uppdelningen\ni moduler ändras; indata, utdata och sidoeffekter förblir exakt som de var.\nVerbet är att refaktorera, och en enskild sådan ändring kallas också en\nrefaktorering. På engelska heter det refactoring.\n\nMartin Fowler definierar begreppet i sin bok Refactoring och upprepade\ndefinitionen på sin webbplats 2004. Som substantiv är en refaktorering en\nändring av programvarans inre struktur som gör den lättare att förstå och\nbilligare att ändra, utan att dess observerbara beteende ändras. Som verb\nbetyder att refaktorera att omstrukturera programvara genom att tillämpa en\nserie sådana ändringar, återigen utan att ändra det observerbara beteendet. Båda\nhalvorna räknas. Syftet är en billigare nästa ändring, och villkoret är att\ningen utanför koden kan se att något har hänt.\n\nFowler drar gränsen skarpt: ”Refactoring isn't another word for cleaning up\ncode,” skriver han på refactoring.com. Ordet betecknar en bestämd teknik. Han\nanvänder omstrukturering (restructuring) som det bredare ordet för att\nomorganisera kod med alla medel, även sådana som inte bevarar beteendet i varje\nsteg. Det som gör refaktorering till en teknik är storleken. Varje steg är en\nliten transformation som gör lite i sig och sällan går fel, och systemet hålls\nfullt fungerande efter vart och ett. En lång rad av dem kan ändå tillsammans bli\nen stor ändring av strukturen.\n\nStegen har namn. Katalogen på refactoring.com, som hör till bokens andra\nupplaga, listar dem tillsammans med de äldre namn de ersätter: Extract Function,\ntidigare kallad Extract Method, och dess motsats Inline Function; Inline\nVariable; Rename Variable; Move Function; Split Phase och dussintals till. Ett\ngemensamt namn låter en utvecklare säga med två ord vad en ändring var och låter\nden som granskar koden hålla den mot ett känt recept.\n\n## Varför det spelar roll\n\nProgramvara som lyckas fortsätter att förändras. Ny funktionalitet och\nrättningar läggs ovanpå varandra, och var och en gör gärna nästa lite svårare,\ntills nytt arbete, med Fowlers beskrivning, nästan står still. Refaktorering är\nmotvikten: den formar om koden så att varje tillägg inte för med sig komplexitet\nsom det inte behöver. Vinsten mäts i priset för nästa ändring, inte i hur koden\nser ut.\n\nDärför behandlar Fowler det som en del av vanlig programmering och inte som en\nuppgift som står i en projektplan. Han nämner tre tillfällen. Innan han lägger\ntill ny funktionalitet kontrollerar han om koden har en form som gör den lätt\natt lägga till, och om inte refaktorerar han först, vilket han oftast tycker går\nsnabbare än att tvinga in funktionaliteten. När funktionaliteten fungerar\nrefaktorerar han resultatet till en form som någon som kommer tillbaka om några\nveckor kan följa utan att fundera. Och när han måste läsa obekant kod för att\nförstå den refaktorerar han så att nästa läsare inte kör fast på samma ställe.\nDet första av de tre har ett eget namn, förberedande refaktorering (preparatory\nrefactoring), och Fowler tillskriver Kent Beck regeln bakom det: vid varje\nändring ska man först forma om koden tills ändringen är lätt, vilket kan vara\nden svåra delen, och först därefter göra den.\n\nRefaktorering håller också risken låg på ett sätt som arbete med ny\nfunktionalitet inte kan. Fowler för vidare ännu en av Becks metaforer, de två\nhattarna. Med refaktoreringshatten på bevarar varje ändring beteendet, och\ntesterna förblir gröna hela vägen. När man lägger till funktionalitet tillkommer\nnya tester och befintliga går sönder, vilket är mer stressigt och mer riskfyllt.\nEn utvecklare som vet vilken hatt som sitter på huvudet vet också vad ett test\nsom fallerar betyder: under en refaktorering betyder det att det senaste steget\nvar fel.\n\nDet är också så det mesta av den tekniska skulden betalas tillbaka. Artikeln\nfrån Google om dold skuld i maskininlärningssystem nämner refaktorering av kod\nförst bland sätten att amortera skuld. Verktyg hjälper: många språk har nu\neditorer som automatiserar vanliga refaktoreringar. Fowler räknar sådana verktyg\nsom värdefulla men inte nödvändiga, och där de saknas håller han sig till små\nsteg och täta tester.\n\n## Så ser det ut i praktiken\n\nTa en funktion, skriven för den här artikeln, som summerar en order och skriver\nut ett kvitto på ett och samma ställe:\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\nEtt nytt krav kommer: samma totalsumma ska stå på en faktura. I stället för att\nkopiera loopen refaktorerar utvecklaren först. Första steget är Extract\nFunction: loopen flyttas till en egen funktion, namngiven efter vad den\nberäknar, och testerna körs. Andra steget bryter ut utskriften på samma sätt, så\natt ett funktionsnamn ersätter kommentaren, och testerna körs igen. Tredje\nsteget är Inline Variable: variabeln `total` används nu bara på ett ställe, så\nanropet får ta dess plats. Efter varje steg gör programmet exakt samma sak som\nförut och skulle kunna committas för 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 läggs totalsumman på fakturan till, och det kräver en rad i\nfakturakoden som anropar `orderTotal`. Inget i de tre refaktoreringsstegen\nkrävde ett nytt test, eftersom inget observerbart ändrades; det är testerna som\nredan täckte kvittot som bevisar det.\n\nInfrastrukturkod refaktoreras också, och där står mer på spel, eftersom namnen\nsyftar på resurser som körs. Terraforms dokumentation varnar för att en ändrad\nadress för en resurs i konfigurationen som standard är en instruktion att ta\nbort den befintliga resursen och skapa en ny. Att byta namn från\n`aws_instance.a` till `aws_instance.web` för läsbarhetens skull skulle alltså\nersätta en server. Sedan Terraform v1.1 registrerar ett `moved`-block i stället\nden gamla adressen, och nästa plan uppdaterar adressen utan att ta bort något:\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 tidigare versioner hänvisar dokumentationen till kommandot `terraform state\nmv` för samma flytt. Hur som helst är refaktoreringen säker först när planen har\nlästs och visar en flytt, inte en borttagning och ett nyskapande.\n\nDet är lättare att hålla isär sådana ändringar och arbete med ny funktionalitet\nnär historiken säger vad som är vad. Commitstandarden som beskrivs i\nportföljposten här på webbplatsen om att\n[låta fyra repon följa en och samma historikstandard](/sv/portfolio/held-4-repositories-to-one-history-standard/)\nlåter varje commitmeddelande börja med ett konventionellt prefix som anger typen\nav ändring, och en hook för commitmeddelanden upprätthåller det. Portföljposten,\nsom gäller arbete utfört i juli 2026, räknar 26 refaktoreringar i historiken för\ndet största repot vid sidan av 156 commits för funktioner och 133 rättningar.\nDen säger också ärligt att hooken kontrollerar formatet och inte innehållet. En\ncommit som är märkt som refaktorering måste fortfarande genom sina tester och en\nkodgranskning visa att den har lämnat beteendet i fred.\n\n## Var det går fel\n\n**Beteendeändringar smyger med i refaktoreringen.** En utvecklare städar i en\nfunktion och rättar ett fel i den i samma commit. När ett test fallerar kan\ningen se vilken av de två som var orsaken, och den som granskar koden måste läsa\nvarje rad som en möjlig ändring av beteendet. Ha en hatt på i taget: refaktorera\ni en commit, ändra beteendet i nästa, och om ett test fallerar under\nrefaktoreringen, ångra det senaste steget i stället för att lappa vidare på det.\n\n**En stor omstrukturering kallas refaktorering.** En gren står i veckor med ett\nbygge som inte fungerar, medan koden sägs ”refaktoreras”. Det är omstrukturering\ni Fowlers mening, och den bär just den risk som refaktorering är gjord för att\nundvika. Dela upp arbetet i steg som vart och ett lämnar systemet i fungerande\nskick och kan slås samman var för sig; där det inte går, kalla det en\nomskrivning och planera det som en.\n\n**Det finns inga tester som visar att inget har ändrats.** Bevarat beteende är\nett påstående, och utan tester är det en gissning. Innan du rör kod som saknar\ntester, skriv tester som låser fast vad den gör i dag, även där det ser fel ut,\noch rätta egenheterna i separata ändringar efteråt. Fowlers tumregel från hans\nexempel på förberedande refaktorering gäller här: varje gång lusten kommer att\nköra koden och granska utdata med egna ögon, skriv ett test i stället.\n\n**Ett namnbyte i infrastrukturkod ersätter resursen.** Ett snyggt nytt namn i\nTerraform ser ut som en refaktorering vid kodgranskningen, och planen föreslår i\ntysthet att ta bort en databas och skapa en tom. Registrera varje namnbyte och\nvarje flytt in i eller ut ur en modul med ett `moved`-block, och betrakta varje\nborttagning i planen för en ändring som var tänkt som refaktorering som ett\nmisslyckat steg.\n\n**Ett gammalt `moved`-block tas bort.** Moved-block samlas på hög, och att ta\nbort dem ser ut som vanlig städning. Terraforms dokumentation kallar det en\nändring som bryter kompatibiliteten: varje konfiguration som fortfarande står på\nden gamla adressen kommer då att planera att ta bort det befintliga objektet i\nstället för att flytta det. Behåll de historiska blocken, kedja ihop dem när ett\nobjekt byter namn två gånger, och ta bara bort dem från en privat modul när alla\nsom använder den har kört apply med den version som innehåller dem.\n\n**Refaktoreringen väntar på en egen fas.** Ett team som skjuter upp\nrefaktoreringen till en särskild period längre fram fortsätter att lägga till\nfunktionalitet i kod som stretar emot, och en period som är planerad till senare\när lätt att stryka när en deadline flyttas. Fowlers råd går åt andra hållet:\nrefaktorera som en del av varje ändring, först för att göra ändringen lätt och\nefteråt för att lämna resultatet tydligt, så att arbetet aldrig behöver en egen\nplats i planen.\n\n## Läs mer\n\n- [Definition Of Refactoring](https://martinfowler.com/bliki/DefinitionOfRefactoring.html)\n  — Martin Fowlers definitioner som substantiv och verb, så som han ger dem i\n  sin bok.\n- [Refactoring](https://refactoring.com/) — Fowlers webbplats för boken, om\n  varför refaktorering hör till den dagliga programmeringen, och med hela\n  katalogen.\n- [Extract Function](https://refactoring.com/catalog/extractFunction.html)\n  — katalogens post för en av de vanligaste refaktoreringarna, med dess motsats\n  och namnet från första upplagan.\n- [An example of preparatory refactoring](https://martinfowler.com/articles/preparatory-refactoring-example.html)\n  — Fowler formar om sin egen kod i små steg innan han lägger till ny\n  funktionalitet och förklarar de två hattarna.\n- [Refactor modules](https://developer.hashicorp.com/terraform/language/modules/develop/refactoring)\n  — Terraforms dokumentation om `moved`-block, namnbyten, uppdelning av moduler\n  och varför gamla block bör stå kvar.\n\n\u003chttps://engineer.company/sv/glossary/refactoring/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad som räknas som refaktorering, hur små steg håller koden fungerande, hur infrastruktur byter namn på ett säkert sätt och var refaktorering går fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/refactoring/index.gmi","gopher":"https://engineer.company/sv/glossary/refactoring/gophermap","html":"https://engineer.company/sv/glossary/refactoring/","json":"https://engineer.company/sv/glossary/refactoring/index.json","markdown":"https://engineer.company/sv/glossary/refactoring/index.md","pdf":"https://engineer.company/sv/glossary/refactoring/index.pdf"},"kind":"page","language":"sv","title":"Vad är refaktorering?","url":"https://engineer.company/sv/glossary/refactoring/","version":1}