Frontend
const createCounter = () => {
Taak 1: In de Vue-toepassing is de component AddLoan (formulier voor het toevoegen van een lening) al geïmporteerd. Het moet zo worden ingesteld dat dit formulier standaard verborgen is en verschijnt/verbergt bij het klikken op een knop (implementeren van het wisselen van zichtbaarheid van het formulier, bijvoorbeeld via v-if/v-show en flag/toggle, en ook het emitten van een sluitgebeurtenis van het formulier van het component naar boven).
Hoe was GitFlow georganiseerd in het project?
Tot slot is CSS een fundamentele technologie in front-end ontwikkeling, waarmee ontwikkelaars de lay-out, styling en visuele presentatie van webapplicaties kunnen controleren. Wie stelde CSS voor en in welk jaar werd het voor het eerst geïntroduceerd?
Schrijf de types voor de functie reduce met behulp van generics (voor array, callback en resultaat).
We hebben een groot project in een monorepo met een uniforme release-stroom. We hebben besloten het op te splitsen en de frontend in aparte repositories te plaatsen met hun eigen releasecyclus. Er ontstaat het probleem van versie-inconsistentie tussen de backend en de client. Hoe zou je dit probleem oplossen? Hoe organiseer je het werk om zo goed mogelijk beschermd te zijn tegen storingen in productie?
Welke andere methoden van de Promise API ken je naast Promise.all?
Wat zijn de nadelen of problemen van SSR?
Wat is het verschil tussen Promise en async/await? Hoe voer je twee asynchrone verzoeken parallel uit? Welke Promise-methoden ken je (all, allSettled, race, any)?
Hoe update je handmatig de weergave van een component met OnPush en wat is het verschil tussen markForCheck en detectChanges?
/* * Functie die het aanvragen van gegevens vanaf de backend nabootst. * Backend heeft een RPS-beperking en zal falen, * als het aantal parallelle verzoeken meer is dan MAX_PARALLEL_REQUESTS. */ function requestData(id: number): Promise<string> { parallelRequests++; if (parallelRequests > MAX_PARALLEL_REQUESTS) { throw new Error("Te veel parallelle verzoeken"); } return new Promise((res) => { setTimeout(() => { parallelRequests--; return res(`${id * 2}`); }, Math.floor(Math.random() * 2000)) }); } function prepareData( ids: number[], maxParallelRequests: number, ): Promise<string[]> { /* * TODO: implementeer het aanvragen van alle gegevens, * met niet meer dan maxParallelRequests * parallelle verbindingen. */ }
const submit = useCallback((el) => () => { log(el); }, []); arr.map(el => <button onClick={submit(el)} />) arr.map(el => <SomeComp key={} onClick={() => submit(el)} />) const param = useMemo(() => ({c: a + b}), [a,b]) return <Child value={param} /> Child = React.memo(() => {})
We hebben de componenten geoptimaliseerd — geef een voorbeeld van hoe het was vóór de optimalisatie en wat er daarna was.
Vertel me over het gebruik van Astro: hoe hebben ze het gekozen, hoe beheren ze de inhoud?
Waarom is het beter om useCallback te laten of niet te laten, en waarom?
Noem de redenen waarom een React-component opnieuw wordt gerenderd. Waarom richt React zich op het wijzigen van de verwijzing en niet op het wijzigen van de waarde?
Begrepen, Dmytro. Een kleine opmerking: je zei "fouten" — bedoelde je "pijlen"? In een echte app, hoe zou je dit gedrag aan een teamgenoot uitleggen zodat ze per ongeluk de toegankelijkheid niet breken terwijl ze de prestaties optimaliseren?
Implementeer een functie foo die een array neemt en een object retourneert waarbij de sleutels de elementen van de array zijn en de waarden allemaal 0.
Waarom is de uitvoeringstijd van sleep niet precies 1000 en 2000 milliseconden, maar iets meer? Wat beïnvloedt de vertraging?
Vertel me meer over de taken op je huidige werkplek, wat was vooral interessant en moeilijk.