Vue

Vue(发音为 /vjuː/,类似 view)是一款用于构建用户界面的 JavaScript 框架。它基于标准 HTML、CSS 和 JavaScript 构建,并提供了一套声明式的、组件化的编程模型,帮助你高效地开发用户界面,无论是简单还是复杂的界面都可以胜任。

其核心思想是**基于标准 HTML 的声明式渲染与组件化开发**,让开发者把关注点放在数据上,从而以更少的代码高效地构建可维护的前端界面。

传统前端开发需要手动操作 DOM 来同步数据与视图,而 Vue 通过双向数据绑定与响应式系统自动完成视图更新,大幅降低了界面开发的复杂度。
Vue 2 # Vue ## 1. 概述 ### 1.1 简介与入门 > 前端框架,便于书写。 > > 基于 MVVM 的思想,实现数据的双向绑定,将编程的关注点放在数据上。 - 新建 HTML 页面,引入 Vue.js 文件:
<script src="js/vue.min.js"></script>
- 在 JS 代码区域,创建 Vue 核心对象,定义数据模型:
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title></title>
    <script src="js/vue.js"></script>
  </head>
  <body>
    <div id="app">
      {{message}} - {{age}}
    </div>
    <script>
      const app = new Vue({
        el:"#app",  //#id
        data:{
          message:"Lani",
          age:10
        }			
      });
    </script>
  </body>
</html>
### 1.2 双大括号表达式 > 1. 表达式,一个表达式会生成一个值,可以放在任何一个需要值的地方: > - (1) `a` > - (2) `a+b` > - (3) `demo()` > - (4) `x==y?x:y` > 2. JS 代码(不能放在插值里): > - (1) `if(){}` > - (2) `for(){}` ### 1.3 注意事项 - Vue 实例和容器里的代码为 Vue 模板。 - 真实开发中一般只创建一个 Vue 实例。 ## 2. Vue 实例创建与数据代理 ### 2.1 Vue 实例的创建
const vm = new Vue({
    /* 第一种写法 */
    //el:"#root",
    data:{
        name:"za",
        adress:"sh"
    }
});
/* 第二种写法 */
vm.$mount("#root");
/* data第一种写法 */
data:{
    name:"za",
    adress:"sh"
} 
/* 第二种写法 */
data:function(){
    return {
        name:"za",
        adress:"sh"
    }
}
### 2.2 数据代理
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(){
    	console.log('有人读取age属性了')
    	return number
    },
    //当有人修改person的age属性时,set函数(setter)就会被调用,且会收到修改的具体值
    set(value){
    	console.log('有人修改了age属性,且值是',value)
    	number = value
    }
}
> **Vue 中的数据代理原理:** > > 1. Vue 中的数据代理:通过 `vm` 对象来代理 `data` 对象中属性的操作(读/写)。 > 2. Vue 中数据代理的好处:更加方便的操作 `data` 中的数据。 > 3. 基本原理:通过 `Object.defineProperty()` 把 `data` 对象中所有属性添加到 `vm` 上;为每一个添加到 `vm` 上的属性,都指定一个 getter/setter;在 getter/setter 内部去操作(读/写)`data` 中对应的属性。 ## 3. 事件与键盘处理 ### 3.1 事件的基本使用 > 事件的基本使用: > > 1. 使用 `v-on:xxx` 或 `@xxx` 绑定事件,其中 `xxx` 是事件名; > 2. 事件的回调需要配置在 `methods` 对象中,最终会在 `vm` 上; > 3. `methods` 中配置的函数,不要用箭头函数!否则 `this` 就不是 `vm` 了; > 4. `methods` 中配置的函数,都是被 Vue 所管理的函数,`this` 的指向是 `vm` 或组件实例对象; > 5. `@click="demo"` 和 `@click="demo($event)"` 效果一致,但后者可以传参。 ### 3.2 事件修饰符 | 修饰符 | 说明 | | ---- | ---- | | `prevent` | 阻止默认事件(常用) | | `stop` | 阻止事件冒泡(常用) | | `once` | 事件只触发一次(常用) | | `capture` | 使用事件的捕获模式 | | `self` | 只有 `event.target` 是当前操作的元素时才触发事件 | | `passive` | 事件的默认行为立即执行,无需等待事件回调执行完毕 | ### 3.3 键盘事件
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="../vue.min.js"></script>
</head>
<body>
    <div id="root">
        <input type="text" placeholder="输入" @keyup.delete="show">
    </div>
    <script>
            const vm = new Vue({
             el:"#root",
            data:{
                name:"za",
                adress:"sh"
            },
            methods:{
                show(event){
                    //alert("message");
                    console.log(event.target.value);
                }
            }
        });
    </script>
</body>
</html>
常用按键别名: | 按键 | 别名 | | ---- | ---- | | 回车 | `enter` | | 删除 / 退格 | `delete`(捕获“删除”和“退格”键) | | 退出 | `esc` | | 空格 | `space` | | 换行 | `tab` | | 上 / 下 / 左 / 右 | `up` / `down` / `left` / `right` | 其他说明: 1. Vue 未提供别名的按键,可以使用按键原始的 key 值去绑定,但注意要转为 kebab-case(短横线命名)。 2. 系统修饰键(用法特殊):`ctrl`、`alt`、`shift`、`meta` - (1) 配合 `keyup` 使用:按下修饰键的同时,再按下其他键,随后释放其他键,事件才被触发; - (2) 配合 `keydown` 使用:正常触发事件。 3. 也可以使用 `keyCode` 去指定具体的按键(不推荐),例如 `13` 是回车。 4. `Vue.config.keyCodes.自定义键名 = 键码`,可以去定制按键别名。 ## 4. 计算属性与监视属性 ### 4.1 计算属性
computed:{
    fullname:{
        /* 当读取fullname时get调用 */
        get(){
            return this.name+'-'+this.nname;
        },
        /* 修改fullaname的时候启动 */
        set(value){
            console.log("set"+value);
        }
    }
    
}
//简写
computed:{
    info(){
        return this.isHot ? "热":"冷";
    }
}
1. 定义:要用的属性不存在,要通过已有属性计算得来。 2. 原理:底层借助了 `Object.defineproperty` 方法提供的 getter 和 setter。 3. `get` 函数什么时候执行? - (1) 初次读取时会执行一次; - (2) 当依赖的数据发生改变时会被再次调用。 4. 优势:与 `methods` 实现相比,内部有缓存机制(复用),效率更高,调试方便。 5. 备注: - 计算属性最终会出现在 `vm` 上,直接读取使用即可; - 如果计算属性要被修改,那必须写 `set` 函数去响应修改,且 `set` 中要引起计算时依赖的数据发生改变的处理逻辑。 ### 4.2 监视属性 `@xxx="yyy"` 可以执行一些简单案例:
const vm = new Vue({
    el:"#root",
    data:{
        isHot:true
    },
    methods:{
        change(){
            console.log(1);
            this.isHot=!this.isHot;
        }
    },
    computed:{
        info(){
            return this.isHot ? "热":"冷";
        }
    },
    watch:{
        isHot:{
            /* 立即执行 */
            immediate:true,
            handler(newValue,oldValue){
                console.log("修改1");
            }
        }
    }
});
vm.$watch('isHot',{
    handler(newValue,oldValue){
        console.log("修改2");
    }
})
### 4.3 深度监视
watch:{
    /* 监视a的变化 */
    'numbers.a':{
        /* 立即执行 */
        //immediate:true,
        handler(newValue,oldValue){
            console.log("aaaa");
        }
    },
        /* 监视a的变化 */
        numbers:{
            /* 可以检测内部值的改变 */
            //deep:true,
            handler(newValue,oldValue){
                console.log("bbbb");
            }
        }
}
监视的简写:
isHot(newValue,oldValue){
    console.log("修改333");
}
vm.$watch('isHot',function(newValue,oldValue){
    console.log("修改2");
})
### 4.4 computed 与 watch 的区别 1. `computed` 能完成的功能,`watch` 都可以完成。 2. `watch` 能完成的功能,`computed` 不一定能完成,例如:`watch` 可以进行异步操作。 两个重要的小原则: 1. 所有被 Vue 管理的函数,最好写成普通函数,这样 `this` 的指向才是 `vm` 或组件实例对象。 2. 所有不被 Vue 所管理的函数(定时器的回调函数、ajax 的回调函数等),最好写成箭头函数,这样 `this` 的指向才是 `vm` 或组件实例对象。 ## 5. 样式绑定 ### 5.1 class 样式绑定 写法:`:class="xxx"`,`xxx` 可以是字符串、对象、数组。 - **字符串写法**适用于:类名不确定,要动态获取。 - **对象写法**适用于:要绑定多个样式,个数不确定,名字也不确定。 - **数组写法**适用于:要绑定多个样式,个数确定,名字也确定,但不确定用不用。
<div class="basic" :class="backgroundColor">hello</div>
<div class="basic" :class="classArr">hello</div>
<div class="basic" :class="classObj">hello</div>
### 5.2 style 样式绑定 - `:style="{fontSize:xxx}"` 其中 `xxx` 是动态值。 - `:style="[a,b]"` 其中 `a`、`b` 是样式对象。 字符串写法:适用于样式的类名不太确定,需要动态指定的情况(代码中的 `backgroundColor` 是变量名)。 ## 6. Vue 指令 ### 6.1 模板语法的两大类 > 1. 插值语法: > - 功能:用于解析标签体内容。 > - 写法:`{{xxx}}`,`xxx` 是 js 表达式,且可以直接读取到 `data` 中的所有属性。 > 2. 指令语法: > - 功能:用于解析标签(包括:标签属性、标签体内容、绑定事件……)。举例:`v-bind:href="xxx"` 或简写为 `:href="xxx"`,`xxx` 同样要写 js 表达式,且可以直接读取到 `data` 中的所有属性。 > 3. 备注:Vue 中有很多的指令,且形式都是:`v-????` ### 6.2 v-bind 绑定 HTML 标签属性: ` 1 ` ### 6.3 v-model 双向数据绑定: ``
<body>
    //v-bind将超链接改为url
    <div id="app">
        <a v-bind:href="url">超链接1</a>
        <a :href="url">超链接2</a>
    //事实绑定修改url,a标签里的url也会随着改变
        <input type="text" v-model="url">
    </div>

</body>

<script>
    new Vue({
        el:"#app",
        data:{
            url:"https://baidu.com"
        }	
    })
</script>
必须在数据模型中声明,例如上面的 url。
### 6.4 v-on > 为 HTML 标签绑定事件。 `v-on:事件` 或者简写为 `@事件`
<body>
    <div id="app">
        <input type="text" v-on:click="handle">输入
    </div>
</body>

<script>
    new Vue({
        el:"#app",
        data:{
            
        },
        methods:{
            handle:function(){
                alert("哈");
            }
        }	
    })
</script>
### 6.5 v-if / v-else-if / v-else > 根据条件是否渲染;中间不能被其他语句断开。
<body>
    <div id="app">
        <span v-if="age>=45" >old</span>
        <span v-else-if="age<45 && age>=18" >mid</span>
        <span v-if="age<18" >low</span>

        <input type="text" v-model="age">输入
        
    </div> 
</body>

<script>
    new Vue({
        el:"#app",
        data:{
            age:0
        }
    })
</script>
### 6.6 v-show > 与 `v-if` 的区别为 `display` 属性的值。
<body>
    <div id="app">
        <input type="text" v-model="age">输入
        <span v-show="age>=45" >old</span>
        <span v-show="age<45 && age>=18" >mid</span>
        <span v-show="age<18" >low</span>
    </div> 
</body>

<script>
    new Vue({
        el:"#app",
        data:{
            age:0
        }
    })
</script>
### 6.7 v-for 与 key > 列表渲染,遍历容器的元素或者对应的属性。
<body>
    <div id="app">
        <div v-for="addr in addrs"> {{addr}} </div>
        <div v-for="(addr,index) in addrs"> {{index+1}}:{{addr}} </div>
    </div>
</body>

<script>
    new Vue({
        el:"#app",
        data:{
            addrs:["一","二","三","四"]
        },

    })
</script>
**虚拟 DOM 中 key 的作用(key 的内部原理):** key 是虚拟 DOM 对象的标识。当状态中的数据发生变化时,Vue 会根据【新数据】生成【新的虚拟 DOM】,随后进行【新虚拟 DOM】与【旧虚拟 DOM】的差异比较,规则如下: 1. 对比规则: - (1) 旧虚拟 DOM 中找到了与新虚拟 DOM 相同的 key: - 若虚拟 DOM 中内容没变,直接使用之前的真实 DOM; - 若虚拟 DOM 中内容变了,则生成新的真实 DOM,随后替换掉页面中之前的真实 DOM。 - (2) 旧虚拟 DOM 中未找到与新虚拟 DOM 相同的 key:创建新的真实 DOM,随后渲染到页面。 2. 用 `index` 作为 key 可能会引发的问题: - (1) 若对数据进行逆序添加、逆序删除等破坏顺序操作:会产生没有必要的真实 DOM 更新(界面效果没问题,但效率低); - (2) 如果结构中还包含输入类的 DOM:会产生错误 DOM 更新(界面有问题)。 3. 开发中如何选择 key: - (1) 最好使用每条数据的唯一标识作为 key,比如 id、手机号、身份证号、学号等唯一值; - (2) 如果不存在对数据的逆序添加、逆序删除等破坏顺序操作,仅用于渲染列表展示,使用 `index` 作为 key 是没有问题的。 ### 6.8 v-once 与 v-pre - `v-once`:在初次渲染后就视为静态内容。 - `v-pre`:用于没有指令语法、没有使用插值语法的节点,可提高编译速度。 ## 7. 列表操作与数据监测 ### 7.1 列表过滤 使用 `watch`:
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="../vue.js"></script>
</head>
<body>
    <div id="root">
        <h1>人员</h1>
        <input type="text" placeholder="请输入" v-model="keyWord">
        <ul>
            <li v-for="(p,index) of filperson" :key="index">
                {{p.name}}---{{p.sex}}
            </li>
        </ul>
    </div>
    <script>
        const vm = new Vue({
            el:"#root",
            data:{
                keyWord:"",
                person:[
                    {
                        id:"001",name:"爱坤",sex:"女"
                    },
                    {
                        id:"002",name:"树枝",sex:"男"
                    },
                    {
                        id:"003",name:"荔枝",sex:"女"
                    },
                    {
                        id:"004",name:"坤黑子",sex:"男"
                    }
                ],
                filperson:[]
            },
            watch:{
                keyWord:{
                    immediate:true,
                    handler(val){
                        this.filperson = this.person.filter(p=>{
                        	return p.name.indexOf(val) !== -1
                        })
                    }
                }
            }
        })
    </script>
</body>
</html>
使用 `computed`:
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="../vue.js"></script>
</head>
<body>
    <div id="root">
        <h1>人员</h1>
        <input type="text" placeholder="请输入" v-model="keyWord">
        <ul>
            <li v-for="(p,index) of filperson" :key="index" >
                {{p.name}}---{{p.sex}}
            </li>
        </ul>
    </div>
    <script>
        const vm = new Vue({
            el:"#root",
            data:{
                keyWord:"",
                person:[
                    {
                        id:"001",name:"爱坤",sex:"女"
                    },
                    {
                        id:"002",name:"树枝",sex:"男"
                    },
                    {
                        id:"003",name:"荔枝",sex:"女"
                    },
                    {
                        id:"004",name:"坤黑子",sex:"男"
                    }
                ],
            },
            computed:{
                filperson(){
                    return this.person.filter((p)=>{
                        return p.name.indexOf(this.keyWord) !== -1;
                    });
                }
            }
        })
    </script>
</body>
</html>
### 7.2 列表排序
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="../vue.js"></script>
</head>
<body>
    <div id="root">
        <h1>人员</h1>
        <input type="text" v-model="keyWord" placeholder="请输入">
        <button @click="sortType=2">按年龄升序</button>
        <button @click="sortType=1">按年龄降序</button>
        <button @click="sortType=0">原顺序</button>
        <ul>
            <li v-for="(p,index) of filperson" :key="index" >
                {{p.name}}---{{p.sex}}---{{p.age}}
            </li>
        </ul>
    </div>
    <script>
        const vm = new Vue({
            el:"#root",

            data:{
                keyWord:"",
                sortType:0,
                person:[
                    {
                        id:"001",name:"爱坤",sex:"女",age:100
                    },
                    {
                        id:"002",name:"树枝",sex:"男",age:34
                    },
                    {
                        id:"003",name:"荔枝",sex:"女",age:88
                    },
                    {
                        id:"004",name:"坤黑子",sex:"男",age:90
                    }
                ],
            },
            computed:{
                filperson(){
                    const arr=this.person.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>
</body>
</html>
### 7.3 数据监测原理 `vm` 实例的 `name` 和 `address` 其实都来自 `_data`,`_data` 中的数据来自于我们所传入的配置项 `data`,也就是 `vm._data = data`。 1. 加工我们传入的 `data` 数据(黄色框):将我们 `data` 中的每一组 key-value 形成 getter 和 setter,`vm._data = data`。 2. 监测对象中的数据:通过 setter 实现监视,且要在 `new Vue` 时就传入要监测的数据。 - (1) 对象中后追加的属性,Vue 默认不做响应式处理; - (2) 如需给后添加的属性做响应式,请使用 `Vue.set(target, propertyName/index, value)` 或 `vm.$set(target, propertyName/index, value)`。 3. 如何监测数组中的数据:通过包裹数组更新元素的方法实现,本质就是做了两件事: - (1) 调用原生对应的方法对数组进行更新; - (2) 重新解析模板,进而更新页面。 4. 在 Vue 中修改数组中的某个元素一定要用如下方法: - (1) 使用这些 API:`push()`、`pop()`、`shift()`、`unshift()`、`splice()`、`sort()`、`reverse()`; - (2) `Vue.set()` 或 `vm.$set()`。 特别注意:`Vue.set()` 和 `vm.$set()` 不能给 `vm` 或 `vm` 的根数据对象(例如 `data`)添加属性!
let data = {
    name:"zd",
    age:"33"
}

const obs = new Observer(data);

let vm={};
vm._data = data=obs;

function Observer(obj){
    const keys= Object.keys(obj);
    keys.forEach((k)=>{
        Object.defineProperty(this,k,{
            get(){
                console.log("获取");
                return obj[k];
            },
            set(value){
                console.log("修改");
                obj[k]=value;
            }
        });
    })
}
### 7.4 Vue.set 与 $set > `Vue.set( target, propertyName/index, value )` - **参数**: - `{Object | Array} target` - `{string | number} propertyName/index` - `{any} value` - **返回值**:设置的值。 - **用法**:向响应式对象中添加一个 property,并确保这个新 property 同样是响应式的,且触发视图更新。它必须用于向响应式对象上添加新 property,因为 Vue 无法探测普通的新增 property(比如 `this.myObject.newProperty = 'hi'`)。 注意:对象不能是 Vue 实例,或者 Vue 实例的根数据对象。 > 数组更新检测包括对整个数组的更改。 ### 7.5 收集表单数据(v-model) - 若:``,则 `v-model` 收集的是 `value` 值,用户输入的就是 `value` 值。 - 若:``,则 `v-model` 收集的是 `value` 值,且要给标签配置 `value` 值。 - 若:``: 1. 没有配置 `input` 的 `value` 属性,那么收集的就是 `checked`(勾选 or 未勾选,是布尔值); 2. 配置了 `value` 属性: - (1) `v-model` 的初始值是非数组,那么收集的就是 `checked`(勾选 or 未勾选,是布尔值); - (2) `v-model` 的初始值是数组,那么收集的就是 `value` 组成的数组。 备注:`v-model` 的三个修饰符: - `lazy`:失去焦点再收集数据; - `number`:输入字符串转为有效的数字; - `trim`:输入首尾空格过滤。 写法:`v-model.lazy`、`v-model.number`、`v-model.trim`。 ### 7.6 v-text 与 v-html > `v-text`:向其所在节点中渲染文本内容;`v-text` 会替换掉节点里的内容。
<div id="root">
    <span v-text="str"></span>
    <span v-text="str2"></span>
    <span v-html="str"></span>
    <span v-html="str2"></span>
    <div v-fbind=""></div>
</div>
<script>
    new Vue({
        el:"#root",
        data:{
            str:"hello",
            str2:"<h3>hello</h3>"
        }
    })
</script>
> `v-html` 指令: > > 1. 作用:向指定节点中渲染包含 html 结构的内容。 > 2. 与插值语法的区别: > - (1) `v-html` 会替换掉节点中所有的内容,`{{xx}}` 则不会; > - (2) `v-html` 可以识别 html 结构。 > 3. `v-html` 有安全性问题: > - (1) 在网站上动态渲染任意 HTML 是非常危险的,容易导致 XSS 攻击; > - (2) 一定要在可信的内容上使用 `v-html`,永不要用在用户提交的内容上。
安全提示 使用 v-html 渲染用户提交的内容会导致 XSS 攻击风险,务必只在可信内容上使用。
## 8. 自定义指令与过滤器 ### 8.1 自定义指令 **一、定义语法:** (1) 局部指令:
new Vue({

  directives:{指令名:配置对象}

})

new Vue({
    
  directives{指令名:回调函数}
        
})
(2) 全局指令:`Vue.directive(指令名, 配置对象)` 或 `Vue.directive(指令名, 回调函数)`。 **二、配置对象中常用的 3 个回调:** 1. `bind`:指令与元素成功绑定时调用; 2. `inserted`:指令所在元素被插入页面时调用; 3. `update`:指令所在模板结构被重新解析时调用。 **三、备注:** 1. 指令定义时不加 `v-`,但使用时要加 `v-`; 2. 指令名如果是多个单词,要使用 kebab-case 命名方式,不要用 camelCase 命名。 函数写法:
fbind(element,binding){
    const input = document.createElement("input");
    document.body.appendChild(input)
    input.focus(); 
}
对象写法:
fbind:{
    /* 指令与元素成功绑定时 */
    bind(element,binding){
        element.value = binding.value;
    },
        /* 指令所在的元素插入页面时 */
        inserted(element,binding){
            element.focus();
            //element.value=binding.value;
        },
            /* 指令所在的模板被重新解析时 */
            update(element,binding){
                element.value = binding.value;
            }
}
如果有 `-` 可以使用引号包裹,例如:
'input-number':{

}
### 8.2 过滤器 使用管道符进行运算 `|`:
//注册
Vue.filter('my-filter', function (value) { 
    // 返回处理后的值
}) 
getter,返回已注册的过滤器
var myFilter = Vue.filter('my-filter')
// 创建 Vue 实例,得到 ViewModel
var vm = new Vue({
    el: '#app',
    data: {
        msg: 'filter'
    },
    methods: {},
    //定义私用局部过滤器。只能在当前 vue 对象中使用
    filters: {
        // msg表示要过滤的数据
        // a表示传入的参数
        dataFormat(msg,a) {
            return msg+a;
        }
    }
});
<!--html部分-->
<div id="app">
    <p>{{ msg | dataFormat("你好")}}</p>
<!--结果   <p>filter你好</p>-->
</div>
> 全局过滤器
Vue.filter('toDouble', function(msg) {
            // 字符串的  replace 方法,第一个参数,除了可写一个 字符串之外,还可以定义一个正则
            return msg < 10 ? msg : "0" +msg
         })
## 9. Vue 生命周期 `mounted`:挂载完成,Vue 初始化成功,HTML 页面渲染成功(可在此发送请求到服务端,加载数据)。 | 状态 | 阶段周期 | | ---- | ---- | | beforeCreate | 创建前 | | created | 创建后 | | beforeMount | 载入前 | | mounted | 挂载完成 | | beforeUpdate | 更新前 | | updated | 更新后 | | beforeDestroy | 销毁前 | | destroyed | 销毁后 |
mounted() {
    setInterval(()=>{
        this.opacity -= 0.01;
        if (this.opacity < 0) this.opacity=1;
    },16)
},
> 常用的生命周期钩子: > > 1. `mounted`:发送 ajax 请求、启动定时器、绑定自定义事件、订阅消息等【初始化操作】。 > 2. `beforeDestroy`:清除定时器、解绑自定义事件、取消订阅消息等【收尾工作】。 关于销毁 Vue 实例: 1. 销毁后借助 Vue 开发者工具看不到任何信息。 2. 销毁后自定义事件会失效,但原生 DOM 事件依然有效。 3. 一般不会在 `beforeDestroy` 操作数据,因为即便操作数据,也不会再触发更新流程了。 ## 10. 组件化基础 ### 10.1 对组件的理解 > 实现应用中局部功能代码和资源的集合。 - **非单文件组件**:一个文件中包含 n 个组件。 - **单文件组件**:一个文件只包含一个组件。
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="../vue.js"></script>
</head>
<body>
    <div id="root">
        <school></school>
        <student></student>
    </div>
    
    <script>
        /* 组件1 */
        const school ={
            template:`    
            <div>  
                <h2>名称:{{name1}}</h2>
                <span>地址:{{adress}}</span>
            </div>`,
            data(){
                return {
                    name1:"g",
                    adress:"gl"
                }
            }
        }

        const student = {
            template:`        
            <div>
                <h2>姓名:{{name2}}</h2>
                <span>年龄:{{age}}</span>
            </div>
            `,
            data() {
                return {
                    name2:"rc",
                    age:30
                }
            }
        }

        const vm = new Vue({
            el:"#root",
            components:{
                school:school,
                student:student
            }
        })
    </script>
</body>
</html>
### 10.2 组件的注意点 > 1. 关于组件名: > - 一个单词组成:第一种写法(首字母小写)`school`;第二种写法(首字母大写)`School`。 > - 多个单词组成:第一种写法(kebab-case 命名)`my-school`;第二种写法(CamelCase 命名)`MySchool`(需要 Vue 脚手架支持)。 > - (1) 组件名尽可能回避 HTML 中已有的元素名称,例如:`h2`、`H2` 都不行。 > - (2) 可以使用 `name` 配置项指定组件在开发者工具中呈现的名字。 > 2. 关于组件标签: > - 第一种写法:``; > - 第二种写法:``。 > - 备注:不用脚手架时,`` 会导致后续组件不能渲染。 > 3. 一个简写方式:`const school = Vue.extend(options)` 可简写为 `const school = options`。
const school = {
    data() {
        return {
            name:'zs'
        }
    },
}

const student = {
    data() {
        return {
            name:"ls"
        }
    },
    components:{
        school:school
    }
}
### 10.3 VueComponent Vue 中使用组件的三大步骤: 1. 定义组件(创建组件); 2. 注册组件; 3. 使用组件(写组件标签)。 **一、定义一个组件**:使用 `Vue.extend(options)` 创建,其中 `options` 和 `new Vue(options)` 时传入的那个 `options` 几乎一样,但也有点区别: 1. `el` 不要写——最终所有的组件都要经过一个 `vm` 的管理,由 `vm` 中的 `el` 决定服务哪个容器。 2. `data` 必须写成函数——避免组件被复用时,数据存在引用关系。 3. 备注:使用 `template` 可以配置组件结构。 **二、注册组件**: 1. 局部注册:靠 `new Vue` 的时候传入 `components` 选项; 2. 全局注册:靠 `Vue.component('组件名', 组件)`。 **三、编写组件标签**:``。 关于 `VueComponent`: 1. `school` 组件本质是一个名为 `VueComponent` 的构造函数,且不是程序员定义的,是 `Vue.extend` 生成的。 2. 我们只需要写 `` 或 ``,Vue 解析时会帮我们创建 `school` 组件的实例对象,即 Vue 帮我们执行的:`new VueComponent(options)`。 3. 特别注意:每次调用 `Vue.extend`,返回的都是一个全新的 `VueComponent`! 4. 关于 `this` 指向: - (1) 组件配置中:`data` 函数、`methods` 中的函数、`watch` 中的函数、`computed` 中的函数,它们的 `this` 均是【VueComponent 实例对象】; - (2) `new Vue(options)` 配置中:`data` 函数、`methods` 中的函数、`watch` 中的函数、`computed` 中的函数,它们的 `this` 均是【Vue 实例对象】。 5. `VueComponent` 的实例对象,以后简称 `vc`(也可称之为:组件实例对象);`Vue` 的实例对象,以后简称 `vm`。
重要的内置关系 VueComponent.prototype.__proto__ === Vue.prototype
### 10.4 单文件组件
<template>
    <div class="demo">  
        <h2>名称:{{name1}}</h2>
        <span @click="demo">地址:{{adress}}</span>
    </div>
</template>

<script>
/*     const school ={
        data(){
            return {
                name1:"g",
                adress:"gl"
            }
        }
    }
    export default school; */
    export default {
        name:"school",
        data:{
            data(){
            return {
                name1:"g",
                adress:"gl"
            }
        }
        },
        methods: {
            demo(){
                alert("1");
            }
        },
    }
</script>

<style>
    .demo{
        background-color: red;
        border:1px solid black;
    }
</style>
### 10.5 创建 Vue 脚手架 > Vue CLI:`npm i -g @vue/cli` > 在文件路径内输入: > > `vue create richu` > > 启动服务:`npm run serve` ## 11. 脚手架与组件进阶 ### 11.1 ref 属性 1. 被用来给元素或子组件注册引用信息(id 的替代者); 2. 应用在 html 标签上获取的是真实 DOM 元素,应用在组件标签上是组件实例对象(vc); 3. 使用方式: - 打标识:`

.....

` 或 ``; - 获取:`this.$refs.xxx`。 ### 11.2 配置项 props > 功能:让组件接收外部传过来的数据。 传递数据:`` 接收数据: - 第一种方式(只接收):`props:['name']` - 第二种方式(限制类型):`props:{ name:Number }` - 第三种方式(限制类型、限制必要性、指定默认值):
props:{
    name:{
        type:String,//类型
        required:true,//必要性
        default:'老王'//默认值
    }
}
备注:`props` 是只读的,Vue 底层会监测你对 `props` 的修改,如果进行了修改,就会发出警告。若业务需求确实需要修改,那么请复制 `props` 的内容到 `data` 中一份,然后去修改 `data` 的数据。 ### 11.3 mixin 混入 功能:可以把多个组件共用的配置提取成一个混入对象。 使用方式: 1. 第一步定义混合,例如:`data(){....}`、`methods:{....}`; 2. 第二步使用混入: - (1) 全局混入:`Vue.mixin(xxx)`; - (2) 局部混入:`mixins:['xxx']`。 ### 11.4 插件 功能:用于增强 Vue。 本质:包含 `install` 方法的一个对象,`install` 的第一个参数是 `Vue`,第二个以后的参数是插件使用者传递的数据。 定义插件:
对象.install = function(Vue,options){

  1.添加全局过滤器Vue.filter(....)

  2.添加全局指令
  Vue.directive(....)

  3.配置全局混入(合)
  Vue.mixin(....)

  4.添加实例方法
  Vue.prototype.$myMethod = function () {...]
  Vue.prototype.$myProperty = xXxx

}
使用插件:`Vue.use()`。 ### 11.5 scoped 样式 > 让样式在局部生效,防止冲突。 > 写法:`