Meerdere eigenschappen parallel en sequentieel animeren
Stel animaties samen met Animated.parallel om ze gelijktijdig uit te voeren en met Animated.sequence om ze na elkaar te koppelen voor complexe entry-animaties.
Meerdere eigenschappen parallel en sequentieel animeren is een gratis React Native Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject React Native Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus React Native Academy bevat in totaal 4 lessen.
Complexe animaties samenstellen
Animaties in echte gebruikersinterfaces bestaan zelden uit slechts één waarde die afzonderlijk verandert. Een modaal venster kan tegelijk omhoogschuiven en vervagen. Een pictogram voor succes kan eerst opveren, waarna een label naar binnen schuift. De Animated API van React Native biedt hulpmiddelen voor compositie waarmee je meerdere samenwerkende animaties kunt orkestreren: Animated.parallel, Animated.sequence, Animated.stagger en Animated.delay.
Deze compositiemethoden leveren animatieobjecten op die je kunt starten en stoppen en zelfs in elkaar kunt nesten voor complexe effecten met meerdere stappen.
Animated.parallel: gelijktijdige animaties
Animated.parallel neemt een array met animaties en voert ze allemaal tegelijk uit. Zodra alle animaties in de array zijn voltooid, is de parallelle groep klaar. Dit is de juiste keuze wanneer meerdere eigenschappen tegelijk moeten veranderen, bijvoorbeeld wanneer iets vervaagt en tegelijk omhoogschuift.
Standaard worden alle andere animaties ook gestopt als één animatie in een parallelle groep stopt, bijvoorbeeld door een onderbreking. Je kunt dit overschrijven met { stopTogether: false } als tweede argument.
const opacity = useRef(new Animated.Value(0)).current;
const translateY = useRef(new Animated.Value(50)).current;
Animated.parallel([
Animated.timing(opacity, {
toValue: 1,
duration: 400,
useNativeDriver: true,
}),
Animated.timing(translateY, {
toValue: 0,
duration: 400,
useNativeDriver: true,
}),
]).start();Animated.sequence: de ene na de andere
Animated.sequence neemt een array met animaties en voert deze één voor één uit: de volgende animatie start pas wanneer de vorige is voltooid. Dit is ideaal voor choreografieën met meerdere stappen: eerst wordt een knop ingedrukt, daarna verschijnt een laadindicator en vervolgens springt een vinkje naar binnen.
Als een animatie in een reeks wordt gestopt, worden de daaropvolgende animaties niet uitgevoerd. Je kunt reeksen nesten in parallelle groepen en andersom voor complexe choreografieën.
const scale = useRef(new Animated.Value(1)).current;
const checkOpacity = useRef(new Animated.Value(0)).current;
Animated.sequence([
// Step 1: button shrinks
Animated.spring(scale, { toValue: 0.9, useNativeDriver: true }),
// Step 2: wait 300ms
Animated.delay(300),
// Step 3: checkmark appears
Animated.timing(checkOpacity, {
toValue: 1,
duration: 200,
useNativeDriver: true,
}),
]).start();Animated.delay: pauzeren tussen stappen
Animated.delay doet gedurende een opgegeven aantal milliseconden niets. Dit is alleen nuttig binnen een reeks, waar het een pauze tussen animatiestappen creëert. Met delay kun je een natuurlijk tempo in animaties met meerdere stappen inbouwen.
Je kunt bijvoorbeeld na het voltooien van een actie een succesbericht met een korte vertraging tonen. Zo krijgt je gebruiker de tijd om te begrijpen wat er is gebeurd voordat de gebruikersinterface verandert. Vertragingen onder 300 ms zijn meestal niet merkbaar; 400–800 ms voelt doelbewust en weloverwogen aan.
Animated.sequence([
Animated.timing(opacity, { toValue: 1, duration: 300, useNativeDriver: true }),
Animated.delay(500), // pause for half a second
Animated.timing(opacity, { toValue: 0, duration: 300, useNativeDriver: true }),
]).start();Animated.stagger: trapsgewijze effecten
Animated.stagger lijkt op parallel, maar voegt een tijdsverschil toe tussen het starten van elke animatie. De eerste animatie start onmiddellijk, de tweede start na de stagger-vertraging, de derde na tweemaal die vertraging, enzovoort. Zo ontstaan fraaie trapsgewijze effecten bij het verschijnen van lijsten of menu's.
Stagger is ideaal om lijstitems te animeren wanneer ze op het scherm verschijnen: elk item vervaagt of schuift iets na het vorige naar binnen, waardoor het oog een duidelijke route door de inhoud kan volgen.
const items = [0, 1, 2, 3];
const opacities = items.map(() => new Animated.Value(0));
Animated.stagger(
100, // 100ms between each start
opacities.map(opacity =>
Animated.timing(opacity, {
toValue: 1,
duration: 300,
useNativeDriver: true,
})
)
).start();Een modaal venster in meerdere stappen laten verschijnen
Een goed uitgewerkte animatie voor het verschijnen van een modaal venster kan er als volgt uitzien: (1) de overlay vervaagt naar binnen, (2) de kaart van het modale venster schuift omhoog en vervaagt tegelijk naar binnen, (3) de titeltekst verschijnt. Deze choreografie in drie fasen gebruikt een reeks waarvan de eerste stap de overlay is, de tweede stap een parallelle animatie voor de kaart en de derde stap de titel.
Als je dit omhult met een useEffect die wordt uitgevoerd wanneer het modale venster zichtbaar wordt, krijg je de volledige verschijningsanimatie die door de status wordt gestart.
const overlayOpacity = useRef(new Animated.Value(0)).current;
const cardTranslateY = useRef(new Animated.Value(80)).current;
const cardOpacity = useRef(new Animated.Value(0)).current;
useEffect(() => {
if (visible) {
Animated.sequence([
Animated.timing(overlayOpacity, { toValue: 0.5, duration: 200, useNativeDriver: true }),
Animated.parallel([
Animated.timing(cardOpacity, { toValue: 1, duration: 300, useNativeDriver: true }),
Animated.spring(cardTranslateY, { toValue: 0, useNativeDriver: true }),
]),
]).start();
}
}, [visible]);Een verdwijningsanimatie voor een modaal venster bouwen
Verdwijningsanimaties worden in omgekeerde volgorde uitgevoerd: eerst schuift de kaart weg en vervaagt deze, daarna vervaagt de overlay en vervolgens werk je de status bij om het modale venster uit de componentstructuur te verwijderen. Start het verdwijnen in de sluitingsafhandelaar, wacht in de callback tot de animatie is voltooid en roep pas daarna setVisible(false) aan.
Zo voorkom je dat het modale venster abrupt verdwijnt voordat de animatie is voltooid, een veelgemaakte fout waardoor apps goedkoop aanvoelen.
function closeModal() {
Animated.sequence([
Animated.parallel([
Animated.timing(cardOpacity, { toValue: 0, duration: 200, useNativeDriver: true }),
Animated.timing(cardTranslateY, { toValue: 80, duration: 200, useNativeDriver: true }),
]),
Animated.timing(overlayOpacity, { toValue: 0, duration: 150, useNativeDriver: true }),
]).start(() => setVisible(false)); // unmount AFTER animation
}Parallel binnen een reeks nesten
Je kunt compositiemethoden vrij nesten. Een parallelle animatie binnen een reeks betekent dat er tijdens die stap meerdere dingen tegelijk gebeuren. Een reeks binnen een parallelle animatie betekent dat één tak stap voor stap wordt uitgevoerd terwijl een andere tak onmiddellijk parallel begint.
Je kunt dit vergelijken met het plannen van een theatervoorstelling: sommige acteurs staan tegelijk op het podium (parallel), sommige scènes volgen elkaar direct op (reeks) en sommige speciale effecten worden met een rimpelvertraging uitgevoerd (stagger).
// Sequence with a parallel step inside
Animated.sequence([
Animated.timing(step1, { toValue: 1, duration: 300, useNativeDriver: true }),
Animated.parallel([
Animated.timing(step2a, { toValue: 1, duration: 400, useNativeDriver: true }),
Animated.spring(step2b, { toValue: 1, useNativeDriver: true }),
]),
Animated.timing(step3, { toValue: 1, duration: 200, useNativeDriver: true }),
]).start();Samengestelde animaties stoppen en resetten
Het object dat door compositiemethoden wordt geretourneerd, heeft een methode .stop(). Sla de animatie op in een ref, zodat je deze van buitenaf kunt stoppen, bijvoorbeeld wanneer een component halverwege de animatie wordt verwijderd of wanneer een nieuwe animatie de huidige moet onderbreken.
Stop animaties altijd in de opruimfunctie van useEffect om waarschuwingen over 'setState on unmounted component' en geheugenlekken te voorkomen, vooral bij herhalende of langlopende reeksen.
const animRef = useRef(null);
useEffect(() => {
animRef.current = Animated.sequence([
Animated.timing(a, { toValue: 1, duration: 500, useNativeDriver: true }),
Animated.timing(b, { toValue: 1, duration: 500, useNativeDriver: true }),
]);
animRef.current.start();
return () => {
if (animRef.current) animRef.current.stop();
};
}, []);Lijstitems trapsgewijs laten verschijnen
Bij een praktische implementatie van stagger initialiseer je een array met Animated.Values, één per lijstitem, allemaal op transparantie 0. Vervolgens voer je een stagger-animatie uit in een useEffect wanneer de gegevens zijn geladen. Elk item in de weergegeven lijst wordt via zijn index gekoppeld aan de bijbehorende animated value.
Door deze techniek voelen schermen met veel inhoud dynamischer aan. Gebruikers ervaren trapsgewijs laden als sneller dan wanneer alles tegelijk verschijnt, ook al duurt het in totaal langer.
const itemAnimations = useRef(data.map(() => new Animated.Value(0))).current;
useEffect(() => {
Animated.stagger(
80,
itemAnimations.map(anim =>
Animated.timing(anim, { toValue: 1, duration: 350, useNativeDriver: true })
)
).start();
}, [data]);
// In renderItem:
<Animated.View style={{ opacity: itemAnimations[index] }}>
<ItemComponent item={item} />
</Animated.View>Coördineren met de levenscyclus van componenten
Door animaties met de levenscyclus van een component samen te stellen, zorg je dat ze op het juiste moment worden afgespeeld. Gebruik useEffect voor animaties bij het koppelen, effecten van statuswijzigingen voor voorwaardelijke animaties en compositie van callbacks voor verdwijningsanimaties voordat de component wordt verwijderd.
Houd de animatielogica dicht bij de component die de animated values beheert. Als de animatielogica complex wordt, kun je deze verplaatsen naar een aangepaste hook die de animated values en triggerfuncties retourneert, zodat de JSX-laag overzichtelijk blijft.
// Custom hook pattern
function useFadeSlide() {
const opacity = useRef(new Animated.Value(0)).current;
const translateY = useRef(new Animated.Value(20)).current;
const animateIn = () =>
Animated.parallel([
Animated.timing(opacity, { toValue: 1, duration: 300, useNativeDriver: true }),
Animated.timing(translateY, { toValue: 0, duration: 300, useNativeDriver: true }),
]);
return { opacity, translateY, animateIn };
}Korte controle
Test je begrip van de concepten uit React Native Mobile Development die in deze les zijn behandeld.
Samenvatting van de les
In deze les heb je geleerd dat Animated.parallel meerdere animaties tegelijk uitvoert, dat Animated.sequence animaties aan elkaar koppelt, zodat elke animatie start nadat de vorige is voltooid en dat Animated.stagger trapsgewijze effecten maakt door de starttijden binnen een array met animaties te verschuiven. Hierna leer je hoe je met useNativeDriver animaties van 60 fps maakt door het werk uit te besteden aan de native thread.
Leer JavaScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Meerdere eigenschappen parallel en sequentieel animeren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad React Native Academy, waaronder “Meerdere eigenschappen parallel en sequentieel animeren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus React Native Academy bevat in totaal 4 lessen.
Wat leer ik in “Meerdere eigenschappen parallel en sequentieel animeren”?
Stel animaties samen met Animated.parallel om ze gelijktijdig uit te voeren en met Animated.sequence om ze na elkaar te koppelen voor complexe entry-animaties. Je oefent met React Native Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met React Native Academy te beginnen?
Ervaring vooraf is niet nodig. React Native Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Meerdere eigenschappen parallel en sequentieel animeren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over React Native Academy?
Ja. Elke les over React Native Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Animated.Value en Animated.View
- Spring- en decay-animaties
- Meerdere eigenschappen parallel en sequentieel animeren
- useNativeDriver voor animaties met 60 fps