VueJS - przejście i animacja

W tym rozdziale omówimy funkcje przejść i animacji dostępne w VueJS.

Przejście

VueJS zapewnia różne sposoby zastosowania przejścia do elementów HTML, gdy są one dodawane / aktualizowane w DOM. VueJS ma wbudowany komponent przejściowy, który należy owinąć wokół elementu, który wymaga przejścia.

Składnia

<transition name = "nameoftransition">
   <div></div>
</transition>

Rozważmy przykład, aby zrozumieć działanie przejścia.

Przykład

<html>
   <head>
      <title>VueJs Instance</title>
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <style>
         .fade-enter-active, .fade-leave-active {
            transition: opacity 2s
         }
         .fade-enter, .fade-leave-to /* .fade-leave-active below version 2.1.8 */ {
            opacity: 0
         }
      </style>
      <div id = "databinding">
         <button v-on:click = "show = !show">Click Me</button>
         <transition name = "fade">
            <p v-show = "show" v-bind:style = "styleobj">Animation Example</p>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#databinding',
            data: {
               show:true,
               styleobj :{
                  fontSize:'30px',
                  color:'red'
               }
            },
            methods : {
            }
         });
      </script>
   </body>
</html>

Powstał przycisk o nazwie clickme, za pomocą którego możemy zmienić wartość zmiennej show na true na false i odwrotnie. Tam jestp tagktóry pokazuje element tekstowy tylko wtedy, gdy zmienna jest prawdziwa. Owinęliśmy znacznik p elementem przejściowym, jak pokazano w poniższym fragmencie kodu.

<transition name = "fade">
   <p v-show = "show" v-bind:style = "styleobj">Animation Example</p>
</transition>

Nazwa przejścia to fade. VueJS udostępnia kilka standardowych klas przejść, a nazwy tych klas są poprzedzone nazwą przejścia.

Oto kilka standardowych klas do przejścia -

  • v-enter- Ta klasa jest wywoływana początkowo przed aktualizacją / dodaniem elementu. To stan początkowy.

  • v-enter-active- Ta klasa służy do definiowania opóźnienia, czasu trwania i krzywej łagodzenia przy wchodzeniu w fazę przejściową. Jest to stan aktywny dla całego, a klasa jest dostępna podczas całej fazy wchodzenia.

  • v-leave - Dodano, gdy zostanie uruchomione przejście wyjściowe, usunięte.

  • v-leave-active- Stosowany w fazie wyjścia. Jest usuwany po zakończeniu przejścia. Ta klasa jest używana do stosowania krzywej opóźnienia, czasu trwania i łagodzenia podczas fazy wychodzenia.

Każda z powyższych klas będzie poprzedzona nazwą przejścia. Nazwaliśmy to przejście jako zanikanie, stąd nazwa klas.fade_enter, .fade_enter_active, .fade_leave, .fade_leave_active.

Są zdefiniowane w poniższym kodzie.

<style>
   .fade-enter-active, .fade-leave-active {
      transition: opacity 2s
   }
   .fade-enter, .fade-leave-to /* .fade-leave-active below version 2.1.8 */ {
      opacity: 0
   }
</style>

.Fade_enter_active i .fade_leave_active są zdefiniowane razem i stosuje przejście na początku i na końcu etapu. Właściwość krycia jest zmieniana na 0 w ciągu 2 sekund.

Czas trwania jest zdefiniowany w plikach .fade_enter_active i .fade_leave_active. Ostatni etap jest zdefiniowany w plikach .fade_enter, .fade_leave_to.

Sposób wyświetlania w przeglądarce wygląda następująco.

Po kliknięciu przycisku tekst zniknie w ciągu dwóch sekund.

Po dwóch sekundach tekst zniknie całkowicie.

Rozważmy inny przykład, w którym znajduje się obraz i jest on przesuwany na osi X po kliknięciu przycisku.

Przykład

<html>
   <head>
      <title>VueJs Instance</title>
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <style>
         .shiftx-enter-active, .shiftx-leave-active {
            transition: all 2s ease-in-out;
         }
         .shiftx-enter, .shiftx-leave-to /* .fade-leave-active below version 2.1.8 */ {
            transform :  translateX(100px);
         }
      </style>
      <div id = "databinding">
         <button v-on:click = "show = !show">Click Me</button>
         <transition name = "shiftx">
            <p v-show = "show">
               <img src = "images/img.jpg" style = "width:100px;height:100px;" />
            </p>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#databinding',
            data: {
               show:true
            },
            methods : {
            }
         });
      </script>
   </body>
</html>

Nazwa przejścia to shiftx. Właściwość transform służy do przesuwania obrazu na osi X o 100 pikseli przy użyciu następującego fragmentu kodu.

<style>
   .shiftx-enter-active, .shiftx-leave-active {
      transition: all 2s ease-in-out;
   }
   .shiftx-enter, .shiftx-leave-to /* .fade-leave-active below version 2.1.8 */ {
      transform :  translateX(100px);
   }
</style>

Poniżej znajduje się wynik.

Po kliknięciu przycisku obraz przesunie się o 100 pikseli w prawo, jak pokazano na poniższym zrzucie ekranu.

Animacja

Animacje są stosowane w taki sam sposób, jak przejście. Animacja zawiera również klasy, które muszą zostać zadeklarowane, aby efekt miał miejsce.

Rozważmy przykład, aby zobaczyć, jak działa animacja.

Przykład

<html>
   <head>
      <title>VueJs Instance</title>
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <style>
         .shiftx-enter-active {
            animation: shift-in 2s;
         }
         .shiftx-leave-active {
            animation: shift-in 2s reverse;
         }
         @keyframes shift-in {
            0%   {transform:rotateX(0deg);}
            25%  {transform:rotateX(90deg);}
            50%  {transform:rotateX(120deg);}
            75%  {transform:rotateX(180deg);}
            100% {transform:rotateX(360deg);}
         }
      </style>
      <div id = "databinding">
         <button v-on:click = "show = !show">Click Me</button>
         <transition name = "shiftx">
            <p v-show = "show">
               <img src = "images/img.jpg" style = "width:100px;height:100px;" />
            </p>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#databinding',
            data: {
               show:true
            },
            methods : {
            }
         });
      </script>
   </body>
</html>

Aby zastosować animację, istnieją takie same klasy, jak przejście. W powyższym kodzie mamy obraz zamknięty w tagu p, jak pokazano w poniższym fragmencie kodu.

<transition name = "shiftx">
   <p v-show = "show"><img src = "images/img.jpg" style = "width:100px;height:100px;" /></p>
</transition>

Nazwa przejścia to shiftx. Zastosowana klasa jest następująca -

<style>
   .shiftx-enter-active {
      animation: shift-in 2s;
   }
   .shiftx-leave-active {
      animation: shift-in 2s reverse;
   }
   @keyframes shift-in {
      0%   {transform:rotateX(0deg);}
      25%  {transform:rotateX(90deg);}
      50%  {transform:rotateX(120deg);}
      75%  {transform:rotateX(180deg);}
      100% {transform:rotateX(360deg);}
   }
</style>

Klasa jest poprzedzona nazwą przejścia, tj. Shiftx-enter-active i .shiftx-leave-active. Animacja jest definiowana za pomocą klatek kluczowych od 0% do 100%. Istnieje transformacja zdefiniowana w każdej z klatek kluczowych, jak pokazano na poniższym fragmencie kodu.

@keyframes shift-in {
   0%   {transform:rotateX(0deg);}
   25%  {transform:rotateX(90deg);}
   50%  {transform:rotateX(120deg);}
   75%  {transform:rotateX(180deg);}
   100% {transform:rotateX(360deg);}
}

Poniżej znajduje się wynik.

Po kliknięciu przycisku obraca się od 0 do 360 stopni i znika.

Niestandardowe klasy przejścia

VueJS udostępnia listę klas niestandardowych, które można dodać jako atrybuty do elementu przejściowego.

  • enter-class
  • enter-active-class
  • leave-class
  • leave-active-class

Własne klasy w zasadzie wchodzą w grę, gdy chcemy użyć zewnętrznej biblioteki CSS, takiej jak animate.css.

Przykład

<html>
   <head>
      <link href = "https://cdn.jsdelivr.net/npm/[email protected]" rel = "stylesheet" type = "text/css">
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <div id = "animate" style = "text-align:center">
         <button @click = "show = !show"><span style = "font-size:25px;">Animate</span></button>
         <transition
            name = "custom-classes-transition"
            enter-active-class = "animated swing"
            leave-active-class = "animated bounceIn">
            <p v-if = "show"><span style = "font-size:25px;">Example</span></p>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm =  new Vue({
            el: '#animate',
            data: {
               show: true
            }
         });
      </script>
   </body>
</html>

Wynik

Wynik

Wynik

W powyższym kodzie zastosowano dwie animacje. Jedna enter-active-class = „animowany swing”, a druga leave-active-class = „animowane bounceIn”. Korzystamy z niestandardowych klas animacji do zastosowania animacji z biblioteki innej firmy.

Wyraźny czas trwania przejścia

Możemy zastosować przejście i animację na elemencie za pomocą VueJS. Vue czeka, aż zdarzenie transionend i animationend wykryje, czy animacja lub przejście są zakończone.

Czasami przejście może powodować opóźnienie. W takich przypadkach czas trwania możemy zastosować wyraźnie w następujący sposób.

<transition :duration = "1000"></transition>
<transition :duration = "{ enter: 500, leave: 800 }">...</transition>

Możemy użyć właściwości duration z: na elemencie przejściowym, jak pokazano powyżej. W przypadku konieczności oddzielnego określenia czasu wejścia i wyjścia, można to zrobić tak, jak pokazano na powyższym fragmencie kodu.

Hooki JavaScript

Klasy przejścia można wywołać jako metody przy użyciu zdarzeń JavaScript. Rozważmy przykład lepszego zrozumienia.

Przykład

<html>
   <head>
      <title>VueJs Instance</title>
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <script src = "https://cdnjs.cloudflare.com/ajax/libs/velocity/1.2.3/velocity.min.js"></script>
      <div id = "example-4">
         <button @click = "show = !show">
            <span style = "font-size:25px;">Toggle</span>
         </button>
         <transition  v-on:before-enter = "beforeEnter"
            v-on:enter = "enter"
            v-on:leave = "leave"
            v-bind:css = "false">
            <p v-if = "show" style = "font-size:25px;">Animation Example with velocity</p>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#example-4',
            data: {
               show: false
            },
            methods: {
               beforeEnter: function (el) {
                  el.style.opacity = 0
               },
               enter: function (el, done) {
                  Velocity(el, { opacity: 1, fontSize: '25px' }, { duration: 1000 })
                  Velocity(el, { fontSize: '10px' }, { complete: done })
               },
               leave: function (el, done) {
                  Velocity(el, { translateX: '15px', rotateZ: '50deg' }, { duration: 1500 })
                  Velocity(el, { rotateZ: '100deg' }, { loop: 2 })
                  Velocity(el, {
                     rotateZ: '45deg',
                     translateY: '30px',
                     translateX: '30px',
                     opacity: 0
                  }, { complete: done })
               }
            }
         });
      </script>
   </body>
</html>

Wynik

W powyższym przykładzie wykonujemy animację przy użyciu metod js na elemencie przejściowym.

Metody przejścia są stosowane w następujący sposób -

<transition  v-on:before-enter = "beforeEnter"
   v-on:enter = "enter"
   v-on:leave = "leave"
   v-bind:css = "false">
   <p v-if = "show" style = "font-size:25px;">Animation Example with velocity</p>
</transition>

Dodano przedrostek v-onoraz nazwę zdarzenia, do którego wywoływana jest metoda. Metody są zdefiniowane w instancji Vue w następujący sposób -

methods: {
   beforeEnter: function (el) {
      el.style.opacity = 0
   },
   enter: function (el, done) {
      Velocity(el, { opacity: 1, fontSize: '25px' }, { duration: 1000 })
      Velocity(el, { fontSize: '10px' }, { complete: done })
   },
   leave: function (el, done) {
      Velocity(el, { translateX: '15px', rotateZ: '50deg' }, { duration: 1500 })
      Velocity(el, { rotateZ: '100deg' }, { loop: 2 })
      Velocity(el, {
         rotateZ: '45deg',
         translateY: '30px',
         translateX: '30px',
         opacity: 0
      }, { complete: done })
   }
}

Wymagane przejście jest stosowane w każdej z tych metod. Po kliknięciu przycisku oraz po zakończeniu animacji stosowana jest animacja krycia. Do animacji używana jest biblioteka innej firmy.

Istnieje właściwość dodana do przejścia v-bind: css = "false", która jest wykonywana, aby Vue zrozumiał, że jest to przejście JavaScript.

Przejście w początkowym renderowaniu

Aby dodać animację na początku, musimy dodać właściwość „pojawi się” do elementu przejścia.

Spójrzmy na przykład, aby lepiej to zrozumieć.

Przykład

<html>
   <head>
      <link href = "https://cdn.jsdelivr.net/npm/[email protected]" rel = "stylesheet" type = "text/css">
      <script type = "text/javascript" src = "js/vue.js"></script>
   </head>
   <body>
      <div id = "animate" style = "text-align:center">
         <transition
            appear
            appear-class = "custom-appear-class"
            appear-active-class = "animated bounceIn">
            <h1>BounceIn - Animation Example</h1>
         </transition>
         <transition
            appear
            appear-class = "custom-appear-class"
            appear-active-class = "animated swing">
            <h1>Swing - Animation Example</h1>
         </transition>
         <transition
            appear
            appear-class = "custom-appear-class"
            appear-active-class = "animated rubberBand">
            <h1>RubberBand - Animation Example</h1>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm =  new Vue({
            el: '#animate',
            data: {
               show: true
            }
         });
      </script>
   </body>
</html>

W powyższym przykładzie użyliśmy trzech różnych animacji z biblioteki animate.css. Dodaliśmy wygląd do elementu przejściowego.

Po wykonaniu powyższego kodu w przeglądarce pojawi się następujący wynik.

Animacja na komponentach

Możemy zawinąć przejście dla komponentów za pomocą następującego kodu. Użyliśmy tutaj komponentu dynamicznego.

Przykład

<html>
   <head>
      <title>VueJs Instance</title>
      <script type = "text/javascript" src = "js/vue.js"></script>
      <link href = "https://cdn.jsdelivr.net/npm/[email protected]" rel = "stylesheet" type = "text/css">
   </head>
   <body>
      <div id = "databinding" style = "text-align:center;">
         <transition  appear
            appear-class = "custom-appear-class"
            appear-active-class = "animated wobble">
            <component v-bind:is = "view"></component>
         </transition>
      </div>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#databinding',
            data: {
               view: 'component1'
            },
            components: {
               'component1': {
                  template: '<div><span style = "font-
                  size:25;color:red;">Animation on Components</span></div>'
               }
            }
         });
      </script>
   </body>
</html>

Wynik

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved