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/animate.css@3.5.1" 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
          }
        }
      )
    }
  }
})