Vue学习笔记
初识Vue
Vue.js是什么
Vue是一套用于构建用户界面的渐进式框架。与其他大型框架不同的是，Vue被设计为可以自底向上逐层应用。Vue的核心库只关心视图层。
Vue的特点：
-
采用组件化模式，提高代码复用率、且让代码刚好维护
-
声明式编码，让编码人员无需直接操作DOM，提高开发效率
-
使用虚拟的DOM和优秀的Diff算法，尽量复用DOM节点
初始Vue：
-
想让Vue工作，就必须创建一个Vue实例，且要传入一个配置对象
- 容器实例一一对应
- 真实开发中只有一个Vue实例，并且会配合着组件一起使用
- 插值语法{{xxx}}中的xxx只能写js表达式，且xxx可以自动读取到data中的所有属性，每一个数据绑定只能包含单个表达式
- data中的值一旦发生变化那么模板中用到该数据的地方也会自动更新
-
root容器里面的代码依然符合html规范，只不过混入了一些特殊的Vue语法
-
root容器里面的的代码被称为Vue模板
vue.config.productionTip = false;//阻止vue在启动时生成生产提示
<!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>初始Vue</title>
<!-- 引入Vue -->
<script src="../js/vue.js"></script>
</head>
<body>
<!-- 容器 -->
<div id="root">
<!-- 插值语法 {{}}里面只能写js表达式-->
<h1>hello, {{name}}</h1>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const x = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: 'test'
}
});
</script>
</body>
</html>
Vue模板语法有两大类：
-
插值语法：
- 功能：用于解析标签体内容
- 写法：{{xxx}}, xxx是js表达式(不是js代码，即js语句)，且可以直接读取到data中的所有属性
- a
- a+b
- demo(1)
- x === y ? ‘a’ : ‘b’
-
指令语法：
-
功能：用于解析标签（包括标签属性、标签体内容、绑定事件等）
-
Vue中有很多的指令，形式都是v-???
如 v-bind:href=“test.url” ，可简写为 :href=“test.url”
-
<body>
<!-- 容器 -->
<div id="root">
<h1>插值语法</h1>
<h2>你好，{{name}}</h2>
<hr/>
<h1>指令语法</h1>
<a v-bind:href="test.url">点击前往{{test.name}}</a>
<!-- 等价于 -->
<a :href="test.url">点击前往{{test.name}}</a>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const x = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: '007',
test:{
name: '百度',
url: 'http://baidu.com/'
}
}
});
</script>
</body>
Vue中有两种数据绑定的方式：
- 单向绑定：v-bind，数据只能从data流向页面
- 双向绑定：v-model, 数据能从data流向页面，也能从页面流向data
- 双向绑定一般都应用于表单类元素（input、select等）
- v-model: value可简写为v-model，v-model的默认收集值是value值
<body>
<!-- 容器 -->
<div id="root">
<!-- 普通写法 -->
单向数据绑定：<input type="text" v-bind:value="name"><br>
双向数据绑定：<input type="text" v-model:value="name">
<!-- 简写 -->
单向数据绑定：<input type="text" :value="name"><br>
双向数据绑定：<input type="text" v-model="name">
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const x = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: '007',
}
});
</script>
</body>
el与data的两种写法：
- el的两种写法：
- new Vue的时候配置el属性
- 先创建Vue实例，随后再通过vm.$mount(‘#root’)指定el的值
- data的两种写法：
- 对象式
- 函数式（主）
- 由Vue管理的函数一定不能写箭头函数，一旦写了箭头那么this就不再是Vue实例
<body>
<div id="root">
<h1>你好，{{name}}</h1>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
//el的两种写法
const v = new Vue({
//第一种
el: '#root',
data:{
name: '007'
}
});
//第二种写法
v.$mount('#root');
//data的两种写法
new Vue({
el:'root',
//第一种
data:{
name:'007'
}
//第二种
data(){
console.log('@',this);//this是Vue实例对象
return{
name:'007'
}
}
});
</script>
</body>
MVVM模型：
- data中所有属性，最后都出现在了vm身上（即vm里面有什么插值语法就能写什么）
- vm身上所有属性及Vue原型（-proto-）上所有属性，在Vue模板中都可以直接使用。
数据代理：
-
**回顾Object.defineProperty()方法：(数据劫持、数据代理都用到这个方法)**给对象添加属性，给对象定义属性
- 在下面这个例子中，通过改变number变量改变对象属性靠getter，直接改变对象属性靠setter
<script type="text/javascript"> let number = 18; let person = { name:"007", sex:"男" //age:18 这里的age无法枚举 } Object.defineProperty(persoon,'age',{ //四个基本配置项 value:18, enumberable: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("已经被修改", value); number = value; } }) </script> -
数据代理：通过一个对象代理对另外一个对象中的属性的操作（读/写）
- Vue中的数据代理：
- 通过vm对象来代理data对象中属性的操作（读/写）
- Vue中数据代理的好处：
- 更加方便地操作data中的数据
- 基本原理：
- 通过Object.defineProperty()把data对象中所有属性添加到vm上，为每一个添加到vm上的属性都指定一个getter/setter，在getter和setter内部去操作（读/写）data中对应的属性
- Vue中的数据代理：
<script>
let obj1 = {x:10};
let obj2 = {y:20};
Object.defineProperty(obj2, "x", {
get(){
return obj1.x;
},
set(value){
obj1.x = value;
}
});
</script>
事件处理
事件的基本使用：
-
使用v-on: xxx 或者 @xxx 绑定事件，其中xxx是事件名
-
事件的回调需要配置在methods对象中，最终会在vm上
-
methods中配置的的函数，不要用箭头函数，否则this就不是vm了
-
method中配置的函数，都是被Vue管理的，this指向vm或组件对象实例
-
@click="demo"和@click="demo($event)"效果相同，但后者可以传参
如果事件绑定里面的事件不写小括号表示传的参数为$event,如果小括号里面有值则表示该值的调用事件
@click="demo" @click="demo(event)" //两者一样 @click="demo(n)" //表示调用n值产生的事件
<body>
<!-- 容器 -->
<div id="root">
<h1>测试</h1>
<button v-on:click="showInfo1">点击弹出信息1(不传参)</button>
<button v-on:click="showInfo2($event, 66)">点击弹出信息(传参)</button>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: '007',
},
methods:{
showInfo1(events) {
alert("你好！");
},
showInfo2(events,number) {
alert("你好！");
console.log(number);
}
}
});
</script>
</body>
Vue中的事件修饰符：
- prevent: 阻止默认事件
- stop：阻止事件冒泡
- once：事件只能触发一次
- capture：使用事件的捕获模式
- self：只有event.target是当前操作元素时才触发事件
- passive：事件的默认行为立即执行，无需等待事件回调执行完毕
事件修饰符是可以连续写的。
<style>
*{
margin-top: 20px;
}
.demo1{
height: 50px;
background-color: skyblue;
}
.box1{
padding: 5px;
background-color: skyblue;
}
.box2{
padding: 5px;
background-color: orange;
}
.list{
width: 200px;
height: 200px;
background-color: peru;
overflow: auto;
}
li{
height: 100px;
}
</style>
<body>
<!-- 容器 -->
<div id="root">
<h1>测试</h1>
<!-- 默认点击弹到链接页面 prevent阻止默认事件-->
<a href="http://www.baidu.com" @click.prevent="showInfo">点我提示信息</a>
<!-- 阻止事件冒泡（常用） -->
<div class="demo1" @click="showInfo">
<button @click.stop="showInfo">点我提示信息</button>
<!-- 修饰符可以连续写 -->
<!-- <a href="http://www.baidu.com" @click.prevent.stop="showInfo">点我提示信息</a> -->
<!-- 事件只触发一次（常用） -->
<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="showInfo">点我提示信息</button>
</div>
<!-- 事件的默认行为立即执行，无需等待事件回调执行完毕； -->
<!-- wheel鼠标滚轮事件 -->
<ul @wheel.passive="demo" class="list">
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
</ul>
</div>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: '007',
},
methods:{
showInfo(events) {
alert("你好！");
},
showMsg(number) {
alert("你好！");
console.log(number);
},
demo(){
for (let i = 0; i < 100000; i++) {
console.log('#')
}
console.log('累坏了')
}
}
});
</script>
</body>
键盘事件：
- Vue中常用的按键别名：
- 回车 => enter
- 删除 => delete （捕获“删除”和“退格”键）
- 退出 => esc
- 空格 => space
- 换行 => tab (特殊，必须配合keydown使用，@keydown.huiche=“showInfo” )
- 上 => up
- 下 => down
- 左 => left
- 右 =>right
- Vue中未提供别名的按键，可以使用按键原始的key值去绑定，但要注意转为keybab-case（短横线命名）
- 系统修饰键（用法特殊）：ctrl、alt、shift、meta
- 配合keyup使用：按下修饰键的同时，再按下其他键，随后释放其他键，事件才被触发
- 配合keydown使用：正常触发事件
- 可以使用keyCode去指定具体的按键（不推荐）
- Vue.config.keyCode. 自定义键名 = 键名，可以定制按键别名
<body>
<!-- 容器 -->
<div id="root">
<h1>测试</h1>
<input type="text" @keyup="showInfo">
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root', //el 用于指定当前vue实例为哪个容器服务，值通常为css选择器字符串
data: { //data用于储存数据，数据提供el所指定的容器去使用
name: '007',
},
methods:{
showInfo(e) {
console.log(e.target.value);
}
}
});
</script>
</body>
计算属性
姓名案例
-
插值语法实现
<body> <!-- 容器 --> <div id="root"> 姓：<input type="text" v-model="familyName"> 名：<input type="text" v-model="name"> 姓名：<span>{{familyName + name}}</span> </div> <script type="text/javascript"> Vue.config.productionTip = false; //创建vue实例 const vm = new Vue({ el: '#root', data: { name: '北漂', familyName:"沈" } }); </script> </body> -
methods方法实现
<body> <!-- 容器 --> <div id="root"> 姓：<input type="text" v-model="familyName"> 名：<input type="text" v-model="name"> 姓名：<span>{{fullName()}}</span> </div> <script type="text/javascript"> Vue.config.productionTip = false; //创建vue实例 const vm = new Vue({ el: '#root', data: { name: '北漂', familyName:"沈" }, methods:{ fullName() { return this.familyName + " " + this.name; } } }); </script> </body> -
计算属性实现
- 定义：要用的属性不存在，要通过已有的属性计算得来
- 原理：底层借助了Object.defineProperty方法提供的getter和setter
- get函数什么时候执行：
- 初次读取时会执行一次
- 当依赖的数据发生改变时会被再次调用
- 优势：与methods实现相比，内部有缓存机制（复用），效率更高，调试方便
- 计算属性最终会出现在vm上，直接读取使用即可
- 如果计算属性要被修改，那必须写在set函数去响应修改，且set中要引起计算时依赖的数据发生变化
<body> <!-- 容器 --> <div id="root"> 姓：<input type="text" v-model="familyName"> 名：<input type="text" v-model="name"> 姓名：<span>{{fullName}}</span> </div> <script type="text/javascript"> Vue.config.productionTip = false; //创建vue实例 const vm = new Vue({ el: '#root', data: { name: '北漂', familyName:"沈" }, computed: { //完整写法 fullName: { //get的作用：当读取fullName时，get被调用，且返回值作为fullName的值 //get什么时候被调用：1.初次读取fullName时 2.所依赖的数据发生变化时 get(){ console.log("get被调用"); return this.familyName + this.name; }, //set什么时候被调用？ 当fullName被修改时 set(value) { console.log('set', value); const arr = value.split('-'); this.familyName = arr[0]; this.name = arr[1]; } } //简写 确定只读取不修改（只有get没有set） /* fullName() { console.log('get被调用了'); return this.familyName + '-' + this.name; } */ } }); </script> </body>
当你想要在模板中的多处包含此翻转字符串时，就会更加难以处理。所以，对于任何复杂逻辑，你都应当使用计算属性。
计算属性缓存与方法的比较
我们可以将一个函数定义为计算属性或者方法。计算属性是基于它们的的响应式依赖进行缓存的，只在相关响应式依赖发生改变时才会重新求值。相比之下，每当触发重新渲染时，调用方法会再次执行函数。
我们为什么需要缓存？
假设我们有一个性能开销比较大的计算属性A，它需要遍历一个巨大的数组并做大量的计算。然后我们可能有其他的计算属性依赖于A，如果没有缓存，那么我们将不可避免的多次执行A的getter。
监视属性（侦听属性）
天气案例普通实现：
<body>
<!-- 容器 -->
<div id="root">
<h2>今天天气很{{info}}</h2>
<button @click="changeWeather">切换天气</button>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
isHot:true,
},
computed: {
info(){
return this.isHot ? '炎热' : '凉爽';
}
},
methods: {
changeWeather(){
this.isHot = !this.isHot;
}
}
});
</script>
</body>
监视属性实现：
监视属性watch：
- 当被监视的属性发生变化时，回调函数自动调用，进行相关操作
- 当监视属性必须存在时，才能进行监视
- 监视的两种写法
- new Vue时传入watch配置
- 通过vm.$watch监视
<body>
<!-- 容器 -->
<div id="root">
<h2>今天天气很{{info}}</h2>
<button @click="changeWeather">切换天气</button>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
isHot:true,
},
computed: {
info(){
return this.isHot ? '炎热' : '凉爽';
}
},
methods: {
changeWeather(){
this.isHot = !this.isHot;
}
},
//当我们明确要监视什么属性时可以采用这种方法
// watch: {
// isHot:{
// //初始化时让handler调用
// //handler什么时候调用：当isHot发生改变时
// immediate: true,
// handler(newValue,oldValue) {
// console.log("isHot别修改了", newValue, oldValue);
// }
// }
// }
});
vm.$watch('isHot',{
immediate: true,
handler(newValue,oldValue) {
console.log("isHot被修改了", newValue, oldValue);
}
})
</script>
</body>
深度监视
- Vue中的watch默认不监测对象内部值的改变（一层）
- 配置deep:true可以监视对象内部值的改变（多层）
- Vue自身可以监测对象内部值的改变，但Vue提供的watch默认不可以
- 使用watch时根据数据的具体结构来决定是否采用深度监视
<body>
<!-- 容器 -->
<div id="root">
<h3>a的值是：{{numbers.a}}</h3>
<button @click="numbers.a++">点我加一</button>
<h3>b的值是:{{numbers.b}}</h3>
<button @click="numbers.b++">点我让b+1</button>
<button @click="numbers = {a:666,b:888}">彻底替换掉numbers</button>
{{numbers.c.d.e}}
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
isHot:true,
numbers:{
a:1,
b:1,
c:{
d:{
e:100
}
}
}
},
watch:{
//监视多级结构中某个属性的变化
// 'numbers.a':{
// handler(){
// console.log('a被改变了');
// }
// }
//监视多级结构中的所有属性的变化
numbers:{
deep:true,
handler(){
console.log('numbers被改变了');
}
}
}
});
</script>
</body>
监视属性的简写：
如果watch的配置项里面不需要immediate和deep时可以简写
//正常写法
watch:{
isHot:{
handler(){
console.log('改变了'，newValue, oldVlue);
}
}
}
//简写
watch:{
isHot(newValue,oldValue) {
console.log('修改了'，newValue， oldValue);
}
}
vm.$watch('isHot',function(){
console.log('改变了', newValue， oldValue);
})
计算属性与监视属性之间的区别：
- computed能完成的功能，watch都能完成
- watch能完成的功能，computed不一定能完成，例如watch可以进行异步操作
<body>
<!-- 容器 -->
<div id="root">
姓：<input type="text" v-model="familyName">
名：<input type="text" v-model="name">
全名：<span>{{fullName}}</span>
</div>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
familyName:'张',
name:'三',
fullName:'张-三'
},
watch:{
familyName(val){
setTimeout(()=>{
console.log(this);
this.fullName = val + this.name;
},1000);
},
name(val){
this.fullName = this.familyName + val;
}
}
});
</script>
</body>
- 所被Vue管理的函数，最好写成普通函数，这样this的指向才是vm或者组件对象实例
- 所有不被Vue管理的函数（定时器的回调函数、Ajax的回调函数、Promise的回调函数），最好写成箭头函数，这样this的指向才是vm或者组件实例对象
关于handler函数的一些文章：
class与style的绑定
- class样式
- 写法：class=“xxx” xxx可以是字符串、对象、数组
- 字符串适用于：类名不确定，要动态获取
- 对象写法适用于：要绑定多个样式，个数不确定，名字也不确定
- 数组写法适用于：要绑定多个样式，个数确定，名字也确定，但不确定用不用。
- style样式
- :style=“{fontSize: xxx }”, 其中xxx是动态值
- :style="[a,b]"其中a,b是样式对象
- 对象写法、数组写法
<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>初始Vue</title>
<style>
.basic{
width: 400px;
height: 100px;
border: 1px solid black;
}
.happy{
border: 4px solid red;;
background-color: rgba(255, 255, 0, 0.644);
background: linear-gradient(30deg,yellow,pink,orange,yellow);
}
.sad{
border: 4px dashed rgb(2, 197, 2);
background-color: gray;
}
.normal{
background-color: skyblue;
}
.class1{
background-color: yellowgreen;
}
.class2{
font-size: 30px;
text-shadow:2px 2px 10px red;
}
.class3{
border-radius: 20px;
}
</style>
<!-- 引入Vue -->
<script src="../js/vue.js"></script>
</head>
<body>
<!-- 容器 -->
<div id="root">
<!-- 绑定class样式--字符串写法，适用于：样式类名不确定，需要动态指定 -->
<div class="basic" :class="mood" @click="changeMood">{{name}}</div><br/><br/>
<!-- 绑定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>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
name: '007',
mood:'normal',
classArr:['class1','class2','class3'],
classObj:{
class1: false,
class2: false,
},
styleObj:{
fontSize: '40px',
color:'red',
},
styleObj2:{
backgroundColor:'orange'
},
styleArr:[
{
fontSize: '40px',
color:'blue',
},
{
backgroundColor:'gray'
}
]
},
methods:{
changeMood(){
const arr = ['happy', 'sad', 'normal'];
const index = Math.floor(Math.random() * 3);
this.mood = arr[index];
}
},
});
</script>
条件渲染
隐藏div的三种方法
-
div的visibility控制div的隐藏和显示
-
设置display属性，可以是div隐藏后释放占用的空间
-
opacity设置元素透明度为0
<div style="visibility:none"></div> <div style="display:none"></div> <div style="opacity:0"></div>
- v-if
写法：
(1).v-if=“表达式”
(2).v-else-if=“表达式”
(3).v-else=“表达式”
适用于：切换频率较低的场景。
特点：不展示的DOM元素直接被移除。v-if是通过控制DOM节点的存在与否来控制元素的显隐。
注意：v-if可以和:v-else-if、v-else一起使用，但要求结构不能被“打断”。
- v-show
写法：v-show=“表达式”
适用于：切换频率较高的场景。
特点：不展示的DOM元素未被移除，仅仅是通过设置DOM元素的display样式显隐（block显示，none隐藏）
使用v-if的时，元素可能无法获取到，而使用v-show一定可以获取到。
template只能与v-if配合使用，不能和v-show配合，template不影响结构，把template改为div影响结构
<body>
<!-- 容器 -->
<div id="root">
<h2>当前的n值是{{n}}</h2>
<button @click="n++">点击我加一</button>
<h2>v-if的使用</h2>
<h3 v-if="true">好好学习！</h3>
<h3 v-if="false">吃喝玩乐！</h3>
<!-- v-if与template的配合使用 -->
<template v-if="n === 1">
<h2>{{name}}你好！</h2>
</template>
<h2>v-show的使用</h2>
<h3 v-show="false">坚持就是胜利！</h3>
<h3 v-show="n === 2">坚持就是胜利！</h3>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
name:'007',
n:0
}
});
</script>
列表渲染
v-for指令
- 用于展示列表数据
- 语法：v-for=" item in items " :key=“index”
- 可遍历数组、对象、字符串、指定次数
<body>
<!-- 容器 -->
<div id="root">
<h2>人员列表(遍历数组)</h2>
<ul>
<li v-for="item in items" :key="item.id">{{item.message}}</li>
<!-- 可选的第二个参数 索引-->
<li v-for="(item, index) in items" :key="item.id">{{item.message}}----{{index}}</li>
</ul>
<h2>汽车信息(遍历对象)</h2>
<ul>
<li v-for="value in car" :key="i">{{value}}</li>
<!-- 可选的第二个参数 索引-->
<li v-for="(value, index) in car" :key="i">{{value}}----{{index}}</li>
</ul>
<h2>字符串信息(遍历字符串)</h2>
<ul>
<li v-for="(char, index) of str" :key="index">{{char}}-{{index}}</li>
</ul>
<h2>遍历指定整数范围内次数</h2>
<ul>
<li v-for="(number, index) of 10" :key="index">{{number}}-{{index}}</li>
</ul>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
items:[
{id:'001', message:'Hello'},
{id:'002', message:'world'},
],
car:{
name:'奥迪A8',
price:'70万',
color:'黑色'
},
str:'hello',
}
});
</script>
v-for中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，然后渲染到页面。
- key是虚拟DOM对象的标识，当数据发生变化时，vue会根据【新数据】生成【新的虚拟DOM】，随后vue进行【新虚拟DOM】与【旧虚拟DOM】的差异比较，比较规则如下：
- 用index作为key可能会引发的问题：
- 若对数据进行：顺序添加、逆序删除等破坏顺序操作，则会产生没有必要的真实DOM更新，页面效果没影响，但效率低。
- 如果结构中还包含输入类的DOM：会产生错误的DOM更新，界面直接出现问题。
- 开发中如何正确选择key：
- 最好使用每条数据的唯一标识作为key，比如id、手机号、学号等唯一值
- 如果不存在对数据的逆序添加、逆序删除等破坏顺序操作，仅用于渲染列表用于展示，使用index作为key是没有问题的。
<body>
<!-- 容器 -->
<div id="root">
<h2>人员列表(遍历数组)</h2>
<button @click="add">添加一个老刘</button>
<ul>
<li v-for="p in persons" :key="p.id">{{p.name}}---{{p.age}} <input type="text"></li>
</ul>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
persons:[
{id:'001',name:'张三',age:18},
{id:'002',name:'李四',age:19},
{id:'003',name:'王五',age:20}
]
},
methods:{
add(){
const p = {id:'004',name:'007',age:200};
this.persons.unshift(p);
}
}
});
</script>
列表过滤
filter():用于把Array中的某些元素过滤掉，然后返回剩下的元素
’abc‘:indexOf(a) 判断字符串出现的索引位置，没有就返回-1
<body>
<!-- 容器 -->
<div id="root">
<h2>人员列表</h2>
<input type="text" placeholder="请输入名字" v-model="keyWord">
<ul>
<li v-for="p in filPersons" :key="p.id">{{p.name}}---{{p.age}} </li>
</ul>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false;
//创建vue实例
const vm = new Vue({
el: '#root',
data: {
keyWord:'',
persons:[
{id:'001',name:'张三',age:18},
{id:'002',name:'李四',age:19},
{id:'003',name:'王五',age:20}
],
//filPersons: []
},
//watch实现
// watch:{
// keyWord: {
// immediate: true,
// handler(val){
// this.filPersons = this.persons.filter((p)=>{
// return p.name.indexOf(val) !== -1;
// })
// }
// }
// }
//computed实现
computed:{
filPersons(){
return this.persons.filter((p)=>{
return p.name.indexOf(this.keyWord) !== -1;
})
}
}
});
</script>
列表排序
<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="p.id">
{{p.name}}-{{p.age}}
<input type="text">
</li>
</ul>
</div>
<script>
Vue.config.productionTip = false;
new Vue({
el:'#root',
data:{
keyWord:'',
sortType:0,//0原顺序 1降序 2升序
persons:[
{id:'oo1', name:'马冬梅',age:30},
{id:'oo2', name:'周冬雨', age:31},
{id:'o03', name:'周杰伦', age:18},
{id:'o04', name:'温兆伦', age:l9}
]
},
//计算属性
computed:{
filPersons(){
const arr = this.persons.filter((p)=>{
return p.name.indexOf(this.keyWords) !== -1;
})
//判断是否需要排序
if(this.sortType) {
arr.sort((p1,p2) =>{
return this.sortType === 1 ? p2.age - p1.age : p1.age - p2.age;
})
}
return arr;
}
}
});
</script>
</body>
列表更新时的一个问题：Vue里面原本就有一个watch，而侦听属性的watch是给程序员用的。
<body>
<!-- 准备好一个容器-->
<div id="root">
<h2>人员列表</h2>
<button @click="updateMei">更新马冬梅的信息</button>
<ul>
<li v-for="(p,index) of persons" :key="p.id">
{{p.name}}-{{p.age}}-{{p.sex}}
</li>
</ul>
</div>
<script type="text/javascript">
Vue.config.productionTip = false
const vm = new Vue({
el:'#root',
data:{
persons:[
{id:'001',name:'马冬梅',age:30,sex:'女'},
{id:'002',name:'周冬雨',age:31,sex:'女'},
{id:'003',name:'周杰伦',age:18,sex:'男'},
{id:'004',name:'温兆伦',age:19,sex:'男'}
]
},
methods: {
updateMei(){
// this.persons[0].name = '马老师' //奏效
// this.persons[0].age = 50 //奏效
// this.persons[0].sex = '男' //奏效
// this.persons[0] = {id:'001',name:'马老师',age:50,sex:'男'} //不奏效
this.persons.splice(0,1,{id:'001',name:'马老师',age:50,sex:'男'})
}
}
})
</script>
模拟一个Vue数据监测
let data = {
name: '007',
address:'重庆',
};
//创建一个监视的实例对象，用于监视data中属性的变化
const obs = new Observer(data);
console.log(obs);
//准备一个vm实例对象
let vm = {};
vm._data = obs;
function Observer(obj) {
//汇总对象中所有属性形成一个数组
const keys = Object.keys(obj);
//遍历
keys.forEach((k)=>{
Object.defineProperty(this, k, {
get() {
return obj[k];
},
set(value) {
console.log(`${k}被改了`);
obj[k] = value;
}
});
})
}
Vue监测数据改变的原理—对象
<body>
<!-- 准备好一个容器-->
<div id="root">
<h2>学校名称：{{name}}</h2>
<h2>学校地址：{{address}}</h2>
</div>
</body>
<script type="text/javascript">
Vue.config.productionTip = false //阻止 vue 在启动时生成生产提示。
const vm = new Vue({
el:'#root',
data:{
name:'尚硅谷',
address:'北京',
student:{
name:'tom',
age:{
rAge:40,
sAge:29,
},
friends:[
{name:'jerry',age:35}
]
}
}
})
</script>
Vue.set()的使用
<body>
<div id="root">
<h1>学校信息</h1>
<h2>学校名称：{{name}}</h2>
<h2>学校地址：{{address}}</h2>
<h2>校长是：{{leader}}</h2>
<hr/>
<h1>学生信息</h1>
<button @click="addSex">添加一个性别属性，默认值是男</button>
<h2>姓名：{{student.name}}</h2>
<h2 v-if="student.sex">性别：</h2>
<h2>年龄：真实{{student.age.rAge}}, 对外：{{student.age.sAge}}</h2>
<h2>朋友们</h2>
<ul>
<li v-for="(f, index) in student.friends" :key="index">
{{f.name}}---{{f.age}}
</li>
</ul>
</div>
<script type="text/javascript">
const vm = new Vue({
el:'#root',
data:{
school:{
name: '尚硅谷',
address:'北京',
},
student:{
name: '007',
age:{
rAge:40,
sAge:35,
},
friends:[
{name: 'John', age:34},
{name: 'Jack', age:24}
]
}
},
methods:{
addSex(){
this.$set(this.student, 'sex', '男')；
}
}
});
</script>
</body>
Vue监测数据改变的原理—数组
- 在Vue中修改数组中的某个元素一定要使用如下方法：
- 使用API：push()、pop()、shift()、unshift()、splice()、sort()、reverse()
- Vue.set()或vm.$set()
<body>
<!-- 准备好一个容器-->
<div id="root">
<h1>学校信息</h1>
<h2>学校名称：{{school.name}}</h2>
<h2>学校地址：{{school.address}}</h2>
<h2>校长是：{{school.leader}}</h2>
<hr/>
<h1>学生信息</h1>
<button @click="addSex">添加一个性别属性，默认值是男</button>
<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>
</body>
<script type="text/javascript">
Vue.config.productionTip = false //阻止 vue 在启动时生成生产提示。
const vm = new Vue({
el:'#root',
data:{
school:{
name:'尚硅谷',
address:'北京',
},
student:{
name:'tom',
age:{
rAge:40,
sAge:29,
},
hobby:['抽烟','喝酒','烫头'],
friends:[
{name:'jerry',age:35},
{name:'tony',age:36}
]
}
},
methods: {
addSex(){
// Vue.set(this.student,'sex','男')
this.$set(this.student,'sex','男')
}
}
})
</script>
总结Vue数据监测
Vue监测数据的原理：
- Vue会监视data中所有层次的数据
- 如何监测对象中的数据？
- 通过setter实现监视，且要在new Vue时就传入要监测的数据
- 对象中后追加的属性，Vue默认不做响应式处理
- 如需给后追加的属性做响应式，请使用API：Vue.set(target, propertyName/index, value) 或者 vm.$set(target,propertyName/index, value)
- 通过setter实现监视，且要在new Vue时就传入要监测的数据
- 如何监测数组中的数据？
- 通过包裹数组更新元素的方法实现，本质就是做了两件事：
- 调用原生对应的方法对数组实现更新
- 重新解析模板，进而更新页面
- 通过包裹数组更新元素的方法实现，本质就是做了两件事：
- 在Vue中修改数组中的某个元素一定要用如下方法：
- 使用API：push()、pop()、shift()、unshift()、splice()、sort()、reverse()
- Vue.set()或vm.$set() — 不能给vm或者vm的根数据对象添加属性
<body>
<div id="root">
<h1>学生信息</h1>
<button @click="student.age++">年龄+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/>
<button @click="removeSmoke">过滤掉爱好中的抽烟</button> <br/>
<h3>姓名：{{student.name}}</h3>
<h3>年龄：{{student.age}}</h3>
<h3 v-if="student.sex">性别：{{student.sex}}</h3>
<h3>爱好：</h3>
<ul>
<li v-for="(h,index) in student.hobby" :key="index">
{{h}}
</li>
</ul>
<h3>朋友们：</h3>
<ul>
<li v-for="(f,index) in student.friends" :key="index">
{{f.name}}--{{f.age}}
</li>
</ul>
</div>
<script type="text/javascript">
const vm = new Vue({
el:'#root',
data:{
student:{
name:'tom',
age:18,
hobby:['抽烟','喝酒','烫头'],
friends:[
{name:'jerry',age:35},
{name:'tony',age:36}
]
}
},
methods: {
addSex(){
// Vue.set(this.student,'sex','男')
this.$set(this.student,'sex','男')
},
addFriend(){
this.student.friends.unshift({name:'jack',age:70})
},
updateFirstFriendName(){
this.student.friends[0].name = '张三'
},
addHobby(){
this.student.hobby.push('学习')
},
updateHobby(){
// this.student.hobby.splice(0,1,'开车')
// Vue.set(this.student.hobby,0,'开车')
this.$set(this.student.hobby,0,'开车')
},
removeSmoke(){
this.student.hobby = this.student.hobby.filter((h)=>{
return h !== '抽烟'
})
}
}
});
</script>
</body>
相关文章
Vue监测数据变化（包括数组）的原理
Vue学习看这篇就够
vue 数据变化侦测原理详解（Object篇）
vue 数据变化侦测原理详解（Array篇）
5355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
