Het minimaliseren en identificeren van duplicatie in een legacy codebase vereist een gestructureerde aanpak. Hieronder vind je technieken, best practices en een strategie om duplicatie effectief te beheren en te voorkomen. 1. Analyseren en Detecteren van Duplicatie a. Handmatige Inspectie: - Lees de code en markeer patronen die herhaald worden. - Let op gelijkaardige functies, logica of codeblokken. b. Automatische Tools: - Gebruik tools zoals SonarQube, PMD, or ESLint (voor JavaScript) om duplicatie te detecteren. - Sommige IDE's (zoals IntelliJ IDEA of Visual Studio Code) bieden ingebouwde functies voor duplicatieanalyse. c. Code Metrics: - Meet complexiteit en herhaling, bijvoorbeeld via cyclomatic complexity of code clone detection tools. 2. Refactoren naar Herbruikbare Componenten a. Identificeer Gemeenschappelijke Logica: - Bijvoorbeeld, functies `berekenBTW` en `berekenKorting` kunnen worden samengevoegd of herschreven. b. Creëer Algemene Functies: - Bijvoorbeeld, maak een algemene functie voor procentuele berekeningen: ```javascript function berekenPercentage(bedrag, percentage) { return bedrag * (percentage / 100); } ``` c. Gebruik Objecten of Klassen: - Groepeer gerelateerde functies in objecten of klassen voor betere structuur. d. Modulariseer Code: - Verdeel grote bestanden in kleinere modules die herbruikbare logica bevatten. 3. Voorkomen van Toekomstige Duplicatie a. Code Reviews: - Stimuleer peer reviews gericht op duplicatie en hergebruik. b. Documentatie en Richtlijnen: - Stel coding standards op die hergebruik en modulariteit bevorderen. c. Automatisering: - Integreer tools voor duplicatiecontrole in je CI/CD-pijplijn. d. Testen: - Schrijf unit tests om te zorgen dat refactored code correct functioneert en hergebruik veilig is. 4. Specifieke Strategie voor Legacy Code a. Incrementeel Refactoren: - Begin met de meest problematische delen. - Pas refactoring toe in kleine stappen om regressies te voorkomen. b. Wrappen van Legacy Code: - Maak adapterlagen of wrappers voor oude functies om hergebruik te faciliteren. c. Documenteer Duplicaten: - Houd bij waar duplicaten gevonden en aangepakt worden voor toekomstige referentie. Voorbeeldherstructurering van je code: ```javascript // Oude code function berekenBTW(bedrag) { return bedrag * 0.21; } function berekenKorting(bedrag) { return bedrag * 0.1; } // Geoptimaliseerd function berekenPercentage(bedrag, percentage) { return bedrag * (percentage / 100); } // Gebruik const btw = berekenPercentage(bedrag, 21); const korting = berekenPercentage(bedrag, 10); ``` Door deze aanpak te volgen, verbeter je de structuur van je code, reduceer je duplicatie en creëer je een onderhoudsvriendelijkere codebase.

Absoluut. Hier is een gestructureerde strategie, specifiek toegespitst op legacy code met veel overlappende functies, om duplicatie aan te pakken in het Nederlands. ### Algemene Strategie: "Find, Fix, Prevent" De aanpak bestaat uit drie hoofdonderdelen: het **opspeuren** van duplicatie, het **refactoren** ervan, en het **voorkomen** van nieuwe duplicatie. --- ### Deel 1: Opsporen van Duplicatie (Find) Bij legacy code is handmatig zoeken onbegonnen werk. Gebruik geautomatiseerde tools. 1. **Statische Code-Analyse Tools (Linters):** * **ESLint (voor JavaScript/TypeScript):** Installeer de plugin `eslint-plugin-sonarjs`. Deze bevat regels zoals `no-duplicate-string` en `no-identical-functions` die specifiek zoeken naar duplicatie. * **SonarQube / SonarCloud:** Dit zijn krachtige, professionele tools die een volledige analyse van je codebase doen. Ze geven een duidelijk overzicht van "code smells", waaronder **duplicated lines** en **duplicated blocks**. Dit is vaak de beste start. 2. **Manuele Inspectie (Gericht):** * **Zoek naar "code hunches":** Let op functies met vergelijkbare namen (`berekenX`, `getY`, `fetchZ`). * **Gebruik de zoekfunctie van je IDE:** Zoek op sleutelwoorden, magic numbers (zoals `0.21`), of specifieke logica die je vaker voor ziet komen. --- ### Deel 2: Refactoren naar Herbruikbare Componenten (Fix) Zodra je duplicatie hebt gevonden, is refactoren de volgende stap. We gebruiken je voorbeeld als vertrekpunt. **Uitgangspunt:** ```javascript function berekenBTW(bedrag) { return bedrag * 0.21; } function berekenKorting(bedrag) { return bedrag * 0.1; } ``` **Stap 1: Identificeer het Patroon** Beide functies doen hetzelfde: ze vermenigvuldigen een bedrag met een percentage. Alleen het percentage verschilt. **Stap 2: Creëer een Generieke Functie** Vervang de specifieke functies door één algemene, herbruikbare functie. ```javascript // GENERIEKE FUNCTIE - De "single source of truth" function berekenPercentage(bedrag, percentage) { return bedrag * percentage; } ``` **Stap 3: Refactor de Bestaande Code (Opties)** Kies een aanpak die bij je codebase past. * **Optie A: Vervang directe aanroepen** ```javascript // Vervang dit: const btw = berekenBTW(100); const korting = berekenKorting(100); // Door dit: const btw = berekenPercentage(100, 0.21); const korting = berekenPercentage(100, 0.1); ``` * **Optie B: Houd bestaande functies voor leesbaarheid (Aanbevolen voor legacy)** *Behoud de oude functienamen als een "laag" om je nieuwe generieke functie, voor backward compatibility en duidelijkheid.* ```javascript // Nieuwe, generieke kernfunctie function berekenPercentage(bedrag, percentage) { return bedrag * percentage; } // Bestaande functies refactoren om de generieke functie te gebruiken function berekenBTW(bedrag) { return berekenPercentage(bedrag, 0.21); } function berekenKorting(bedrag) { return berekenPercentage(bedrag, 0.1); } ``` **Voordeel:** Alle bestaande code die `berekenBTW()` of `berekenKorting()` aanroept, blijft werken! Je introduceert geen bugs en de logica is gecentraliseerd. **Stap 4: Elimineer "Magic Numbers"** Vervang de percentages (0.21, 0.1) door benoemde constanten. Dit maakt de code zelf-documenterend en voorkomt fouten. ```javascript // Definieer constanten op een centrale plek, bijvoorbeeld een configuratiebestand const BTW_PERCENTAGE = 0.21; const STANDAARD_KORTING = 0.1; function berekenPercentage(bedrag, percentage) { return bedrag * percentage; } function berekenBTW(bedrag) { return berekenPercentage(bedrag, BTW_PERCENTAGE); } function berekenKorting(bedrag) { return berekenPercentage(bedrag, STANDAARD_KORTING); } ``` --- ### Deel 3: Voorkomen van Toekomstige Duplicatie (Prevent) 1. **Code Reviews (Pull Requests):** Maak code reviews verplicht. Een tweede paar ogen is het beste wapen tegen duplicatie. Vraag expliciet: "Zien we deze logica elders ook?" 2. **"Drie is een Herhaling"-regel:** Spreek af dat als dezelfde code **drie keer** voorkomt, deze *moet* worden gerefactord naar een herbruikbare component. Eén keer is toeval, twee keer is verdacht, drie keer is een patroon. 3. **Schrijf Testen (Unit Tests):** Voor je begint met refactoren, schrijf je unit tests voor de bestaande functies. Dit geeft je de zekerheid dat je na het refactoren niets kapot maakt ("regressie"). ```javascript // Eenvoudige test voor berekenBTW test('berekenBTW geeft 21 euro terug voor 100 euro', () => { expect(berekenBTW(100)).toBe(21); }); ``` 4. **Architectuur en Principes:** * **DRY (Don't Repeat Yourself):** Maak dit principe tot een kernwaarde binnen je team. * **Single Responsibility Principle:** Zorg ervoor dat elke functie of module maar één ding doet. Dit maakt ze van nature herbruikbaar. * **Centrale Configuratie:** Houd waarden zoals percentages, API URLs, en andere constanten in één centraal configuratiebestand. ### Samenvatting voor jouw Legacy Code 1. **Start met een Tool:** Zet SonarQube of ESLint met de juiste plugins op om de ergste duplicatie in kaart te brengen. 2. **Begin Klein:** Kies een klein, overzichtelijk stukje duplicatie (zoals het BTW/voorbeeld) en refactor dat. Dit levert een snel succes op. 3. **Gebruik de "Wrapper"-aanpak (Optie B):** Dit is de veiligste manier voor legacy code omdat je geen bestaande aanroepers breekt. 4. **Introduceer Constanten:** Vervang magic numbers overal waar je ze tegenkomt. 5. **Voer Code Reviews en Tests In:** Dit zijn de langetermijnoplossingen om de codebase gezond te houden. Door deze stappen methodisch toe te passen, kun je de chaos in je legacy codebase geleidelijk aan transformeren naar een goed gestructureerde, onderhoudbare codebase.