React Native Academy · leksjon

Spring- og decay-animasjoner

Bruk Animated.spring til å opprette spretten, fysikkbasert bevegelse, juster parameterne for tension og friction, og bruk Animated.decay for rulleffekter basert på bevegelsesmomentum.

Leksjon 2 av 413 trinn

Spring- og decay-animasjoner er en gratis leksjon i React Native Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i React Native Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i React Native Academy inneholder totalt 4 leksjoner.

Utover lineær bevegelse: fysikkbasert bevegelse

Lineære tidsanimasjoner føles mekaniske fordi objekter i den virkelige verden sjelden beveger seg med konstant hastighet. Fysikkbaserte animasjoner simulerer naturlige krefter som fjærer og bevegelsesmengde, slik at bevegelsene i brukergrensesnittet føles levende og naturlige. React Natives Animated API tilbyr to fysikkmotorer: Animated.spring for elastisk sprett og Animated.decay for nedbremsing basert på bevegelsesmengde.

Valget av riktig animasjonstype påvirker den opplevde kvaliteten betydelig. Timing passer for opasitetsuttoninger, spring passer for interaktive elementer som knapper og kort, og decay passer for sveipebevegelser som avviser elementer.

Animated.spring: Sprettende bevegelse

Animated.spring simulerer en fjær som trekker en verdi mot en målverdi. Verdien går forbi målverdien og svinger frem og tilbake til den stabiliserer seg — den klassiske sprettende effekten. Som minimum oppgir De toValue og useNativeDriver.

Fjæranimasjoner føles naturlige for elementer som reagerer på brukerinteraksjon, for eksempel en knapp som skaleres opp når den trykkes på, eller en modal som glir inn nedenfra. Standardparametrene for fjæren er allerede justert for å føles gode på mobil, men De kan tilpasse dem.

import { Animated } from 'react-native';
import { useRef } from 'react';

const scale = useRef(new Animated.Value(0)).current;

Animated.spring(scale, {
  toValue: 1,
  useNativeDriver: true,
}).start();

Justere fjæren med tension og friction

Hvordan en fjæranimasjon føles, styres av to parametere: tension og friction. Tension styrer hvor raskt fjæren trekkes mot målverdien — høyere tension gir raskere og mer kontant bevegelse. Friction styrer hvor raskt svingningene dempes — lavere friction gir mer sprett.

Standardverdien for tension er 40, og for friction er den 7. Prøv tension 100 og friction 10 for en rask og responsiv følelse. Prøv tension 20 og friction 3 for en langsom og ustødig effekt. Eksperimenter for å finne riktig følelse for brukergrensesnittet.

Animated.spring(scale, {
  toValue: 1,
  tension: 100,    // higher = snappier
  friction: 10,    // higher = less bouncy
  useNativeDriver: true,
}).start();

// Wobbly alternative:
Animated.spring(scale, {
  toValue: 1,
  tension: 20,
  friction: 3,
  useNativeDriver: true,
}).start();

Fjær med stiffness, mass og damping

React Native støtter også en mer fysikkorrekt fjærmodell ved hjelp av stivhet, masse og demping. Disse tilsvarer fysiske egenskaper ved et fjærsystem – stivhet er fjærkonstanten, masse er objektets vekt, og demping er luftmotstandskoeffisienten.

Denne modellen er kompatibel med fjæranimasjoner i iOS UIKit og Framer Motion på nettet, noe som gjør det enklere å gjenskape animasjoner som er utformet i prototypingsverktøy. Bruk enten spennings-/friksjonsmodellen eller stivhets-/masse-/dempingsmodellen – ikke begge samtidig.

Animated.spring(translateY, {
  toValue: 0,
  stiffness: 120,
  mass: 1,
  damping: 14,
  useNativeDriver: true,
}).start();

Bygge en fjærende trykkeffekt for knapper

Et vanlig mønster for fjæranimasjoner er å skalere en knapp litt ned når den trykkes på, og tilbake til full størrelse når trykket slippes, slik at brukeren får en tilfredsstillende taktil tilbakemelding. Bruk Pressable med onPressIn og onPressOut for å utløse fjæranimasjoner på skaleringsverdien.

Den raske fjærbevegelsen ned ved trykk og tilbake ved slipp får knappene til å føles fysiske og responsive. Dette er mer tilfredsstillende enn en enkel endring av gjennomsiktighet og brukes ofte i gjennomarbeidede mobilapper.

const scale = useRef(new Animated.Value(1)).current;

const onPressIn = () => {
  Animated.spring(scale, { toValue: 0.9, useNativeDriver: true }).start();
};
const onPressOut = () => {
  Animated.spring(scale, { toValue: 1, useNativeDriver: true }).start();
};

return (
  <Pressable onPressIn={onPressIn} onPressOut={onPressOut}>
    <Animated.View style={{ transform: [{ scale }] }}>
      <Text>Press Me</Text>
    </Animated.View>
  </Pressable>
);

Hva er Animated.decay?

Animated.decay simulerer bevegelsesmengde: Den begynner å bevege en verdi med en angitt hastighet og bremser den gradvis over tid, som om friksjon virket på den. Det finnes ingen målverdi – animasjonen kjører til bevegelsesmengden er brukt opp.

Decay er det naturlige supplementet til sveipebevegelser. Når brukeren sveiper raskt over et kort eller en liste, sendes hastigheten ved slipp direkte inn i en decay-animasjon. Da fortsetter elementet å bevege seg og bremser naturlig – akkurat slik mobilapper oppførte seg før digitale brukergrensesnitt.

// velocity is obtained from a gesture handler's onGestureEvent
Animated.decay(position, {
  velocity: 0.8,       // initial velocity (pixels per millisecond)
  deceleration: 0.997, // how quickly momentum fades (0-1)
  useNativeDriver: true,
}).start();

Decay etter en sveipebevegelse

Det typiske decay-mønsteret er å spore fingerens posisjon under en pan-bevegelse og sende den endelige hastigheten fra bevegelsen til Animated.decay når fingeren løftes. Verdien for deceleration (standardverdi 0.997) styrer hvor raskt elementet bremser – en verdi nærmere 1 gir lengre glidning, mens en verdi nærmere 0 gir en rask stopp.

Når decay-animasjonen er ferdig, fester du vanligvis elementet til en sluttposisjon ved hjelp av en fjæranimasjon dersom det er nødvendig, for eksempel ved å feste et kort tilbake til midten eller til en posisjon som viser at det er avvist.

// In a PanResponder onPanResponderRelease:
onPanResponderRelease: (evt, gestureState) => {
  Animated.decay(position, {
    velocity: gestureState.vx, // velocity at finger lift
    deceleration: 0.997,
    useNativeDriver: true,
  }).start(({ finished }) => {
    if (finished) {
      // optionally snap to final position
    }
  });
}

Sammenligning av spring, decay og timing

Det er viktig å forstå når de ulike animasjonstypene bør brukes, for å få et naturlig brukergrensesnitt:

  • Animated.timing – forutsigbar og har fast varighet. Egner seg best for tilbakemeldinger i brukergrensesnittet, som endringer i gjennomsiktighet og fremdriftsindikatorer, der nøyaktig timing er viktig.
  • Animated.spring – elastisk og går forbi målverdien. Egner seg best for responsive interaktive elementer som knapper, kort og visning av modaler.
  • Animated.decay – basert på bevegelsesmengde og uten fast sluttpunkt. Egner seg best for å fortsette en bevegelse etter at en bevegelse er sluppet, for eksempel ved sveiping.

Bruke hastighet fra brukerinteraksjon

Fjærer har også parameteren velocity, som angir fjærens starthastighet og gjør at de kobles naturlig til bevegelse fra en gest. Når brukeren drar i et kort og slipper, kan du starte en fjær med hastigheten fra gesten, slik at bevegelsen fortsetter jevnt.

Dette skaper en sømløs overgang mellom gest og animasjon – kortet føles som om det ble kastet med brukerens hånd, i stedet for å bli flyttet brått til hvileposisjonen.

// After a pan gesture releases:
onPanResponderRelease: (evt, { vx, vy }) => {
  Animated.spring(position, {
    toValue: { x: 0, y: 0 }, // snap back to center
    velocity: { x: vx, y: vy },
    tension: 50,
    friction: 8,
    useNativeDriver: true,
  }).start();
}

Spring med Animated.ValueXY

Animated.ValueXY er en praktisk omslagsklasse som inneholder et par Animated.Values for x- og y-koordinater. Den forenkler 2D-animasjoner, for eksempel når kort skal dras. Både spring og decay fungerer med ValueXY, som også har hjelpemetoder som getTranslateTransform() for automatisk å generere transformasjonsmatrisen.

ValueXY reduserer mengden standardkode når du må animere et elements posisjon i et 2D-område, fordi du slipper å håndtere to separate Animated.Values manuelt.

const position = useRef(new Animated.ValueXY({ x: 0, y: -200 })).current;

useEffect(() => {
  Animated.spring(position, {
    toValue: { x: 0, y: 0 },
    useNativeDriver: true,
  }).start();
}, []);

return (
  <Animated.View style={position.getTranslateTransform()}>
    <Text>Falls into place</Text>
  </Animated.View>
);

Tilbakestille Animated-verdier

Du kan tilbakestille en Animated.Value til starttilstanden ved å kalle .setValue(initialValue). Dette er nyttig før du kjører en animasjon på nytt – for eksempel ved å tilbakestille en skalering til 0 før du kjører en ny innfjæringsanimasjon, eller ved å tilbakestille posisjonen før du spiller av en innledende animasjon på nytt.

Tilbakestill alltid synkront før du starter animasjonen, slik at du unngår et synlig blink. Kall setValue i den samme hendelsesbehandleren eller i useEffect, umiddelbart etterfulgt av Animated.spring(...).start().

function replay() {
  // Reset to start position
  scale.setValue(0);
  // Then spring to final position
  Animated.spring(scale, {
    toValue: 1,
    tension: 80,
    friction: 8,
    useNativeDriver: true,
  }).start();
}

Kort test

Test forståelsen Deres av konseptene innen React Native Mobile Development fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen lærte De at Animated.spring oppretter fysikkbasert, sprettende bevegelse som justeres med tension og friction, at Animated.decay simulerer bevegelsesmengdebasert bremsing fra en starthastighet, og at hver animasjonstype passer til ulike interaksjonsmønstre – spring for tilbakemelding ved trykk og decay når en gest slippes. Deretter skal vi se på hvordan flere animasjoner kan settes sammen parallelt og i sekvens.

Gratis å komme i gang

Lær deg JavaScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120

Ofte stilte spørsmål

Er leksjonen «Spring- og decay-animasjoner» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien React Native Academy, inkludert «Spring- og decay-animasjoner», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i React Native Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Spring- og decay-animasjoner»?

Bruk Animated.spring til å opprette spretten, fysikkbasert bevegelse, juster parameterne for tension og friction, og bruk Animated.decay for rulleffekter basert på bevegelsesmomentum. Du øver på React Native Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med React Native Academy?

Ingen tidligere erfaring er nødvendig. React Native Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Spring- og decay-animasjoner»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne React Native Academy-leksjonen?

Ja. Alle React Native Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Animated.Value og Animated.View
  2. Spring- og decay-animasjoner
  3. Animere flere egenskaper parallelt og i sekvens
  4. useNativeDriver for animasjoner med 60 bilder per sekund
← Tilbake til React Native Academy