Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Refaktorering og forbedring af eksisterende kode

Lektion 6 af 20 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Transformering af gammel kode til moderne kode
  2. Strukturel refaktorering
  3. Modernisering af kode
  4. Forbedring af kvalitet
  5. Refaktorering baseret på mønstre
  6. Verificering af refaktoreringen
  7. Vigtige pointer

Transformering af gammel kode til moderne kode

Refaktorering er en af de mest tidskrævende opgaver inden for udvikling, og sjældent den mest påskønnede: Ingen gratulerer dig med at opdele en fil på 800 linjer. Netop derfor hober det sig op, sprint efter sprint, indtil det bliver den reelle årsag til, at det går langsommere. Codex reducerer timers manuelt arbejde til minutter, samtidig med at den eksisterende funktionalitet bevares – det er det eneste, der virkelig betyder noget ved en refaktorering.

Strukturel refaktorering

Det hyppigste tilfælde er den altomfattende fil, som ingen tør røre ved, fordi den importeres overalt.

"Refactor src/utils/helpers.ts: this file is 800 lines long. 
Split it into thematic modules in src/utils/ (string.ts, 
date.ts, validation.ts, formatting.ts). Update all imports 
across the project."

Codex håndterer denne type opgaver exceptionelt godt: Det identificerer funktioner, grupperer dem efter tema, opretter de nye filer og opdaterer derefter alle imports i projektet. Det sidste trin er normalt det, der afskrækker fra manuel refaktorering – fyrre filer skal rettes, ét manglende import, så brister buildet på det værst tænkelige tidspunkt. Og resultatet er objektivt verificerbart: Hvis testene bestod før og stadig gør, er opdelingen korrekt.

Modernisering af kode

Det andet store tilfælde er opdatering til moderne mønstre, hvor transformationen er mekanisk, men så repetitiv, at den konstant bliver skubbet videre i backloggen.

"Migrate all callbacks in src/lib/database.ts to 
async/await. Preserve existing error handling."

Udgangspunktet er callback-baseret JavaScript med dens kaskadeformede fejlhåndtering:

function getUser(id, callback) {
  db.query("SELECT * FROM users WHERE id = ?", [id], 
    (err, rows) => {
      if (err) return callback(err);
      callback(null, rows[0]);
    });
}

Her er resultatet fra Codex:

async function getUser(id: string): Promise<User> {
  const rows = await db.query(
    "SELECT * FROM users WHERE id = ?", 
    [id]
  );
  return rows[0];
}

Tre ting skete på én gang: TypeScript-typer dukkede op, callbacks blev erstattet af async/await, og fejlhåndteringen blev forenklet, da undtagelser nu propagerer naturligt. Forretningslogikken forbliver identisk – og det er præcis det, du verificerer under review, ikke resultatets elegance.

Forbedring af kvalitet

Du kan også målrette en specifik kvalitetsdimension frem for en syntaktisk transformation, forudsat at du specificerer kravene.

"In src/api/, improve error handling:
- Replace generic try/catch blocks with typed errors
- Add appropriate HTTP error codes
- Add logging with request context
- Ensure Prisma errors are mapped correctly"

Formuleret på denne måde bliver anmodningen verificerbar punkt for punkt under review. En isoleret prompt om at „forbedre fejlhåndteringen” ville producere noget, der ser plausibelt ud, men er ubrugeligt, fordi hverken du eller agenten ville vide, hvornår målet var nået.

Refaktorering baseret på mønstre

Den mest kraftfulde variant indebærer, at du udpeger en fil, der allerede overholder standarden, og anmoder om generalisering.

"All React components in src/components/ that use 
useState for forms must migrate to react-hook-form. 
Apply the same pattern as src/components/LoginForm.tsx, 
which is already migrated."

Codex læser referencekomponenten, udtrækker mønsteret og anvender det på målkomponenterne, samtidig med at den håndterer kanttilfælde – brugerdefineret validering, sideeffekter – i stedet for at udføre en blind udskiftning. Den praktiske konsekvens er interessant: Den første komponent, den du selv migrerer, betaler for alle de andre. Brug omsorg på denne modelfil; den er lige så meget værd som en specifikation.

Verificering af refaktoreringen

Codex kører test efter hver refaktorering, men en refaktorering, der består testene, er ikke nødvendigvis klar til produktion. Fire kontroller udgør minimumskravet, og hver af dem adresserer en anden risiko.

KontrolKommandoHvad den verificerer
Enhedstestnpm run testFunktionalitet bevaret
Typernpx tsc --noEmitIngen typefejl
Lintingnpm run lintKonventioner overholdt
Buildnpm run buildKlar til produktion

Det typiske tilfælde, der begrunder denne liste: Flytning af filer efterlader testene grønne, fordi de importerer fra en barrel-fil, men ødelægger produktionsbuildet på grund af en cirkulær import, som intet andet afslører. Tilføj disse fire kommandoer til din fil AGENTS.md, så vil Codex køre dem efter hver ændring, uden at du behøver tænke på det eller minde den om det.

Vigtige pointer

  • Refaktorering er den opgave, hvor Codex leverer den største tidsbesparelse
  • Referer til en modelfil for at styre refaktoringsmønsteret
  • Codex opdaterer imports og referencer på tværs af hele projektet
  • Verificer altid med test, typekontrol og build efter refaktorering
  • Dokumenter verifikationskommandoer i AGENTS.md