Vue(二)

1. 生命周期

什么是生命周期：从Vue实例创建、运行、到销毁期间，总是伴随着各种各样的事件，这些事件，统称为生命周期！

生命周期钩子：就是生命周期事件的别名而已；生命周期钩子 = 生命周期函数 = 生命周期事件

主要的生命周期函数分类：

  • 创建期间的生命周期函数：

    • beforeCreate：实例刚在内存中被创建出来，此时，还没有初始化好 data 和 methods 属性
    • created：实例已经在内存中创建OK，此时 data 和 methods 已经创建OK，此时还没有开始编译模板
    • beforeMount：此时已经完成了模板的编译，但是还没有挂载到页面中
    • mounted：此时，已经将编译好的模板，挂载到了页面指定的容器中显示

  • 运行期间的生命周期函数：

    • beforeUpdate：状态更新之前执行此函数， 此时 data 中的状态值是最新的，但是界面上显示的数据还是旧的，因为此时还没有开始重新渲染DOM节点
    • updated：实例更新完毕之后调用此函数，此时 data 中的状态值 和 界面上显示的数据，都已经完成了更新，界面已经被重新渲染好了！

  • 销毁期间的生命周期函数：

    • beforeDestroy：实例销毁之前调用。在这一步，实例仍然完全可用。
    • destroyed：Vue 实例销毁后调用。调用后，Vue 实例指示的所有东西都会解绑定，所有的事件监听器会被移除，所有的子实例也会被销毁。

image-20200720163701324

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            msg: 'ok'
        },
        methods: {
            show() {
                console.log('执行了show方法')
            }
        },
        beforeCreate() { // 这是我们遇到的第一个生命周期函数，表示实例完全被创建出来之前，会执行它
            // console.log(this.msg)
            // this.show()
            // 注意： 在 beforeCreate 生命周期函数执行的时候，data 和 methods 中的 数据都还没有没初始化
        },
        created() { // 这是遇到的第二个生命周期函数
            // console.log(this.msg)
            // this.show()
            //  在 created 中，data 和 methods 都已经被初始化好了！
            // 如果要调用 methods 中的方法，或者操作 data 中的数据，最早，只能在 created 中操作
        },
        beforeMount() { // 这是遇到的第3个生命周期函数，表示 模板已经在内存中编辑完成了，但是尚未把模板渲染到页面中
            // console.log(document.getElementById('h3').innerText)
            // 在 beforeMount 执行的时候，页面中的元素，还没有被真正替换过来，只是之前写的一些模板字符串
        },
        mounted() { // 这是遇到的第4个生命周期函数，表示，内存中的模板，已经真实的挂载到了页面中，用户已经可以看到渲染好的页面了
            // console.log(document.getElementById('h3').innerText)
            // 注意： mounted 是 实例创建期间的最后一个生命周期函数，当执行完 mounted 就表示，实例已经被完全创建好了，此时，
            // 如果没有其它操作的话，这个实例，就静静的 躺在我们的内存中，一动不动
        },

        // 接下来的是运行中的两个事件
        beforeUpdate() { // 这时候，表示 我们的界面还没有被更新【数据被更新了吗？  数据肯定被更新了】
            /* console.log('界面上元素的内容：' + document.getElementById('h3').innerText)
            console.log('data 中的 msg 数据是：' + this.msg) */
            //得出结论： 当执行 beforeUpdate 的时候，页面中的显示的数据，还是旧的，此时 data 数据是最新的，
            // 页面尚未和最新的数据保持同步
        },
        updated() {
            console.log('界面上元素的内容：' + document.getElementById('h3').innerText)
            console.log('data 中的 msg 数据是：' + this.msg)
            // updated 事件执行的时候，页面和 data 数据已经保持同步了，都是最新的
        }
    });
</script>

2. vue-resource 实现 get, post, jsonp请求

2.1 引用

直接在页面中，通过script标签，引入 vue-resource 的脚本文件；

注意：引用的先后顺序是：先引用 Vue 的脚本文件，再引用 vue-resource 的脚本文件；

1
2
3
4
5
6
7
8
9
10
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="./lib/vue-2.4.0.js"></script>
    <!-- 注意：vue-resource 依赖于 Vue，所以先后顺序要注意  -->
    <!-- this.$http.jsonp -->
    <script src="./lib/vue-resource-1.3.4.js"></script>
</head>

2.2 发起get请求

1
2
3
4
5
6
7
getInfo() { // 发起get请求
    // 当发起get请求之后， 通过 .then 来设置成功的回调函数
    this.$http.get('http://vue.studyit.io/api/getlunbo').then(function (result) {
        // 通过 result.body 拿到服务器返回的成功的数据
        console.log(result.body)
    })
}

2.3 发送post请求

1
2
3
4
5
6
7
8
9
10
postInfo() {
  var url = 'http://127.0.0.1:8899/api/post';
  // post 方法接收三个参数：
  // 参数1： 要请求的URL地址
  // 参数2： 要发送的数据对象
  // 参数3： 指定post提交的编码类型为 application/x-www-form-urlencoded
  this.$http.post(url, { name: 'zs' }, { emulateJSON: true }).then(res => {
        console.log(res.body);
  });
}

2.4 发送JSONP请求

1
2
3
4
5
jsonpInfo() { // 发起JSONP 请求
    this.$http.jsonp('http://vue.studyit.io/api/jsonp').then(result => {
        console.log(result.body)
    })
}

2.5 全局配置请求路径

如果我们通过全局配置了请求的数据接口根域名，则在每次单独发起 http 请求的时候，请求的 url 路径，应该以相对路径开头，前面不能带 / ，否则不会启用根路径做拼接；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<script>
    Vue.http.options.root = 'http://vue.studyit.io/';
    // 全局启用 emulateJSON 选项
    Vue.http.options.emulateJSON = true;

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        methods: {
            getAllList() {
                this.$http.get('api/getprodlist').then(result => {
                    
                })
            }
        }
    });
</script>

3. 动画

动画能够提高用户的体验，帮助用户更好的理解页面中的功能；

3.1 不使用动画

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<div id="app">
    <input type="button" value="toggle" @click="flag=!flag">
    <!-- 需求： 点击按钮，让 h3 显示，再点击，让 h3 隐藏 -->
    <h3 v-if="flag">这是一个H3</h3>
</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            flag: false
        },
        methods: {}
    });
</script>

3.2 使用过渡类名实现动画

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<div id="app">
    <input type="button" value="toggle" @click="flag=!flag">
    <!-- 需求： 点击按钮，让 h3 显示，再点击，让 h3 隐藏 -->
    
    <!-- 1. 使用 transition 元素，把 需要被动画控制的元素，包裹起来 -->
    <!-- transition 元素，是 Vue 官方提供的 -->
    <transition>
        <h3 v-if="flag">这是一个H3</h3>
    </transition>
</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            flag: false
        },
        methods: {}
    });
</script>

<!-- 2. 自定义两组样式，来控制 transition 内部的元素实现动画 -->
<style>
    /* v-enter 【这是一个时间点】 是进入之前，元素的起始状态，此时还没有开始进入 */
    /* v-leave-to 【这是一个时间点】 是动画离开之后，离开的终止状态，此时，元素 动画已经结束了 */
    .v-enter,
    .v-leave-to {
        opacity: 0;
        transform: translateX(150px);
    }

    /* v-enter-active 【入场动画的时间段】 */
    /* v-leave-active 【离场动画的时间段】 */
    .v-enter-active,
    .v-leave-active {
        transition: all 0.8s ease;
    }
</style>

3.3 修改v-前缀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<div id="app">

    <input type="button" value="toggle2" @click="flag2=!flag2">
    <transition name="my">
        <h6 v-if="flag2">这是一个H6</h6>
    </transition>
</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            flag2: false
        },
        methods: {}
    });
</script>

<!-- 2. 自定义两组样式，来控制 transition 内部的元素实现动画 -->
<style>

    .my-enter,
    .my-leave-to {
        opacity: 0;
        transform: translateY(70px);
    }

    .my-enter-active,
    .my-leave-active {
        transition: all 0.8s ease;
    }
</style>

3.4 使用第三方 CSS 动画库

1、导入动画类库

1
<link rel="stylesheet" type="text/css" href="./lib/animate.css">

2、定义 transition 及属性

1
2
3
4
5
6
7
<!-- 使用  :duration="{ enter: 200, leave: 400 }"  来分别设置 入场的时长 和 离场的时长  -->
<transition
            enter-active-class="bounceIn"
            leave-active-class="bounceOut"
            :duration="{ enter: 200, leave: 400 }">
    <h3 v-if="flag" class="animated">这是一个H3</h3>
</transition>

3.5 使用动画钩子函数

1、定义 transition 组件以及三个钩子函数：

1
2
3
4
5
6
7
8
9
10
<div id="app">
    <input type="button" value="快到碗里来" @click="flag=!flag">
    <!-- 1. 使用 transition 元素把 小球包裹起来 -->
    <transition
            @before-enter="beforeEnter"
            @enter="enter"
            @after-enter="afterEnter">
        <div class="ball" v-show="flag"></div>
    </transition>
</div>
  1. 定义三个 methods 钩子方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            isshow: false
        },
        methods: {
            // 注意： 动画钩子函数的第一个参数：el，表示要执行动画的那个DOM元素，是个原生的JS DOM对象
            // 大家可以认为 ， el 是通过 document.getElementById('') 方式获取到的原生JS DOM对象
            beforeEnter(el) {
                // beforeEnter 表示动画入场之前，此时，动画尚未开始，可以在 beforeEnter 中，设置元素开始动画之前的起始样式
                // 设置小球开始动画之前的，起始位置
                el.style.transform = "translate(0, 0)"
            },
            enter(el, done) {
                // 这句话，没有实际的作用，但是，如果不写，出不来动画效果；
                // 可以认为 el.offsetWidth 会强制动画刷新
                el.offsetWidth;
                // enter 表示动画 开始之后的样式，这里，可以设置小球完成动画之后的，结束状态
                el.style.transform = "translate(150px, 450px)";
                el.style.transition = 'all 1s ease';

                // 这里的 done， 起始就是 afterEnter 这个函数，也就是说：done 是 afterEnter 函数的引用
                done()
            },
            afterEnter(el) {
                // 动画完成之后，会调用 afterEnter
                // console.log('ok')
                this.flag = !this.flag
            }
        }
    });
</script>
  1. 定义样式：
1
2
3
4
5
6
.ball {
    width: 15px;
    height: 15px;
    border-radius: 50%;
    background-color: red;
}

3.6 列表动画

1
2
3
4
5
6
7
8
9
10
11
<!-- <ul> -->
<!-- 在实现列表过渡的时候，如果需要过渡的元素，是通过 v-for 循环渲染出来的，不能使用 transition 包裹，需要使用 transitionGroup -->
<!-- 如果要为 v-for 循环创建的元素设置动画，必须为每一个 元素 设置 :key 属性 -->
<!-- 给 transition-group 添加 appear 属性，实现页面刚展示出来时候，入场时候的效果 -->
<!-- 通过 为 transition-group 元素，设置 tag 属性，指定 transition-group 渲染为指定的元素，如果不指定 tag 属性，默认，渲染为 span 标签 -->
<transition-group appear tag="ul">
    <li v-for="(item, i) in list" :key="item.id" @click="del(i)">
        { {item.id} } --- { {item.name} }
    </li>
</transition-group>
<!-- </ul> -->

<transition-group> 组件还有一个特殊之处。不仅可以进入和离开动画，还可以改变定位。要使用这个新功能只需了解新增的 v-move 特性，它会在元素的改变定位的过程中应用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<style>
    li {
        border: 1px dashed #999;
        margin: 5px;
        line-height: 35px;
        padding-left: 5px;
        font-size: 12px;
        width: 100%;
    }

    li:hover {
        background-color: hotpink;
        transition: all 0.8s ease;
    }


    .v-enter,
    .v-leave-to {
        opacity: 0;
        transform: translateY(80px);
    }

    .v-enter-active,
    .v-leave-active {
        transition: all 0.6s ease;
    }

    /* 下面的 .v-move 和 .v-leave-active 配合使用，能够实现列表后续的元素，渐渐地漂上来的效果 */
    .v-move {
        transition: all 0.6s ease;
    }

    .v-leave-active {
        position: absolute;
    }
</style>

4. 组件

什么是组件： 组件的出现，就是为了拆分Vue实例的代码量的，能够让我们以不同的组件，来划分不同的功能模块，将来我们需要什么样的功能，就可以去调用对应的组件即可；
组件化和模块化的不同：

  • 模块化： 是从代码逻辑的角度进行划分的；方便代码分层开发，保证每个功能模块的职能单一；
  • 组件化： 是从UI界面的角度进行划分的；前端的组件化，方便UI组件的重用；

4.1 组件定义的三种方式：

1、使用 Vue.extend 配合 Vue.component 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<div id="app">
    <!-- 如果要使用组件，直接，把组件的名称，以 HTML 标签的形式，引入到页面中，即可 -->
    <mycom1></mycom1>
</div>

<script>
    // 1.1 使用 Vue.extend 来创建全局的Vue组件
    // var com1 = Vue.extend({
    //   template: '<h3>这是使用 Vue.extend 创建的组件</h3>' // 通过 template 属性，指定了组件要展示的HTML结构
    // })

    // 1.2 使用 Vue.component('组件的名称', 创建出来的组件模板对象)
    // Vue.component('myCom1', com1)
    // 如果使用 Vue.component 定义全局组件的时候，组件名称使用了 驼峰命名，则在引用组件的时候，需要把 大写的驼峰改为小写的字母，同时，两个单词之前，使用 - 链接；
    // 如果不使用驼峰,则直接拿名称来使用即可;
    // Vue.component('mycom1', com1)

    // Vue.component 第一个参数:组件的名称,将来在引用组件的时候,就是一个 标签形式 来引入 它的
    // 第二个参数: Vue.extend 创建的组件  ,其中 template 就是组件将来要展示的HTML内容
    Vue.component('mycom1', Vue.extend({
        template: '<h3>这是使用 Vue.extend 创建的组件</h3>'
    }));


    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {}
    });
</script>

2、直接使用 Vue.component 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<div id="app">
    <!-- 还是使用 标签形式,引入自己的组件 -->
    <mycom2></mycom2>
</div>

<script>
    // 注意:不论是哪种方式创建出来的组件,组件的 template 属性指向的模板内容,必须有且只能有唯一的一个根元素
    Vue.component('mycom2', {
        template: '<div><h3>这是直接使用 Vue.component 创建出来的组件</h3><span>123</span></div>'
    })

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {}
    });
</script>

3、引用template标签

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<div id="app">
    <mycom3></mycom3>
</div>

<!-- 在被控制的 #app 外面,使用 template 元素,定义组件的HTML模板结构  -->
<template id="tmpl">
    <div>
        <h1>这是通过 template 元素,在外部定义的组件结构,这个方式,有代码的只能提示和高亮</h1>
        <h4>好用,不错!</h4>
    </div>
</template>

<script>
    Vue.component('mycom3', {
        template: '#tmpl'
    });

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {}
    });
</script>

注意： 组件中的DOM结构，有且只能有唯一的根元素（Root Element）来进行包裹！

4.2 私有组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<div id="app2">
    <login></login>
</div>

<template id="tmpl2">
    <h1>这是私有的 login 组件</h1>
</template>

<script>
    var vm2 = new Vue({
        el: '#app2',
        data: {},
        methods: {},
        filters: {},
        directives: {},
        components: { // 定义实例内部私有组件的
            login: {
                template: '#tmpl2'
            }
        }
    })
</script>

4.3 组件中展示数据和响应事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<div id="app">
    <mycom1></mycom1>
</div>

<script>
    // 1. 组件可以有自己的 data 数据
    // 2. 组件的 data 和 实例的 data 有点不一样,实例中的 data 可以为一个对象,但是 组件中的 data 必须是一个方法
    // 3. 组件中的 data 除了必须为一个方法之外,这个方法内部,还必须返回一个对象才行;
    // 4. 组件中 的data 数据,使用方式,和实例中的 data 使用方式完全一样!!!
    Vue.component('mycom1', {
        template: '<h1>这是全局组件 --- { {msg} }</h1>',
        data: function () {
            return {
                msg: '这是组件的中data定义的数据'
            }
        }
    });

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {}
    });
</script>

5. 组件切换

5.1 flag标识符结合v-if和v-else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<div id="app">
    <a href="" @click.prevent="flag=true">登录</a>
    <a href="" @click.prevent="flag=false">注册</a>

    <login v-if="flag"></login>
    <register v-else="flag"></register>
</div>

<script>
    Vue.component('login', {
        template: '<h3>登录组件</h3>'
    });
    Vue.component('register', {
        template: '<h3>注册组件</h3>'
    });

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            flag: false
        },
        methods: {}
    });
</script>

5.2 使用Vue提供的compoent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<div id="app">
    <a href="" @click.prevent="comName='login'">登录</a>
    <a href="" @click.prevent="comName='register'">注册</a>

    <!-- Vue提供了 component ,来展示对应名称的组件 -->
    <!-- component 是一个占位符, :is 属性,可以用来指定要展示的组件的名称 -->
    <component :is="comName"></component>
</div>

<script>
    // 组件名称是 字符串
    Vue.component('login', {
        template: '<h3>登录组件</h3>'
    })

    Vue.component('register', {
        template: '<h3>注册组件</h3>'
    })

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            comName: 'login' // 当前 component 中的 :is 绑定的组件的名称
        },
        methods: {}
    });
</script>

5.3 切换动画

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!-- 通过 mode 属性,设置组件切换时候的 模式 -->
<transition mode="out-in">
    <component :is="comName"></component>
</transition>


<style>
    .v-enter,
    .v-leave-to {
        opacity: 0;
        transform: translateX(150px);
    }

    .v-enter-active,
    .v-leave-active {
        transition: all 0.5s ease;
    }
</style>

6. 组件传值

6.1 父组件向子组件传值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<div id="app">
    <!-- 父组件，可以在引用子组件的时候， 通过 属性绑定（v-bind:） 的形式,
    把 需要传递给 子组件的数据，以属性绑定的形式，传递到子组件内部，供子组件使用 -->
    <com1 v-bind:parentmsg="msg"></com1>
</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            msg: '123 啊-父组件中的数据'
        },
        methods: {},
        components: {
            // 结论：经过演示，发现，子组件中，默认无法访问到 父组件中的 data 上的数据 和 methods 中的方法
            com1: {
                data() { // 注意： 子组件中的 data 数据，并不是通过 父组件传递过来的，而是子组件自身私有的，
                    // 比如： 子组件通过 Ajax ，请求回来的数据，都可以放到 data 身上；
                    // data 上的数据，都是可读可写的；
                    return {
                        title: '123',
                        content: 'qqq'
                    }
                },
                template: '<h1 @click="change">这是子组件 --- { { parentmsg } }</h1>',
                // 注意： 组件中的 所有 props 中的数据，都是通过 父组件传递给子组件的
                // props 中的数据，都是只读的，无法重新赋值
                props: ['parentmsg'], // 把父组件传递过来的 parentmsg 属性，先在 props 数组中，定义一下，这样，才能使用这个数据
                methods: {
                    change() {
                        this.parentmsg = '被修改了'
                    }
                }
            }
        }
    });
</script>

6.2 父组件向子组件传递方法

子组件向父组件传值

原理：父组件将方法的引用，传递到子组件内部，子组件在内部调用父组件传递过来的方法，同时把要发送给父组件的数据，在调用方法的时候当作参数传递进去；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<div id="app">
    <!-- 父组件向子组件传递方法，使用的是事件绑定机制；v-on, 当我们自定义了 一个事件属性之后，
    那么，子组件就能够，通过某些方式，来调用传递进去的这个方法了 -->
    <com2 @func="show"></com2>
</div>

<template id="tmpl">
    <div>
        <h1>这是子组件</h1>
        <input type="button" value="这是子组件中的按钮 - 点击它，触发 父组件传递过来的 func 方法" @click="myclick">
    </div>
</template>

<script>
    // 定义了一个字面量类型的 组件模板对象
    var com2 = {
        template: '#tmpl', // 通过指定了一个 Id, 表示说，要去加载 这个指定Id的 template 元素中的内容，当作组件的HTML结构
        data() {
            return {
                sonmsg: {name: '小头儿子', age: 6}
            }
        },
        methods: {
            myclick() {
                // 当点击子组件的按钮的时候，如何 拿到父组件传递过来的 func 方法，并调用这个方法？？？
                // emit 英文原意： 是触发，调用、发射的意思
                // this.$emit('func123', 123, 456)
                this.$emit('func', this.sonmsg)
            }
        }
    }
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            datamsgFormSon: null
        },
        methods: {
            show(data) {
                // console.log('调用了父组件身上的 show 方法: --- ' + data)
                this.datamsgFormSon = data
            }
        },
        components: {
            com2
        }
    });
</script>

7. 使用ref获取DOM元素和组件引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<div id="app">
    <input type="button" value="获取元素" @click="getElement" ref="mybtn">
    <h3 id="myh3" ref="myh3">哈哈哈， 今天天气太好了！！！</h3>
    <hr>
    <login ref="mylogin"></login>
</div>
<script>
    var login = {
        template: '<h1>登录组件</h1>',
        data() {
            return {
                msg: 'son msg'
            }
        },
        methods: {
            show() {
                console.log('调用了子组件的方法')
            }
        }
    }
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {
            getElement() {
                console.log(document.getElementById('myh3').innerText);
                //  ref  是 英文单词 【reference】   值类型 和 引用类型  referenceError
                console.log(this.$refs.myh3.innerText);
                console.log(this.$refs.mylogin.msg);
                this.$refs.mylogin.show();
            }
        },
        components: {
            login
        }
    });
</script>

8. 路由

后端路由：对于普通的网站，所有的超链接都是URL地址，所有的URL地址都对应服务器上对应的资源；

前端路由：对于单页面应用程序来说，主要通过URL中的hash(#号)来实现不同页面之间的切换，同时，hash有一个特点：HTTP请求中不会包含hash相关的内容；所以，单页面程序中的页面跳转主要用hash实现；

在单页面应用程序中，这种通过hash改变来切换页面的方式，称作前端路由（区别于后端路由）；

8.1 在 vue 中使用 vue-router

8.1.1 导入 vue-router 组件类库

1
2
3
<script src="./lib/vue-2.4.0.js"></script>
<!-- 1. 安装 vue-router 路由模块 -->
<script src="./lib/vue-router-3.0.1.js"></script>

8.1.2 创建组件的模板对象

1
2
3
4
5
6
7
8
// 组件的模板对象
var login = {
    template: '<h1>登录组件</h1>'
};

var register = {
    template: '<h1>注册组件</h1>'
};

8.1.3 创建一个路由对象

当 导入 vue-router 包之后，在 window 全局对象中，就有了一个 路由的构造函数，叫做 VueRouter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 在 new 路由对象的时候，可以为 构造函数，传递一个配置对象
var routerObj = new VueRouter({
    // route // 这个配置对象中的 route 表示 【路由匹配规则】 的意思
    routes: [ // 路由匹配规则 
        // 每个路由规则，都是一个对象，这个规则对象，身上，有两个必须的属性：
        //  属性1 是 path， 表示监听 哪个路由链接地址；
        //  属性2 是 component， 表示，如果 路由是前面匹配到的 path ，则展示 component 属性对应的那个组件
        // 注意： component 的属性值，必须是一个 组件的模板对象， 不能是 组件的引用名称；
        // { path: '/', component: login },
        { path: '/', redirect: '/login' }, // 这里的 redirect 和 Node 中的 redirect 完全是两码事
        { path: '/login', component: login },
        { path: '/register', component: register }
    ],
    linkActiveClass: 'myactive'
});

8.1.4 创建 Vue 实例，得到 ViewModel

1
2
3
4
5
6
7
// 创建 Vue 实例，得到 ViewModel
var vm = new Vue({
    el: '#app',
    data: {},
    methods: {},
    router: routerObj // 将路由规则对象，注册到 vm 实例上，用来监听 URL 地址的变化，然后展示对应的组件
});
1
2
3
4
5
6
<!-- <a href="#/login">登录</a> -->
<!-- <a href="#/register">注册</a> -->

<!-- router-link 默认渲染为一个a 标签 -->
<router-link to="/login" tag="span">登录</router-link>
<router-link to="/register">注册</router-link>

8.1.6 使用 router-view 组件来显示匹配到的组件

1
2
3
<!-- 这是 vue-router 提供的元素，专门用来 当作占位符的，将来，路由规则，匹配到的组件，就会展示到这个 router-view 中去 -->
<!-- 所以： 我们可以把 router-view 认为是一个占位符 -->
<router-view></router-view>

8.2 使用tag属性指定router-link渲染的标签类型

1
2
<!-- router-link 默认渲染为一个a 标签 -->
<router-link to="/login" tag="span">登录</router-link>

8.3 设置路由重定向redirect

1
2
3
routes: [ // 路由匹配规则
    { path: '/', redirect: '/login' } // 这里的 redirect 和 Node 中的 redirect 完全是两码事
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<style>
    .router-link-active,
    .myactive {
        color: red;
        font-weight: 800;
        font-style: italic;
        font-size: 80px;
        text-decoration: underline;
        background-color: green;
    }
</style>

var routerObj = new VueRouter({
    routes: [ // 路由匹配规则
        { path: '/register', component: register }
    ],
    linkActiveClass: 'myactive'
});

8.5 设置路由切换动效

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<style>
    .v-enter,
    .v-leave-to {
        opacity: 0;
        transform: translateX(140px);
    }

    .v-enter-active,
    .v-leave-active {
        transition: all 0.5s ease;
    }
</style>

<transition mode="out-in">
    <router-view></router-view>
</transition>

9. 在路由规则中定义参数

9.1 通过 this.$route.query来获取路由中的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 如果在路由中，使用 查询字符串，给路由传递参数，则 不需要修改 路由规则的 path 属性 -->
<router-link to="/login?id=10&name=zs">登录</router-link>

var login = {
    template: '<h1>登录 --- { { $route.query.id } } --- { { $route.query.name } }</h1>',
    data() {
        return {
            msg: '123'
        }
    },
    created() { // 组件的生命周期钩子函数
        // console.log(this.$route)
        console.log(this.$route.query.id)
    }
};

9.2 通过 this.$route.params来获取路由中的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<!-- 如果在路由中，使用 查询字符串，给路由传递参数，则 不需要修改 路由规则的 path 属性 -->
<router-link to="/login/12/ls">登录</router-link>

var login = {
    template: '<h1>登录 --- { { $route.params.id } } --- { { $route.params.name } }</h1>',
    data() {
        return {
            msg: '123'
        }
    },
    created() { // 组件的生命周期钩子函数
        console.log(this.$route.params.id)
    }
};

var register = {
	template: '<h1>注册</h1>'
};

var router = new VueRouter({
    routes: [
        {path: '/login/:id/:name', component: login},
        {path: '/register', component: register}
    ]
});

10. 路由嵌套

10.1 定义组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<template id="tmpl">
    <div>
        <h1>这是 Account 组件</h1>

        <router-link to="/account/login">登录</router-link>
        <router-link to="/account/register">注册</router-link>

        <router-view></router-view>
    </div>
</template>

<script>
	// 组件的模板对象
    var account = {
        template: '#tmpl'
    };

    var login = {
        template: '<h3>登录</h3>'
    };

    var register = {
        template: '<h3>注册</h3>'
    };
</script>

10.2 定义router

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var router = new VueRouter({
  routes: [
    {
      path: '/account',
      component: account,
      // 使用 children 属性，实现子路由，同时，子路由的 path 前面，不要带 / ，
      // 否则永远以根路径开始请求，这样不方便我们用户去理解URL地址
      children: [
        {path: 'login', component: login},
        {path: 'register', component: register}
      ]
    }
    // { path: '/account/login', component: login },
    // { path: '/account/register', component: register }
  ]
});

<div id="app">
  <router-link to="/account">Account</router-link>
  <router-view></router-view>
</div>

11. 命名视图实现经典布局

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<div id="app">
    <router-view></router-view>
    <div class="container">
        <router-view name="left"></router-view>
        <router-view name="main"></router-view>
    </div>
</div>

<script>
    var header = {
        template: '<h1 class="header">Header头部区域</h1>'
    };
    var leftBox = {
        template: '<h1 class="left">Left侧边栏区域</h1>'
    };
    var mainBox = {
        template: '<h1 class="main">mainBox主体区域</h1>'
    };
    // 创建路由对象
    var router = new VueRouter({
        routes: [
            {
                path: '/', components: {
                    'default': header,
                    'left': leftBox,
                    'main': mainBox
                }
            }
        ]
    });
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {},
        router
    });
</script>

12. 监听

12.1 methods keyup事件监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<div id="app">

    <!-- 分析： -->
    <!-- 1. 我们要监听到 文本框数据的改变，这样才能知道 什么时候去拼接 出一个 fullname -->
    <!-- 2. 如何监听到 文本框的数据改变呢？？？ -->

    <input type="text" v-model="firstname" @keyup="getFullname"> +
    <input type="text" v-model="lastname" @keyup="getFullname"> =
    <input type="text" v-model="fullname">

</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            firstname: '',
            lastname: '',
            fullname: ''
        },
        methods: {
            getFullname() {
                this.fullname = this.firstname + '-' + this.lastname
            }
        }
    });
</script>

12.2 watch监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<div id="app">

    <input type="text" v-model="firstname"> +
    <input type="text" v-model="lastname"> =
    <input type="text" v-model="fullname">

</div>

<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            firstname: '',
            lastname: '',
            fullname: ''
        },
        methods: {},
        watch: { // 使用这个 属性，可以监视 data 中指定数据的变化，然后触发这个 watch 中对应的 function 处理函数
            'firstname': function (newVal, oldVal) {// 第一个参数是新数据，第二个参数是旧数据
                // console.log('监视到了 firstname 的变化')
                // this.fullname = this.firstname + '-' + this.lastname
                this.fullname = newVal + '-' + this.lastname
            },
            'lastname': function (newVal) {
                this.fullname = this.firstname + '-' + newVal
            }
        }
    });
</script>

12.3 监视路由地址的改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 3. 创建一个路由对象
var router = new VueRouter({
    routes: [ // 路由规则数组
        {path: '/', redirect: '/login'},
        {path: '/login', component: login},
        {path: '/register', component: register}
    ],
    linkActiveClass: 'myactive' // 和激活相关的类
})

// 创建 Vue 实例，得到 ViewModel
var vm = new Vue({
    el: '#app',
    data: {},
    methods: {},
    // router: router
    router,
    watch: {
        //  this.$route.path
        '$route.path': function (newVal, oldVal) {
            // console.log(newVal + ' --- ' + oldVal)
            if (newVal === '/login') {
                console.log('欢迎进入登录页面')
            } else if (newVal === '/register') {
                console.log('欢迎进入注册页面')
            }
        }
    }
});

12.4 computed-计算属性的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<div id="app">

    <input type="text" v-model="firstname"> +
    <input type="text" v-model="middlename"> +
    <input type="text" v-model="lastname"> =
    <input type="text" v-model="fullname">

    <p>{{ fullname }}</p>
    <p>{{ fullname }}</p>
    <p>{{ fullname }}</p>
</div>
<script>
    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {
            firstname: '',
            lastname: '',
            middlename: ''
        },
        methods: {},
        computed: { // 在 computed 中，可以定义一些 属性，这些属性，叫做 【计算属性】， 计算属性的，
            // 本质，就是 一个方法，只不过，我们在使用 这些计算属性的时候，是把 它们的 名称，
            // 直接当作 属性来使用的；并不会把 计算属性，当作方法去调用；

            // 注意1： 计算属性，在引用的时候，一定不要加 () 去调用，直接把它 当作 普通 属性去使用就好了；
            // 注意2： 只要 计算属性，这个 function 内部，所用到的 任何 data 中的数据发送了变化，
            // 就会 立即重新计算 这个 计算属性的值
            // 注意3： 计算属性的求值结果，会被缓存起来，方便下次直接使用； 如果 计算属性方法中，所以来的任何数据，
            // 都没有发生过变化，则，不会重新对 计算属性求值；
            'fullname': function () {
                console.log('ok')
                return this.firstname + '-' + this.middlename + '-' + this.lastname
            }
        }
    });
</script>

12.5 watch、computed和methods之间的对比

  1. computed属性的结果会被缓存，除非依赖的响应式属性变化才会重新计算。主要当作属性来使用；
  2. methods方法表示一个具体的操作，主要书写业务逻辑；
  3. watch一个对象，键是需要观察的表达式，值是对应回调函数。主要用来监听某些特定数据的变化，从而进行某些具体的业务逻辑操作；可以看作是computed和methods的结合体；

13. 使用render函数渲染组件

在页面中渲染基本的组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<div id="app">
    <p>33333</p>
    <login></login>
</div>

<script>

    var login = {
        template: '<h1>这是登录组件</h1>'
    }

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {},
        components: {
            login
        }
    });
</script>

在页面中使用render函数渲染组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<div id="app">
    <p>444444</p>
</div>

<script>

    var login = {
        template: '<h1>这是登录组件</h1>'
    }

    // 创建 Vue 实例，得到 ViewModel
    var vm = new Vue({
        el: '#app',
        data: {},
        methods: {},
        render: function (createElements) { // createElements 是一个 方法，调用它，能够把 指定的 组件模板，渲染为 html 结构
            return createElements(login)
            // 注意：这里 return 的结果，会 替换页面中 el 指定的那个 容器
        }
    });
</script>

14. Vuex

vuex 是 Vue 配套的公共数据管理工具，它可以把一些共享的数据，保存到 vuex 中，方便 整个程序中的任何组件直接获取或修改我们的公共数据

image-20200728140456544

14.1 安装

在 Vue 之后引入 vuex 会进行自动安装

1
2
<script src="/path/to/vue.js"></script>
<script src="/path/to/vuex.js"></script>

NPM

1
npm install vuex --save

Yarn

1
yarn add vuex

在一个模块化的打包系统中，您必须显式地通过 Vue.use() 来安装 Vuex：

1
2
3
4
import Vue from 'vue'
import Vuex from 'vuex'

Vue.use(Vuex)

当使用全局 script 标签引用 Vuex 时，不需要以上安装过程。

每一个 Vuex 应用的核心就是 store（仓库）。“store”基本上就是一个容器，它包含着你的应用中大部分的状态 (state)。Vuex 和单纯的全局对象有以下两点不同：

  • Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候，若 store 中的状态发生变化，那么相应的组件也会相应地得到高效更新。
  • 你不能直接改变 store 中的状态。改变 store 中的状态的唯一途径就是显式地提交 (commit) mutation。这样使得我们可以方便地跟踪每一个状态的变化，从而让我们能够实现一些工具帮助我们更好地了解我们的应用。

14.2 最简单的 Store

安装Vuex 之后，让我们来创建一个 store。创建过程直截了当——仅需要提供一个初始 state 对象和一些 mutation：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import Vue from 'vue'
import Vuex from 'vuex'

Vue.use(Vuex)

const store = new Vuex.Store({
  state: {
    count: 0
  },
  mutations: {
    increment (state) {
      state.count++
    }
  }
})

现在，你可以通过 store.state 来获取状态对象，以及通过 store.commit 方法触发状态变更：

1
2
3
store.commit('increment')

console.log(store.state.count) // -> 1

为了在 Vue 组件中访问 this.$store property，你需要为 Vue 实例提供创建好的 store。Vuex 提供了一个从根组件向所有子组件，以 store 选项的方式“注入”该 store 的机制：

1
2
3
4
new Vue({
  el: '#app',
  store: store,
})

14.3 案例

main.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// 入口文件
import Vue from 'vue'
// 配置vuex的步骤
// 1. 运行 cnpm i vuex -S
// 2. 导入包
import Vuex from 'vuex'
import App from './App.vue'
// 3. 注册vuex到vue中
Vue.use(Vuex)
// 4. new Vuex.Store() 实例，得到一个 数据仓储对象
var store = new Vuex.Store({
    state: {
        // 大家可以把 state 想象成 组件中的 data ,专门用来存储数据的
        // 如果在 组件中，想要访问，store 中的数据，只能通过 this.$store.state.*** 来访问
        count: 0
    },
    mutations: {
        // 注意： 如果要操作 store 中的 state 值，只能通过 调用 mutations 提供的方法，才能操作对应的数据，不推荐直接操作 state 中的数据，因为 万一导致了数据的紊乱，不能快速定位到错误的原因，因为，每个组件都可能有操作数据的方法；
        increment(state) {
            state.count++
        },
        // 注意： 如果组件想要调用 mutations 中的方法，只能使用 this.$store.commit('方法名')
        // 这种 调用 mutations 方法的格式，和 this.$emit('父组件中方法名')
        subtract(state, obj) {
            // 注意： mutations 的 函数参数列表中，最多支持两个参数，其中，参数1： 是 state 状态； 参数2： 通过 commit 提交过来的参数；
            console.log(obj)
            state.count -= (obj.c + obj.d)
        }
    },
    getters: {
        // 注意：这里的 getters， 只负责 对外提供数据，不负责 修改数据，如果想要修改 state 中的数据，请 去找 mutations
        optCount: function (state) {
            return '当前最新的count值是：' + state.count
        }
        // 经过咱们回顾对比，发现 getters 中的方法， 和组件中的过滤器比较类似，因为 过滤器和 getters 都没有修改原数据， 都是把原数据做了一层包装，提供给了 调用者；
        // 其次， getters 也和 computed 比较像， 只要 state 中的数据发生变化了，那么，如果 getters 正好也引用了这个数据，那么 就会立即触发 getters 的重新求值；
    }
})

// 总结：
// 1. state中的数据，不能直接修改，如果想要修改，必须通过 mutations
// 2. 如果组件想要直接 从 state 上获取数据： 需要 this.$store.state.***
// 3. 如果 组件，想要修改数据，必须使用 mutations 提供的方法，需要通过 this.$store.commit('方法的名称'， 唯一的一个参数)
// 4. 如果 store 中 state 上的数据， 在对外提供的时候，需要做一层包装，那么 ，推荐使用 getters, 如果需要使用 getters ,则用 this.$store.getters.***

const vm = new Vue({
    el: '#app',
    render: c => c(App),
    store // 5. 将 vuex 创建的 store 挂载到 VM 实例上， 只要挂载到了 vm 上，任何组件都能使用 store 来存取数据
})

counter.vue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<template>
    <div>
        <input type="button" value="减少" @click="remove">
        <input type="button" value="增加" @click="add">
        <br>
        <input type="text" v-model="$store.state.count">
    </div>
</template>

<script>
    export default {
        data() {
            return {
                // count: 0
            };
        },
        methods: {
            add() {
                // 千万不要这么用，不符合 vuex 的设计理念
                // this.$store.state.count++;
                this.$store.commit("increment");
            },
            remove() {
                this.$store.commit("subtract", {c: 3, d: 1});
            }
        },
        computed: {
            fullname: {
                get() {
                },
                set() {
                }
            }
        }
    };
</script>

<style lang="scss" scoped>

</style>

amount.vue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<template>
    <div>
        <!-- <h3>{ { $store.state.count } }</h3> -->
        <h3>{ { $store.getters.optCount } }</h3>

    </div>
</template>

<script>
</script>

<style lang="scss" scoped>

</style>


-------------本文结束感谢您的阅读-------------



本文作者： Wgy
本文标题： Vue(二)
本文链接： https://wgy1993.gitee.io/archives/a5e3c20a.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

本站总访问量:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序员的一天