WEBVTT

00:00.570 --> 00:04.940
在上一个视频中, 我们讨论了低级语言和高级语言｡ 

00:04.950 --> 00:11.340
不, 我们已经知道, 高级语言更像是英语, 更容易让人理解｡ 

00:12.180 --> 00:17.340
在上一个视频中,

00:17.340 --> 00:25.170
我解释了有许多高级编程语言, 有些语言是基于编译器的, 有些是基于解释的, 有些是混合的｡

00:25.980 --> 00:28.230
那么, 基于编译器是什么意思呢？

00:28.230 --> 00:30.500
基于解释器是什么意思｡ 

00:30.530 --> 00:33.160
我们将在这段视频中了解｡ 

00:33.540 --> 00:36.260
因此, 主题是编译器与解释器｡ 

00:36.300 --> 00:38.610
然后我也将讨论混合语言｡

00:38.930 --> 00:40.590
所以对于理解这一点｡ 

00:40.590 --> 00:43.420
我们应该知道编译器和解释器的工作是什么｡ 

00:43.430 --> 00:45.580
有什么重大任务｡ 

00:45.790 --> 00:49.230
请参阅编译器或解释器的任务无论它是什么｡

00:49.260 --> 00:54.020
第一件事是它会检查错误, 检查错误｡ 

00:54.060 --> 00:54.810
好吧, 我知道了

00:54.810 --> 00:56.640
所以这是第一件事｡ 

00:56.670 --> 01:03.150
那么第二件事就是转换成机器代码, 转换成机器｡ 

01:03.160 --> 01:05.290
代码｡ 

01:05.460 --> 01:11.890
所以我就写M｡  C. C. 机器代码,

01:12.000 --> 01:16.890
或者机器代码语言, 参见高级语言, 得到商品化的低级语言,

01:16.910 --> 01:27.000
也就是机器可以理解的机器代码, 所以编译器和解释器, 他们做的是转换的工作, 第三件事是执行, 执行一个程序, 这个程序在运行｡

01:27.420 --> 01:31.500
运行程序意味着你知道, 就像我已经告诉你的, 程序被带到主内存中,

01:31.500 --> 01:33.920
并由CPU执行｡

01:34.160 --> 01:39.630
因此, 机器指令将进入主存储器, CPU将执行它｡ 

01:40.140 --> 01:45.520
那就是执行, 现在运行一个程序对于这三件事情让我们明白这一点｡

01:45.550 --> 01:52.340
当我们写这样的程序的时候, 我会把这个程序叫做源代码, 当你写任何源代码的时候,

01:52.340 --> 01:57.180
源代码可能会有错误｡

01:57.570 --> 02:03.270
那么你为什么会有错误呢？ 我看你可能说错了什么, 或者你可能忘记了一些陈述,

02:03.690 --> 02:06.000
或者你没有正确地写陈述｡

02:06.000 --> 02:09.370
可能存在一些错误, 因此这些错误称为语法错误｡ 

02:09.480 --> 02:11.380
因此, 无论是编译器还是解释器｡ 

02:11.400 --> 02:17.180
它必须首先检查代码, 你写的源代码没有任何错误,

02:17.250 --> 02:23.260
这是第一件事, 如果没有错误, 那么它将把它转换成机器代码｡

02:24.080 --> 02:30.580
因此, 编译器或解释器主要有两个任务, 它们都做这件事, 检查错误｡ 

02:30.780 --> 02:38.780
如果源代码是无错误的, 那么生成机器码, 然后第三件事, 程序的执行｡ 

02:39.750 --> 02:51.010
如果我谈到执行, 编译器不负责执行, 但解释器负责执行｡

02:51.210 --> 02:54.730
编译器如果不参与程序的执行就涉及解释器｡ 

02:55.320 --> 02:59.040
所以这件事情的一切我们都会详细了解对吧｡ 

02:59.070 --> 03:04.110
因此, 我们一步一步地了解编译器和解释器之间的差异｡ 

03:04.110 --> 03:10.670
因此, 请记住, 这是与编译器和解释器相关的三个主要问题｡ 

03:10.680 --> 03:14.900
现在让我们逐一比较一下｡ 

03:14.910 --> 03:17.640
为了比较, 我已经采取了一些程序代码在这里.

03:17.640 --> 03:24.350
这是用C++编写的源代码, 也是用Javascript编写的源代码｡ 

03:24.570 --> 03:26.550
我举了两个例子｡ 

03:26.610 --> 03:36.150
C++是一种基于编译器的语言, 它只有一个编译器, 没有解释器javascript, 这对写网页很有用｡

03:36.150 --> 03:40.600
它将成为该页面的一部分, 并在浏览器内运行｡ 

03:40.600 --> 03:47.040
大多数的网站, 如果你用浏览器访问, 如果你检查代码, 你会发现html和javascript在javascript中,

03:47.040 --> 03:50.700
所以这是一个大家都知道的常见名字｡

03:50.760 --> 03:53.130
这是在网络编程中使用的｡ 

03:53.130 --> 03:54.690
这是基于解释的｡ 

03:55.500 --> 03:57.490
这是我写的源代码｡ 

03:57.580 --> 04:02.280
这不是机器代码, 因此可以通过编译器和人工方式来理解｡ 

04:02.280 --> 04:07.320
这可以被解释器和人类理解, 所以我已经举了一个基于编译器的语言的例子,

04:07.320 --> 04:10.830
现在让我们理解语言的解释器的区别｡

04:10.890 --> 04:18.420
看看我有没有这个程序, 我想编译的意思是翻译成机器码, 如果我给予它给一个编译器,

04:18.420 --> 04:25.560
编译器会把这个代码转换成机器码, 你们可以看到, 我把这个程序分成了两部分,

04:25.560 --> 04:28.460
两部分在这里｡

04:28.740 --> 04:31.610
这是add函数, 这是main函数.

04:31.720 --> 04:37.110
不, 我们现在对函数一无所知, 但我刚刚把程序分成两部分写出来｡

04:37.230 --> 04:44.950
因此, 当生成机器代码时, 它将生成两个不同的部分, 即add函数的机器代码｡

04:45.000 --> 04:47.670
和Main功能的机器代码｡ 

04:47.670 --> 04:52.620
所以这里你要明白的是, 如果你把程序分成几部分,

04:52.620 --> 04:55.380
那么这些部分将以机器代码的形式生成｡

04:55.440 --> 04:57.120
这很重要｡ 

04:57.120 --> 05:00.000
这是生成的机器代码｡ 

05:00.000 --> 05:02.280
先看这是文件｡ 

05:02.310 --> 05:08.970
编译之后, 我们得到了一些中间文件, 最后我们得到了可执行文件,

05:08.970 --> 05:15.740
我们得到了第一个｡ exe文件､ 可执行文件｡ 

05:16.140 --> 05:18.910
所以在这里我已经展示了最难的｡ 

05:19.000 --> 05:25.290
第一个｡  如果你调用一个编译器,

05:25.640 --> 05:32.050
编译器会运行到内存中, 它会很好的处理这个程序, 首先要理解并检查是否有错误, 如果没有错误, 它会生成一个机器代码文件｡

05:32.220 --> 05:41.270
那是第一次｡  exe, 它将在硬盘上为它服务, 就像这样,

05:41.270 --> 05:55.910
你会得到一个单独的文件, 名为第一｡ exe这是第一个｡  exe编译器生成机器代码, 如果没有错误, 它就生成机器代码｡

05:55.910 --> 05:55.910
编译器的工作结束了｡ 

05:56.560 --> 05:59.570
它已经生成了机器码, 下一步我想运行｡

05:59.770 --> 06:12.280
我说有三件事是正确的检查错误, 转换, 没有错误, 转换｡  现在执行如果你想现在运行程序你可以先运行这个程序｡

06:12.280 --> 06:17.800
你可以运行, 你可以运行很多次, 你现在不需要编译器, 编译器已经翻译了一次, 这就足够了, 现在你运行你的程序n次,

06:17.800 --> 06:23.160
每当你运行你的程序, 这｡

06:23.220 --> 06:29.740
将使用exe｡

06:29.740 --> 06:37.900
源代码是关闭没有使用现在和在所有您正在作出任何改变在这一个然后您可以重新编译得到一个重新生成第一 exe文件, 并且该文件将是一个新程序或全新或更新的程序｡

06:38.200 --> 06:44.080
因此, 这意味着源代码到机器代码的编译或翻译只需要一次｡ 

06:44.090 --> 06:48.590
这是第一点, 并且编译器生成单独的可执行文件｡ 

06:48.590 --> 06:54.610
还有第二点, 第三点, 当你想运行程序时,

06:54.610 --> 07:01.210
你不需要编译器, 翻译只进行一次, 因为这就是为什么你运行程序时, 不需要任何编译器,

07:01.210 --> 07:08.950
编译器的一个更重要的事情是, 看它们有几行, 12345678, 大约10,

07:08.950 --> 07:15.340
15行｡ 在这一行中, 如果在某个地方有任何错误,

07:15.410 --> 07:21.940
假设我从这里开始, 12345, 四行是完美的, 第五行有一些错误,

07:21.940 --> 07:28.060
你的程序没有被编译｡ 如果第五行有错误,

07:28.060 --> 07:34.330
你程序将无法编译｡ 2前四行是正确的, 对吗？

07:34.330 --> 07:37.520
但是它必须生成完整的机器代码, 它不能将其转换成机器代码｡

07:37.780 --> 07:39.390
这些就是关于编译器的要点｡ 

07:39.670 --> 07:44.680
让我快速重复编译器将生成一个机器代码文件单独的文件和程序的翻译是唯一的, 编译器将不会在程序运行时出现,

07:44.720 --> 07:49.740
对, 大多数学生认为编译器将在执行时出现编译器将不会出现,

07:49.750 --> 07:55.270
最后一点是, 如果有任何错误, 在一些行,

07:55.270 --> 08:01.450
那么程序将不会得到编译｡ 现在我们来看看解释器,

08:01.570 --> 08:07.240
为了解释解释器, 我将删除此文件, 并更改此文件, 现在让我们看看解释器,

08:07.240 --> 08:15.040
对于解释器, 我有一些javascript代码, 不要试图阅读和理解代码, 只有一些行, 好的｡

08:15.100 --> 08:18.990
这些都是用JavaScript编写的, 现在解释器是如何工作的｡ 

08:19.000 --> 08:19.720
让我们来看看｡ 

08:19.780 --> 08:26.220
看到这是假设一个文件名为我的｡  JavaScript是我的｡ 

08:27.550 --> 08:33.180
js文件, 然后我还有一个叫做Chrome的程序, 它是一个常用的浏览器｡

08:33.190 --> 08:35.170
所以我在这里用了chrome这个名字｡ 

08:35.200 --> 08:40.320
所以这个铬｡  EXE是一个浏览器javascript运行在浏览器｡ 

08:40.360 --> 08:42.500
它不能独立运行｡ 

08:42.530 --> 08:48.010
现在javascript是如何工作的chrome是如何作为JavaScript的解释器工作的｡ 

08:48.180 --> 08:49.240
让我想想｡ 

08:49.250 --> 08:53.040
首先, 请看我运行这个程序来执行这个程序｡ 

08:53.050 --> 08:57.430
我不是直接说翻译或任何东西, 我是说执行第三步｡ 

08:57.430 --> 08:58.350
记住这个｡ 

08:58.510 --> 09:04.680
我必须运行chrome, 在Chrome里面, 我可以运行javascript, 我可以在chrome中打开那个文件｡ 

09:04.690 --> 09:10.150
通常我们不从本地机器打开文件, 我们从互联网上获得页面, 但在这里, 如果你打开chrome,

09:10.150 --> 09:12.870
那么你可以打开JavaScript文件｡

09:13.150 --> 09:19.530
如果你在chrome里面打开, Chrome就会执行这个代码, 不管它是什么｡ 

09:19.530 --> 09:24.650
只是让它做什么, 它这样做的代码可以执行的铬｡ 

09:24.760 --> 09:30.530
那怎么办？ Chromebook作为JavaScript的解释器｡ 

09:30.700 --> 09:33.690
所以现在你可以看到它是如何工作的｡ 

09:33.700 --> 09:35.700
首先, Chrome将运行｡ 

09:35.860 --> 09:42.640
然后如果你让它使用这个文件它会把这个文件, 然后, 它会通过这个文件,

09:42.640 --> 09:44.900
它会翻译它逐行｡

09:44.930 --> 09:48.030
经过翻译后, 它将转换成机器代码｡ 

09:48.040 --> 09:48.930
是的, 我知道

09:48.970 --> 09:59.730
它也会被执行, Chrome会像C++程序一样执行它, 编译器不会在这里执行它｡

09:59.730 --> 10:03.450
Chrome是JavaScript解释器Chrome将执行它

10:03.450 --> 10:10.470
是的, 那么它将如何执行它将不会翻译整个事情, 然后开始执行, 它将翻译第一行｡

10:10.690 --> 10:11.220
执行｡ 

10:11.230 --> 10:13.640
第二行, 执行第三行｡ 

10:13.950 --> 10:17.400
所以逐行翻译以及执行｡ 

10:17.400 --> 10:22.190
现在让我们比较一下这个编译器解释器C编译器会读的程序｡ 

10:22.260 --> 10:26.340
它将逐行生成机器代码,

10:26.340 --> 10:33.330
但它将生成一个机器代码, 用于分离整个程序, 并制作一个单独的文件, 但浏览器是JavaScript的解释器｡

10:33.330 --> 10:36.070
它不会为JavaScript创建EXE文件｡ 

10:36.720 --> 10:43.430
这是第一个区别｡  第二个不同之处是,

10:43.430 --> 10:47.120
编译器只是将其转换为不执行, 而将其解释为Chrome, 它将转换为执行｡

10:47.220 --> 10:48.720
第二个区别｡ 

10:48.720 --> 10:56.610
第二个区别, 第三个区别, 如果一旦翻译成机器代码, 现在你可以随心所欲地使用它, 你不需要编译器,

10:56.610 --> 11:03.120
翻译只做一次, 但在这里, 每当你想运行javascript时, 你应该调用chrome,

11:03.180 --> 11:06.880
Chrome每次都会运行它, 它会翻译｡

11:07.290 --> 11:17.990
所以如果你执行n次, 那么n次翻译就会完成（解释器语言）, 如果这里有任何错误, 那么它就不会编译｡

11:18.030 --> 11:23.340
这里, 如果这里有任何错误, 假设在某行中, 那么前两行肯定会被执行｡

11:23.670 --> 11:28.460
因为您只是在转换和执行转换和执行｡ 

11:28.500 --> 11:32.750
如果在任何点上有任何错误, 则它将停止｡ 

11:32.790 --> 11:41.960
所以直到那里它才会执行解释器会执行编译器程序运行独立的解释器程序运行在眼前｡

11:42.010 --> 11:43.080
翻译｡ 

11:43.100 --> 11:48.510
翻译没有最后的结论点谁更快｡ 

11:50.010 --> 11:57.570
编译程序还是解释程序？ 编译后的程序速度更快, 因为它们作为一个独立的程序是独立的｡

11:57.870 --> 12:03.060
解释器程序不被培养, 因为它们不独立运行,

12:03.270 --> 12:10.200
在解释器的解释器上下文内部有一个内部解释器, 所以它们比较慢, 容易编写｡

12:10.500 --> 12:13.470
如果在一行中有任何错误, 它将不会编译｡ 

12:13.490 --> 12:20.920
如果某行中有任何行错误, 则不能运行, 然后可以执行前一行｡ 

12:21.170 --> 12:22.100
所以很简单｡ 

12:22.940 --> 12:26.360
所以在某种程度上你可以看到程序在这个地方运行｡ 

12:26.370 --> 12:27.970
好的, 有个错误我可以删除它.

12:28.370 --> 12:30.480
所以这些语言都很简单｡ 

12:30.560 --> 12:36.350
解释器语言比基于编译器的语言更容易｡ 

12:36.410 --> 12:40.820
这就是编译器和解释器的区别｡  现在我给大家举一个小例子｡ 

12:40.820 --> 12:45.350
有了这个你就可以记住这整个事情我已经讨论过了｡ 

12:45.350 --> 12:56.000
假设你正在做一道中国菜, 你正在准备一道菜, 所以你有一道中国菜的食谱｡

12:56.000 --> 13:01.140
这是用中文写的, 这是用中文写的｡ 

13:01.140 --> 13:02.330
你不懂中文｡ 

13:02.400 --> 13:09.030
我懂中文和英语所以我可以帮你我可以再翻译一遍把它翻译对｡ 

13:09.040 --> 13:10.840
所以你要准备一道菜｡ 

13:10.840 --> 13:14.700
现在我可以翻译的方法有哪些｡ 

13:14.750 --> 13:22.590
第一种方法我可以看完整个食谱, 然后准备好英语版给予你｡ 

13:22.760 --> 13:26.570
是第一法接着第二法｡ 

13:27.250 --> 13:29.400
我要中国食谱｡ 

13:29.970 --> 13:38.260
我读了第一行翻译它, 我告诉你, 你也将执行它意味着你现在正在准备一道菜｡

13:38.260 --> 13:40.700
我会说拿一个这样大小的容器｡ 

13:40.790 --> 13:46.180
好吧你拿着然后拿着这个这个这个, 你拿着, 拿一些水煮开｡ 

13:46.300 --> 13:52.710
你会煮它, 所以我阅读中文, 翻译成英语, 我会, 我也会执行它｡ 

13:52.710 --> 13:54.430
你正在做｡ 

13:54.500 --> 13:56.130
还有第二种方法｡ 

13:56.190 --> 13:58.570
现在让我们比较一下, 第一种方法｡ 

13:58.600 --> 14:04.830
如果我给予你一个英语副本, 那么翻译只做一次, 你不需要我｡ 

14:04.860 --> 14:11.410
当你准备一盘菜2区别权利和你可以独立工作｡ 

14:11.450 --> 14:11.870
好吧, 我知道了

14:11.870 --> 14:13.610
同样的事情第二个区别｡ 

14:13.640 --> 14:14.790
现在这里｡ 

14:15.000 --> 14:22.270
每次你想再准备一道菜你会来更多的中文请翻译我会翻译正确的这一个｡

14:22.850 --> 14:26.980
第二件事, 无论何时你准备你的菜, 我必须被送到你｡ 

14:27.010 --> 14:29.700
你不独立｡ 

14:29.950 --> 14:31.960
这就是你所能记住的区别｡ 

14:31.990 --> 14:36.090
如果我翻译的话, 我会在另一张纸上给你一个单独的英语版本｡ 

14:36.100 --> 14:39.360
现在, 中文版, 你可以保持在检查, 如果你不需要它｡ 

14:39.640 --> 14:45.550
你有英语版, 你不需要我再做同样的食谱, 但在这里, 你每次都需要我,

14:45.550 --> 14:50.930
因为我在翻译, 我让你完成, 所有的工作都结束了｡

14:50.950 --> 14:58.940
所以同样的方法, 这个chrome将进入主内存, 它将接受javascript和翻译, 并让它由Cpu执行｡

14:59.050 --> 15:05.070
这个chrome是我自己, 这个是中国配方, 这个是你自己,

15:05.080 --> 15:09.190
用来执行你理解的机器代码, 就像编译器一样｡

15:09.280 --> 15:10.170
你打电话给我｡ 

15:10.170 --> 15:13.850
我先拿了｡  Cpp又先转换成了一个｡  exe文件｡ 

15:13.930 --> 15:18.070
现在你不需要我, 只要你想, 你可以直接执行该exe文件.

15:19.690 --> 15:21.470
这些就是区别｡ 

15:21.480 --> 15:29.400
最后, 让我们来谈谈混合语言, 混合语言, 比如Java, 或者所有被采用的语言,

15:29.660 --> 15:32.360
比如C.

15:32.370 --> 15:33.790
现在这些是混合型｡ 

15:33.790 --> 15:45.790
它们有一个部分组合, 首先编译器将其转换为字节码, 然后由JVM转换为机器｡

15:45.820 --> 15:51.460
所以我不打算详细解释, 只是简单地告诉你们, 他们有两个步骤,

15:51.460 --> 15:55.800
编译器也是他们的解释器, JVM也是他们的解释器｡

15:55.800 --> 15:57.000
这是翻译｡ 

15:57.070 --> 16:04.360
为什么两个阶段的编译器会检查编译器会做什么, 它不会生成机器码, 编译器只是检查错误,

16:04.390 --> 16:10.420
如果没有错误, 字节码就是无错误的代码, 然后Jvm会转换或翻译成机器码,

16:10.420 --> 16:17.620
所以两个步骤的过程我强调了三件事, 比如检查错误, 翻译,

16:17.620 --> 16:21.850
然后机器码和执行｡

16:21.940 --> 16:23.260
第三是处决｡ 

16:23.380 --> 16:26.820
因此编译器只检查是否有错误｡ 

16:26.950 --> 16:32.450
它不是机器代码, 而是咬代码, 然后JVM将其转换为机器代码并执行｡ 

16:32.450 --> 16:37.820
所以它是一个解释器, 解释字节码, 而不是源代码.

16:38.800 --> 16:44.930
因此, 这两个步骤提供了平台独立性或dotnet语言｡ 

16:44.930 --> 16:47.400
它是用于依赖关系中的语言｡ 

16:47.410 --> 16:52.630
这些都是不同的主题, 只是要知道, 有一些基于编译器的语言,

16:52.630 --> 16:58.210
有一些解释器语言, 还有一些是混合的, 既有编译器, 也有解释器｡

16:58.300 --> 17:03.980
该采取的好处, 这两个, 并试图提供一些优秀的功能, 使所有与这个主题｡ 

17:04.050 --> 17:06.290
让我们继续下一个视频中的主题｡