WEBVTT

00:00:05.140 --> 00:00:08.460
你这个连接不了吗

00:00:08.460 --> 00:00:14.510
第三个

00:00:14.510 --> 00:00:20.460
那是第三个吧

00:00:20.460 --> 00:00:22.220
这个可能网段不一样

00:00:22.220 --> 00:00:25.340
把这个发给大家

00:00:25.340 --> 00:00:37.440
还有的是这个录像

00:00:37.440 --> 00:00:38.640
昨天我们看一下

00:00:38.640 --> 00:00:40.240
你可以在这个平台上

00:00:40.240 --> 00:00:41.360
它有一个复习

00:00:41.360 --> 00:00:42.700
可以看这个录像

00:00:42.700 --> 00:00:44.020
对

00:00:44.020 --> 00:00:45.800
但是有个问题是在于

00:00:45.800 --> 00:00:48.000
它录上的声音

00:00:48.000 --> 00:00:50.060
是有画面

00:00:50.060 --> 00:00:53.220
昨天我们看了一下

00:00:53.220 --> 00:00:57.180
这要声音的话

00:00:57.180 --> 00:00:59.920
可能你们在现场去准备一个设备

00:00:59.920 --> 00:01:00.580
去录一下

00:01:00.580 --> 00:01:09.110
会议

00:01:09.110 --> 00:01:11.990
我好像没有这个东西

00:01:11.990 --> 00:01:21.540
我这没有腾讯会议

00:01:21.540 --> 00:02:03.700
然后呢

00:02:03.700 --> 00:02:08.280
我们可以进入下一步

00:02:08.280 --> 00:02:10.480
它这个页面呢

00:02:10.480 --> 00:02:12.280
就是直接输出了一个hello world

00:02:12.280 --> 00:02:13.360
很简单

00:02:13.360 --> 00:02:19.000
下一个步就是我们可以根据这个来做一下

00:02:19.000 --> 00:02:22.120
看看什么样是什么叫做声明式渲染

00:02:22.120 --> 00:02:28.280
我们现在就看到这是一个单文件组件

00:02:28.280 --> 00:02:31.400
单文件组件什么叫单文件组件

00:02:31.400 --> 00:02:34.200
它就是以vue结本的一个文件

00:02:34.200 --> 00:02:39.000
它里面包含了一个浏览器元素

00:02:39.000 --> 00:02:42.200
所有要渲染出来的所有必要的条件

00:02:42.200 --> 00:02:45.800
就是template跟JavaScript跟CSS

00:02:47.000 --> 00:02:51.560
提供这相应的元素之后

00:02:52.360 --> 00:02:56.760
vue就可以把vue.vue文件编译成相应浏览器

00:02:56.760 --> 00:02:59.840
可以识别的HTML JS跟CSS

00:03:01.640 --> 00:03:09.440
然后我们可以跟着这边做一个简单的练习

00:03:09.440 --> 00:03:20.900
然后可以怎么样让它去动态的显示一个数字的增减

00:03:20.900 --> 00:03:23.520
大家可以试试

00:03:23.520 --> 00:03:25.360
这边是可以编辑的

00:03:25.360 --> 00:03:26.460
这边是可以编辑的

00:03:26.460 --> 00:03:27.980
直接可以在自己电脑上编辑

00:03:27.980 --> 00:04:25.930
这边下面有一个按钮

00:04:25.930 --> 00:04:29.770
这个可以点击一下看答案

00:04:29.770 --> 00:04:35.150
然后右边这个也会变成实际的一个答案

00:04:35.150 --> 00:04:37.550
下面会输出这个内容

00:04:38.950 --> 00:04:40.350
然后可以再点一下

00:04:40.350 --> 00:04:42.270
就会变成之前的题目

00:04:42.630 --> 00:04:44.190
然后可以这样去对比

00:04:44.470 --> 00:04:45.310
对比看一下

00:04:45.550 --> 00:05:40.430
我已经看到这个很简单

00:05:40.430 --> 00:05:43.910
分页一个

00:05:43.910 --> 00:05:45.070
然后直接就用了

00:05:45.910 --> 00:05:48.190
就把昨天我们要做的那种

00:05:48.190 --> 00:05:50.190
传承H5的这个步骤

00:05:50.270 --> 00:05:51.150
简化了很多

00:05:51.830 --> 00:05:54.030
这个大件有理解吧

00:05:54.030 --> 00:05:54.670
有概念吗

00:05:55.470 --> 00:05:56.030
能理解吗

00:05:56.030 --> 00:05:57.030
这块也没问题

00:05:57.790 --> 00:05:58.510
能不能理解

00:05:58.510 --> 00:06:00.110
这块还是比较

00:06:00.110 --> 00:06:13.240
然后容易理解,那就是我们看这个tablet,现在这个tablet就多了一个叫square,这个是tablet,

00:06:13.240 --> 00:06:31.130
tablet如果有的话,它就有一个gen,一个view,每个view文件都基本上都有,有的可能只有tablet,

00:06:31.130 --> 00:06:39.130
square加上它所在的那个gen才有什么能力,但是最多就是这半块,一般不会有其他的东西,

00:06:39.130 --> 00:06:41.690
这其他有其他东西也不会被选择,

00:06:41.690 --> 00:06:44.890
那就是这个语法呀,

00:06:44.890 --> 00:06:49.130
这个现在这个你们看这边叫script setup,

00:06:49.130 --> 00:06:51.130
那其实还有别的语法,

00:06:51.130 --> 00:06:54.730
因为我们都知道我们现在是在vue3了,

00:06:54.730 --> 00:06:57.130
vue2还有其他的一些语法,

00:06:57.130 --> 00:06:59.130
我们各位不用关心,

00:06:59.130 --> 00:07:03.730
我们现在只专注于现在vue3版本的语法就可以了,

00:07:03.730 --> 00:07:07.530
就是这个script setup这个代码块,

00:07:07.530 --> 00:07:11.990
如果这一块声明是渲染

00:07:11.990 --> 00:07:14.290
我们没有问题了

00:07:14.290 --> 00:07:17.990
那我们就进入下一个课程

00:07:17.990 --> 00:07:26.090
我们要去绑定这个属性

00:07:26.090 --> 00:07:29.950
我们要去把这个转出来

00:07:29.950 --> 00:07:33.430
我们现在就是看这个字是个黑色的

00:07:33.430 --> 00:07:39.850
我们定义了一个CSS

00:07:39.850 --> 00:07:42.810
然后它是个红色

00:07:42.810 --> 00:07:46.810
我们怎么样去把这个在vue里面怎么样去把这个

00:07:46.810 --> 00:07:49.810
make me ride变成红色呢

00:07:49.810 --> 00:07:51.410
大家可以尝试一下

00:07:51.410 --> 00:07:52.630
也可以看答案

00:07:52.630 --> 00:07:54.410
然后左边右边对比都可以

00:07:54.410 --> 00:09:14.320
我看到有同学已经传出了

00:09:14.320 --> 00:09:20.420
有没有问题

00:09:20.420 --> 00:09:24.480
这块是可能一开始接触比较肉

00:09:24.480 --> 00:09:26.220
包括前面前面一颗

00:09:26.220 --> 00:09:29.100
这个动态声明这一块

00:09:29.100 --> 00:09:32.920
这块理解了6这边就比较容易入门了

00:09:32.920 --> 00:09:35.460
给大家一个提问

00:09:35.460 --> 00:09:39.440
然后我们现在要在这个

00:09:39.440 --> 00:09:42.720
make me write的后面加一个数字

00:09:42.720 --> 00:09:46.520
比如说我们要加一个数字666

00:09:46.520 --> 00:09:51.580
我们用动态声明的方式去加一下看看

00:09:51.580 --> 00:09:55.720
结合上一课我们学到的那个例子

00:09:55.720 --> 00:09:57.000
当然不能

00:09:57.000 --> 00:10:07.130
然后666等会我们也可以改成一个别的什么数字

00:10:07.130 --> 00:10:09.170
你们也可以就上一步发到上一课

00:10:09.170 --> 00:10:11.930
如果说还没太清楚的话

00:10:11.930 --> 00:10:13.130
看一看上一课内容

00:10:13.130 --> 00:10:17.690
然后想清楚之后再回来

00:10:17.690 --> 00:10:19.010
然后再添加修改

00:10:19.010 --> 00:16:27.000
这个概念可能不是太好理解

00:16:27.000 --> 00:16:28.660
我们慢慢来不要着急

00:16:28.660 --> 00:16:35.600
这个思路我们主要是用它来了解这个思路

00:16:35.600 --> 00:16:43.430
第一个是第一个那个就是我们要怎么样去动态去声明

00:16:43.430 --> 00:16:48.000
比如说我们要显示666的话

00:16:48.000 --> 00:16:54.700
我们就这边就是要声明一个666

00:16:54.700 --> 00:17:04.680
然后那个这样去去去去展示通过双花括号去把它引用过来

00:17:04.680 --> 00:17:09.200
关键点就是第一定义定义

00:17:09.200 --> 00:17:10.580
我们要首先定义

00:17:10.580 --> 00:17:12.480
如果说是常数的话

00:17:12.480 --> 00:17:14.820
比如说string或者说这个number

00:17:14.820 --> 00:17:16.980
我们可以不用定义直接写

00:17:16.980 --> 00:17:18.060
如果说是del

00:17:18.060 --> 00:17:19.820
或者其他的东西

00:17:19.820 --> 00:17:21.320
或者其他的complement

00:17:21.320 --> 00:17:22.300
我们要先定义

00:17:22.300 --> 00:17:24.100
定义了之后

00:17:24.100 --> 00:17:25.600
用这个ief API

00:17:25.600 --> 00:17:27.500
ief就是reference

00:17:27.500 --> 00:17:28.720
就是参考参照

00:17:28.720 --> 00:17:32.180
去把它引用进来

00:17:32.180 --> 00:17:34.000
引用进来

00:17:34.000 --> 00:17:38.360
然后再去用花库号绑定

00:17:38.360 --> 00:17:43.610
然后这一课其实还有另一个知识点

00:17:43.610 --> 00:17:44.550
就是绑定属性

00:17:44.550 --> 00:17:48.490
我们看到这个title class

00:17:48.490 --> 00:17:51.450
它是一个实际上是一个css

00:17:51.450 --> 00:17:54.450
我们肯定不能把它放到这个

00:17:54.450 --> 00:17:56.470
H1或者P标签里面

00:17:56.470 --> 00:17:58.810
把它打印出来给用户看

00:17:58.810 --> 00:17:59.350
没有意义

00:17:59.350 --> 00:18:03.950
我们要把它绑定到这个H1的class上去

00:18:03.950 --> 00:18:04.730
怎么绑定呢

00:18:04.730 --> 00:18:06.490
关键字就是前面有个冒号

00:18:06.490 --> 00:18:10.020
它实际上是呢

00:18:10.020 --> 00:18:14.260
正常的也不是正常的语法

00:18:14.260 --> 00:18:16.020
就是说应该是vue

00:18:16.180 --> 00:18:18.420
前面是个vue是个v横杠

00:18:18.420 --> 00:18:19.500
然后class

00:18:20.180 --> 00:18:24.700
然后这样写就是书写很麻烦

00:18:24.700 --> 00:18:26.900
所以说vue提供了这么个语法堂

00:18:27.940 --> 00:18:31.900
就是用冒号可以把前面v横杠简化掉

00:18:32.060 --> 00:18:35.060
就冒号class或者冒号bond

00:18:35.300 --> 00:18:38.660
或者冒号id相当于vue-id

00:18:38.660 --> 00:18:44.180
这个就是一个绑定的一块

00:18:45.220 --> 00:18:47.700
绑定属性跟声明

00:18:47.700 --> 00:18:53.980
然后我们看看我们轮到现在我们能展示数字了

00:18:53.980 --> 00:18:55.180
能展示文字了

00:18:56.700 --> 00:18:59.940
昨天我们做了addListenerEvent这个东西

00:19:02.240 --> 00:19:04.320
我们怎么样去监听用户点击

00:19:05.160 --> 00:19:06.040
用view来做

00:19:06.920 --> 00:19:08.280
就是这一块内容

00:19:08.280 --> 00:19:09.840
大家看试一下

00:19:09.840 --> 00:19:14.410
在用户点击之后

00:19:14.410 --> 00:19:16.450
它数字会跳

00:19:16.450 --> 00:19:20.690
对大家也可以看答案

00:19:20.690 --> 00:19:23.930
然后重置来尝试一下

00:19:23.930 --> 00:20:14.550
我们就是先看这里

00:20:14.550 --> 00:20:17.770
我们刚才大家可能已经看过答案

00:20:17.770 --> 00:20:19.050
然后尝试过

00:20:19.050 --> 00:20:21.070
然后重点就是

00:20:21.070 --> 00:20:23.270
我们要消明

00:20:23.270 --> 00:20:24.150
也是一样

00:20:24.150 --> 00:20:25.430
不然就消明一个

00:20:25.430 --> 00:20:28.870
抗的变量

00:20:28.870 --> 00:20:30.670
保存的

00:20:30.670 --> 00:20:33.170
我们这个名字的词我们后面的语录

00:20:34.170 --> 00:20:36.670
然后我们又定义了一个

00:20:36.670 --> 00:20:37.170
一个呢

00:20:37.170 --> 00:20:38.470
它是一个方法

00:20:39.670 --> 00:20:41.970
它用方法原来做了那个就是抗核

00:20:41.970 --> 00:20:43.170
使用Value加加

00:20:44.780 --> 00:20:45.980
这个Value是哪来的

00:20:46.880 --> 00:20:48.780
这个Value就是要分

00:20:49.580 --> 00:20:51.480
IF和这个KPI

00:20:51.980 --> 00:20:52.980
这些分数呢

00:20:53.580 --> 00:20:54.280
它就会

00:20:55.080 --> 00:20:56.280
你可以看到的是一个Value

00:20:56.280 --> 00:20:56.980
这个Value呢

00:20:58.880 --> 00:21:00.280
这个Value是一个固定的

00:21:00.280 --> 00:21:02.280
就是你只要用IF去定义了

00:21:02.280 --> 00:21:03.280
它就会有这个Value

00:21:03.680 --> 00:21:33.660
他才有可能,然后呢,这个软柱是对应了他的真实值,我们当对这个软柱进行更改,包括加加或者读不上重新复制的话,这个操作就会标记这个我们之前提过那个我手中,这个操作就是会要告诉你,这种卧槽都已经变大了,去一下,它其实就相当于一个,嗯,它实际上你可以理解为它实际上是一个

00:21:33.680 --> 00:21:52.680
背后是一个方向,它是一个方向,然后呢,对它做操作之后,它会在背后呢,对这个系统内做一些操作,包括这个标记这个对应的变量,这个已经需要更新了。

00:21:52.680 --> 00:22:01.680
下一个是一个固定的方法

00:22:01.680 --> 00:22:06.680
以后就是可以直接这样

00:22:06.680 --> 00:22:09.680
比如说这边是个IF

00:22:09.680 --> 00:22:12.680
你想把它让我们有一个

00:22:12.680 --> 00:22:17.340
靠导温托论的去修改这个值

00:22:17.340 --> 00:22:19.340
然后我们就需要把它去

00:22:19.340 --> 00:22:21.340
首先就是我们要展示这个值

00:22:51.340 --> 00:22:58.340
然后点击的方式让大家能不能理解

00:22:58.340 --> 00:23:03.740
有些东西可能就是他没有什么背后一个原理

00:23:03.740 --> 00:23:05.940
或者什么就是需要符记了

00:23:05.940 --> 00:23:11.520
比如说这个就像我们比如说写账码

00:23:11.520 --> 00:23:12.880
负药这些东西

00:23:12.880 --> 00:23:13.880
它就是关键字

00:23:13.880 --> 00:23:16.640
你要用vue框架

00:23:16.640 --> 00:23:17.640
它就是这么定义的

00:23:17.640 --> 00:23:18.760
你就必须这样用

00:23:18.760 --> 00:23:22.560
都是vue提供的这块能力

00:23:22.560 --> 00:23:25.400
就是让我们再看

00:23:25.400 --> 00:23:27.840
原来这是vue的版本

00:23:27.840 --> 00:23:30.400
如果说我们昨天按照我们昨天的思路

00:23:30.400 --> 00:23:32.120
写15个版本

00:23:32.120 --> 00:23:33.380
它应该比较多

00:23:33.380 --> 00:23:35.160
而是不是我们这要加1.1

00:23:35.160 --> 00:23:37.000
加1.1

00:23:37.000 --> 00:23:40.240
然后在那个script

00:23:40.240 --> 00:23:41.580
这些我们写上

00:23:41.580 --> 00:24:00.990
是不是就是步骤要比这个多

00:24:00.990 --> 00:24:01.490
非常多

00:24:01.490 --> 00:24:01.790
对吧

00:24:01.790 --> 00:24:05.770
所以说这是vue就带来一个便利性

00:24:05.770 --> 00:24:12.990
另外就是还有一个大家应该也发现了

00:24:12.990 --> 00:24:14.310
那我点击了之后

00:24:14.310 --> 00:24:18.190
它自动就会变成更新到5678

00:24:18.190 --> 00:24:19.330
就自动会反应

00:24:19.330 --> 00:24:21.250
这就是刚才我们说的

00:24:21.250 --> 00:24:26.170
那个动态渲染

00:24:26.170 --> 00:24:27.990
也不是动态渲染

00:24:27.990 --> 00:24:30.870
就是实时反馈用户的修改

00:24:30.870 --> 00:24:34.370
这个是怎么做到的

00:24:34.370 --> 00:24:36.470
如果说我们用H5

00:24:36.470 --> 00:24:37.670
是不是应该去

00:24:38.970 --> 00:24:40.570
get还是一样

00:24:40.570 --> 00:24:42.970
这个就是我们这个h5

00:24:43.470 --> 00:24:44.770
h5的话就是

00:24:50.100 --> 00:24:51.900
是不是我们有一个idea

00:24:52.400 --> 00:24:54.700
然后h5要改的话就是

00:25:06.370 --> 00:25:08.570
然后这边我们就会用这个

00:25:09.070 --> 00:25:19.430
对吧然后

00:25:19.830 --> 00:25:20.430
这是

00:25:21.230 --> 00:25:23.530
如果我们要改这个button的

00:25:24.930 --> 00:25:26.630
内容就会inner

00:25:28.030 --> 00:25:28.630
text

00:25:28.630 --> 00:25:58.440
然后再加上一个,在前面看到还有一个变量,这一块就是H5,对吧,用户点了之后,

00:25:58.440 --> 00:26:09.440
当然我已经把那个add event listener已经简化掉了,实际上应该还更多,还要多长时间,这是H5,

00:26:09.440 --> 00:26:15.310
那这就是这个view为什么不用这么费劲

00:26:15.310 --> 00:26:21.730
它就可以展示出来当前这个content的值呢

00:26:21.730 --> 00:26:27.190
就是因为我们刚才提到这个dota声明

00:26:27.190 --> 00:26:29.150
以及那个绑定

00:26:29.150 --> 00:26:36.510
我们在这更新了这个value了

00:26:36.510 --> 00:26:39.550
然后通知这个view系统框架

00:26:39.550 --> 00:26:41.930
我们这个content的值修改了

00:26:41.930 --> 00:27:14.130
然后他在渲染这一块呢,他就会找到所有用到这个Count的这个元素,然后自动去把这个值去反映上,反映到这个元素上,这一块是可以理解的吧,所以说他这边就是比H5简化掉了这个AddEventListener跟一个InternetText,包括取这个元素的一个步骤,没有什么问题。

00:27:14.810 --> 00:27:17.810
没有问题,我们继续下一格。

00:27:17.810 --> 00:27:29.240
那进一步就是说我们要来去看看怎么样去绑定一些表单元素了。

00:27:29.240 --> 00:27:35.240
我们现在就是要获取用户的输入,

00:27:35.240 --> 00:27:39.550
我们可以看这道题,

00:27:39.550 --> 00:27:42.550
怎么样去获取在下面,

00:27:42.550 --> 00:27:44.550
比如说用户输入hello world,

00:27:44.550 --> 00:27:47.550
然后能向对应的去给他展示出来呢?

00:27:47.550 --> 00:28:29.930
输入的内容之后呢,它会在项目里面比较偏向把它下面的显示出来。

00:28:29.930 --> 00:28:35.930
输入的时候呢,这是我们通过上几个课程,上几个练习学到的内容。

00:28:35.930 --> 00:28:47.980
通过IF,然后练习了一个方法,然后把它用户输入的时候,把它这个显示的内容绑到这个判词。

00:28:47.980 --> 00:29:10.090
Vue又提供了一个关键词叫Model,其实就是一个双向绑定,你用这个关键词,它就把你自动上传了Tax.Vue导入一个什么东西的方式,

00:29:10.090 --> 00:29:13.090
它就系统内置了,

00:29:13.090 --> 00:29:17.090
然后你们这关键字之后呢,

00:29:17.090 --> 00:29:19.090
它就自动会上传了,

00:29:19.090 --> 00:29:27.640
会自动帮你把那个Value等于那个,

00:29:27.640 --> 00:29:30.640
那个元素那个属性给你写上,

00:29:30.640 --> 00:29:35.640
就是这个Value等于和这个RM input,

00:29:35.640 --> 00:29:41.640
全部由那个VModel那个关键字自动生成了,

00:29:41.640 --> 00:29:43.640
你又不需要去再写了,

00:29:43.640 --> 00:29:49.780
这样整个办法又一步化

00:29:49.780 --> 00:30:01.530
另一个开启的时候

00:30:01.530 --> 00:30:03.170
这个开始的时候做更新

00:30:03.170 --> 00:30:04.770
更新的内容呢

00:30:04.770 --> 00:30:05.890
要显示到这个

00:30:05.890 --> 00:30:12.360
他也要去在这个批标签上去

00:30:12.360 --> 00:30:15.660
这样就是更进一步的去简化

00:30:15.660 --> 00:30:17.880
这个view的这个操作

00:30:17.880 --> 00:30:21.080
这款是前面如果几步没有问题的话

00:30:21.080 --> 00:30:24.440
这个应该也是很容易理解了

00:30:24.440 --> 00:30:26.520
那我们下一步

00:30:26.520 --> 00:30:29.960
下一步就是条件渲染

00:30:29.960 --> 00:30:31.160
这个就很好理解了

00:30:31.160 --> 00:30:34.960
就是我们就是vue里面的if

00:30:34.960 --> 00:30:39.200
我们不仅可以在那个jar script

00:30:39.200 --> 00:30:40.200
代码里面写if

00:30:40.200 --> 00:30:42.360
我们也可以在这个template

00:30:42.360 --> 00:30:46.680
就是html这个页面上

00:30:46.680 --> 00:30:47.560
也可以写if

00:30:47.560 --> 00:30:50.320
它这个

00:30:50.320 --> 00:31:11.620
这个其实就是个vue模板内的一个代码条件判断

00:31:11.620 --> 00:31:14.820
这个东西也是比较有用的

00:31:14.820 --> 00:31:19.120
比如说在我们判断用户状态

00:31:19.120 --> 00:31:26.140
就是用户的是否验证身份是否已经登录过了

00:31:26.140 --> 00:31:27.900
有权限访问某些页面的时候

00:31:27.900 --> 00:31:30.240
我们实际上可以用这个v1

00:31:30.240 --> 00:31:31.040
v2

00:31:31.040 --> 00:31:32.880
如果他登录了

00:31:32.880 --> 00:31:36.480
我们就让他访问这个页面实际内容

00:31:36.480 --> 00:31:37.400
如果说没有登录

00:31:37.400 --> 00:31:40.220
我们显示一个文字告诉他没有登录

00:31:40.220 --> 00:31:41.500
让他去登录

00:31:41.500 --> 00:31:44.320
这个是比较一个典型的用法

00:31:44.320 --> 00:31:46.400
这块没有问题

00:31:46.400 --> 00:31:47.840
我们就下一步

00:31:47.840 --> 00:31:54.900
这个实际上就是去看怎么样去渲染一个列表

00:31:54.900 --> 00:31:56.820
我们现在有这个了

00:31:56.820 --> 00:31:58.540
那我们要怎么样渲染它呢

00:31:58.540 --> 00:31:59.880
有什么方法吗

00:31:59.880 --> 00:32:02.560
我们有既然我们有了if else了

00:32:02.560 --> 00:32:03.840
是不是也有for

00:32:03.840 --> 00:32:12.100
或者说这个就是怎么样去在view的html template里面

00:32:12.100 --> 00:32:15.860
用这个for循环去渲染一个列表

00:32:15.860 --> 00:32:26.360
我们以前可能会写JS去

00:32:26.360 --> 00:32:30.360
在JS里面去操作DOM去上传列表

00:32:30.360 --> 00:32:35.660
现在vue可以直接就是在template上去使用

00:32:35.660 --> 00:32:36.260
仿循环了

00:32:36.260 --> 00:32:40.560
再加给大家在这加个小题目

00:32:40.560 --> 00:32:47.100
在这边显示一个文字

00:32:47.100 --> 00:32:48.380
就是列表为空

00:32:48.380 --> 00:32:54.640
把这个删掉

00:32:54.640 --> 00:32:56.420
这时候呢

00:32:56.420 --> 00:32:58.440
在这边显示一个文字列表为空

00:32:58.440 --> 00:33:00.040
如果说

00:33:00.040 --> 00:33:04.950
这列表没有任何内容的话

00:33:04.950 --> 00:33:05.610
就显示出来

00:33:05.610 --> 00:33:07.870
如果说有内容了

00:33:07.870 --> 00:33:08.790
这个列表为空

00:33:08.790 --> 00:33:09.750
这个字就消失掉

00:33:09.750 --> 00:33:15.850
结合刚才我们学的那个V1-L4

00:33:15.850 --> 00:33:18.050
我们可以尝试一下

00:33:18.050 --> 00:35:04.140
要做这个题呢

00:35:04.140 --> 00:35:06.280
就是我们首先要考虑一点

00:35:06.280 --> 00:35:07.640
就是这个to do

00:35:09.460 --> 00:35:13.400
怎么样拿到它的length它的长度

00:35:13.420 --> 00:35:14.820
如果说拿到这个长度了

00:35:14.820 --> 00:35:16.940
成功拿到长度之后呢

00:35:16.960 --> 00:35:20.940
要判断这个长度是不是等于零

00:35:20.940 --> 00:35:21.960
如果等于零呢

00:35:21.960 --> 00:35:24.960
就要去显示那个列表为空

00:35:24.960 --> 00:35:26.540
如果else呢

00:35:26.560 --> 00:35:27.720
就显示这个

00:35:28.680 --> 00:35:31.460
刚才这个实际上这个为fault循环

00:35:31.460 --> 00:35:35.740
让他去把这个内容打印出来

00:35:35.740 --> 00:38:52.780
然后刚才那个说的内容呢

00:38:52.780 --> 00:38:56.880
就是让在todo的时候是空的时候

00:38:56.880 --> 00:39:01.580
我们要显示一个列表为空这么个内容

00:39:01.580 --> 00:39:02.740
对吧

00:39:02.740 --> 00:39:04.680
然后呢

00:39:04.680 --> 00:39:08.100
如果说用户加入了一些内容呢

00:39:08.100 --> 00:39:12.970
他就如果说用户加入一些内容呢

00:39:12.970 --> 00:39:14.290
就显示实际的列表

00:39:14.290 --> 00:39:27.620
然后我们可以看主要代码就是在这,这边会加一个P标签

00:39:27.620 --> 00:39:37.620
它会判断ToDo数的Length强度是0,它就会显示列表为空这个文字

00:39:37.620 --> 00:39:44.620
在这个UL这呢,加了一个else,就是说如果说这个条件不成立,就是不为空的话

00:39:44.620 --> 00:39:49.120
它就会循环显示这个列表

00:39:49.120 --> 00:39:53.180
大家能理解吗

00:39:53.180 --> 00:39:57.280
就和结合上一个这个内容

00:39:57.280 --> 00:40:11.160
然后这个就是

00:40:11.160 --> 00:40:17.750
这道题呢

00:40:17.750 --> 00:40:20.390
还有它的本来的目的

00:40:20.390 --> 00:40:25.270
是让大家能成功的这个添加todo

00:40:25.270 --> 00:40:29.870
和这个删除todo的内容

00:40:30.370 --> 00:40:31.650
大家把这个做一下

00:40:31.650 --> 00:40:39.670
然后加上刚才页表一空条件

00:40:40.150 --> 00:40:41.190
vif-else

00:40:41.190 --> 00:40:42.630
这算是一个综合联系

00:40:43.390 --> 00:40:46.030
他本来的这个题的本来的要求

00:40:46.030 --> 00:40:48.230
就是能用户输入

00:40:48.710 --> 00:40:51.790
然后可以在这个列表上展示出

00:40:51.790 --> 00:40:53.990
用户反映出用户的输入

00:40:54.470 --> 00:40:56.230
然后点 x

00:40:57.310 --> 00:40:59.550
要能删掉用户

00:41:00.550 --> 00:41:02.850
点的对应的那个条目

00:41:03.550 --> 00:41:06.750
然后我这边加了一个那个v if else的

00:41:06.750 --> 00:41:07.250
运用

00:41:07.850 --> 00:41:09.450
就是列表v空的时候

00:41:11.050 --> 00:41:12.650
要显示一个列表v空

00:41:14.050 --> 00:41:14.950
展示给用户

00:41:15.550 --> 00:41:18.650
然后不v空的时候就展示那个整个列表

00:41:18.650 --> 00:41:20.150
内容给给用户

00:42:01.120 --> 00:42:02.820
基本要求效果是这样的

00:42:03.420 --> 00:42:05.620
就是用户输入的时候

00:42:06.920 --> 00:42:09.020
可以在这边添加上用户的输入

00:42:09.020 --> 00:42:12.080
对应的条目用户可以点击叉

00:42:12.080 --> 00:42:14.240
可以把它删掉

00:42:16.040 --> 00:42:17.060
删完了之后呢

00:42:17.060 --> 00:42:19.580
要显示一个input list

00:42:19.580 --> 00:42:20.480
有列表为空

00:42:23.780 --> 00:42:24.920
算是一个综合计

00:42:38.220 --> 00:42:45.710
再说一下

00:42:45.710 --> 00:42:46.370
嗯

00:42:46.370 --> 00:42:51.210
说一下这个啊

00:42:51.210 --> 00:42:52.310
这个题呢

00:42:52.310 --> 00:42:55.050
他这边也实现了效果

00:42:55.470 --> 00:42:56.830
没有问题

00:42:57.190 --> 00:42:59.910
但是我们说一下

00:42:59.910 --> 00:43:03.150
就是我们在工作中一般碰到这种情况

00:43:03.150 --> 00:43:04.470
其实还是比较多的

00:43:05.110 --> 00:43:06.350
我们的选择

00:43:08.470 --> 00:43:10.790
我需要接一下控制群

00:43:21.630 --> 00:43:25.310
它这边会在 to do 列表为空的时候

00:43:25.310 --> 00:43:26.110
显示一囊

00:43:26.350 --> 00:43:28.550
如果说不为空显示一二三

00:43:28.990 --> 00:43:29.830
这是没有问题的

00:43:29.830 --> 00:43:32.350
但是有个问题是它这边还是在

00:43:32.350 --> 00:43:34.910
不管是不是空的时候

00:43:34.910 --> 00:43:36.510
它都会渲染这个列表

00:43:37.350 --> 00:43:39.390
但是为为什么渲没渲染出来

00:43:39.390 --> 00:43:41.270
原因是因为它的没有东西

00:43:41.270 --> 00:43:44.910
所以说是暴循环不会运行

00:43:45.510 --> 00:43:45.910
对吧

00:43:48.430 --> 00:43:50.750
这个是达到了我们的要求的

00:43:50.750 --> 00:43:54.430
但是有个问题是它会有些性能上的问题

00:43:54.630 --> 00:43:56.110
在我们实际项目运用中

00:43:57.310 --> 00:44:00.990
因为你实际上它还是渲染出来了

00:44:00.990 --> 00:44:02.030
即使它没有东西

00:44:02.030 --> 00:44:11.260
我们看我们看它实际的内容的话

00:44:11.260 --> 00:44:13.140
你会发现这还是有个ul

00:44:14.020 --> 00:44:16.220
你看是有空ul在这

00:44:17.580 --> 00:44:18.260
对吧

00:44:20.650 --> 00:44:23.090
所以说我们在实际工作当中

00:44:23.250 --> 00:44:25.930
我们不会去这样

00:44:27.530 --> 00:44:30.330
我们会尽量的去减少渲染

00:44:30.770 --> 00:44:31.970
因为渲染越少

00:44:32.130 --> 00:44:34.570
它浏览器的速度越快

00:44:35.410 --> 00:44:36.410
用户体验就越好

00:44:36.410 --> 00:44:41.410
我们就会一般把会把他们包起来

00:44:42.530 --> 00:44:49.880
再加个div这样就是说

00:44:50.500 --> 00:44:54.420
那用户如果说 to do list

00:44:54.420 --> 00:44:55.780
它有vcon的时候

00:44:55.780 --> 00:45:00.020
这个用户就不会看到这个p标签

00:45:00.020 --> 00:45:01.100
以及这个url

00:45:01.100 --> 00:45:02.420
它压根就不会渲染

00:45:04.900 --> 00:45:12.810
我们再看一下这个点多了

00:45:13.050 --> 00:45:15.470
你看现在这边是不是就没有那个url了

00:45:16.370 --> 00:45:16.790
对吧

00:45:17.130 --> 00:45:19.690
这样浏览器就少渲染了一个url出来

00:45:19.690 --> 00:45:24.290
当然在这个这个环境这个场景下面呢啊无所谓

00:45:24.290 --> 00:45:25.890
这个只是一个UIL而已

00:45:25.890 --> 00:45:30.090
但是如果还是换比如说我们工厂bomb啊这种环境下面

00:45:30.090 --> 00:45:32.290
他整个小渲染一个bomb

00:45:32.290 --> 00:45:38.090
或者是其他的一些比较大的比较占资源的一些元素的话

00:45:38.090 --> 00:45:39.890
那这个浏览器速度就会变很快

00:45:39.890 --> 00:45:40.890
是吧

00:45:40.890 --> 00:45:50.620
好那这个题这个题大家应该都没问题了

00:45:50.620 --> 00:45:52.620
通过这个题呢

00:45:52.620 --> 00:45:54.000
和这个综合练习呢

00:45:54.000 --> 00:45:57.320
大家应该是掌握了这个双向绑定

00:45:57.320 --> 00:46:00.580
以及vif和else

00:46:00.580 --> 00:46:01.660
vif的应用

00:46:01.660 --> 00:46:04.280
那我们再往下看

00:46:04.280 --> 00:46:09.520
我们这边就来到一个进阶了

00:46:09.520 --> 00:46:10.980
我们就开始要

00:46:10.980 --> 00:46:14.040
要学这个计算属性了

00:46:14.040 --> 00:46:17.860
我们通常就是会遇到一个

00:46:17.860 --> 00:46:20.120
比如说我们算价格的时候

00:46:20.120 --> 00:46:21.100
算价格的时候

00:46:21.100 --> 00:46:21.980
它会有一个公式

00:46:21.980 --> 00:46:24.200
然后你要通过一系列

00:46:24.200 --> 00:46:26.600
好多好多步去运算出一个值来

00:46:27.260 --> 00:46:31.260
那这个东西我们怎么样告诉view

00:46:31.900 --> 00:46:33.340
这个价格改变的时候

00:46:33.700 --> 00:46:34.900
你要刷新页面呢

00:46:35.600 --> 00:46:38.260
我们就是用这个计算属性来去

00:46:39.140 --> 00:46:40.200
来去做这件事

00:46:44.000 --> 00:46:45.100
看这这道题呢

00:46:45.100 --> 00:46:48.240
就是说是运用这个计算属性

00:46:48.940 --> 00:46:50.860
他呢他做的是一个这个

00:46:51.600 --> 00:46:54.540
列表的一个动态的更新

00:46:54.540 --> 00:47:14.440
它呢是通过用户比如说点击这个勾和这个去掉这个勾了去显示或者隐藏这个勾选的对象

00:47:14.440 --> 00:47:16.960
这就是一个计算属性

00:47:16.960 --> 00:47:21.100
它并没有去真正的去删除或者增加这个todos

00:47:21.100 --> 00:47:24.520
它是通过计算属性来过滤

00:47:24.520 --> 00:47:28.660
把这个过滤结果让view选出来

00:47:28.660 --> 00:47:32.980
它整个的代码呢

00:47:32.980 --> 00:47:35.680
并没有去做一个实质的值的操作

00:47:35.680 --> 00:47:37.840
这就是所谓的计算属性

00:47:37.840 --> 00:47:40.180
就是只计算

00:47:40.180 --> 00:47:42.860
不更改任何的那个内容

00:47:42.860 --> 00:47:48.120
就套到我们刚才的那个场景

00:47:48.120 --> 00:47:50.400
就是比如说我们一个商品价格

00:47:50.400 --> 00:47:51.980
商品价格可能有成本

00:47:51.980 --> 00:47:53.480
有那个员工工资

00:47:53.480 --> 00:47:56.040
还有一个加工费用

00:47:56.040 --> 00:47:58.020
这些变量组成

00:47:58.020 --> 00:48:00.460
比如说我们的员工工资改变了

00:48:00.460 --> 00:48:02.640
那你这个商品价格就应该改变

00:48:02.640 --> 00:48:05.440
那这时候呢

00:48:05.440 --> 00:48:07.860
我们就可以用一个computer

00:48:07.860 --> 00:48:10.760
就是变成那个product price

00:48:10.760 --> 00:48:13.540
然后任何一个值改变了时候呢

00:48:13.540 --> 00:48:16.720
它就会自动去算出这个最终商品价格

00:48:16.720 --> 00:48:19.920
而不需要去定义一个商品价格

00:48:19.920 --> 00:48:21.260
藏在数据库里面或者怎么样

00:48:21.260 --> 00:48:23.220
它可以自动它的去计算

00:48:23.220 --> 00:48:26.680
这就是一个那个计算属性

00:48:26.680 --> 00:48:31.780
再给一个增强练习

00:48:31.780 --> 00:48:39.440
现在就是用户点了这个head的时候

00:48:39.440 --> 00:48:42.360
在下面再加一行文字

00:48:42.360 --> 00:48:46.880
用计算属性来输出一下

00:48:46.880 --> 00:48:48.360
当前

00:48:48.360 --> 00:48:56.460
反过来显示一下

00:48:56.460 --> 00:48:59.020
当前被隐藏的元素数量了

00:48:59.020 --> 00:49:00.680
加上字

00:49:00.680 --> 00:49:02.080
当前隐藏了多少个

00:49:02.080 --> 00:49:05.660
或者说当前勾选了多少个

00:49:05.660 --> 00:49:07.580
就是打勾的有多少个

00:49:07.580 --> 00:49:10.620
但是要求用那个计算属性来实现

00:49:10.620 --> 00:54:00.310
好

00:54:00.310 --> 00:54:02.110
我们先看一下这个

00:54:02.110 --> 00:54:05.890
还是看一下单单的这个

00:54:05.890 --> 00:54:07.530
这个桌面

00:54:07.530 --> 00:54:15.600
你这边能先把那个回滚一下吗

00:54:15.600 --> 00:54:16.660
别别别

00:54:16.660 --> 00:54:24.080
先看我这边

00:54:24.080 --> 00:54:31.460
我这边看这个

00:54:31.460 --> 00:54:34.900
这个就是刚才一个说的比较经典的案例了

00:54:34.900 --> 00:54:37.960
这是我们计算产品价格

00:54:37.960 --> 00:54:41.120
我们计算产品价格

00:54:41.120 --> 00:54:45.000
用计算属性computed去计算

00:54:45.000 --> 00:54:52.480
我们这边给了三个输入框

00:54:52.480 --> 00:54:55.260
这个是员工工资

00:54:55.260 --> 00:54:59.160
然后对应employee cost

00:54:59.160 --> 00:55:01.940
然后物料成本atom cost

00:55:01.940 --> 00:55:03.700
这是这个数换

00:55:03.700 --> 00:55:07.820
然后revenue就是那个利润

00:55:07.820 --> 00:55:10.020
利润是个现在是0.1

00:55:10.020 --> 00:55:16.480
我们去计算这个产品最终价格呢

00:55:16.480 --> 00:55:17.600
就是用这个计算属性

00:55:17.600 --> 00:55:20.100
然后去员工工资

00:55:20.100 --> 00:55:22.280
加上物料成本

00:55:22.280 --> 00:55:24.460
这就是我们一个总成本

00:55:24.460 --> 00:55:31.180
总成本然后再乘上利润率

00:55:31.180 --> 00:55:32.620
就是我们一个利润

00:55:32.620 --> 00:55:34.800
再加上总成本

00:55:34.800 --> 00:55:38.960
就是一个最终的产品价格

00:55:38.960 --> 00:55:39.840
就是2块2

00:55:39.840 --> 00:55:43.420
这是一个比较经典案例

00:55:43.420 --> 00:55:48.140
如果说我现在员工工资涨了

00:55:48.140 --> 00:55:50.080
员工工资从1块变成2块了

00:55:50.080 --> 00:55:53.860
你看我们用这个计算属性的话

00:55:53.860 --> 00:55:56.860
computed可以自动你只要一改值

00:55:57.460 --> 00:56:00.180
它这边就跟着就算出来最重的价格了

00:56:01.900 --> 00:56:03.980
这边如果说我们物料也涨了

00:56:03.980 --> 00:56:05.660
物料也涨到2块了

00:56:06.420 --> 00:56:09.180
它这边就总价就变成4块4了

00:56:10.140 --> 00:56:14.260
一样我们利润率如果说还调到30%

00:56:14.820 --> 00:56:15.740
就变成5块2了

00:56:17.300 --> 00:56:20.220
这就是一个比较综合应用

00:56:20.540 --> 00:56:22.340
这边用到了一个双向绑定

00:56:23.860 --> 00:56:25.980
就是把员工工资

00:56:26.300 --> 00:56:30.300
然后成本利润率先保定到我们提前

00:56:30.300 --> 00:56:33.060
上面编练上

00:56:33.300 --> 00:56:35.860
然后再通过一个计算属性computed

00:56:36.060 --> 00:56:37.460
把最终的价格算出来

00:56:38.740 --> 00:56:39.180
对吧

00:56:39.180 --> 00:56:41.260
这是一个比较典型的例子

00:56:41.580 --> 00:56:44.340
然后还有一个

00:56:44.340 --> 00:56:46.300
就刚才我刚才让大家做那个题

00:56:48.140 --> 00:56:50.420
输出它已经隐藏的

00:56:53.450 --> 00:56:55.250
已经被用户选中

00:56:55.850 --> 00:56:58.470
在这个条目数量

00:56:58.470 --> 00:57:04.070
这个题其实主要的点就是让大家理解

00:57:04.070 --> 00:57:18.430
让大家理解这computed实际上是可以和一个变量一样去重复利用的

00:57:18.430 --> 00:57:25.450
它并不是说到它这就终点了

00:57:25.450 --> 00:57:30.570
我们要学会去综合去用的这个东西

00:57:30.570 --> 00:59:00.780
然后在这儿我们可以把这个原因我们不深究了

00:59:00.780 --> 00:59:02.300
可能会比较费一点时间

00:59:02.300 --> 00:59:05.940
就是说这边主要还是让大家理解

00:59:05.940 --> 00:59:08.860
就是这个东西虽说它是一个计算

00:59:08.860 --> 00:59:10.660
computer属性的一个结果

00:59:10.780 --> 00:59:13.660
但是我们可以在其他地方在另一个computer

00:59:13.660 --> 00:59:16.900
是不是另一个方向里边去接着运用它

00:59:17.500 --> 00:59:18.940
去把它拿出来接着用

00:59:18.940 --> 00:59:25.230
然后它甚至可以有多个computer的可以进行符合

00:59:26.030 --> 00:59:26.550
好吧

00:59:26.550 --> 00:59:50.150
我们在这边下一个,这边就是我们在这边要看看怎么样去手动的去,就像我们昨天去用这个H5的方法,去直接的操作动物。

00:59:50.150 --> 01:00:01.150
有的时候呢,其实我们就是在有些特别情况下,我们必须要去操作动物,到时候我们可能就会需要用这个,这种方法。

01:00:01.150 --> 01:00:22.680
这边先跟大家说一下这个amounting,这个方法也是一个vue框架内置的一个方法。

01:00:22.680 --> 01:00:29.680
它的意思就是force view,我现在要监听amounting的试验。

01:00:29.680 --> 01:00:35.680
这个vue框架我们刚才说了,它在不停地渲染这个页面,直到更改了一圈。

01:00:35.680 --> 01:00:51.440
他这个意思就是说,我这个你就要直接下载这个方式的内容,什么时候是挂载的,就是说这个我们浏览器肯定会先下载HTML下载所有JS跟那个样式,

01:00:51.440 --> 01:01:02.680
加载了之后,他会去浏览器,因为Vue接管页面了之后,就会进入Vue的那个渲染,刚才我们看到那个渲染图,它的说明就切了,

01:01:02.680 --> 01:01:05.680
它就会有一个挂门,

01:01:05.680 --> 01:01:08.680
挂门的意思就是说vue已经监管页面了,

01:01:08.680 --> 01:01:13.680
然后这个页面所有的动物已经被vue挂门了,

01:01:13.680 --> 01:01:16.680
挂门就是被vue管理了,

01:01:16.680 --> 01:01:19.680
这个就会被触发,

01:01:19.680 --> 01:01:22.680
触发之后你就可以做一个初始化,

01:01:22.680 --> 01:01:45.100
这相当于一个初始化函数,

01:01:45.100 --> 01:01:48.100
这块大家能理解吗?

01:01:48.100 --> 01:02:44.100
这刚才我们提到的生命如期,

01:02:44.100 --> 01:02:50.100
这就是那个内部的一个一个子强的力量满了一个生命机器,

01:02:50.100 --> 01:02:56.100
它会有那个比方说这一页很明显,

01:02:56.100 --> 01:02:58.100
就是说我在创建之前,

01:02:58.100 --> 01:03:00.100
我这个页面在创建之前,

01:03:00.100 --> 01:03:03.100
就是所有内部,所有执行之前,

01:03:03.100 --> 01:03:05.100
然后呢,还有科学的,

01:03:05.100 --> 01:03:07.100
科学的意思就是说,

01:03:07.100 --> 01:03:10.100
我现在这页面有没有出,

01:03:10.100 --> 01:03:12.100
现在呢就是被换成了三大,

01:03:12.100 --> 01:03:15.100
刚才大家看到的四个锐子在踏火

01:03:15.100 --> 01:03:17.100
现在在V53就换成它了

01:03:17.100 --> 01:03:19.100
人家说它这个

01:03:19.100 --> 01:03:21.100
我们不需要再用这两个东西

01:03:21.100 --> 01:03:23.100
但是这两个东西还是存在的

01:03:23.100 --> 01:03:26.100
它其实是说被这个东西解放

01:03:26.100 --> 01:03:31.260
然后这个页面再换

01:03:31.260 --> 01:03:34.770
页面上的动物

01:03:34.770 --> 01:03:35.770
在这里面已经有了一个

01:03:35.770 --> 01:03:38.880
这么要挂了的时候

01:03:38.880 --> 01:03:41.190
就说哇

01:03:41.190 --> 01:03:44.190
我得是要去读一个部枪的一些消息

01:03:44.190 --> 01:03:46.190
我说不拿就行

01:03:46.190 --> 01:03:47.190
就这样

01:03:47.190 --> 01:03:48.190
人家都做了

01:03:48.190 --> 01:03:49.190
在做完了之后呢

01:03:49.190 --> 01:04:19.080
你发了之后呢,然后高兴也是,你发了之后,他就会进入一个高兴阶段,你有会计告知,你需要进入一个高兴阶段,你发现这种东西,我马上要公开给你,如果没有了,你才会这样,如果所有这种状态刷新了,你才会发现这个元素,你要常用,这样就麻麻麻的了。

01:04:19.080 --> 01:04:24.120
这个基本上就是说,我们在做这个view项目的时候

01:04:24.120 --> 01:04:25.560
在做页面出画的时候

01:04:25.560 --> 01:04:27.160
基本上都是会放在这

01:04:27.160 --> 01:04:28.440
这方面段呢

01:04:28.440 --> 01:04:31.000
你如果写一些东西写的代码进去了

01:04:31.000 --> 01:04:33.120
它会影响到更新项目

01:04:33.120 --> 01:04:37.850
也就是你的俗称就是刷新比较慢

01:04:37.850 --> 01:04:54.660
但是这个那个view有个整个生命周期

01:04:54.660 --> 01:04:57.620
然后我们现在就是现在下一个内容

01:04:57.620 --> 01:04:59.780
我们就看这个监听器

01:04:59.780 --> 01:05:00.940
就是我们现在

01:05:00.940 --> 01:05:04.740
比如说我们改了那count给他加一了

01:05:04.740 --> 01:05:10.080
那么我们现在想用另一个东西

01:05:10.080 --> 01:05:13.640
想在这个count改动的时候

01:05:13.640 --> 01:05:16.800
让他去执行一些什么操作

01:05:16.800 --> 01:05:19.740
比如说刚才那个例子

01:05:19.740 --> 01:05:20.940
那个员工工资

01:05:20.940 --> 01:05:25.780
什么还有这个物料长板

01:05:25.780 --> 01:05:27.220
这些东西修改了之后

01:05:27.220 --> 01:05:29.440
最终价格被重新计算了

01:05:29.440 --> 01:05:34.720
这个最终价格成那个重新计算之后呢

01:05:34.720 --> 01:05:38.560
我希望把这个最终价格发送到服务器

01:05:38.560 --> 01:05:42.000
我们就可以用这个监听监听这个最终价格变动

01:05:42.000 --> 01:05:44.020
当这个值变动之后呢

01:05:44.020 --> 01:05:49.960
就可以在这个监听器里面把这个最终价格上报给服务器

01:05:49.960 --> 01:05:51.940
这是一个监听器的一个作用

01:05:53.560 --> 01:05:58.950
大家看这个例子

01:05:58.950 --> 01:06:03.150
这个例子就是说比较那个实际的一个应用了

01:06:03.150 --> 01:06:05.950
就是说他今天听了这个todo list

01:06:05.950 --> 01:06:07.450
todo data

01:06:07.450 --> 01:06:10.230
这个todo data如果说变更了

01:06:10.230 --> 01:06:17.610
他就会去往这个服务器去去去做一个那个拉曲操作

01:06:17.610 --> 01:06:22.090
就是去去拉那个对应的数据下来

01:06:22.090 --> 01:06:25.650
这个这块大家可以理解吗

01:06:25.650 --> 01:06:27.290
这个关键点就是这个watch

01:06:27.290 --> 01:06:35.690
这个Wash就能用一个,Wash官员就把这个输入ID和这个fetchdata绑定,

01:06:35.690 --> 01:06:51.930
fetchdata的方式,就是说你这个从服务器去做一个下载,就会调这个fetchdata。

01:06:51.930 --> 01:07:04.380
大家可以试一试,我们如果点这个按钮的话,它这边就会去下对应的那个,

01:07:04.380 --> 01:07:10.120
从服务器上下对应的那个内容下来

01:07:10.120 --> 01:07:12.100
这个大家能不能理解

01:07:12.100 --> 01:07:14.060
这个还是比较

01:07:14.060 --> 01:07:15.840
这个应该还是比较好理解的

01:07:15.840 --> 01:07:16.080
对吧

01:07:16.080 --> 01:08:11.080
上节课讲过node js对吧

01:08:11.080 --> 01:08:14.120
node js大家要理解的概念就是

01:08:14.120 --> 01:08:15.160
比如说我们java

01:08:15.160 --> 01:08:19.170
java script是java和csharp

01:08:19.170 --> 01:08:21.230
或者说是c++ python

01:08:21.230 --> 01:08:22.990
这些所有的语言

01:08:22.990 --> 01:08:25.190
它都是组塞执行的

01:08:25.190 --> 01:08:26.950
什么叫组塞执行

01:08:26.950 --> 01:09:03.630
就是说我让执行完最绝的执行完毕,就是这样子顺序一步一步执行完,这叫做阻塞执行,然后呢,弄的很不一样,弄的一步执行就是说,这个,如果这种,这种执行叫做一步执行,如果说,这样当然就是带来一个显著的问题,比如说,你,我这个算是你执行,你执行这个减分,他肯定会搞错,这样,没有遇见到情况,他这个是一回,我这个是,

01:09:03.630 --> 01:09:27.280
我这个方法是一个绿的方法,里面会告诉你说绿的绿的绿的绿的,我这边不管是操作磁盘啊,操作网络啊,我会跑去去去挑选,不会说今天要五三,你这个其他双眼。

01:09:27.280 --> 01:09:30.280
然后我们另一个解释就是说,

01:09:30.280 --> 01:09:33.280
你转转一步就行了的方法,

01:09:33.280 --> 01:09:35.280
它实际上就要等我,

01:09:35.280 --> 01:09:37.280
如果没有的话,

01:09:37.280 --> 01:09:39.280
它就接那一步,

01:09:39.280 --> 01:09:41.280
然后它就有了。

01:09:41.280 --> 01:09:43.280
为什么这么做呢?

01:09:43.280 --> 01:09:45.280
就是说这个Node,

01:09:45.280 --> 01:09:47.280
它这样做的效率会比较高,

01:09:47.280 --> 01:09:49.280
有的情况下,

01:09:49.280 --> 01:09:51.280
比如说我们读写文件,

01:09:51.280 --> 01:09:56.280
可能读上百上千个JS文件解析的时候,

01:09:56.280 --> 01:10:24.280
它就可以,这种计划就可以不用加热力,我们就在地板就同时去做这种计划,这样就比那个,如果说我们用加热和自己的加热,用加热和手动去触发一些并线的门槛的一些操作,用的就不需要,用的就,它因为它默认就是这种一步之行嘛,这就会有一个相容的情况,但是相应带来的就是一些这个代码书写的一个。

01:10:24.280 --> 01:10:33.280
现在我们看的这个为啥,这个方法呢,也是大致是,对于实验演技来讲,是不难假的一个方法。

01:10:33.280 --> 01:10:37.280
之前我们有一个东西,就是说,叫回调抑郁。

01:10:37.280 --> 01:10:45.280
也就是说,我们之前吧,就是在暂时出盘会有靠盘,会有方法。

01:10:45.280 --> 01:10:49.280
有方法会在它进行完之后,调到那个方法。

01:10:49.280 --> 01:11:11.270
但是现在解析完了之后,然后再会有一个调用,它的样子是就是大概是这样的,就是比如说fetch,对,你是比较早期了是吗?

01:11:11.270 --> 01:11:20.670
那就是很恶心的那种切法,就是比较早期的那个node了,比如说这个data就是在这个fetch的一个结果,

01:11:20.670 --> 01:11:30.850
然后就是我们在json

01:11:30.850 --> 01:11:36.460
这是举例子

01:11:36.460 --> 01:11:38.460
不一定真是那么写

01:11:38.460 --> 01:11:44.660
然后又一个对它

01:11:44.660 --> 01:11:51.280
然后然后点点点

01:11:51.280 --> 01:11:54.280
你看看我们早期先弄gif是这样写的

01:11:54.280 --> 01:11:56.280
我们先去这个这个

01:11:56.280 --> 01:12:02.960
然后我们再把它

01:12:02.960 --> 01:12:07.310
弄gif的一个

01:12:07.310 --> 01:12:10.310
然后如果你要处理这个

01:12:10.310 --> 01:12:12.110
要处理这个也是叫力量

01:12:12.110 --> 01:12:13.870
如果你要再处理这个力量

01:12:13.870 --> 01:12:14.990
将来有不需要

01:12:14.990 --> 01:12:15.950
如果还有一组操作

01:12:15.950 --> 01:12:17.510
就要再开启

01:12:17.510 --> 01:12:18.830
后面一只二只

01:12:18.830 --> 01:12:20.510
因为一桶套一桶一桶套一桶

01:12:21.750 --> 01:12:23.310
所以说这个写法就比较

01:12:23.310 --> 01:12:24.510
呃

01:12:24.510 --> 01:12:25.870
比较讨厌

01:12:25.870 --> 01:12:26.670
就很丑陋

01:12:26.670 --> 01:12:29.470
我们就是管这个呃

01:12:29.470 --> 01:12:31.150
就是程序而管

01:12:31.150 --> 01:12:32.910
这个就要回回掉地域

01:12:33.910 --> 01:12:36.070
他一桶套一桶可能泡到自己头

01:12:36.070 --> 01:12:37.630
他会变得非常好

01:12:37.630 --> 01:12:39.470
而且你一定要海洋运动

01:12:39.470 --> 01:12:45.720
这样写就是比较贴近像是加瓦

01:12:45.720 --> 01:12:47.220
费亚也比较好理解

01:12:48.120 --> 01:12:48.320
好吧

01:12:48.320 --> 01:12:50.320
就是这个

01:12:54.120 --> 01:12:57.720
那个我们上午先这样下午还有些题

01:12:58.420 --> 01:12:59.220
那个

01:13:00.420 --> 01:13:02.520
关于上午我们学这些东西

01:13:03.520 --> 01:13:05.020
大家有什么问题

01:13:05.020 --> 01:13:06.020
就是速度快不快

01:13:06.020 --> 01:13:06.920
没有什么问题吗

01:13:08.420 --> 01:13:09.520
那大家先休息一下

01:14:31.740 --> 01:14:33.740
双向绑定大家能理解了吗

01:14:33.740 --> 01:14:36.740
他这个就是刚才我们已经要学过那个vmodel

01:14:36.740 --> 01:14:38.740
需要再单转来给大家说一下

01:14:38.740 --> 01:14:54.920
是第最初第三课还是第四课

01:14:54.920 --> 01:15:00.830
这就是个表单绑定

01:15:00.830 --> 01:15:03.830
这就是一个那个双向绑定嘛

01:15:03.830 --> 01:15:05.830
这很简单

01:15:05.830 --> 01:15:09.830
其实这个view这些东西啊

01:15:09.830 --> 01:15:12.830
他他这个前端这边就是会发明一些

01:15:12.830 --> 01:15:15.830
会发明一些比较听着比较高大上的一些名词

01:15:16.230 --> 01:15:17.630
他听着挺唬人的

01:15:18.130 --> 01:15:21.330
但是实际上他这个东西很简单

01:15:21.330 --> 01:15:23.630
就是比如这个数据双向绑定

01:15:23.630 --> 01:15:27.230
它归结的下来就是这个微博老关键字

01:15:27.530 --> 01:15:30.530
它做的作用就是给大家把这个

01:15:31.430 --> 01:15:33.030
省了一个这个function

01:15:34.430 --> 01:15:35.530
其实就这个事

01:16:20.190 --> 01:16:21.090
大家看这儿

01:16:23.600 --> 01:16:25.700
这其实也是一个双向绑定

01:16:25.700 --> 01:16:27.700
但是刚才上一个我们是看的是

01:16:27.700 --> 01:16:29.440
对那个输入框的双向绑定

01:16:29.440 --> 01:16:31.900
它这个实际上是对这个

01:16:31.900 --> 01:16:33.940
checkbox的一个双向绑定

01:16:33.940 --> 01:16:36.460
它这个用户勾选的时候

01:16:36.460 --> 01:16:38.920
就会把这个对应的这个

01:16:38.920 --> 01:16:41.440
to do的当这个

01:16:41.440 --> 01:16:44.640
这个值做对应的更改

01:16:44.640 --> 01:16:49.380
它这个双向绑定

01:16:49.380 --> 01:16:51.760
不光可以绑这个输入框

01:16:51.760 --> 01:16:52.780
还有这个checkbox

01:16:52.780 --> 01:16:54.720
包括那个下拉选择列表

01:16:54.720 --> 01:16:56.700
还有那个日期选择框

01:16:56.700 --> 01:16:59.780
这些基本可以与用户互动的元素

01:16:59.780 --> 01:17:01.780
都可以进行稍微磨叠

01:17:01.780 --> 01:18:35.580
大家休息一下

01:18:35.580 --> 01:18:37.580
我们下午还是1点10分

01:18:37.580 --> 01:19:37.650
休息一下

01:19:37.650 --> 01:19:41.650
下午我们1点半再过来继续
