Vue2学习笔记

I Vue核心

什么是Vue？

箭头函数没有this，往上层找，找到的第一个就是该this

可以自底向上逐层的应用

简单应用：只需一个轻量小巧的核心库

复杂应用：可以引入各式各样的Vue插件

特点：

• 采用组件化模式，提高代码复用率、且让代码更好维护。
• 声明式编码，让编码人员无需直接操作DOM—(文档对象模型)，提高开发效率 。
• 使用虚拟DOM+优秀的Diff算法，尽量复用DOM节点。

一、初识Vue

• 1.想让Vue工作，就必须创建一个Vue实例，且要传入一个配置对象；
• 2.root容器里的代码依然符合html规范，只不过混入了一些特殊的Vue语法；
• 3.root容器里的代码被称为【Vue模板】。
• 4.Vue实例和容器是一一对应的；
• 5.真实开发中只有一个Vue实例，并且会配合着组件一切使用；
• 6.{{xxx}}中的xxx要写成js表达式，且xxx可以自动读取到data中的所有属性；
• 7.一旦data中的数据发生改变，那么页面中用到该数据的地方也会自动更新；

<!--root容器-->
<div id="root">
    <h1>hello,{{name}}</h1>
</div>

<script type="text/javascript">
    Vue.config.productionTip = false //阻止 vue在启动时生成生产提示

    //创建Vue实例
    const x =new Vue({
        el:'#root', //el用于指定当前Vue实例为哪个容器服务，值通常为css选择器字符串。
        data:{  //data中用于存储数据，数据供el所指定的容器去使用，值我们暂时先写出一个对象。
            name:'world'
        }
    })
</script>

注意区分：js表达式 和 js代码（语句）

• 表达式：一个表达式会产生一个值，可以放在任何一个需要值的地方：
  • a
  • a+b
  • demo（1）
  • x===y ? ‘a’ : ‘b’
• js代码(语句)
  • if(){}
  • for(){}

二、Vue模板语法

• 插值语法：
  • 功能：用于解析标签体内容
  • 写法：{{xxx}},xxx是js表达式，且可以直接读取到data中的所有属性。
• 指令语法：
  • 功能：用于解析标签（包括：标签属性、标签体内容、绑定事件…）
  • 举例：v-bind:href=“xxx” 或 简写成 :href=“xxx”，xxx同样要写js表达式，且可以直接读取到data中的所有属性。
  • 备注：Vue中有很多的指令，且形式都是： v-???

1.插值语法

<h3>你好，{{name}}</h3>

2.指令语法

<div id="root">
            <h1>插值语法</h1>
            <h3>你好，{{name}}</h3>
            <hr/>
            <h1>指令语法</h1>
            <a v-bind:href="school.url.toUpperCase()">点我去{{school.name}}1</a><br>
            <a :href="school.url">点我去{{school.name}}2</a>
        </div>

        <script type="text/javascript">
            Vue.config.productionTip = false
            new Vue({
                el:'#root',
                data:{
                    name:'jack',
                    school:{
                        name:'百度',
                        url:'https://www.baidu.com'
                    }
                }
            })
        </script>

三、数据绑定

• 单向绑定（v-bind）：数据只能从data流向页面。
• 双向绑定（v-model）：数据不仅能从data流向页面，也可以从页面流向data。
  • 备注：
    • 1.双向绑定一般都应用在表单类元素上（如input、select等）
    • 2.v-model:value可以简写成 v-model，因为v-model默认收集的就是value值。

1.单向绑定

单向数据绑定：<input type="text" v-bind:value="name"><br>

2.双向绑定

双向数据绑定：<input type="text" v-model:value="name">

注：

<!--如下代码是错误的，因为v-model只能应用在表单类元素（输入类元素）上-->
<h2 v-model:x="name">你好啊</h2>

四、el与data的两种写法

• 1.el有两种写法
  • （1）new Vue时候配置el属性。
  • （2）先创建Vue实例，随后再通过v.$mount(’#root’)指定el的值。
• 2.data有两种写法
  • （1）对象式
  • （2）函数式
  • 如何选择：运用到组件时，data必须使用函数式，否则会报错。
• 3.一个重要的原则
  • 由Vue管理的函数，一定不要写成箭头函数，一旦写了箭头函数，this就不再是Vue实例了。(往上级查找)

//el的两种写法
const v =new Vue({
    el:'#root', //第一种写法
    data:{
        name:'world'
    }
})
console.log(v)
v.$mount('#root')//第二种写法
setTimeout(()=>{
                v.$mount('#root')
},1000)//利用定时器

//data的两种写法
new Vue({
    el: '#root',
    // data:{  //第一种写法：对象式
    //     name:'world'
    // }
    //data的第二种写法：函数式
    data: function () {//或者写成data()
        console.log('@@@', this) //此处的this是Vue实例对象
        return {
        name: 'world'
        }
    }
})

五、MVVM模型

1. M：模型（Model）：对应data中的数据

2. V：视图（View）：模板

3. VM：视图模型（ViewModel）：Vue实例对象

​ 观察发现：

​ 1. data中所有的属性，最后都出现在了vm身上。

​ 2. vm身上所有的属性 及 Vue原型上的所有属性，在Vue模板中都可以直接使用。

<h1>姓名:{{name}}</h1>
<h1>地址:{{address}}</h1>
<h1>测试一下1:{{$emit}}</h1>
<h1>测试一下2:{{$options}}</h1>

const vm = new Vue({
            el:'#root',
            data:{
                name:'小华',
                address:'上海'
            }
})
console.log(vm)

六、数据代理

<script type="text/javascript">
    Vue.config.productionTip = false

    let number = 18
    let person = {
        name:'张三',
        sex:'男'
    }

    Object.defineProperty(person,'age',{
        // value:18,
        // enumerable:true,//控制属性是否可以枚举，默认是false
        // writable:true,//控制属性是否可以被修改，默认值是false
        // configurable:true//控制属性是否可以被删除，默认值是false

        //当有人读取person的age属性时，get函数（getter)就会被调用，且返回值就是age的
        get:function () {
            console.log("有人读取了age属性")
            return number
        },

        //当有人修改person的age属性时，set函数（setter）就会被调用，且会收到修改的具体值
        set(value){
            console.log("有人修改了age属性，且值是",value)
            number = value
        }
    })

    for (let key in person){
        console.log(person[key])
    }

    console.log(person)
</script>

验证getter和setter图解

• Vue中的数据代理：
  • 通过vm对象来代理data对象中属性的操作（读/写）
• Vue中数据代理的好处：
  • 更加方便的操作data中的数据
• 基本原理：
  • 通过Object.defineproperty()把data对象中所有属性添加到vm上，为每一个添加到vm上的属性，都指定一个getter/setter。在每个getter/setter内部去操作（读/写）data中对应的属性。

七、事件处理

事件的基本使用

• 使用v-on:xxx 或@xxx绑定事件，其中xxx是事件名；
• 事件的回调需要配置在methods对象中，最终会在vm上；
• methods中配置的函数，不要用箭头函数！否则this就不是vm了；
• methods中配置的函数，都是被Vue所管理的函数，this的指向是vm 或 组件实例对象；
• @click=“demo” 和 @click=“demo($event)” 效果一致，但后者可以传参。

<div id="root">
    <h2>欢迎{{name}}，你好</h2>
    <button v-on:click="showInfo1">点我提示信息（不传参）</button>
    <button @click="showInfo2($event,66)">点我提示信息（传参）</button>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            name:'world'
        },
        methods:{
            showInfo1(event){
                console.log(event.target.innerText)
                console.log(this) //此处this是vm
                alert("同学你好！")
            },
            showInfo2(event,number){
                console.log(event,number)
                alert("同学你好啊！")
            }
        }
    })

事件修饰符

• prevent:阻止默认事件（常用）
• stop：阻止事件冒泡（常用）
• once：事件只触发一次（常用）
• capture：使用事件的捕获模式
• self：只有event.target是当前操作的元素时才触发事件
• passive：事件的默认行为立即执行，无需等待事件回调执行完毕

<div id="root">
    <h2>欢迎{{name}}，你好</h2>
    <!--   阻止默认事件（常用） -->
    <a href="https://www.baidu.com/" @click.prevent="showInfo">点我提示信息</a>
    <!--   阻止事件冒泡（常用） -->
    <div class="demo1" @click="showInfo">
        <button @click.stop="showInfo">点我提示信息</button>
    </div>
    <!--  事件只触发一次（常用） -->
    <button @click.once="showInfo">点我提示信息</button>

    <!--  使用事件的捕获模式 -->
    <div class="box1" @click.capture="showMsg(1)">
        div1
        <div class="box2" @click="showMsg(2)">
            div2
        </div>
    </div>

    <!--   只有event.target是当前操作的元素时才触发事件； -->
    <div class="demo1" @click.self="showInfo">
        <button @click.stop="showInfo">点我提示信息</button>
        <!-- 修饰符可以连续写 -->
        <a href="https://www.baidu.com/" @click.stop.prevent="showInfo">点我提示信息</a>
    </div>

    <!-- 事件的默认行为立即执行，无需等待事件回调执行完毕； -->
    <%--scroll 滚动条   wheel 鼠标滚轮--%>
    <ul @wheel.passive="demo"  class="list">
        <li>1</li>
        <li>2</li>
        <li>3</li>
        <li>4</li>
    </ul>

</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            name:'world'
        },
        methods:{
            showInfo(event){
                // alert("同学你好！")
                console.log(event.target)
            },
            showMsg(msg){
                console.log(msg)
            },
            demo(){
                for(let i=0;i <100000;i++){
                    console.log('#')
                }
                console.log("累坏了")
            }
        }
    })
</script>

键盘事件

1.Vue中常用的按键别名：

• 回车 => enter
• 删除 => delete(捕获“删除”和“退格“键)
• 退出 => esc
• 空格 => space
• 换行 => tab(特殊，必须配合keydown去使用)
• 上 => up
• 下 => down
• 左 => left
• 右 => right

2.Vue未提供别名的按键，可以使用按键原始的key值去绑定，但注意要转为kebad-case(短横线命名)

3.系统修饰键（用法特殊）：ctrl、alt、shift、meta

• 配合keyup使用：按下修饰键的同时，再按下其他键，随后释放其他键，事件才被触发/
• 配合keydown使用：正常触发事件。

4.也可以使用keyCode去指定具体的按键（不推荐）

5.Vue.config.keyCodes.自定义键名 = 键码， 可以去定制按键别名

<div id="root">
    <h2>欢迎{{name}}，你好</h2>
    <!--当用系统修饰符时，只想绑定确定的按键，可以写成keyup.ctrl.y-->
    <input type="text" placeholder="按下ctrl提示输入" @keydown.ctrl="showInfo">
    <input type="text" placeholder="按下ctrl提示输入" @keyup.ctrl.y="showInfo">
</div>
<script type="text/javascript">
    Vue.config.productionTip = false

    new Vue({
        el:'#root',
        data:{
            name:"xiaohua"
        },
        methods:{
            showInfo(e){
                console.log(e.target)
            }
        }
    })
</script>

八、计算属性与监视

1. 插值语法实现

<div id="root">
    姓：<input type="text" v-model="firstName"><br/><br/>
    名：<input type="text" v-model="lastName"><br/><br/>
    全名：<span>{{firstName.slice(0,3)}}-{{lastName}}</span>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            firstName:'张',
            lastName:'三'
        }
    })
</script>

2.methods实现

<div id="root">
    姓：<input type="text" v-model="firstName"><br/><br/>
    名：<input type="text" v-model="lastName"><br/><br/>
    全名：<span>{{fullName()}}</span>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            firstName:'张',
            lastName:'三'
        },
        methods:{
            fullName(){
                console.log('@---fullName')
                return this.firstName + "-" + this.lastName
            }
        }
    })
</script>

3.计算属性实现 computed

• 定义：要用的属性不存在，要通过已有属性计算得来；
• 原理：底层借助了Object.defineproperty方法提供的getter和setter；
• get函数什么时候执行？
  • 初次读取时会执行一次
  • 当依赖的数据发生改变时会被再次调用
• 优势：与methods实现相比，内部有缓存机制（复用），效率更高，调试方便；
• 备注：
  • 计算属性最终会出现再vm上，直接读取使用即可；
  • 如果计算属性要被修改，那必须写set函数去响应修改，且set中要引起计算时依赖的数据发生改变。

<div id="root">
    姓：<input type="text" v-model="firstName"><br/><br/>
    名：<input type="text" v-model="lastName"><br/><br/>
    全名：<span>{{fullName}}</span>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    const vm = new Vue({
        el:'#root',
        data:{
            firstName:'张',
            lastName:'三'
        },
        computed:{
            fullName:{
                //get有什么用？当有人读取fullName时，get就会被调用，且返回值就作为fullName的值
                //get什么时候调用？1.初次读取fullName时。 2.所依赖的数据发生变化时。
                get(){
                    console.log('get被调用了')
                    return this.firstName + "-" + this.lastName
                },
                //set什么时候调用？当fullName被修改时
                set(value){
                    const arr = value.split('-')
                    this.firstName = arr[0]
                    this.lastName =  arr[1]
                }
            }
        }
    })
</script>

4.计算属性简写

当计算属性 computed 只有get()时

//简写,只考虑读取，不考虑修改时才可用
 fullName(){
     console.log('get被调用了')
     return this.firstName + "-" + this.lastName
 }

5.监视属性watch

• 当被监视的属性发生变化时，回调函数自动调用，进行相关操作；
• 监视的属性必须存在，才能进行监视；
• 监视的两种写法：
  • new Vue时传入watch配置
  • 通过vm.$watch监视

<div id="root">
    <h2>今天天气很{{info}}</h2>
    <!--  绑定事件的时候：@xxx="yyy"  yyy可以写一些简单的语句  -->
    <!--  <button @click="isHot = !isHot">切换天气</button>  -->
    <button @click="changeWeather">切换天气</button>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    const vm = new Vue({
        el:'#root',
        data:{
            isHot:true
        },
        methods:{
            changeWeather(){
                this.isHot = !this.isHot
            }
        },
        computed:{
            info(){
                return this.isHot ? '炎热' : '凉爽'
            }
        },
        /*watch:{
            isHot:{
                immediate:true, //初始化时让handler调用一下
                //handler什么时候调用？当isHot发生改变时。
                handler(newValue,oldValue){
                    console.log('isHot被修改了',newValue,oldValue)
                }
            }
        }*/
    })
    vm.$watch('isHot',{
        immediate:true, //初始化时让handler调用一下
        //handler什么时候调用？当isHot发生改变时。
        handler(newValue,oldValue){
            console.log('isHot被修改了',newValue,oldValue)
        }
    })
</script>

6.深度监视

• Vue中的watch默认不监测对象内部值的改变（一层）
• 配置 deep: true 可以监测对象内部值改变（多层）
• 备注：
  • Vue自身可以监测对象内部值的改变，但Vue提供的watch默认不可以！
  • 使用watch时根据数据的具体结构，决定是否采用深度监视

<div id="root">
     <h2>a的值：{{numbers.a}}</h2>
    <button @click="numbers.a++">点我a+1</button>

    <h2>b的值：{{numbers.b}}</h2>
    <button @click="numbers.b++">点我b+1</button>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    const vm = new Vue({
        el:'#root',
        data:{
            numbers:{
                a:1,
                b:1
            }
        },
        watch:{
            //监视多级结构中某个属性的变化
           /* 'numbers.a':{
                handler(){
                    console.log("a被改变了")
                }
            }*/
           //监视多级结构中所有属性的变化
            numbers:{
                deep:true,
                handler(){
                    console.log('numbers改变了')
                }
            }
        }
    })
</script>

深度监视简写：当watch属性里只有handler时

watch:{
    //正常写法
   isHot:{
        handler(newValue,oldValue){
            console.log('isHot被修改了',newValue,oldValue)
        }
    }
   //简写
   isHot(newValue,oldValue){
        console.log('isHot被修改了',newValue,oldValue)
    }
}

//正常写法
vm.$watch('isHot',{
    handler(newValue,oldValue){
    console.log('isHot被修改了',newValue,oldValue)
  	}
})
//简写
vm.$watch('isHot',function(newValue,oldValue){
	console.log('isHot被修改了',newValue,oldValue)
})

7.watch与computed对比

区别：

• computed能完成的功能，watch都可以完成；
• watch能完成的功能，computed不一定能完成，例如：watch可以进行异步操作

两个重要的小原则:

• 所被Vue管理的函数,最好写成普通函数,这样this的指向才是vm 或 组件实例对象
• 所有不被Vue所管理的函数(定时器的回调函数,ajax的回调函数,promise的回调函数),最好写成箭头函数,这样this的指向才是vm 或 组件实例对象

九、class与style绑定

• class样式
  • 写法：class=“xxx” xxx可以是字符串、对象、数组。
    • 字符串写法适用于：类名不确定，要动态获取。
    • 对象写法适用于：要绑定多个样式，个数不确定，名字也不确定
    • 数组写法适用于：要绑定多个样式，个数确定，名字也确定，但不确定用不用
• style样式
  • :style="{fontSize:xxx}" 其中xxx是动态值
  • :style="[a,b]" 其中a、b是样式对象

<!--  绑定class样式--字符串写法：适用于：样式的类名不确定，需要动态指定  -->
<div class="basic" :class="mood" @click="changeMood">{{name}}</div>

<!--  绑定class样式--数组写法：适用于：要绑定的样式的个数不确定，名字也不确定  -->
<div class="basic" :class="classArr">{{name}}</div>

<!--  绑定class样式--对象写法：适用于：要绑定的样式个数确定，名字也确定，但要动态决定用不用  -->
<div class="basic" :class="classObj">{{name}}</div>

<!--  绑定style样式--对象写法   -->
<div class="basic" :style="styleObj">{{name}} </div>

<!--  绑定style样式--对象写法   -->
<div class="basic" :style="styleArr">{{name}} </div>

data:{
    isHot:true,
    name:'xiaoha',
    mood:'normal',
    classArr:['at1','at2','at3'],
    classObj:{
        at1:false,
        at2:false
    }，
 	styleObj:{
        fontSize:'40px'
    },
    styleArr:[
        {
            fontSize:'40px',
            color:'blue'
        },
        {
        	backgroundColor:'gray'
        }
    ]
}

十、条件渲染

• v-if
  • 写法：
    • v-if=”表达式“
    • v-else-if=“表达式”
    • v-else=”表达式“
  • 适用于：切换频率较低的场景
  • 特点：不展示的DOM元素直接被移除
  • 注意：v-if可以和：v-else-if、v-else一起使用，但要求结构不能被”打断“
• v-show
  • 写法：v-show=”表达式“
  • 适用于：切换频率较高的场景
  • 特点：不展示的DOM元素未被移除，仅仅是使用样式隐藏掉
• 备注：使用v-if时，元素可能无法被获取到，而使用v-show一定可以获取到

<template v-if="n===1"
    <h2>你好</h2>
	<h2>小华</h2>
	<h2>上海</h2>
</template>

十一、列表渲染

1.基本列表

• v-for指令
  • 用于展示列表数据
  • 语法：v-for="(item, index)" in xxx" :key=“yyy”
  • 可遍历：数组、对象、字符串（用的很少）、指定次数（用的很少）

<div id="root">
    <%--遍历数组--%>
    <h2>人员列表(遍历数组)-用的最多</h2>
    <ul>
       <%-- <li v-for="p in persons">
            {{p.name}}-{{p.age}}
        </li>--%>
        <li v-for="(p,index) of persons" :key="index">
            {{p.name}}-{{p.age}}
        </li>
    </ul>

    <%--遍历对象--%>
    <h2>汽车信息(遍历对象)</h2>
    <ul>
        <li v-for="(value,key) in car" :key="key">
            {{key}}-{{value}}
        </li>
    </ul>

    <%--遍历字符串--%>
    <h2>测试遍历字符串(用的少)</h2>
    <ul>
        <li v-for="(char,index) in str" :key="index">
            {{index}}-{{char}}
        </li>
    </ul>

    <%--遍历指定次数--%>
    <h2>测试遍历字符串(用的少)</h2>
    <ul>
        <li v-for="(number,index) of 5" :key="index">
            {{index}}-{{number}}
        </li>
    </ul>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            persons:[
                {id:'001',name:'张三',age:18},
                {id:'002',name:'李四',age:19},
                {id:'003',name:'王五',age:20}
            ],
            car:{
                name:"奥迪A8",
                price:'70W',
                color:'黑色'
            },
            str:'hello'
        }
    })
</script>

2.key的原理

面试题：react、vue中的key有什么作用？（key的内部原理）

• 虚拟DOM中key的作用：
  • key是虚拟DOM对象的标识，当数据发生变化时，Vue会根据【新数据】生成【新的虚拟DOM】，随后Vue进行【新虚拟DOM】与【旧虚拟DOM】的差异比较，比较规则如下：
• 对比规则：
  • 旧虚拟DOM中找到了与新虚拟DOM相同的key：
    • 若虚拟DOM中内容没变，直接使用之前的真实DOM！
    • 若虚拟DOM中内容变了，则生成新的真实DOM，随后替换掉页面中之前的真实DOM
  • 旧虚拟DOM中未找到与新虚拟DOM相同的key：
    • 创建新的真实DOM，随后渲染到页面
• 用index作为key可能会引发的问题：
  • 若对数据进行：逆序添加、逆序删除等破坏顺序操作：
    • 会产生没有必要的真实DOM更新 ==> 页面效果没问题，但效率低。
  • 如果结构中还包含输入类的DOM：
    • 会产生错误DOM更新 ==> 界面有问题。
• 开发中如何选择key？
  • 最好使用每条数据的唯一标识作为key，比如id、手机号、身份证号、学号等唯一值。
  • 如果不存在对数据的逆序添加、逆序删除等破坏顺序操作，仅用于渲染列表以展示，使用index作为key是没有问题的。

3.列表过滤

<div id="root">
    <h2>人员列表</h2>
    <input type="text" placeholder="请输入名字" v-model="keyWord">
    <ul>
        <li v-for="(p,index) of filPersons" :key="index">
            {{p.name}}-{{p.age}}-{{p.sex}}
        </li>
    </ul>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    //用watch实现
   /* new Vue({
        el:'#root',
        data:{
            keyWord:"",
            persons:[
                {id:'001',name:'马冬梅',age:18,sex:'女'},
                {id:'002',name:'周冬雨',age:19,sex:'女'},
                {id:'003',name:'周杰伦',age:20,sex:'男'},
                {id:'004',name:'温兆伦',age:21,sex:'男'}
            ],
            filPersons:[]
        },
        watch:{
            keyWord:{
                immediate:true,
                handler(val){
                    this.filPersons = this.persons.filter((p)=>{
                        return p.name.indexOf(val) !== -1
                    })
                }
            }
        }
    })*/
   
   //用computed实现
    new Vue({
        el:'#root',
        data:{
            keyWord:"",
            persons:[
                {id:'001',name:'马冬梅',age:18,sex:'女'},
                {id:'002',name:'周冬雨',age:19,sex:'女'},
                {id:'003',name:'周杰伦',age:20,sex:'男'},
                {id:'004',name:'温兆伦',age:21,sex:'男'}
            ]
        },
        computed:{
            filPersons(){
                return this.persons.filter((p)=>{
                    return p.name.indexOf(this.keyWord) !== -1
                })
            }
        }
    })
</script>

4.列表排序

注意：@click里是赋值语句，sort排序函数，降序为后数-前数，反之为前数-后数

<div id="root">
    <h2>人员列表</h2>
    <input type="text" placeholder="请输入名字" v-model="keyWord">
    <button @click="sortType = 2">年龄升序</button>
    <button @click="sortType = 1">年龄降序</button>
    <button @click="sortType = 0">原顺序</button>
    <ul>
        <li v-for="(p,index) of filPersons" :key="index">
            {{p.name}}-{{p.age}}-{{p.sex}}
        </li>
    </ul>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false

    //用computed实现
    new Vue({
        el:'#root',
        data:{
            keyWord:"",
            sortType:0, //0 原顺序  1降序  2升序
            persons:[
                {id:'001',name:'马冬梅',age:20,sex:'女'},
                {id:'002',name:'周冬雨',age:19,sex:'女'},
                {id:'003',name:'周杰伦',age:25,sex:'男'},
                {id:'004',name:'温兆伦',age:21,sex:'男'}
            ]
        },
        computed:{
            filPersons(){
                const arr = this.persons.filter((p)=>{
                    return p.name.indexOf(this.keyWord) !== -1
                })
                if(this.sortType){
                    arr.sort((p1,p2)=>{
                        return this.sortType === 1  ? p2.age-p1.age : p1.age-p2.age
                    })
                }
                return arr
            }
        }
    })
</script>

5.总结Vue数据监测

Vue监视数据的原理：

• vue会监视data中所有层次的数据。
• 如何监测对象中的数据？
  • 通过setter实现监视，且要在new Vue时就传入要监测的数据。
    • 对象中后追加的属性，Vue默认不做响应式处理
    • 如需给后添加的属性做响应式，请使用如下API：
      • Vue.set(target,propertyName/index,value)或
      • vm.$set(target,propertyName/index,value)
• 如何监测数组中的数据？
  • 通过包裹数组更新元素的方法实现，本质就是做了两件事：
    • 调用原生对应的方法对数组进行更新。
    • 重新解析模板，进而更新页面。
• 在Vue修改数组中的某个元素一定要用如下方法：
  • 使用这些API：push()、pop()、shift()、unshift()、splice()、sort()、reverse()
  • Vue.set() 或 vm.$set()
• 特别注意：Vue.set() 和 vm.$set() 不能给vm 或 vm的根数据对象 添加属性！！！

<div id="root">
    <h1>学校信息</h1>
    <h2>学校名称：{{school.name}}</h2>
    <h2>学校地址：{{school.address}}</h2>
    <h2 v-if="school.leader">校长是:{{school.leader}}</h2>
    <hr/>
    <h1>学生信息</h1>
    <button @click="student.age.rAge++">年龄+1岁</button><br/>
    <button @click="addSex">添加一个性别属性，默认值为男</button><br/>
    <button @click="student.sex = '未知'">修改性别</button><br/>
    <button @click="addFriend">在列表首位添加一个朋友</button><br/>
    <button @click="updateFirstFriendName">修改第一个朋友的名字为：张三</button><br/>
    <button @click="addHobby">添加一个爱好</button><br/>
    <button @click="updateHobby">修改第一个爱好为：开车</button><br/>
    <h2>姓名：{{student.name}}</h2>
    <h2 v-if="student.sex">性别：{{student.sex}}</h2>
    <h2>年龄：真实{{student.age.rAge}},对外{{student.age.sAge}}</h2>
    <h2>爱好</h2>
    <ul>
        <li v-for="(h,index) in student.hobby" :key="index">
            {{h}}
        </li>
    </ul>
    <h2>朋友们</h2>
    <ul>
        <li v-for="(f,index) in student.friends"  :key="index">
            {{f.name}}---{{f.age}}
        </li>
    </ul>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false

    const vm = new Vue({
        el:'#root',
        data:{
            school:{
                name:"尚硅谷",
                address:"北京"
            },
            student:{
                name:"小华",
                age:{
                    rAge:35,
                    sAge:25
                },
                hobby:['抽烟','喝酒','烫头'],
                friends:[
                    {name:'小张',age:19},
                    {name:"小李",age:25}
                ]
            }
        },
        methods:{
            addSex(){
                this.$set(this.student,'sex','男')
            },
            addFriend(){
                this.student.friends.unshift({name:'jack',age:36})
            },
            updateFirstFriendName(){
                this.student.friends[0].name = "张三"
            },
            addHobby(){
                this.student.hobby.push('学习')
            },
            updateHobby(){
                this.student.hobby.splice(0,1,'开车')
                Vue.set(this.student.hobby,0,'开车')
            },
            removeSmoke(){
                this.student.hobby = this.student.hobby.filter((h)=>{
                    return h !=='抽烟'
                })
            }
        }
    })
</script>

十二、收集表单数据

• 若：，则v-model收集的是value值，用户输入的就是value值。
• 若：,则v-model收集的是value值，且要给标签配置value值。
• 若：
  • 没有配置input的value属性，那么收集的就是checked（勾选 or 未勾选，是布尔值）
  • 配置input的value属性：
    • v-model的初始值是非数组，那么收集的还是checked（勾选 or 未勾选，是布尔值）
    • v-model的初始值是数组，那么收集的就是value组成的数组
• 备注：v-model的三个修饰符
  • lazy：失去焦点再收集数据
  • number：输入字符串转为有效的数字
  • trim：输入首尾空格过滤

<div id="root">
    <form @submit.prevent="sub">
        账号：<input type="text" placeholder="请输入账号" v-model.trim="account"><br/><br/>
        密码：<input type="password" placeholder="请输入密码" v-model.trim="password"><br/><br/>
        年龄：<input type="number" v-model.number="age"><br/><br/>
        性别：
        男<input type="radio"  name="sex" v-model="sex" value="male">
        女<input type="radio"  name="sex" v-model="sex" value="female"><br/><br/>
        爱好:
        乒乓球<input type="checkbox" v-model="hobby" value="pingpang">
        羽毛球<input type="checkbox" v-model="hobby" value="tennis">
        跑步<input type="checkbox" v-model="hobby" value="running"><br/><br/>
        所属校区
        <select v-model="city">
            <option value="">请选择校区</option>
            <option value="beijing">北京</option>
            <option value="shanghai">上海</option>
            <option value="shenzhen">深圳</option>
            <option value="wuhan">武汉</option>
        </select><br/><br/>
        其他信息：
        <textarea v-model.lazy="others"></textarea><br/><br/>
        <input type="checkbox" v-model="agree">阅读并接受<a href="https://www.baidu.com/">《用户协议》</a><br/><br/>
        <button>提交</button>
    </form>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            account:'',
            password:'',
            age:'',
            sex:'male',
            hobby:[],
            city:'',
            others:'',
            agree:''
        },
        methods:{
            sub(){
                console.log(JSON.stringify(this._data))
            }
        }
    })
</script>

十三、过滤器

• 定义：对要显示的数据进行特定格式化后再显示（适用于一些简单逻辑的处理）
• 语法：
  • 注册过滤器：Vue.filter(name,callback) 或 new Vue{filters:{}}
  • 使用过滤器：{{ xxx | 过滤器名}} 或 v-bind:属性 =“xxx | 过滤器名”
• 备注：
  • 过滤器也可以接收额外参数、多个过滤器也可以串联
  • 并没有改变原本的数据，是产生新的对应的数据

<div id="root">
    <h2>显示格式化后的时间</h2>
    <!--计算属性实现-->
    <h3>现在是:{{fmtTime}}</h3>
    <!-- 过滤器实现 -->
    <h3>现在是:{{time | timeFormater}}</h3>
    <!-- 过滤器实现(传参）,有参数就走参数内，无参数就自动调用str内的 -->
    <h3>现在是：{{time | timeFormater('YYYY年MM月DD日') | mySlice}}</h3>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    Vue.filter('mySlice',function (value) {
        return value.slice(0,4)
    })
    new Vue({
        el:'#root',
        data:{
            time:1638498145156 //时间戳
        },
        computed:{
            fmtTime(){
                return dayjs(this.time).format('YYYY-MM-DD HH:mm:ss')
            }
        },
        filters:{
            timeFormater(value,str='YYYY-MM-DD HH:mm:ss'){
                return dayjs(value).format('YYYY-MM-DD HH:mm:ss')
            }
        }
    })
</script>

十四、内置指令

• v-text指令：
  • 作用：向其所在的节点中渲染文本内容。
  • 与插值语法的区别：v-text会替换掉节点中的内容，{{xxx}}则不会

<v-text="name"></v-text>

• v-html指令：
  • 作用：向指定节点中渲染包含html结构的内容。
  • 与插值语法的区别：
    • v-html会替换掉节点中的内容，{{xxx}}则不会
    • v-html可以识别html结构
  • 严重注意：v-html有安全性问题！！！
    • 在网站上动态渲染任意HTML是非常危险的，容易导致XSS攻击
    • 一定要在可信的内容上使用v-html，永不要用在用户提交的内容上！

<v-html="name"></v-text>
name:'<h3>小华</h3>'

• v-cloak指令（没有值）：
  • 本质是一个特殊属性，Vue实例创建完毕并接管容器后，会删掉v-cloak属性。
  • 使用css配合v-cloak可以解决网速慢时页面展示出{{xxx}}的问题。

• v-once指令：
  • v-once所在节点在初次动态渲染后，就视为静态内容了。
  • 以后数据的改变不会引起v-once所在结构的更新，可以用于优化性能。

<h2 v-once>初始化的n值是：{{n}}</h2>
<h2>当前的n值是：{{n}}</h2>
<button @click='n++'>点我n+1</button>

• v-pre指令：
  • 跳过其所造节点的编译过程。
  • 可利用它跳过：没有使用指令语法、插值语法的节点，会加快编译。

<h2 v-pre>Vue其实很简单</h2>//跳过该条语句的编译
<h2>姓名：{{name}}</h2>

十五、自定义指令

一、定义语法：

• 局部指令：
  • new Vue({ directives:{指令名:配置对象}}) 或 new Vue({ directives{指令名:回调函数}})
• 全局指令：
  • Vue.directive(指令名,配置对象) 或 Vue.dircetive(指令名,回调函数)

二、配置对象中常用的3个回调：

• bind：指令与元素成功绑定时调用
• inserted：指令所在元素被插入页面时调用
• update：指令所在模板结构被重新解析时调用

三、备注

• 指令定义时不加v-，但使用时要加v-；
• 指令名如果是多个单词，要使用kebab-case命名发那个是，不要用camelCase命名

<div id="root">
        <h2>当前的n值是:<span v-text="n"></span></h2>
        <h2>放大10倍后的n值是：<span v-big="n"></span></h2>
        <button @click="n++">点我n+1</button>
        <hr/>
        <input type="text" v-fbind:value="n">
    </div>
    <script type="text/javascript">
        Vue.config.productionTip = false
        new Vue({
            el:'#root',
            data:{
                n:1
            },
            directives:{
                //big函数何时会被调用？1.指令与元素成功绑定时（刚开始运行）。 2.指令所在的模板被重新解析时。
                big(element,binding){
                    element.innerText = binding.value * 10
                } ,
                fbind:{
                    //指令与元素成功绑定时（一上来）
                    bind(element,binding){
                        element.value = binding.value
                    },
                    //指令所在元素被插入页面时
                    inserted(element,binding){
                        element.focus()
                    },
                    //指令所在模板被重新解析时
                    update(element,binding){
                        element.value = binding.value
                    }
                }
            }
        })
    </script>

十六、生命周期

• 又名：生命周期回调函数、生命周期函数、生命周期钩子
• 是什么：Vue在关键时刻帮我们调用的一些特殊名称的函数
• 生命周期函数的名字不可更改，但函数的具体内容是程序员根据需求编写的
• 生命周期函数中的this指向的是vm 或 组件实例对象

<div id="root">
    <h2 :style="{opacity}">欢迎学习Vue</h2>
</div>
<script type="text/javascript">
    Vue.config.productionTip = false
    new Vue({
        el:'#root',
        data:{
            opacity:1
        },
        //Vue完成模板的解析并把初识的真实DOM元素放入页面后（挂载完毕） 调用mounted
        mounted(){
            setInterval(()=>{
                this.opacity -= 0.01
                if(this.opacity <= 0)
                    this.opacity = 1
            },16)
        }
    })
</script>

• 常用的生命周期钩子：
  • mounted：发送ajax请求、启动定时器、绑定自定义事件、订阅消息等【初始化操作】
  • beforeDestroy：清除定时器、解绑自定义事件、取消订阅消息等【收尾工作】
• 关于销毁Vue实例：
  • 销毁后借助Vue开发者工具看不到任何信息
  • 销毁后自定义事件会失效，但原生DOM事件（例:methods方法的v-bind绑定事件）依然有效
  • 一般不会在beforeDestroy操作数据，因为即便操作数据，也不会再触发更新流程了

II Vue组件化编程

一、模块与组件、模块化与组件化

1. 模块

• 理解：向外提供特定功能的js程序，一般就是一个js文件
• 为什么： js文件很多很复杂
• 作用：复用js，简化js的编写，提高js运行效率

2. 组件

• 理解：用来实现局部（特定）功能效果的代码集合（html/css/js/image…)
• 为什么：一个界面的功能很复杂
• 作用：复用编码，简化项目编码，提高运行效率

3. 模块化

​ 当应用中的js都以模块来编写的，那这个应用就是一个模块化的应用。

4. 组件化

​ 当应用中的功能都是多组件的方式来编写的，那这个应用就是一个组件化的应用。

二、非单文件组件

一个文件中包含有n个组件

1.Vue使用组件的三大步骤

一、定义组件（创建组件）

二、注册组件

三、使用组件（写组件标签）

• 如何定义一个组件？
  • 使用Vue.extend(options)创建，其中options和new Vue(options)时传入的那个options几乎一样，但也有点区别：
  • 区别如下：
    • 1.el不要写，为什么？——最终所有的组件都要经过一个vm的管理，由vm中的el决定服务哪个容器
    • 2.data必须写成函数，为什么？——避免组件被复用时，数据存在引用关系
  • 备注：使用template可以配置组件结构。
• 如何注册组件？
  • 1.局部注册：靠new Vue的时候传入components选项
  • 2.全局注册：靠Vue.component(‘组件名’,组件)
• 编写组件标签：

<body>
  <div id="root">
    <!-- 第三步：编写组件标签 -->
    <hello></hello>
    <school></school>
    <hr>
    <!-- 第三步：编写组件标签 -->
    <student></student>
    <hello></hello>
  </div>
</body>
<script type="text/javascript">
  Vue.config.productionTip = false

  //第一步：创建school组件
  const school = Vue.extend({
    template:`
      <div>
        <h2>学校名称:{{name}}</h2>
        <h2>学校地址:{{address}}</h2> 
      </div>
    `,
    data(){
      return{
        name:"尚硅谷",
        address:"北京" 
      }
    }
  })

  //第一步：创建student组件
  const student = Vue.extend({
    template:`
      <div>
        <h2>姓名:{{name}}</h2>
        <h2>年龄:{{age}}</h2> 
      </div>
    `,
    data(){
      return{
        name:"张三",
        age:18
      }
    }
  })

  const hello = Vue.extend({
    template:`
      <h2>你好啊，{{name}}</h2>
    `,
    data(){
      return{
        name:"Tom"
      }
    }
  })

  //第二步，注册组件（全局注册）
  Vue.component('hello',hello);

  new Vue({
    el:'#root',
    //第二步，注册组件(局部注册)
    components: {
      school,
      student
    }
  })
</script>

2.几个注意点

• 关于组件名：
  • 一个单词组成：
    • 第一种写法(首字母小写)：school
    • 第二种写法(首字母大写)：School
  • 多个单词组成：
    • 第一种写法(kebab-case命名)：my-school
    • 第二种写法(CamelCase命名)：MySchool(需要Vue脚手架支持)
  • 备注：
    • (1)组件名尽可能回避HTML中已有的元素名称，例如：h2、H2都不行
    • (2)可以使用name配置项指定组件在开发者工具中呈现的名字
• 关于组件标签：
  • 第一种写法：
  • 第二种写法：
  • 备注：不使用脚手架时，会导致后续组件不能渲染
• 一个简写方式：
  • const school = Vue.extend(options) 可简写为：const school = options

3.组件的嵌套

<body>
  <div id="root">
    <!-- 编写组件标签 -->
    
  </div>
</body>
<script type="text/javascript">
  Vue.config.productionTip = false

   //创建student组件
   const student = Vue.extend({
    template:`
      <div>
        <h2>姓名:{{name}}</h2>
        <h2>年龄:{{age}}</h2> 
      </div>
    `,
    data(){
      return{
        name:"张三",
        age:18
      }
    }
  })

  //创建school组件
  const school = Vue.extend({
    template:`
      <div>
        <h2>学校名称:{{name}}</h2>
        <h2>学校地址:{{address}}</h2> 
        <student></student>
      </div>
    `,
    data(){
      return{
        name:"尚硅谷",
        address:"北京" 
      }
    },
    components:{
        student
    }
  })

  //创建hello组件
  const hello = Vue.extend({
    template:`
      <h2>你好啊，{{name}}</h2>
    `,
    data(){
      return{
        name:"Tom"
      }
    }
  })

  //创建app组件
  const app = Vue.extend({
      template:`
        <div>
            <hello></hello>
            <school></school>
        </div>
      `,
      components:{
          school,
          hello
      }

  })
  
  new Vue({
    template:`<app></app>`,
    el:'#root',
    //注册组件(局部注册)
    components: {
      app
    }
  })
</script>

4.VueComponent

• school组件本质是一个名为VueComponent的构造函数，且不是程序员定义的，是Vue.extend生成的
• 我们只需要写或，Vue解析时会帮我们创建school组件的实例对象，即Vue帮我们执行的：new VueComponent(options)
• 特别注意：每次调用Vue.extend，返回的都是一个全新的VueComponent！！！
• 关于this指向：
  • 组件配置中：
    • data函数、methods中的函数、watch中的函数、computed中的函数 ，它们的this均是【VueComponent实例对象】
  • new Vue(options)配置中：
    • data函数、methods中的函数、watch中的函数、computed中的函数 ，它们的this均是【Vue实例对象】
• VueComponent的实例对象，简称vc（也可称之为：组件实例对象），Vue的实例对象，简称vm

5.一个重要的内置关系

• 一个重要的内置关系：VueComponent.prototype.__ proto __ === Vue.prototype
• 为什么要有这个关系：让组件实例对象（vc）可以访问到Vue原型上的属性、方法

三、单文件组件

School.vue

<template>
    <!-- 组件的结构 -->
    <div class="demo">
        <h2>学校名称:{{name}}</h2>
        <h2>学校地址:{{address}}</h2>
        <button @click="showName">点我提示学校名</button>
    </div>
</template>

<script>
    //组件交互相关的代码（数据、方法等等）
    export default {
        name:"School",
        data(){
            return{
                name:"尚硅谷",
                address:"北京"
            }
        },
        methods: {
            showName(){
                alert(this.name)
            }
        }
    }
</script>

<style>
    /* 组件的样式  */
    .demo{
        background-color: aqua;
    }
</style>

Student.vue

<template>
   <div>
        <h2>姓名:{{name}}</h2>
        <h2>年龄:{{age}}</h2> 
    </div>
</template>

<script>
    export default {
        name:"Student",
        data(){
            return{
                name:"张三",
                age:18
            }
        }
    }
</script>

App.vue

<template>
    <div>
        <School></School>
        <Student></Student>
    </div>
</template>

<script>
    //引入组件
    import School from './School.vue'
    import Student from './Student.vue'
   
    export default {
        name:"App",
        components: {
            School,
            Student
        }
    }
</script>

main.js

import App from './App.vue'

new Vue({
    template:`<App></App>`,
    el:'#root',
    components: {
        App
    }    
})

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>练习一个单文件组件的语法</title>
</head>
<body>
    <div id="root">
    </div>
    <script type="text/javascript" src="../js/vue.js"></script>
    <script type="text/javascript" src="./main.js"></script>
</body>
</html>

III 脚手架

一、使用Vue脚手架

CLI：command line interface

1.安装具体步骤

​ 1.下载一个node.js

​ 2.(仅第一次执行)：全局安装@vue/cli

npm install -g @vue/cli

​ 3.切换到你要创建项目的目录，然后使用命令创建项目

cd 具体的项目地址

vue create xxxx(脚手架名称)

​ 4.启动项目

npm run serve

备注: 1.如出现下载缓慢请配置npm淘宝镜像： npm config set registry https://registry.npm.taobao.org

​ 2.Vue 脚手架隐藏了所有webpack相关的配置，若想查看具体的webpack配置，请执行：vue inspect > output.js ——>打开vue.config.js,查看脚手架的默认配置

2.render函数

• vue.js与vue.runtime.xxx.js的区别：

  • vue.js是完整版的Vue,包含：核心功能+模板解析器

  • vue.runtime.xxx.js是运行版的Vue,只包含：核心功能，没有模板解析器

• 因为vue.runtime.xxx.js没有模板解析器，所有不能使用template配置项，需要使用render函数接收到的createElement函数去指定具体内容

3.默认配置

**vue.config.js **

使用vue.config.js可以对脚手架进行个性化定制，详情见：https://cli.vuejs.org/zh/

pages:{
    index:{
        entry:'src/main.js'  //项目入口
    }	
}
lintOnSave：false   //关闭语法检查

4.脚手架文件结构

├── node_modules
├── public
│ ├── favicon.ico: 页签图标
│ └── index.html: 主页面
├── src
│ ├── assets: 存放静态资源
│ │ └── logo.png
│ │── component: 存放组件
│ │ └── HelloWorld.vue
│ │── App.vue: 汇总所有组件
│ │── main.js: 入口文件
├── .gitignore: git 版本管制忽略的配置
├── babel.config.js: babel 的配置文件
├── package.json: 应用包配置文件
├── README.md: 应用描述文件
├── package-lock.json：包版本控制文件

5.ref属性

• 被用来给元素或子组件注册引用信息（id的替代者）
• 应用在html标签上获取的是真实DOM元素，应用在组件标签上获取的是组件实例对象（vc）
• 使用方式：
  • 打标识：

    …

    或
  • 获取：this.$refs.xxx

<template>
  <div>
      <h2 v-text="msg" ref="title"></h2>
      <button @click="showRef" ref="btn">点我获取ref</button>
      <School ref="sch"/>
  </div>
</template>

<script>
    import School from './components/School.vue'
    export default {
        name:"App",
        data() {
            return {
                msg: '欢迎来学习Vue!',
            };
        },
        components: { School },
        methods:{
            showRef(){
                console.log(this.$refs.sch)
            }
        }
    }
</script>

6.props配置

功能：让组件接收外部传过来的数据

• 传递数据：

• 接收数据：

  • 第一种方式（只接收）：

    • props:['name']
      

  • 第二种方式（限制类型）：

    • props：{
      	name:String
      }
      

  • 第三种方式（限制类型、限制必要性、指定默认值）：

    • props:{
      	name:{
      		type:String,//类型 
      		required:true//必要性 
      	},
      	age:{
      		type:int, //类型
      		default:19 //默认值
      	}
      }
      

备注：props是只读的，Vue底层会监测你对props的修改，如果进行了修改，就会发出警告，若业务需求确实需要修改，那么请复制props的内容到data中一份，然后去修改data中的数据。

注：在一个属性中required 和 default 一般不会同时使用

7.mixin混入

功能：可以把多个组件共用的配置提取成一个混入对象(类似于公共类)

使用方式：

• 第一步定义混合mixin.js，例：

{
    data(){
        ......
    },
    methods:{
        ......
    },
    ......
}

• 第二步使用混入，例：
  • 全局混入：Vue.mixin(xxx)
  • 局部混入：mixins:[‘xxx’]

8.插件

功能：用于增强Vue

本质：包含install方法的一个对象，install的第一个参数是Vue，第二个以后的参数是插件使用者传递的数据。

定义插件：

export default{
    install(Vue,options){
         //1.添加全局过滤器
    Vue.filter(....)
    
    //2.添加全局指令
    Vue.directive(....)
    
    //3.配置全局混入(合)
    Vue.mixin(....)
    
    //4.添加实例方法
    Vue.prototype.$myMethod = function() {...}
    Vue.prototype.$myProperty = xxx
    }
}
//或 对象.install = function (Vue, options){ }

使用插件： Vue.use(xxx)

9.scoped样式

功能：让样式在局部生效，防止冲突。

写法：

二、用脚手架写Todo-list案例

• 组件化编码流程：
  • 拆分静态组件：组件要按照功能点拆分，命名不要与html元素冲突。
  • 实现动态组件：考虑好数据的存放位置，数据是一个组件在用，还是一些组件在用：
    • 一个组件在用：放在组件自身即可。
    • 一些组件在用：放在它们共同的父组件上（状态提升）
  • 实现交互：从绑定事件开始。
• props适用于：
  • 父组件 ==> 子组件 通信
  • 子组件 ==> 父组件 通信（要求父先给子一个函数）
• 使用v-model时要切记：v-model绑定的值不能是props传过来的值，因为props是不可以修改的！！！
• props传过来的若是对象类型的值，修改对象中的属性时Vue不会报错（因为Vue是浅监视），但不推荐这样做！

三、WebStorage

• 存储内容大小一般支持5MB左右（不同浏览器可能还不一样）
• 浏览器端通过Window.sessionStorage 和 Window.localStorage属性来实现本地存储机制。
• 相关API:
  • xxxxxStorage.setItem(‘key’,'value); //该方法接受一个键和值作为参数，会把键值对添加到存储中，如果键名存在，则更新其对应的值。
  • xxxxxStorage.getItem(‘key’); //该方法接受一个键名作为参数，返回键名对应的值
  • xxxxxStorage.removeItem(‘key’); // 该方法接受一个键名作为参数，并把该键名从存储中删除
  • xxxxxStorage.clear(); //该方法会清空存储中的所有数据
• 备注：
  • SessionStorage存储的内容会随着浏览器窗口关闭而消失
  • LocalStorage存储的内容，需要手动清除才会消失
  • xxxxxStorage.getItem(xxx) 如果xxx对应的value获取不到，那么getItem的返回值是null
  • JSON.parse(null)的结果依然是null

四、组件的自定义事件

• 一种组件间通信的方式，适用于：子组件===>父组件

• 使用场景：A是父组件，B是子组件，B向给A传数据，那么就要在A中给B绑定自定义事件(事件的回调在A中)

• 绑定自定义事件：

  • 第一种方式：在父组件中：<Demo @getName="test"/> 或 <Demo v-on:getName="test"/>

  • 第二种方式：在父组件中：

    • <Student ref="student"/>
       methods:{
           getStudentName(name){
           	alert(name)
           }
       },
       mounted(){
           setTimeout(()=>{
           	this.$refs.student.$on('getName',this.getStudentName)
           },1000)
          // this.$refs.student.$once('getName',this.getStudentName)  //一次性
      }
      

  • 若向让自定义事件只能触发一次，可以使用once修饰符，或$once方法

• 触发自定义事件：this.$emit('getName',数据)

• 解绑自定义事件：this.$off('getName')

• 组件上也可以绑定原生DOM事件，需要使用native修饰符

• 注意：通过this.$refs.xxx.$on('getName',回调)绑定自定义事件时，回调要么配置在methods中，要么用箭头函数，否则this指向会出问题！！！

五、全局事件总线

• 一种组件间通信的方式，适用于任意组件间通信。

• 安装全局事件总线:

  • new Vue({
    	......
    	beforeCreate(){
    		Vue.prototype.$bus = this //安装全局事件总线，$bus就是当前应用的vm
    	}
    })
    

• 使用事件总线：

  • 1.接收数据：A组件想接收数据，则在A组件中给$bus绑定自定义事件，事件的回调留在A组件自身。

    • methods(){
          demo(data){......}
      }
      ......
      mounted(){
          this.$bus.$on('xxxx',this.demo)
      }
      

  • 2.提供数据：this.$bug.$emit('xxxx',数据)

• 最好在beforeDestory钩子中，用$off去解绑当前组件所用到的事件。

六、消息订阅与发布（pubsub）

• 一种组件间通信的方式，适用于任意组件间通信

• 使用步骤：

  • 安装pubsub:npm i pubsub-js

  • 引入:import pubsub form 'pubsub-js

  • 接收数据：A组件想接收数据，则在A组件中订阅消息，订阅的回调留在A组件自身

    • methods(){
          //demo(msgName,data){......} 
          demo(_,data){......} //第一个参数不需要的时候，用_占位
      }
      ......
      mounted(){
          this.pubId = pubsub.subscribe('xxx',this.demo)//订阅消息
      }
      

  • 提供数据：pubsub.publish('xxx',数据)

  • 最好在beforeDestory钩子中，用pubsub.unsubscribe(this.pubId)去取消订阅

七、nextTick

• 语法：this.$nextTick(回调函数)
• 作用：在下一次DOM更新结束后执行其指定的回调
• 什么时候用：当改变数据后，要基于更新后的新DOM进行某些操作时，要在nextTick所指定的回调函数中执行。

八、过度与动画

• 作用：在插入、更新或移除DOM元素时，在合适的时候给元素添加样式类名

• 图示：

• 写法：

  • 准备好样式:

    • 元素进入的样式：
      • v-enter：进入的起点
      • v-enter-active：进入过程中
      • v-enter-to：进入的终点
    • 元素离开的样式：
      • v-leave：离开的起点
      • v-leave-active：离开过程中
      • v-leave-to：离开的终点

  • 使用<transition>包裹要过度的元素，并配置name属性：

  • <transition name="hello">
        <h1 v-show="isShow">你好啊！</h1>
    </transition>
    

  • 备注：若有多个元素需要过度，则需要使用：<transition-group>，且每个元素都要指定key值

IV Vue中的ajax

一、Vue脚手架配置代理

方法一

• vue.config.js中添加如下配置：

devServer:{
    proxy:"http://localhost:5000"
}

• 说明：
  • 优点：配置简单，请求资源时直接发给前端（8080）即可
  • 缺点：不能配置多个代理，不能灵活的控制请求是否走代理
  • 工作方式：若按照上述配置代理，当请求了前端不存在的资源时，那么该请求会转发给服务器（优先匹配前端资源）

方法二

• 编写vue.config.js配置具体代理规则：

module.exports = {
    devServer:{
        proxy:{
            '/api1':{//匹配所有以 '/api1' 开头的请求路径
                target:'http://localhost:5000', //代理目标的基础路径
                changeOrigin:true, //用于控制请求头中的host值
                ws:true,  // 用于支持websocket
                pathRewrite:{'^/api1':''}
            },
             '/api2':{//匹配所有以 '/api2' 开头的请求路径
                target:'http://localhost:5001', //代理目标的基础路径
                changeOrigin:true,//用于控制请求头中的host值
                ws:true,  // 用于支持websocket
                pathRewrite:{'^/api2':''}
            }
        }
    }
}
/*
	changeOrigin设置为true时，服务器收到的请求头中的host为：localhost:5000
	changeOrigin设置为false时，服务器收到的请求头中的host为：localhost:8080
	changeOrigin默认值为true，ws默认值也为true
*/

• 说明：
  • 优点：可以配置多个代理，且可以灵活的控制请求是否走代理
  • 缺点：配置略微繁琐，请求资源时必须加前缀

二、vue项目中常用的两个Ajax库

1.axios

import axios from 'axios'
axios.get("URL").then(
    response => {
        console.log('请求成功了',response.data)
    },
    error =>{
        console.log('请求失败了',error.message)
    }
)

2.vue-resource

main.js

//引入插件
import vueResource from 'vue-resource'
//使用插件
Vue.use(vueResource)

.vue

this.$http.get("URL").then(
    response => {
        console.log('请求成功了',response.data),
    error =>{
            console.log('请求失败了',error.message)
)

三、slot插槽

• 作用：让父组件可以向子组件指定位置插入html结构，也是一种组件间通信的方式，适用于 父组件 ===> 子组件

• 分类：默认插槽、具名插槽、作用域插槽

• 使用方式：

  • 默认插槽:

    <!-- 父组件中  -->
    <Category>
        <div>html结构</div>
    </Category>
    <!-- 子组件中  -->
    <template>
        <div>
            <!-- 定义插槽  -->
            <slot>我是一个插槽，当使用者没有传递具体结构时，我会出现</slot>
        </div>
    </template>
    

  • 具名插槽：

    <!-- 父组件中  -->
    <Category>
        <template slot="center">
        	<div>html结构1</div>
    	</template>
    </Category>
    <Category>
        <!-- vue2.6最新用法v-slot:插槽名,只能配合template使用  -->
        <template v-slot:"footer">
        	<div>html结构2</div>
    	</template>
    </Category>
    
    <!-- 子组件中  -->
    <template>
        <div>
            <!-- 定义插槽  -->
            <slot name="center">我是一个插槽1，当使用者没有传递具体结构时，我会出现</slot>
            <slot name="footer">我是一个插槽2，当使用者没有传递具体结构时，我会出现</slot>
        </div>
    </template>
    

  • 作用域插槽：

    • 理解：数组在组件的自身，但根据数据生成的结构需要组件的使用者来决定。(films数据在Category组件中，但使用数据所遍历出来的结构由APP组件决定)

    • 具体编码：

      <!-- 父组件中  -->
       <Category title="电影">
           <template scope="{films}">
              <ul>
                  <li v-for="(f,index) in films" :key="index">{{f}}</li>
              </ul>
           </template>
      </Category>
      
      <Category title="电影">
          <!-- getFilms是一个自定义对象名，下面调用时需要getFilms.films -->
          <template scope="getFilms">
              <ol>
          		<li v-for="(f,index) in getFilms.films" :key="index">{{f}}</li>
              </ol>
          </template>
      </Category>
      
      <Category title="电影">
          <template scope="{films}">
      		<h4 v-for="(f,index) in films" :key="index">{{f}}</h4>
          </template>
      </Category>
      
      <!-- 子组件中  -->
      <template>
          <div>
              <!-- 定义插槽  -->
              <slot :films="films">我是一个插槽1，当使用者没有传递具体结构时，我会出现</slot>
          </div>
      </template>
      
      <script>
          export default {
              name:'Category',
              props:['title'],
              data(){
                  return{
                      films:['《教父》','《拆弹专家》','《天使的国度》','《爱丽丝梦游仙境》']
                  }
              }
          }
      </script>
      
      

四、Vuex

1. 基本概念

概念：专门在Vue中实现集中式状态（数据）管理的一个Vue插件，对vue应用中多个组件的共享状态进行集中式的管理（读/写），也是一种组件间通信的方式，且适用于任意组件间通信。

全局事件总线实现

Vuex实现

什么时候使用Vuex？

• 多个组件依赖于同一状态
• 来自不同组件的行为需要变更同一状态

2. Vuex原理

State，Actions，Mutations都是一个对象，三者要经过store

3. 搭建vuex环境

• 创建文件：src/store/index.js

  //引入Vue核心库
  import Vue from 'vue'
  //引入Vuex
  import Vuex from 'vuex'
  //应用Vuex插件
  Vue.use(Vuex)
  
  //准备actions对象——响应组件中用户的动作
  const actions ={}
  //准备mutations对象——修改state中的数据
  const mutations = {}
  //准备state对象——保存具体的数据
  const state = {}
  
  //创建并暴露store
  export default new Vuex.Store({
      actions,
      mutations,
      state
  })
  

• 在main.js中创建vm时传入store配置项

  //引入store, 可以简写成import Store from './store'
  import store from './store/index'
  ......
  //创建vm
  new Vue({
      el:'#app',
      render: h =>h(App),
      store
  })
  

4. 基本使用

• 初始化数据、配置actions、配置mutations、操作文件store.js

  //引入Vue核心库
  import Vue from 'vue'
  //引入Vuex
  import Vuex from 'vuex'
  //应用Vuex插件
  Vue.use(Vuex)
  
  const actions = {
      incrementOdd(context,value){
          console.log(context,value);
          if(context.state.sum % 2){
              context.commit('INCREMENT',value)
          }
      },
      incrementWait(context,value){
          setTimeout(()=>{
              context.commit('INCREMENT',value)  
          },500)
      }
  }
  
  const mutations = {
      INCREMENT(state,value){
          state.sum += value
      },
      DECREMENT(state,value){
          state.sum -= value
      }
  }
  //初始化数据
  const state = {
      sum:0 //当前的和
  }
  
  //创建并暴露store
  export default new Vuex.Store({
      actions,
      mutations,
      state
  })
  

• 组件中读取vuex中的数据：$store.state.sum

• 组件中修改vuex中的数据：this.$store.dispatch('actions中的方法名',数据)或this.$store.commit('mutations中的方法名',数据)

• 备注：若没有网络请求或其他业务逻辑，组件中也可以越过actions，即不写dispatch，直接编写commit

5. getters的使用

• 概念：当state中的数据需要经过加工后再使用时，可以使用getters加工

• 在store.js中追加getters配置

  //准备getters——用于将state中的数据进行加工,注意返回值
  const getters = {
      bigSum(state){
          return state.sum *10
      }
  }
  
  //创建并暴露store
  export default new Vuex.Store({
   	......,
      getters
  })
  

• 组件中读取数据：$store.getters.bigSum

6. 四个map方法的使用

• mapState方法：用于帮助我们映射state中的数据为计算属性

  computed:{
      //借助mapState生成计算属性：sum、school、subject（对象写法）
      ...mapState({sum:'sum',school:'school',subject:'subject'}),
  
      //借助mapState生成计算属性：sum、school、subject（数组写法）
      ...mapState(['sum','school','subject']),
  }
  

• mapGetters方法：用于帮助我们映射getters中的数据为计算属性

  computed:{
      //借助mapGetters生成计算属性：bigSum（对象写法）
      ...mapGetters({bigSum:'bigSum'}),
          
      //借助mapGetters生成计算属性：bigSum（数组写法）
      ...mapGetters(['bigSum'])
  }
  

• mapActions方法：用于帮助我们生成与actions对话的方法，即包含$store.dispatch(xxx)的函数

• methods:{
    	 //借助mapActions生成计算属性：incrementOdd、incrementWait（对象写法）
       ...mapActions({incrementOdd:'incrementOdd',incrementWait:'incrementWait'}),
  
       //借助mapActions生成计算属性：incrementOdd、incrementWait（数组写法）
       ...mapActions(['incrementOdd','incrementWait'])  
  }
  

• mapMutations方法：用于帮助我们生成与mutations对话的方法，即包含$store.commit(xxx)的函数

• methods:{
    	//借助mapMutations生成计算属性：INCREMENT、DECREMENT（对象写法）
  	...mapMutations({INCREMENT:'INCREMENT',DECREMENT:'DECREMENT'}),
  
      //借助mapMutations生成计算属性：INCREMENT、DECREMENT（数组写法）
      ...mapMutations(['INCREMENT','DECREMENT']),  
  }
  

• 备注：mapActions与mapMutations使用时，若需要传递参数：需要在模板中绑定事件时传递好参数，否则参数是事件对象。<button @click="INCREMENT(n)">+</button>

7. 模块化+命名空间

• 目的：让代码更好维护，让多种数据分类更加明确。

• 创建count.js

  export default {
      namespaced: true,//开启命名空间
      actions:{
          incrementOdd(context,value){
              console.log(context,value);
              if(context.state.sum % 2){
                  context.commit('INCREMENT',value)
              }
          },
          incrementWait(context,value){
              setTimeout(()=>{
                  context.commit('INCREMENT',value)  
              },500)
          }
      },
      mutations:{
          INCREMENT(state,value){
              state.sum += value
          },
          DECREMENT(state,value){
              state.sum -= value
          }
      },
      state:{
          sum:0, //当前的和
          school:'尚硅谷',
          subject:'Vue'
      },
      getters:{
          bigSum(state){
              return state.sum *10
          }
      }
  }
  

• 创建person.js

  import axios from 'axios'
  import { nanoid } from 'nanoid'
  
  export default {
      namespaced:true,
      actions:{
          addPersonWang(context,value){
              if(value.name.indexOf('王')===0){
                  context.commit('ADD_PERSON',value)
              }else{
                  alert('添加的人必须为王')
              }
          },
          addPersonServer(context){
              axios.get('https://api.uixsj.cn/hitokoto/get?type=social').then(
                  response => {
                      context.commit('ADD_PERSON',{id:nanoid(),name:response.data})
                  },
                  error =>{
                      alert(error.message)
                  }
              )
          }
      },
      mutations:{
          ADD_PERSON(state,value){
              state.personList.unshift(value)
          }
      },
      state:{
          personList:[
              {id:'001',name:'张三'}
          ]
      },
      getters:{
          firstPersonName(state){
              return state.personList[0].name
          }
      }
  }
  

• 修改store.js

  //引入Vue核心库
  import Vue from 'vue'
  //引入Vuex
  import Vuex from 'vuex'
  import countAbout from './count'
  import personAbout from './person'
  //应用Vuex插件
  Vue.use(Vuex)
  
  //创建并暴露store
  export default new Vuex.Store({
      modules:{
          countAbout,
          personAbout
      }
  })
  

• 开启命名空间后，组件中读取state数据：

  //方式一：自己直接读取
  this.$store.state.personAbout.list
  //方式二：借助mapState读取
  ...mapState('countAbout',['sum','school','subject'])
  

• 开启命名空间后，组件中读取getters数据：

  //方式一：自己直接读取
  this.$store.getters['personAbout/firstPersonName']
  //方式二：借助mapGetters读取
  ...mapGetters('countAbout',['bigSum'])
  

• 开启命名空间后，组件中调用dispatch：

  //方式一：自己直接dispatch
  this.$store.dispatch('personAbout/addPersonWang',person)
  //方式二：借助mapActions
  ...mapActions('countAbout',{incrementOdd:'incrementOdd',incrementWait:'incrementWait'})
  

• 开启命名空间后，组件中调用commit：

  //方式一：自己直接commit
  this.$store.commit('personAbout/ADD_PERSON',person)
  //方式二：借助mapMutations
  ...mapMutations('countAbout',['increment','decrement'])
  

五、路由vue-router

1.相关理解

1.1vue-router的理解

vue的一个插件库，专门用来实现SPA应用

1.2 对SPA应用的理解

• 单页Web应用（single page web application，SPA）
• 整个应用只有一个完整的页面(index.html)。
• 点击页面中的导航链接不会刷新页面，只会做页面的局部更新。
• 数据需要通过ajax请求获取。

1.3 路由的理解

​ 什么是路由？

• 一个路由就是一组映射关系（key-value）
• key为路径，value可能是function或component

​ 路由分类

• 后端路由：
  • 理解：value是function，用于处理客户端提交的请求。
  • 工作过程：服务器收到一个请求时，根据请求路径找到匹配的函数来处理请求，返回响应数据。
• 前端路由：
  • 理解：value是component，用于展示页面内容。
  • 工作过程：当浏览器的路径改变时，对应的组件就会显示。

2. 基本路由

2.1 使用步骤

• 安装vue-router,命令：npm i vue-router

• 应用插件：Vue.use(VueRouter)

• 编写router配置项：

  //引入VueRouter
  import VueRouter from 'vue-router';
  //引入Luyou组件
  import About from '../components/About'
  import Home from '../components/Home'
  
  //创建router实例对象，去管理一组一组的路由规则
  const router = new VueRouter({
      routes:[
          {
              path:'/about',
              component:About
          },
          {
              path:'/home',
              component:Home
          }
      ]
  })
  
  //暴露router
  export default router
  

• 实现切换(active-class可配置高亮样式)

  <router-link class="list-group-item" active-class="active" to="/about">About</router-link>
  

• 指定展示位置

  <router-view></router-view>
  

2.2 几个注意点

• 路由组件通常存放在pages文件夹，一般组件通常存放components文件夹
• 通过切换，“隐藏”了路由组件，默认是被销毁掉的，需要的时候再去挂载
• 每个组件都有自己的$route属性，里面存储着自己的路由信息
• 整个应用只有一个router，可以通过组件的$router属性获取到

3. 嵌套（多级）路由

• 配置路由规则，使用children配置项：

  routes:[
      {
          path:'/about',
          component:About
      },
      {
          path:'/home',
          component:Home,
          children:[//通过children配置子级路由
              {
                  path:'news',//此处一定不要写:/news
                  component:News
              },
              {
                  path:'message',//此处一定不要写:/message
                  component:Message
              }
          ]
      }
  ]
  

• 跳转（要写完整路径）：

  <router-link to="/home/news">News</router-link>
  

4. 路由的query参数

• 传递参数

  <!-- 跳转路由并携带query参数，to的字符串写法 -->
  <!-- <router-link :to="`/home/message/detail?id=${m.id}&title=${m.title}`">{{m.title}}</router-link>&nbsp;&nbsp; -->
  
  <!-- 跳转路由并携带query参数，to的对象写法 -->
  <router-link :to="{
  path:'/home/message/detail',
      query:{
          id:m.id,
              title:m.title
      }
  }">
  跳转
  </router-link>
  

• 接收参数

  <li>消息id:{{$route.query.id}}</li>
  <li>消息标题:{{$route.query.title}}</li>
  

5. 命名路由

• 作用：可以简化路由的跳转

• 如何使用

  • 给路由命名：

    {
        path:'/home',
        component:Home,
        children:[
            {
                path:'news',
                component:News
            },
            {
                path:'message',
                component:Message,
                children:[
                    {
                        name:'xiangqing',//给路由命名
                        path:'detail',
                        component:Detail
                    }
                ]
            }
        ]
    }
    

  • 简化跳转：

    <!-- 简化前,需要写完整的路径 -->
    <router-link :to="/home/message/detail">跳转</router-link>
    
    <!-- 简化后,直接通过名字跳转 -->
    <router-link :to="{name:'xiangqing'}">跳转</router-link>
    
    <!-- 简化写法配合传递参数 -->
    <router-link :to="{
          name:'xiangqing',
          query:{
                id:m.id,
                title:m.title
          }
    }">跳转</router-link>
    

6. 路由的params参数

• 配置路由，声明接收params参数

  {
      path:'/home',
      component:Home,
      children:[
          {
              path:'news',
              component:News
          },
          {
              path:'message',
              component:Message,
              children:[
                  {
                      name:'xiangqing',//给路由命名
                      path:'detail/:id/:title',//使用占位符声明接收params参数
                      component:Detail
                  }
              ]
          }
      ]
  }
  

• 传递参数

  <!-- 跳转路由并携带params参数，to的字符串写法 -->
  <router-link :to="`/home/message/detail/${m.id}/${m.title}`">跳转</router-link>&nbsp;&nbsp;
  
  <!-- 跳转路由并携带params参数，to的对象写法,路径必须用name写法，不能用path -->
  <router-link :to="{
          name:'xiangqing',
          params:{
              id:m.id,
              title:m.title
          }
  }">
  跳转
  </router-link>
  

  特别注意：路由携带params参数时，若使用to的对象写法，则不能使用path配置项，必须使用name配置

• 接收参数

  <li>消息id:{{$route.params.id}}</li>
  <li>消息标题:{{$route.params.title}}</li>
  

7. 路由的props配置

• 作用：让路由组件更方便的收到参数

  // 第一种写法：props值为对象，该对象中所有的key-value的组合最终都会通过props传给Detail组件
  // props:{a:900}
  
  // 第二种写法：props值为布尔值，布尔值为true，则把路由收到的所有params参数通过props传给Detail组件
  // props:true
  
  // 第三种写法：props值为函数
  props($route){
          return{
              id:$route.query.id,
              title:$route.query.title
          }
  } 
  props({query}){
      return{
          id:query.id,
          title:query.title
      }
  }
  

• 接收参数

  <li>消息id:{{id}}</li>
  <li>消息标题:{{title}}</li>
  <script>
      export default {
          ......
          props:['id','title']
      }
  </script>
  

8. <router-link>的replace属性

• 作用：控制路由跳转时操作浏览器历史记录的模式
• 浏览器的历史记录有两种写入方式：分别为push和replace，push是追加历史记录，replace是替换当前记录。路由跳转时候默认为push
• 如何开始replace模式：<router-link replace .......>News</router-link>

9. 编程式路由导航

• 作用：不借助<router-link>实现路由跳转，让路由跳转更加灵活

• 具体编码

• this.$router.push({
      name:'xiangqing',
      query:{
          id:m.id,
          title:m.title
      }
  })，
  this.$router.replace({
      name:'xiangqing',
      query:{
          id:m.id,
          title:m.title
      }
  })
  this.$router.back() //前进
  this.$router.forward() //后退
  this.$router.go(2) //也可前进也可后退
  

10. 缓存路由组件

• 作用：让不展示的路由组件保持挂载，不被销毁

• 具体编码

  <!-- include是包含哪些组件，写组件名  -->
  <!-- 缓存一个路由组件 -->
  <keep-alive include="News">
      <router-view></router-view>
  </keep-alive>
  <!-- 缓存多个路由组件 -->
  <keep-alive :include="['News','Message']">
  

11. 两个新的生命周期钩子

• 作用：路由组件所独有的两个钩子，用于捕获路由组件的激活状态。
• 具体名字：
  • activated路由组件被激活时触发
  • deactivated路由组件失活时触发

12. 路由守卫

• 作用：对路由进行权限控制

• 分类：全局守卫、独享守卫、组件内守卫

• 全局守卫：

  //全局前置路由守卫——初始化的时候被调用、每次路由切换之前被调用
  router.beforeEach((to,from,next)=>{
      console.log('前置路由守卫',to,from)
      if(to.meta.isAuth){//判断是否需要判断权限
          if(localStorage.getItem('name')==='admin'){
              next()
          }else{
              alert('无权限查看!')
          }
      }else{
          next()
      }
  })
  
  //全局后置路由守卫——初始化的时候被调用、每次路由切换之后被调用
  router.afterEach((to,from)=>{
      console.log('后置路由守卫',to,from)
      document.title = to.meta.title ||  '管理系统'
  })
  

• 独享守卫：（只有beforeEnter,没有afterEnter）

  //独享路由守卫
  beforeEnter(to,from,next){
      console.log('beforeEnter',to,from)
      if(to.meta.isAuth){//判断是否需要判断权限
          if(localStorage.getItem('name')==='admin'){
              next()
          }else{
              alert('无权限查看!')
          }
      }else{
          next()
      }
  }
  

• 组件内守卫：

  //通过路由规则，进入该组件时被调用
  beforeRouteEnter(to, from, next){
  },
  //通过路由规则，离开该组件时被调用
  beforeRouteLeave(to, from, next){
  }
  

13. 路由器的两种工作模式

• 对于一个url来说，什么是hash值？— #及其后面的内容就是hash值
• hash值不会包含在HTTP请求中，即：hash值不会带给服务器
• hash模式：
  • 地址中永远带着#号，不美观
  • 若以后将地址通过第三方手机app分享，若app校验严格，则地址会被标记为不合法
  • 兼容性较好
• history模式：
  • 地址干净、美观
  • 兼容性和hash模式相比略差
  • 应用部署上线时需要后端人员支持，解决刷新页面服务端404的问题

V Vue UI组件库

1.移动端常用UI组件库

• Vant https://youzan.github.io/vant
• Cube UI https://didi.github.io/cube-ui
• Mint UI http://mint-ui.github.io

2.PC端常用UI组件库

• Element UI https://element.eleme.cn
• IView UI https://www.iviewui.com