De oorzaak van de prestatieproblemen ligt in de geneste lussen die elk O(n²) complexiteit hebben, en de vergelijkingen die voor elke combinatie van items worden uitgevoerd. Bij grote invoer, zoals meer dan 10.000 items, leidt dit tot zeer trage uitvoering omdat het aantal operaties exponentieel toeneemt. Specifieke problemen: - Elke item wordt met elk ander item vergeleken, inclusief zichzelf. - De dubbele lus zorgt voor herhaalde vergelijkingen zonder dat ze nuttig zijn. - Het console.log() wordt veelvuldig aangeroepen, wat de uitvoering verder vertraagt. Concrete optimalisatiesuggesties: 1. **Gebruik een Set om duplicaten te vinden:** Als je alle duplicaten wilt identificeren, kun je gebruik maken van een Set, wat de complexiteit verlaagt naar O(n). ```javascript function processData(items) { const seen = new Set(); const duplicates = new Set(); for (let item of items) { if (seen.has(item)) { duplicates.add(item); } else { seen.add(item); } } // Bijvoorbeeld: log alle duplicaten for (let dup of duplicates) { console.log(dup); } } ``` 2. **Vermijd onnodige vergelijkingen:** Als je bijvoorbeeld alleen wilt weten welke items meerdere keren voorkomen, is bovenstaande aanpak efficiënt. 3. **Vermijd console.log binnen loops:** Console-uitvoer is traag en moet beperkt worden, vooral bij grote datasets. 4. **Overweeg andere datastructuren of algoritmen:** Afhankelijk van je exacte doel (bijvoorbeeld tellen van frequenties), kunnen hashmaps of objecten beter werken. **Kort samengevat:** De lange uitvoeringstijd wordt veroorzaakt door de O(n²) complexiteit van de dubbele for-lus. Gebruik een Set of een object voor frequentietelling om het aantal benodigde operaties drastisch te verminderen en zo de prestatie te verbeteren bij grote datasets.

Je prestatieprobleem wordt veroorzaakt door een **O(n²) tijdcomplexiteit** in je code. Bij 10.000 items voert je functie 100.000.000 (10.000 × 10.000) vergelijkingen uit! ## Probleemanalyse: - Dubbele geneste lus met O(n²) complexiteit - Onnodige vergelijkingen (inclusief zelf-vergelijkingen en dubbele checks) - Console.log in de binnenste lus vertraagt verder ## Optimalisatiesuggesties: ### 1. Gebruik een Set voor O(1) lookups: ```javascript function processData(items) { const seen = new Set(); const duplicates = new Set(); for(let i = 0; i < items.length; i++) { if(seen.has(items[i])) { duplicates.add(items[i]); } else { seen.add(items[i]); } } // Output alle duplicates duplicates.forEach(item => console.log(item)); } ``` ### 2. Alternatief met object voor counting: ```javascript function processData(items) { const countMap = {}; for(let i = 0; i < items.length; i++) { countMap[items[i]] = (countMap[items[i]] || 0) + 1; } // Output items die meer dan 1 keer voorkomen for(const item in countMap) { if(countMap[item] > 1) { console.log(item); } } } ``` ## Prestatieverbetering: - **Oud**: O(n²) → 100.000.000 operaties bij 10.000 items - **Nieuw**: O(n) → 10.000 operaties bij 10.000 items - **Snelheidswinst**: ≈ 10.000× sneller! ## Extra tips: - Vermijd console.log in grote loops - Gebruik console.time() om prestaties te meten - Overweeg Web Workers voor zeer grote datasets Deze optimalisatie reduceert je uitvoeringstijd van seconden/minuten naar milliseconden bij grote datasets.