zoukankan      html  css  js  c++  java
  • Vue简介教程(四)[自定义指令 | 路由 | 过渡 & 动画]

    Vue.js 自定义指令

    除了默认设置的核心指令( v-model 和 v-show ), Vue 也允许注册自定义指令。

    下面我们注册一个全局指令 v-focus, 该指令的功能是在页面加载时,元素获得焦点:

    <div id="app">
    	<p>页面载入时,input 元素自动获取焦点:</p>
    	<input v-focus>
    </div>
    
    <script>
    // 注册一个全局自定义指令 v-focus
    Vue.directive('focus', {
      // 当绑定元素插入到 DOM 中。
      inserted: function (el) {
        // 聚焦元素
        el.focus()
      }
    })
    // 创建根实例
    new Vue({
      el: '#app'
    })
    </script>
    
    

    我们也可以在实例使用 directives 选项来注册局部指令,这样指令只能在这个实例中使用:

    <div id="app">
      <p>页面载入时,input 元素自动获取焦点:</p>
      <input v-focus>
    </div>
    ​
    <script>
    // 创建根实例
    new Vue({
      el: '#app',
      directives: {
        // 注册一个局部的自定义指令 v-focus
        focus: {
          // 指令的定义
          inserted: function (el) {
            // 聚焦元素
            el.focus()
          }
        }
      }
    })
    </script>
    

    钩子

    钩子函数

    指令定义函数提供了几个钩子函数(可选):

    bind: 只调用一次,指令第一次绑定到元素时调用,用这个钩子函数可以定义一个在绑定时执行一次的初始化动作。

    inserted: 被绑定元素插入父节点时调用(父节点存在即可调用,不必存在于 document 中)。

    update: 被绑定元素所在的模板更新时调用,而不论绑定值是否变化。通过比较更新前后的绑定值,可以忽略不必要的模板更新(详细的钩子函数参数见下)。

    componentUpdated: 被绑定元素所在模板完成一次更新周期时调用。

    unbind: 只调用一次, 指令与元素解绑时调用。

    钩子函数参数

    钩子函数的参数有:

    el: 指令所绑定的元素,可以用来直接操作 DOM 。
    binding: 一个对象,包含以下属性:
    name: 指令名,不包括 v- 前缀。
    value: 指令的绑定值, 例如: v-my-directive="1 + 1", value 的值是 2。
    oldValue: 指令绑定的前一个值,仅在 update 和 componentUpdated 钩子中可用。无论值是否改变都可用。
    expression: 绑定值的表达式或变量名。 例如 v-my-directive="1 + 1" , expression 的值是 "1 + 1"。
    arg: 传给指令的参数。例如 v-my-directive:foo, arg 的值是 "foo"。
    modifiers: 一个包含修饰符的对象。 例如: v-my-directive.foo.bar, 修饰符对象 modifiers 的值是 { foo: true, bar: true }。
    vnode: Vue 编译生成的虚拟节点。
    oldVnode: 上一个虚拟节点,仅在 update 和 componentUpdated 钩子中可用。

    以下实例演示了这些参数的使用:

    <div id="app"  v-runoob:hello.a.b="message">
    </div>
    
    <script>
    Vue.directive('runoob', {
      bind: function (el, binding, vnode) {
        var s = JSON.stringify
        el.innerHTML =
          'name: '       + s(binding.name) + '<br>' +
          'value: '      + s(binding.value) + '<br>' +
          'expression: ' + s(binding.expression) + '<br>' +
          'argument: '   + s(binding.arg) + '<br>' +
          'modifiers: '  + s(binding.modifiers) + '<br>' +
          'vnode keys: ' + Object.keys(vnode).join(', ')
      }
    })
    new Vue({
      el: '#app',
      data: {
        message: '菜鸟教程!'
      }
    })
    </script>
    

    有时候我们不需要其他钩子函数,我们可以简写函数,如下格式:

    Vue.directive('runoob', function (el, binding) {
      // 设置指令的背景颜色
      el.style.backgroundColor = binding.value.color
    })
    

    指令函数可接受所有合法的 JavaScript 表达式,以下实例传入了 JavaScript 对象:

    <div id="app">
        <div v-runoob="{ color: 'green', text: '菜鸟教程!' }"></div>
    </div>
    
    <script>
    Vue.directive('runoob', function (el, binding) {
    	// 简写方式设置文本及背景颜色
    	el.innerHTML = binding.value.text
    	el.style.backgroundColor = binding.value.color
    })
    new Vue({
      el: '#app'
    })
    </script>
    
    

    ue.js 路由

    本章节我们将为大家介绍 Vue.js 路由。

    Vue.js 路由允许我们通过不同的 URL 访问不同的内容。

    通过 Vue.js 可以实现多视图的单页Web应用(single page web application,SPA)。

    Vue.js 路由需要载入 vue-router 库

    中文文档地址:vue-router文档

    安装

    1、直接下载 / CDN

    https://unpkg.com/vue-router/dist/vue-router.js
    

    NPM
    推荐使用淘宝镜像:

    cnpm install vue-router
    
    

    简单实例

    Vue.js + vue-router 可以很简单的实现单页应用。

    是一个组件,该组件用于设置一个导航链接,切换不同 HTML 内容。 to 属性为目标地址, 即要显示的内容。

    以下实例中我们将 vue-router 加进来,然后配置组件和路由映射,再告诉 vue-router 在哪里渲染它们。代码如下所示:

    <div id="app">
      <h1>Hello App!</h1>
      <p>
        <!-- 使用 router-link 组件来导航. -->
        <!-- 通过传入 `to` 属性指定链接. -->
        <!-- <router-link> 默认会被渲染成一个 `<a>` 标签 -->
        <router-link to="/foo">Go to Foo</router-link>
        <router-link to="/bar">Go to Bar</router-link>
      </p>
      <!-- 路由出口 -->
      <!-- 路由匹配到的组件将渲染在这里 -->
      <router-view></router-view>
    </div>
    
    <script>
    // 0. 如果使用模块化机制编程,導入Vue和VueRouter,要调用 Vue.use(VueRouter)
    
    // 1. 定义(路由)组件。
    // 可以从其他文件 import 进来
    const Foo = { template: '<div>foo</div>' }
    const Bar = { template: '<div>bar</div>' }
    
    // 2. 定义路由
    // 每个路由应该映射一个组件。 其中"component" 可以是
    // 通过 Vue.extend() 创建的组件构造器,
    // 或者,只是一个组件配置对象。
    // 我们晚点再讨论嵌套路由。
    const routes = [
      { path: '/foo', component: Foo },
      { path: '/bar', component: Bar }
    ]
    
    // 3. 创建 router 实例,然后传 `routes` 配置
    // 你还可以传别的配置参数, 不过先这么简单着吧。
    const router = new VueRouter({
      routes // (缩写)相当于 routes: routes
    })
    
    // 4. 创建和挂载根实例。
    // 记得要通过 router 配置参数注入路由,
    // 从而让整个应用都有路由功能
    const app = new Vue({
      router
    }).$mount('#app')
    
    // 现在,应用已经启动了!
    </script>
    

    点击过的导航链接都会加上样式 class ="router-link-exact-active router-link-active"。

    
    
    

    相关属性

    接下来我们可以了解下更多关于 的属性。

    to

    表示目标路由的链接。 当被点击后,内部会立刻把 to 的值传到 router.push(),所以这个值可以是一个字符串或者是描述目标位置的对象。

    <!-- 字符串 -->
    <router-link to="home">Home</router-link>
    <!-- 渲染结果 -->
    <a href="home">Home</a>
    
    <!-- 使用 v-bind 的 JS 表达式 -->
    <router-link v-bind:to="'home'">Home</router-link>
    
    <!-- 不写 v-bind 也可以,就像绑定别的属性一样 -->
    <router-link :to="'home'">Home</router-link>
    
    <!-- 同上 -->
    <router-link :to="{ path: 'home' }">Home</router-link>
    
    <!-- 命名的路由 -->
    <router-link :to="{ name: 'user', params: { userId: 123 }}">User</router-link>
    
    <!-- 带查询参数,下面的结果为 /register?plan=private -->
    <router-link :to="{ path: 'register', query: { plan: 'private' }}">Register</router-link>
    
    

    replace

    设置 replace 属性的话,当点击时,会调用 router.replace() 而不是 router.push(),导航后不会留下 history 记录。

    <router-link :to="{ path: '/abc'}" replace></router-link>
    
    

    append

    设置 append 属性后,则在当前 (相对) 路径前添加基路径。例如,我们从 /a 导航到一个相对路径 b,如果没有配置 append,则路径为 /b,如果配了,则为 /a/b

    <router-link :to="{ path: 'relative/path'}" append></router-link>
    
    

    tag

    有时候想要 渲染成某种标签,例如

  • 。 于是我们使用 tag prop 类指定何种标签,同样它还是会监听点击,触发导航。

    <router-link to="/foo" tag="li">foo</router-link>
    <!-- 渲染结果 -->
    <li>foo</li>
    

    active-class

    设置 链接激活时使用的 CSS 类名。可以通过以下代码来替代。

    <style>
       ._active{
          background-color : red;
       }
    </style>
    <p>
       <router-link v-bind:to = "{ path: '/route1'}" active-class = "_active">Router Link 1</router-link>
       <router-link v-bind:to = "{ path: '/route2'}" tag = "span">Router Link 2</router-link>
    </p>
    

    注意这里 class 使用 active_class="_active"。

    exact-active-class
    配置当链接被精确匹配的时候应该激活的 class。可以通过以下代码来替代。

    <p>
       <router-link v-bind:to = "{ path: '/route1'}" exact-active-class = "_active">Router Link 1</router-link>
       <router-link v-bind:to = "{ path: '/route2'}" tag = "span">Router Link 2</router-link>
    </p>
    

    event

    声明可以用来触发导航的事件。可以是一个字符串或是一个包含字符串的数组。

    <router-link v-bind:to = "{ path: '/route1'}" event = "mouseover">Router Link 1</router-link>
    
    

    以上代码设置了 event 为 mouseover ,及在鼠标移动到 Router Link 1 上时导航的 HTML 内容会发生改变。

    Vue.js 过渡 & 动画

    本章节我们主要讨论 Vue.js 的过渡效果与动画效果。

    过渡
    Vue 在插入、更新或者移除 DOM 时,提供多种不同方式的应用过渡效果。

    Vue 提供了内置的过渡封装组件,该组件用于包裹要实现过渡效果的组件。

    语法格式

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

    我们可以通过以下实例来理解 Vue 的过渡是如何实现的:

    <style>
    /* 可以设置不同的进入和离开动画 */
    /* 设置持续时间和动画函数 */
    .fade-enter-active, .fade-leave-active {
        transition: opacity 2s
    }
    .fade-enter, .fade-leave-to /* .fade-leave-active, 2.1.8 版本以下 */ {
        opacity: 0
    }
    </style>
    </head>
    <body>
    <div id = "databinding">
    <button v-on:click = "show = !show">点我</button>
    <transition name = "fade">
        <p v-show = "show" v-bind:style = "styleobj">动画实例</p>
    </transition>
    </div>
    <script type = "text/javascript">
    var vm = new Vue({
    el: '#databinding',
        data: {
            show:true,
            styleobj :{
                fontSize:'30px',
                color:'red'
            }
        },
        methods : {
        }
    });
    </script>
    
    

    实例中通过点击 "点我" 按钮将变量 show 的值从 true 变为 false。如果为 true 显示子元素 p 标签的内容。

    下面这段代码展示了 transition 标签包裹了 p 标签:

    <transition name = "fade">
        <p v-show = "show" v-bind:style = "styleobj">动画实例</p>
    </transition>
    
    

    过渡其实就是一个淡入淡出的效果。Vue在元素显示与隐藏的过渡中,提供了 6 个 class 来切换:

    v-enter:定义进入过渡的开始状态。在元素被插入之前生效,在元素被插入之后的下一帧移除。

    v-enter-active:定义进入过渡生效时的状态。在整个进入过渡的阶段中应用,在元素被插入之前生效,在过渡/动画完成之后移除。这个类可以被用来定义进入过渡的过程时间,延迟和曲线函数。

    v-enter-to: 2.1.8版及以上 定义进入过渡的结束状态。在元素被插入之后下一帧生效 (与此同时 v-enter 被移除),在过渡/动画完成之后移除。

    v-leave: 定义离开过渡的开始状态。在离开过渡被触发时立刻生效,下一帧被移除。

    v-leave-active:定义离开过渡生效时的状态。在整个离开过渡的阶段中应用,在离开过渡被触发时立刻生效,在过渡/动画完成之后移除。这个类可以被用来定义离开过渡的过程时间,延迟和曲线函数。

    v-leave-to: 2.1.8版及以上 定义离开过渡的结束状态。在离开过渡被触发之后下一帧生效 (与此同时 v-leave 被删除),在过渡/动画完成之后移除。

    对于这些在过渡中切换的类名来说,如果你使用一个没有名字的 ,则 v- 是这些类名的默认前缀。如果你使用了 ,那么 v-enter 会替换为 my-transition-enter。

    v-enter-active 和 v-leave-active 可以控制进入/离开过渡的不同的缓和曲线,在下面章节会有个示例说明。

    CSS 过渡

    通常我们都使用 CSS 过渡来实现效果。

    <style>
    /* 可以设置不同的进入和离开动画 */
    /* 设置持续时间和动画函数 */
    .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;
    }
    </style>
    </head>
    <body>
    <div id = "databinding">
    <button v-on:click = "show = !show">点我</button>
    <transition name="slide-fade">
        <p v-if="show">菜鸟教程</p>
    </transition>
    </div>
    <script type = "text/javascript">
    new Vue({
        el: '#databinding',
        data: {
            show: true
        }
    })
    </script>
    

    CSS 动画

    CSS 动画用法类似 CSS 过渡,但是在动画中 v-enter 类名在节点插入 DOM 后不会立即删除,而是在 animationend 事件触发时删除。

    <style>
    .bounce-enter-active {
      animation: bounce-in .5s;
    }
    .bounce-leave-active {
      animation: bounce-in .5s reverse;
    }
    @keyframes bounce-in {
      0% {
        transform: scale(0);
      }
      50% {
        transform: scale(1.5);
      }
      100% {
        transform: scale(1);
      }
    }
    </style>
    </head>
    <body>
    <div id = "databinding">
    <button v-on:click = "show = !show">点我</button>
    <transition name="bounce">
        <p v-if="show">菜鸟教程 -- 学的不仅是技术,更是梦想!!!</p>
    </transition>
    </div>
    <script type = "text/javascript">
    new Vue({
        el: '#databinding',
        data: {
            show: true
        }
    })
    </script>
    

    自定义过渡的类名

    我们可以通过以下特性来自定义过渡类名:

    enter-class
    enter-active-class
    enter-to-class (2.1.8+)
    leave-class
    leave-active-class
    leave-to-class (2.1.8+)
    自定义过渡的类名优先级高于普通的类名,这样就能很好的与第三方(如:animate.css)的动画库结合使用。

    <script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js"></script>
    <link href="https://cdn.jsdelivr.net/npm/animate.css@3.5.1" rel="stylesheet" type="text/css">
    </head>
    <body>
    <div id = "databinding">
    <button v-on:click = "show = !show">点我</button>
    <transition
        name="custom-classes-transition"
        enter-active-class="animated tada"
        leave-active-class="animated bounceOutRight"
    >
        <p v-if="show">菜鸟教程 -- 学的不仅是技术,更是梦想!!!</p>
    </transition>
    </div>
    <script type = "text/javascript">
    new Vue({
        el: '#databinding',
        data: {
            show: true
        }
    })
    </script>
    

    同时使用过渡和动画

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

    但是,在一些场景中,你需要给同一个元素同时设置两种过渡动效,比如 animation 很快的被触发并完成了,而 transition 效果还没结束。在这种情况中,你就需要使用 type 特性并设置 animation 或 transition 来明确声明你需要 Vue 监听的类型。

    显性的过渡持续时间

    在很多情况下,Vue 可以自动得出过渡效果的完成时机。默认情况下,Vue 会等待其在过渡效果的根元素的第一个 transitionend 或 animationend 事件。然而也可以不这样设定——比如,我们可以拥有一个精心编排的一系列过渡效果,其中一些嵌套的内部元素相比于过渡效果的根元素有延迟的或更长的过渡效果。

    在这种情况下你可以用 组件上的 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 结合时使用
      enter: function (el, done) {
        // ...
        done()
      },
      afterEnter: function (el) {
        // ...
      },
      enterCancelled: function (el) {
        // ...
      },
     
      // --------
      // 离开时
      // --------
     
      beforeLeave: function (el) {
        // ...
      },
      // 此回调函数是可选项的设置
      // 与 CSS 结合时使用
      leave: function (el, done) {
        // ...
        done()
      },
      afterLeave: function (el) {
        // ...
      },
      // leaveCancelled 只用于 v-show 中
      leaveCancelled: function (el) {
        // ...
      }
    }
    

    这些钩子函数可以结合 CSS transitions/animations 使用,也可以单独使用。

    当只用 JavaScript 过渡的时候,在 enter 和 leave 中必须使用 done 进行回调。否则,它们将被同步调用,过渡会立即完成。

    推荐对于仅使用 JavaScript 过渡的元素添加 v-bind:css="false",Vue 会跳过 CSS 的检测。这也可以避免过渡过程中 CSS 的影响。

    一个使用 Velocity.js 的简单例子:

    <script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/velocity/1.2.3/velocity.min.js"></script>
    </head>
    <body>
    <div id = "databinding">
    <button v-on:click = "show = !show">点我</button>
    <transition
        v-on:before-enter="beforeEnter"
        v-on:enter="enter"
        v-on:leave="leave"
        v-bind:css="false"
      >
        <p v-if="show">菜鸟教程 -- 学的不仅是技术,更是梦想!!!</p>
    </transition>
    </div>
    <script type = "text/javascript">
    new Vue({
      el: '#databinding',
      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 })
        }
      }
    })
    </script>
    

    初始渲染的过渡

    可以通过 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 钩子:

    多个元素的过渡

    我们可以设置多个元素的过渡,一般列表与描述:

    需要注意的是当有相同标签名的元素切换时,需要通过 key 特性设置唯一的值来标记以让 Vue 区分它们,否则 Vue 为了效率只会替换相同标签内部的内容。

    <transition>
      <table v-if="items.length > 0">
        <!-- ... -->
      </table>
      <p v-else>抱歉,没有找到您查找的内容。</p>
    </transition>
    
    

    如下实例:

    <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 (this.docState) {
          case 'saved': return 'Edit'
          case 'edited': return 'Save'
          case 'editing': return 'Cancel'
        }
      }
    }
    
    
查看全文
  • 相关阅读:
    mysql时间操作函数和存储过程
    puppet foreman
    mysql c haracter
    socket
    socket 网摘
    网络安全
    sqlite3 C接口
    spring 配置文件XSD地址
    programData
    网络安全数据包分析
  • 原文地址:https://www.cnblogs.com/userzf/p/12848892.html
  • Copyright © 2011-2022 走看看