概述
Vue 在插入、更新或者移除 DOM 时，提供多种不同方式的应用过渡效果。
在 CSS 过渡和动画中自动应用 class 可以配合使用第三方 CSS 动画库，如 Animate.css 在过渡钩子函数中使用 JavaScript 直接操作 DOM 可以配合使用第三方 JavaScript 动画库，如 Velocity.js 在这里，我们只会讲到进入、离开和列表的过渡， 你也可以看下一节的 管理过渡状态 .
Vue 提供了 transition 的封装组件，在下列情形中，可以给任何元素和组件添加 entering/leaving 过渡
条件渲染 （使用 v-if） 条件展示 （使用 v-show） 动态组件 组件根节点 这里是一个典型的例子：
<div id ="demo" >
<button v-on:click ="show = !show" >
Toggle
</button >
<transition name ="fade" >
<p v-if ="show" > hello
</p >
</transition >
</div >
new Vue({
el :
'#demo' ,
data : {
show :
true
}
})
.fade-enter-active ,
.fade-leave-active {
transition : opacity .
5s
}
.fade-enter ,
.fade-leave-to
{
opacity :
0
}
元素封装成过渡组件之后，在遇到插入或删除时，Vue 将
自动嗅探目标元素是否有 CSS 过渡或动画，并在合适时添加/删除 CSS 类名。
如果过渡组件设置了过渡的 JavaScript 钩子函数 ，会在相应的阶段调用钩子函数。
如果没有找到 JavaScript 钩子并且也没有检测到 CSS 过渡/动画，DOM 操作（插入/删除）在下一帧中立即执行。(注意：此指浏览器逐帧动画机制，与 Vue，和Vue的 nextTick 概念不同)
会有 6 个(CSS)类名在 enter/leave 的过渡中切换
v-enter: 定义进入过渡的开始状态。在元素被插入时生效，在下一个帧移除。 v-enter-active: 定义进入过渡的结束状态。在元素被插入时生效，在 transition/animation 完成之后移除。
v-enter-to: Only available in versions >=2.1.8. Ending state for enter. Added one frame after element is inserted (at the same time v-enter is removed), removed when transition/animation finishes.
v-leave: 定义离开过渡的开始状态。在离开过渡被触发时生效，在下一个帧移除。
v-leave-active: 定义离开过渡的结束状态。在离开过渡被触发时生效，在 transition/animation 完成之后移除。
v-leave-to: Only available in versions >=2.1.8. Ending state for leave. Added one frame after a leaving transition is triggered (at the same time v-leave is removed), removed when the transition/animation finishes.
对于这些在 enter/leave 过渡中切换的类名，v- 是这些类名的前缀。使用 <transition name="my-transition"> 可以重置前缀，比如 v-enter 替换为 my-transition-enter。
v-enter-active 和 v-leave-active 可以控制 进入/离开 过渡的不同阶段，在下面章节会有个示例说明。
常用的过渡都是使用 CSS 过渡。
下面是一个简单例子：
<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
}
})
.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
{
transform :
translateX (10px);
opacity :
0 ;
}
CSS 动画用法同 CSS 过渡，区别是在动画中 v-enter 类名在节点插入 DOM 后不会立即删除，而是在 animationend事件触发时删除。
示例： (省略了兼容性前缀)
<div id ="example-2" >
<button @click ="show = !show" > Toggle show
</button >
<transition name ="bounce" >
<p v-if ="show" > Look at me!
</p >
</transition >
</div >
new Vue({
el :
'#example-2' ,
data : {
show :
true
}
})
.bounce-enter-active {
animation : bounce-in .
5s ;
}
.bounce-leave-active {
animation : bounce-out .
5s ;
}
@
keyframes bounce-in {
0% {
transform :
scale (0);
}
50% {
transform :
scale (1.5);
}
100% {
transform :
scale (1);
}
}
@
keyframes bounce-out {
0% {
transform :
scale (1);
}
50% {
transform :
scale (1.5);
}
100% {
transform :
scale (0);
}
}
Toggle show
我们可以通过以下特性来自定义过渡类名：
enter-classenter-active-classenter-to-class (>= 2.1.8 only)leave-classleave-active-classleave-to-class (>= 2.1.8 only) 他们的优先级高于普通的类名，这对于 Vue 的过渡系统和其他第三方 CSS 动画库，如 Animate.css 结合使用十分有用。
示例：
<link href ="https://unpkg.com/animate.css@3.5.1/animate.min.css" rel ="stylesheet" type ="text/css" >
<div id ="example-3" >
<button @click ="show = !show" >
Toggle render
</button >
<transition
name =
"custom-classes-transition"
enter-active-class =
"animated tada"
leave-active-class =
"animated bounceOutRight"
>
<p v-if ="show" > hello
</p >
</transition >
</div >
new Vue({
el :
'#example-3' ,
data : {
show :
true
}
})
Vue 为了知道过渡的完成，必须设置相应的事件监听器。它可以是 transitionend 或 animationend ，这取决于给元素应用的 CSS 规则。如果你使用其中任何一种，Vue 能自动识别类型并设置监听。
但是，在一些场景中，你需要给同一个元素同时设置两种过渡动效，比如 animation 很快的被触发并完成了，而 transition 效果还没结束。在这种情况中，你就需要使用 type 特性并设置 animation 或 transition 来明确声明你需要 Vue 监听的类型。
New in 2.2.0
In most cases, Vue can automatically figure out when the transition has finished. By default, Vue waits for the first transitionend or animationend event on the root transition element. However, this may not always be desired - for example, we may have a choreographed transition sequence where some nested inner elements have a delayed transition or a longer transition duration than the root transition element.
In such cases you can specify an explicit transition duration (in milliseconds) using the duration prop on the <transition> component:
<transition :duration ="1000" > ...
</transition >
You can also specify separate values for enter and leave durations:
<transition :duration ="{ enter: 500, leave: 800 }" > ...
</transition >
可以在属性中声明 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 )
},
enter:
function (el, done )
done()
},
afterEnter :
function (el )
},
enterCancelled :
function (el )
},
beforeLeave:
function (el )
},
leave:
function (el, done )
done()
},
afterLeave :
function (el )
},
leaveCancelled:
function (el )
}
}
这些钩子函数可以结合 CSS transitions/animations 使用，也可以单独使用。
当只用 JavaScript 过渡的时候， 在 enter 和 leave 中，回调函数 done 是必须的 。 否则，它们会被同步调用，过渡会立即完成。
推荐对于仅使用 JavaScript 过渡的元素添加 v-bind:css="false"，Vue 会跳过 CSS 的检测。这也可以避免过渡过程中 CSS 的影响。
一个使用 Velocity.js 的简单例子：
Velocity works very much like jQuery.animate and is
a great option for JavaScript animations
-->
<script src ="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.2.3/velocity.min.js" >
</script >
<div id ="example-4" >
<button @click ="show = !show" >
Toggle
</button >
<transition
v-on:before-enter =
"beforeEnter"
v-on:enter =
"enter"
v-on:leave =
"leave"
v-bind:css =
"false"
>
<p v-if ="show" >
Demo
</p >
</transition >
</div >
new Vue({
el :
'#example-4' ,
data : {
show :
false
},
methods : {
beforeEnter :
function (el )
el.style.opacity =
0
el.style.transformOrigin =
'left'
},
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 })
}
}
})
Toggle
可以通过 appear 特性设置节点的在初始渲染的过渡
<transition appear >
</transition >
这里默认和进入和离开过渡一样，同样也可以自定义 CSS 类名。
<transition
appear
appear-class =
"custom-appear-class"
appear-to-class =
"custom-appear-to-class" (>= 2.1.8 only)
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 是一个更好的实践。
示例:
<transition >
<button v-if ="isEditing" key ="save" >
Save
</button >
<button v-else key ="edit" >
Edit
</button >
</transition >
在一些场景中，也可以给通过给同一个元素的 key 特性设置不同的状态来代替 v-if 和 v-else，上面的例子可以重写为：
<transition >
<button v-bind:key ="isEditing" >
{{ isEditing ? 'Save' : 'Edit' }}
</button >
</transition >
使用多个 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 (docState) {
case
'saved' :
return
'Edit'
case
'edited' :
return
'Save'
case
'editing' :
return
'Cancel'
}
}
}
这里还有一个问题，试着点击下面的按钮：
off
在 “on” 按钮和 “off” 按钮的过渡中，两个按钮都被重绘了，一个离开过渡的时候另一个开始进入过渡。这是 <transition> 的默认行为 - 进入和离开同时发生。
在元素绝对定位在彼此之上的时候运行正常：
然后，我们加上 translate 让它们运动像滑动过渡：
同时生效的进入和离开的过渡不能满足所有要求，所以 Vue 提供了 过渡模式
用 out-in 重写之前的开关按钮过渡：
<transition name ="fade" mode ="out-in" >
</transition >
off
只用添加一个简单的特性，就解决了之前的过渡问题而无需任何额外的代码。
in-out 模式不是经常用到，但对于一些稍微不同的过渡效果还是有用的。
很酷吧？
多个组件的过渡甚至更简单 - 我们不需要使用 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
{
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" >
<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)
},
add :
function (
this .items.splice(
this .randomIndex(),
0 ,
this .nextNum++)
},
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
{
opacity :
0 ;
transform :
translateY (30px);
}
这个例子有个问题，当添加和移除元素的时候，周围的元素会瞬间移动到他们的新布局的位置，而不是平滑的过渡，我们下面会解决这个问题。
<transition-group> 组件还有一个特殊之处。不仅可以进入和离开动画，还可以改变定位。要使用这个新功能只需了解新增的 v-move 特性name 属性来自定义前缀，也可以通过 move-class 属性手动设置。
v-move 对于设置过渡的切换时机和过渡曲线非常有用，你会看到如下的例子：
<script src ="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.14.1/lodash.min.js" >
</script >
<div id ="flip-list-demo" class ="demo" >
<button v-on:click ="shuffle" > Shuffle
</button >
<transition-group name ="flip-list" tag ="ul" >
<li v-for ="item in items" v-bind:key ="item" >
{{ 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)
}
}
})
.flip-list-move {
transition : transform
1s ;
}
这个看起来很神奇，内部的实现，Vue 使用了一个叫 FLIP 简单的动画队列
我们将之前实现的例子和这个技术结合，使我们列表的一切变动都会有动画过渡。
<script src ="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.14.1/lodash.min.js" >
</script >
<div id ="list-complete-demo" class ="demo" >
<button v-on:click ="shuffle" > Shuffle
</button >
<button v-on:click ="add" > Add
</button >
<button v-on:click ="remove" > Remove
</button >
<transition-group name ="list-complete" tag ="p" >
<span
v-for =
"item in items"
v-bind:key =
"item"
class =
"list-complete-item"
>
{{ item }}
</span >
</transition-group >
</div >
new Vue({
el :
'#list-complete-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)
},
add :
function (
this .items.splice(
this .randomIndex(),
0 ,
this .nextNum++)
},
remove :
function (
this .items.splice(
this .randomIndex(),
1 )
},
shuffle :
function (
this .items = _.shuffle(
this .items)
}
}
})
.list-complete-item {
transition : all
1s ;
display : inline-block;
margin-right :
10px ;
}
.list-complete-enter ,
.list-complete-leave-to
{
opacity :
0 ;
transform :
translateY (30px);
}
.list-complete-leave-active {
position : absolute;
}
Shuffle
Add
Remove
1 2 3 4 5 6 7 8 9
需要注意的是使用 FLIP 过渡的元素不能设置为 display: inline 。作为替代方案，可以设置为 display: inline-block 或者放置于 flex 中
FLIP 动画不仅可以实现单列过渡，多维网格的过渡也同样简单 :
Lazy Sudoku
Keep hitting the shuffle button until you win.
Shuffle
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
通过 data 属性与 JavaScript 通信 ，就可以实现列表的渐进过渡：
<script src ="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.2.3/velocity.min.js" >
</script >
<div id ="staggered-list-demo" >
<input v-model ="query" >
<transition-group
name =
"staggered-fade"
tag =
"ul"
v-bind:css =
"false"
v-on:before-enter =
"beforeEnter"
v-on:enter =
"enter"
v-on:leave =
"leave"
>
<li
v-for =
"(item, index) in 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
})
}
},
methods : {
beforeEnter :
function (el )
el.style.opacity =
0
el.style.height =
0
},
enter :
function (el, done )
var delay = el.dataset.index *
150
setTimeout(
function (
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)
}
}
})
Bruce Lee Jackie Chan Chuck Norris Jet Li Kung Fury
过渡可以通过 Vue 的组件系统实现复用。要创建一个可复用过渡组件，你需要做的就是将 <transition> 或者 <transition-group> 作为根组件，然后将任何子组件放置在其中就可以了。
使用 template 的简单例子：
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 特性来绑定动态值。
<transition v-bind:name ="transitionName" >
</transition >
当你想用 Vue 的过渡系统来定义的 CSS 过渡/动画 在不同过渡间切换会非常有用。
所有的过渡特性都是动态绑定。它不仅是简单的特性，通过事件的钩子函数方法，可以在获取到相应上下文数据。这意味着，可以根据组件的状态通过 JavaScript 过渡设置不同的过渡效果。
<script src ="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.2.3/velocity.min.js" >
</script >
<div id ="dynamic-fade-demo" >
Fade In:
<input type ="range" v-model ="fadeInDuration" min ="0" v-bind:max ="maxFadeDuration" >
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-on:click ="stop = true" > Stop it!
</button >
</div >
new Vue({
el :
'#dynamic-fade-demo' ,
data : {
show :
true ,
fadeInDuration :
1000 ,
fadeOutDuration :
1000 ,
maxFadeDuration :
1500 ,
stop :
false
},
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
}
}
)
}
}
})
最后，创建动态过渡的最终方案是组件通过接受 props 来动态修改之前的过渡。一句老话，唯一的限制是你的想象力。
原文：http://vuejs.org/guide/transitions.html
0
0
已为社区贡献3条内容
所有评论(0)