vue列表逐个进入过渡动画

Posted Lshy

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了vue列表逐个进入过渡动画相关的知识,希望对你有一定的参考价值。

vue实现列表依次逐渐进入动画

利用vue 中transition-group 实现列表逐个进入动画效果

1.vue3代码,

<template>
  <section class="search-tool">
    <div class="search-content">
      <div class="build-box">
        <div class="list">
          <transition-group name="more" :css="false" @before-enter="beforeEnter" @enter="enter">
            <!-- template 是为了解决vue3 vfor vif一起使用时冲突  -->
            <template v-for="(build, b_index) in data.buildList" :key="b_index">
              <!-- data-key 自定义属性,为过渡效果添加延时  -->
              <!-- 类似 ant motion 中列表渲染时添加的key-->
              <div v-if="data.show" :data-key="b_index">
                <div
                  v-if="build.name.indexOf(data.inputVal) >= 0"
                  class="build-item"
                  :title="build.name"
                >
                  <div class="overflow-1">建筑 b_index </div>
                  <div class="collect" @click="collectBuild()"></div>
                </div>
              </div>
            </template>
          </transition-group>
        </div>
      </div>
    </div>
  </section>
</template>

<script setup>
import  reactive, toRefs, onBeforeMount, onMounted, watchEffect, computed  from \'vue\'
const data = reactive(
  show: false,
  inputVal: \'\',
  buildList: [
    
      name: \'11\'
    ,
    
      name: \'\'
    ,
    
      name: \'\'
    ,
    
      name: \'\'
    ,
    
      name: \'\'
    ,
    
      name: \'\'
    
  ]
)
const collectBuild = () => 
const beforeEnter = (el) => 
  el.style.opacity = 0

const enter = (el, done) => 
  let delay = el.dataset.key * 150 //进入延时
  setTimeout(() => 
    el.style.transition = \'opacity 0.4s \'
    el.style.opacity = 1
    el.style.animation = \'right-to-left 0.4s infinite\' //动画效果
    el.style[\'animation-iteration-count\'] = 1
    done()
  , delay)

onBeforeMount(() => )
onMounted(() => 
  data.show = !data.show
)
watchEffect(() => )
defineExpose(
  ...toRefs(data)
)
</script>
<style scoped lang="scss">
.search-tool 
  width: 500px;
  height: 800px;
  background: rgba($color: #000000, $alpha: 0.7);
  .search-content 
    max-height: 1170px;
    color: #fff;
    font-size: 30px;
    .list 
      max-height: 380px;
      overflow-y: scroll;
      overflow-x: hidden;
    
    .build-item 
      height: 72px;
      background: #000000;
      background-size: 100% 100%;
      background-repeat: no-repeat;
      cursor: pointer;
      margin-bottom: 5px;
      padding-left: 15px;
      box-sizing: border-box;
      position: relative;
      display: flex;
      align-content: center;
      align-items: center;
      .overflow-1 
        display: -webkit-box;
        -webkit-box-orient: vertical;
        -webkit-line-clamp: 1;
        overflow: hidden;
        max-width: 450px;
      
    
    ::-webkit-scrollbar 
      /*滚动条整体样式*/
      width: 12px; /*高宽分别对应横竖滚动条的尺寸*/
      height: 20px;
    
    ::-webkit-scrollbar-thumb 
      /*滚动条里面小方块*/
      border-radius: 5px;
      -webkit-box-shadow: inset 0 0 5px #2c8af3;
      background-color: #2c8af3;
    
    ::-webkit-scrollbar-track 
      /*滚动条里面轨道*/
      -webkit-box-shadow: inset 0 0 5px #a1a1a1;
      border-radius: 0;
      display: none;
    
  

</style>

2.过渡动画放在 统一放在一个css文件夹中,引入到main.js

body
  padding: 0;
  margin: 0;

/* 从右到左 */
@keyframes right-to-left 
  from 
    padding-left: 100%;
  
  to 
    padding-left: 0%;
  

/* 从左到右 */
@keyframes left-to-right 
  from 
      padding-right: 100%;
  
  to 
      padding-right: 0%;
  

 更新:解决循环元素过多,防止延时时间过长,dom长期不显示

let index = 0
const enter = (el, done) => 
  let delay = el.dataset.key * 150 //进入延时
  if(index <= 30)//只循环30条
        setTimeout(() => 
            el.style.transition = \'opacity 0.4s \'
            el.style.opacity = 1
            el.style.animation = \'right-to-left 0.4s infinite\' //动画效果
            el.style[\'animation-iteration-count\'] = 1
            done()
          , delay)
       else 
        el.style.opacity = 1
     
                                        

 

VUE2中文文档:进入离开和列表过度

进入、离开和列表的过渡

概述

当从 DOM 中插入、更新或移除项目时,Vue 提供多种应用过渡效果的方式。包括以下工具:

  • 在 CSS 过渡和动画中自动处理 class
  • 可以配合使用第三方 CSS 动画库,如 Animate.css
  • 在过渡钩子函数中使用 JavaScript 直接操作 DOM
  • 可以配合使用第三方 JavaScript 动画库,如 Velocity.js

 

单元素/组件的过渡

Vue 提供了 transition 外层包裹容器组件(wrapper component),可以给下列情形中的任何元素和组件添加进入/离开(enter/leave)过渡

  • 条件渲染(使用 v-if
  • 条件展示(使用 v-show
  • 动态组件
  • 组件根节点
//这是一个简单的示例
<
div id="demo"> <button v-on:click="show = !show">//每次点击改变data中show的布尔值 Toggle </button> <transition name="fade"> <p v-if="show">hello</p>  //通过show的值判断是否展示该元素    </transition> </div> new Vue({ el: ‘#demo‘, data: { show: true } }) .fade-enter-active, .fade-leave-active {   //设定进入和离开过程中的效果改变属性opacity和时间0.5s transition: opacity .5s; } .fade-enter, .fade-leave-to /* .fade-leave-active 在低于版本 2.1.8 中 */ { //设定进入前和离开后的效果 opacity: 0; }

 

过渡类名(Transition Classes)

  1. v-enter:进入式过渡(entering transition)的开始状态。在插入元素之前添加,在插入元素之后一帧移除。

  2. v-enter-active:进入式过渡的激活状态。应用于整个进入式过渡时期。在插入元素之前添加,过渡/动画(transition/animation)完成之后移除。此 class 可用于定义进入式过渡的 duration, delay 和 easing 曲线。

  3. v-enter-to:仅适用于版本 2.1.8+。进入式过渡的结束状态。在插入元素之后一帧添加(同时,移除 v-enter),在过渡/动画完成之后移除。

  4. v-leave:离开式过渡(leaving transition)的开始状态。在触发离开式过渡时立即添加,在一帧之后移除。

  5. v-leave-active:离开式过渡的激活状态。应用于整个离开式过渡时期。在触发离开式过渡时立即添加,在过渡/动画(transition/animation)完成之后移除。此 class 可用于定义离开式过渡的 duration, delay 和 easing 曲线。

  6. v-leave-to:仅适用于版本 2.1.8+。离开式过渡的结束状态。在触发离开式过渡之后一帧添加(同时,移除 v-leave),在过渡/动画完成之后移除。

CSS 过渡(CSS Transitions)

<div id="example-1">
  <button @click="show = !show">
    Toggle render
  </button>
  <transition name="slide-fade">
    <p v-if="show">hello</p>
  </transition>
</div>

new Vue({
  el: ‘#example-1‘,
  data: {
    show: true
  }
})
/* 进入和离开动画可以分别 */
/* 设置不同的持续时间(duration)和动画函数(timing function) */
.slide-fade-enter-active {   //进入过程
  transition: all .3s ease;
}
.slide-fade-leave-active {   //离开过程
  transition: all .8s cubic-bezier(1.0, 0.5, 0.8, 1.0);
}
.slide-fade-enter, .slide-fade-leave-to   //进入开始和离开结束的状态
/* .slide-fade-leave-active 在低于 2.1.8 版本中 */ {
  transform: translateX(10px);
  opacity: 0;
}

 

CSS 动画(CSS Animations)

<div id="example-2">
  <button @click="show = !show">Toggle show</button>
  <transition name="bounce">
    <p v-if="show">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris facilisis enim libero, at lacinia diam fermentum id. Pellentesque habitant morbi tristique senectus et netus.</p>
  </transition>
</div>

new Vue({
  el: ‘#example-2‘,
  data: {
    show: true
  }
})

.bounce-enter-active {
  animation: bounce-in .5s;        //设定进入过程中执行animation动画bounce-in,时间0.5s
}
.bounce-leave-active {         //设定离开过程中逆向(reverse)执行animation: bounce-in 时间0.5s
  animation: bounce-in .5s reverse;
}
@keyframes bounce-in {
  0% {
    transform: scale(0);             //0%时期状态  规模0 
  }
  50% {
    transform: scale(1.5);       //50%时期状态 规模1.5
  }
  100% {
    transform: scale(1);         //同上
  }
}

 

自定义过渡的 class 类名(Custom Transition Classes)

 

你也可以通过提供一下属性来指定自定义过渡类名

  • enter-class
  • enter-active-class
  • enter-to-class (2.1.8+)
  • leave-class
  • leave-active-class
  • leave-to-class (2.1.8+)

它们将覆盖默认约定的类名,这对于将 Vue 的过渡系统和其他现有的第三方 CSS 动画库(如 Animate.css)集成使用会非常有用。

<link href="https://cdn.jsdelivr.net/npm/[email protected]" rel="stylesheet" type="text/css">  //引用animate.css

<div id="example-3">
  <button @click="show = !show">
    Toggle render
  </button>
  <transition
    name="custom-classes-transition"
    enter-active-class="animated tada"              //使用animate.css中的动画,会覆盖本身的v-enter-active类名
    leave-active-class="animated bounceOutRight"    //同上
  >
    <p v-if="show">hello</p>
  </transition>
</div>
new Vue({
  el: ‘#example-3‘,
  data: {
    show: true
  }
})

同时使用过渡和动画(Using Transitions and Animations Together)  (不懂,如果使用第三方,类名覆盖了还怎么过度?)

Vue 为了知道过渡何时完成,必须附加相应的事件监听器。它可以是 transitionend 或 animationend,这取决于给元素应用的 CSS 规则。如果你使用其中任何一种,Vue 能自动识别正确的类型并设置相应的事件监听器。

但是,在一些情况下,你可能需要给同一个元素同时设置过渡和动画,比如由 Vue 触发 CSS 动画,同时在鼠标悬停时触发 CSS 过渡。在这种情况下,你可能需要通过 type 属性,来显式声明需要 Vue 监听的类型,值可以是 animation 或 transition

 

显式过渡持续时间(Explicit Transition Durations)

你可以使用 <transition> 组件上的 duration 属性 ,来指定一个显式的过渡持续时间(以毫秒为单位):

<transition :duration="1000">...</transition> //过度持续时间

<transition :duration="{ enter: 500, leave: 800 }">...</transition> //进入和离开分别的持续时间

 

JavaScript 钩子函数

可以在属性中声明 JavaScript 钩子

<transition
  v-on:before-enter="beforeEnter"
  v-on:enter="enter"
  v-on:after-enter="afterEnter"
  v-on:enter-cancelled="enterCancelled"

  v-on:before-leave="beforeLeave"
  v-on:leave="leave"
  v-on:after-leave="afterLeave"
  v-on:leave-cancelled="leaveCancelled"
>
  <!-- ... -->
</transition>
// ...
methods: {
  // --------
  // 进入时
  // --------

  beforeEnter: function (el) {
    // ...
  },
  // 在与 CSS 结合使用时
  // 此回调函数 done 是可选项
  enter: function (el, done) {
    // ...
    done()
  },
  afterEnter: function (el) {
    // ...
  },
  enterCancelled: function (el) {
    // ...
  },

  // --------
  // 离开时
  // --------

  beforeLeave: function (el) {
    // ...
  },
  // 在与 CSS 结合使用时
  // 此回调函数 done 是可选项
  leave: function (el, done) {
    // ...
    done()
  },
  afterLeave: function (el) {
    // ...
  },
  // leaveCancelled 只能配合 v-show 使用
  leaveCancelled: function (el) {
    // ...
  }
}

这些钩子函数可以结合 CSS 过渡/动画使用,也可以单独使用。

 

当仅使用 JavaScript 式过渡的时候, 在 enter 和 leave 钩子函数中,必须有 done 回调函数。否则,这两个钩子函数会被同步调用,过渡会立即完成。

推荐对于仅使用 JavaScript 的过渡显式添加 v-bind:css="false",以便 Vue 可以跳过 CSS 侦测。这也可以防止 CSS 规则意外干涉到过渡。

 

 

现在我们深入来看一个示例。这里是一个使用 Velocity.js 的 JavaScript 式过渡:

<!--
Velocity works very much like jQuery.animate and is
a great option for JavaScript animations
-->
<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script> //引用velocity.js

<div id="example-4">
  <button @click="show = !show">
    Toggle
  </button>
  <transition
    v-on:before-enter="beforeEnter"  //监听三个钩子函数,稍后在methods中定义
    v-on:enter="enter"
    v-on:leave="leave"
    v-bind:css="false"        //纯js实现动画,跳过css检测
  >
    <p v-if="show">
      Demo
    </p>
  </transition>
</div>
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: ‘1.4em‘ }, { duration: 300 })   
      Velocity(el, { fontSize: ‘1em‘ }, { complete: done })
    },
    leave: function (el, done) {     //设定离开过程函数
      Velocity(el, { translateX: ‘15px‘, rotateZ: ‘50deg‘ }, { duration: 600 })
      Velocity(el, { rotateZ: ‘100deg‘ }, { loop: 2 })
      Velocity(el, {
        rotateZ: ‘45deg‘,
        translateY: ‘30px‘,
        translateX: ‘30px‘,
        opacity: 0
      }, { complete: done })
    }
  }
})

在初始渲染时过渡

 

如果你还想在节点初始渲染时应用过渡,可以添加 appear 属性:

<transition appear>
  <!-- ... -->
</transition>

默认情况下,对于进入和离开,会使用特定过渡。但是,如果你有需要,也可以指定自定义 CSS 类名:

<transition
  appear
  appear-class="custom-appear-class"
  appear-to-class="custom-appear-to-class"(仅 >= 2.1.8 支持)
  appear-active-class="custom-appear-active-class"
>
  <!-- ... -->
</transition>

以及指定自定义 JavaScript 钩子函数:

<transition
  appear
  v-on:before-appear="customBeforeAppearHook"
  v-on:appear="customAppearHook"
  v-on:after-appear="customAfterAppearHook"
  v-on:appear-cancelled="customAppearCancelledHook"
>
  <!-- ... -->
</transition>

 

多个元素之间切换过渡

我们将在下面讨论多个元素之间切换过渡,但是还是可以使用 v-if/v-else,来对初始元素之间进行切换过渡。最常见的是,一个列表容器和描述列表为空的消息,这两个元素间的切换过渡:

<transition>
  <table v-if="items.length > 0">
    <!-- ... -->
  </table>
  <p v-else>Sorry, no items found.</p>
</transition>

当在具有相同标签名称的元素之间切换时,需要通过给它们分配唯一的 key 属性,以使 Vue 感知它们是不同的元素。否则 Vue 的编译器将因为效率,只会替换元素内部的内容。即使在技术上没有必要,但是,给 <transition> 组件中的多个元素设置 key,被认为是一个最佳实践。

 

通过给同一元素的 key 属性,设置不同的状态来进行过渡。而无需使用 v-if 和 v-else。

实际上,使用 v-if 的多个元素之间的过渡,还可以改为在单个元素上绑定动态属性的方式,来在任意数量的元素之间进行转换。

<transition>
  <button v-if="docState === ‘saved‘" key="saved">
    Edit
  </button>
  <button v-if="docState === ‘edited‘" key="edited">
    Save
  </button>
  <button v-if="docState === ‘editing‘" key="editing">
    Cancel
  </button>
</transition>

可以重写为:

<transition>
  <button v-bind:key="docState">
    {{ buttonMessage }}
  </button>
</transition>
// ...
computed: {
  buttonMessage: function () {
    switch (this.docState) {
      case ‘saved‘: return ‘Edit‘
      case ‘edited‘: return ‘Save‘
      case ‘editing‘: return ‘Cancel‘
    }
  }
}

过渡模式

 当一个过渡进入时,另一个过渡离开。这是 <transition> 的默认行为 - 进入和离开同时发生。

同时生效的进入式和离开式过渡不能满足所有要求,所以 Vue 提供了可选的过渡模式:

  • in-out:新元素先过渡进入(transition in),过渡完成之后,当前元素过渡离开(transition out)。

  • out-in:当前元素先过渡离开(transition out),过渡完成之后,新元素过渡进入(transition in)。

多个组件之间过渡

多个组件之间的过渡甚至更简单 - 我们不需要使用 key 属性。相反,我们需要使用动态组件:

<transition name="component-fade" mode="out-in">
  <component v-bind:is="view"></component>
</transition>

new Vue({ el: ‘#transition-components-demo‘, data: { view: ‘v-a‘ }, components: { ‘v-a‘: { template: ‘<div>Component A</div>‘ }, ‘v-b‘: { template: ‘<div>Component B</div>‘ } } })
.component-fade-enter-active, .component-fade-leave-active { transition: opacity .3s ease; } .component-fade-enter, .component-fade-leave-to /* .component-fade-leave-active 在低于 2.1.8 版本中 */ { opacity: 0; }

 

列表过渡

当我们整个列表的每一项(例如使用 v-for)都需要同时进行渲染呢?在这种情况下,我们将使用 <transition-group> 组件。在我们深入示例之前,先来了解关于这个组件的一些要点:

  • 不同于 <transition>,它会以一个真实元素渲染:默认为 <span>。你也可以通过 tag 属性更换为其他渲染元素
  • 它内部的元素必须具有唯一的 key 属性

进入式/离开式列表过渡

现在让我们来深入一个示例,进入式过渡和离开式过渡都使用与之前相同的 CSS 类名:

<div id="list-demo">
  <button v-on:click="add">Add</button>
  <button v-on:click="remove">Remove</button>
  <transition-group name="list" tag="p">   //列表渲染过度用transition-group标签
    <span v-for="item in items" v-bind:key="item" class="list-item">
      {{ item }}
    </span>
  </transition-group>
</div>
new Vue({
  el: ‘#list-demo‘,
  data: {
    items: [1,2,3,4,5,6,7,8,9],
    nextNum: 10
  },
  methods: {
    randomIndex: function () {
      return Math.floor(Math.random() * this.items.length)   //选取一个随机索引(0.x和当前数组长度乘)
    },
    add: function () {
      this.items.splice(this.randomIndex(), 0, this.nextNum++)     //num++然后加入数组中随机索引位置
    },
    remove: function () {
      this.items.splice(this.randomIndex(), 1)              //随机删除
    },
  }
})
.list-item {
  display: inline-block;
  margin-right: 10px;
}
.list-enter-active, .list-leave-active {
  transition: all 1s;
}
.list-enter, .list-leave-to /* .list-leave-active 在低于 2.1.8 版本中 */ {
  opacity: 0;
  transform: translateY(30px);
}

 

列表的位移过渡

<transition-group> 组件还有一个暗藏玄机之处。不仅可以在进入和离开时进行动画,还可以在位置改变时进行动画。使用此功能所需要知道的唯一新的概念是,在项目位置改变时添加额外的 v-move 类名。与其他类名相同,它的前缀也和设置的 name 属性的值相匹配,你也可以通过 move-class 属性来手动指定类名。

此类名对于指定过渡时间和 easing 过渡曲线非常有用,如下所示:

<script src="https://lib.baomitu.com/lodash.js/4.14.1/lodash.min.js"></script>  //引用lodash.js

<div id="flip-list-demo" class="demo">
  <button v-on:click="shuffle">Shuffle</button>        
  <transition-group name="flip-list" tag="ul">               //此标签真实渲染,通过tag设定为ul,下面可用li,不设定默认span标签
    <li v-for="item in items" v-bind:key="item">         //‘一定带唯一的key
      {{ item }}
    </li>
  </transition-group>
</div>
new Vue({
  el: ‘#flip-list-demo‘,
  data: {
    items: [1,2,3,4,5,6,7,8,9]
  },
  methods: {
    shuffle: function () {
      this.items = _.shuffle(this.items)                  //调用loadsh.js中的_.shuffle
    }
  }
})
.flip-list-move {                         //列表过度,项目发生改变时会添加额外的v-modle属性,通过设置此属性就可以实现变动的项目的过渡效果
  transition: transform 1s;
}

 

需要注意的是,使用 FLIP 过渡的元素,在设置为 display: inline 时,无法正常运行。作为替代方案,可以将元素设置为 display: inline-block,或者将元素放置于 flex 上下文(flex context)中。

FLIP 动画不局限于单个轴线方向(single axis),多个维度网格(multidimensional grid)也同样可以过渡

列表的渐进过渡

通过 data 属性与 JavaScript 式过渡的通信,就可以实现列表的逐项渐进过渡:

<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script>     //引用velocity.js

<div id="staggered-list-demo">
  <input v-model="query">         //和data中的query对象实现双向绑定,query实时接受input的value
  <transition-group
    name="staggered-fade"
    tag="ul"
    v-bind:css="false"                     //跳过css检测
    v-on:before-enter="beforeEnter"      //监听js钩子函数
    v-on:enter="enter"
    v-on:leave="leave"
  >
    <li
      v-for="(item, index) in computedList"       //取computedList中的数组成员
      v-bind:key="item.msg"
      v-bind:data-index="index"            //?? 用此属性作为渐进过度的延迟时间计算
    >{{ item.msg }}</li>
  </transition-group>
</div>
new Vue({
  el: ‘#staggered-list-demo‘,
  data: {
    query: ‘‘,
    list: [
      { msg: ‘Bruce Lee‘ },
      { msg: ‘Jackie Chan‘ },
      { msg: ‘Chuck Norris‘ },
      { msg: ‘Jet Li‘ },
      { msg: ‘Kung Fury‘ }
    ]
  },
  computed: {
    computedList: function () {
      var vm = this
      return this.list.filter(function (item) {           //返回匹配成功的对象数组
        return item.msg.toLowerCase().indexOf(vm.query.toLowerCase()) !== -1      //字母小写=》匹配query   ??!==-1
      })
    }
  },
  methods: {
    beforeEnter: function (el) {
      el.style.opacity = 0
      el.style.height = 0
    },
    enter: function (el, done) {
      var delay = el.dataset.index * 150         //dataset可以读取自定义数据属性,这里dataset.index读取data-index    
      setTimeout(function () {               //设定延迟执行时间,这样data-index越大的过度延迟越久,视觉上就实现了逐步渲染
        Velocity(
          el,
          { opacity: 1, height: ‘1.6em‘ },
          { complete: done }
        )
      }, delay)
    },
    leave: function (el, done) {
      var delay = el.dataset.index * 150
      setTimeout(function () {
        Velocity(
          el,
          { opacity: 0, height: 0 },
          { complete: done }
        )
      }, delay)
    }
  }
})

 

可复用的过渡

通过 Vue 的组件系统可以实现复用过渡。要创建一个可复用过渡,你需要做的就是将 <transition> 或者 <transition-group> 作为组件根节点,然后将全部子内容放置在 transition 组件中就可以了。

Vue.component(‘my-special-transition‘, {
  template: ‘    <transition      name="very-special-transition"      mode="out-in"      v-on:before-enter="beforeEnter"      v-on:after-enter="afterEnter"    >      <slot></slot>    </transition>  ‘,
  methods: {
    beforeEnter: function (el) {
      // ...
    },
    afterEnter: function (el) {
      // ...
    }
  }
})

函数组件更适合完成这个任务:

Vue.component(‘my-special-transition‘, {
  functional: true,
  render: function (createElement, context) {
    var data = {
      props: {
        name: ‘very-special-transition‘,
        mode: ‘out-in‘
      },
      on: {
        beforeEnter: function (el) {
          // ...
        },
        afterEnter: function (el) {
          // ...
        }
      }
    }
    return createElement(‘transition‘, data, context.children)
  }
})

动态过渡

其实,在 Vue 中即使是过渡也是由数据驱动的!动态过渡最基本的例子是,将 name 属性(attribute)和动态属性(dynamic property)绑定在一起。

当你使用多个 Vue 过渡类名约定,来定义 CSS 过渡/动画,并在不同的类名约定之间切换时,动态过渡会非常有用。

所有的过渡属性都可以动态绑定。并且不仅是属性,由于事件钩子函数都是 Vue 的方法(methods),所以可以从 this 上下文访问到所有数据。这意味着,根据组件的状态,JavaScript 式过渡的表现可能会有所不同。

<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script>

<div id="dynamic-fade-demo" class="demo">
  Fade In: <input type="range" v-model="fadeInDuration" min="0" v-bind:max="maxFadeDuration">     //动态绑定max属性到data,但是有何意义?
  Fade Out: <input type="range" v-model="fadeOutDuration" min="0" v-bind:max="maxFadeDuration">
  <transition
    v-bind:css="false"
    v-on:before-enter="beforeEnter"
    v-on:enter="enter"
    v-on:leave="leave"
  >
    <p v-if="show">hello</p>
  </transition>
  <button
    v-if="stop"
    v-on:click="stop = false; show = false"
  >Start animating</button>
  <button
    v-else
    v-on:click="stop = true"
  >Stop it!</button>
</div>
new Vue({
  el: ‘#dynamic-fade-demo‘,
  data: {
    show: true,
    fadeInDuration: 1000,
    fadeOutDuration: 1000,
    maxFadeDuration: 1500,                         
    stop: true
  },
  mounted: function () {
    this.show = false
  },
  methods: {
    beforeEnter: function (el) {
      el.style.opacity = 0
    },
    enter: function (el, done) {
      var vm = this
      Velocity(el,
        { opacity: 1 },
        {
          duration: this.fadeInDuration,
          complete: function () {
            done()
            if (!vm.stop) vm.show = false
          }
        }
      )
    },
    leave: function (el, done) {
      var vm = this
      Velocity(el,
        { opacity: 0 },
        {
          duration: this.fadeOutDuration,
          complete: function () {
            done()
            vm.show = true
          }
        }
      )
    }
  }
})

 

以上是关于vue列表逐个进入过渡动画的主要内容,如果未能解决你的问题,请参考以下文章

Vue过渡动画

Vue.js进入/离开 & 列表过渡

VUE2中文文档:进入离开和列表过度

Vue_(组件)过渡效果

Vue动画

vue3动画transition标签使用