很难给出一个实际的答案，因为差异在于语言定义本身。可以为每一种编译语言构建一个解释器，但不可能为每一种解释语言构建一个编译器。它主要是关于语言的正式定义。所以在大学里没有人喜欢理论信息学。

解释源代码相对于编译源代码的最大优势是可移植性。

如果你的源代码是编译的，你需要为你的程序运行在不同类型的处理器和/或平台编译不同的可执行文件(例如一个用于Windows x86，一个用于Windows x64，一个用于Linux x64，等等)。此外，除非您的代码完全符合标准，并且不使用任何特定于平台的函数/库，否则您实际上需要编写和维护多个代码库!

如果你的源代码是解释型的，你只需要编写一次，它就可以在任何平台上由合适的解释器解释和执行!它是便携!请注意，解释器本身是为特定平台编写和编译的可执行程序。

编译代码的一个优点是它向最终用户隐藏了源代码(可能是知识产权)，因为您部署的不是人类可读的原始源代码，而是一个模糊的二进制可执行文件。

The Python Book©2015 Imagine Publishing Ltd，简单地通过第10页中提到的以下提示来区分差异:

像Python这样的解释型语言是指将源代码转换为机器码，然后在每次程序运行时执行的语言。这与编译语言(如C)不同，后者只将源代码转换为机器代码一次——然后在程序每次运行时执行生成的机器代码。

编译器和解释器做同样的工作:将一种编程语言翻译成另一种编程语言，通常更接近硬件，通常是直接可执行的机器代码。

Traditionally, "compiled" means that this translation happens all in one go, is done by a developer, and the resulting executable is distributed to users. Pure example: C++. Compilation usually takes pretty long and tries to do lots of expensive optmization so that the resulting executable runs faster. End users don't have the tools and knowledge to compile stuff themselves, and the executable often has to run on a variety of hardware, so you can't do many hardware-specific optimizations. During development, the separate compilation step means a longer feedback cycle.

Traditionally, "interpreted" means that the translation happens "on the fly", when the user wants to run the program. Pure example: vanilla PHP. A naive interpreter has to parse and translate every piece of code every time it runs, which makes it very slow. It can't do complex, costly optimizations because they'd take longer than the time saved in execution. But it can fully use the capabilities of the hardware it runs on. The lack of a separrate compilation step reduces feedback time during development.

But nowadays "compiled vs. interpreted" is not a black-or-white issue, there are shades in between. Naive, simple interpreters are pretty much extinct. Many languages use a two-step process where the high-level code is translated to a platform-independant bytecode (which is much faster to interpret). Then you have "just in time compilers" which compile code at most once per program run, sometimes cache results, and even intelligently decide to interpret code that's run rarely, and do powerful optimizations for code that runs a lot. During development, debuggers are capable of switching code inside a running program even for traditionally compiled languages.

编译语言是这样一种语言:程序一旦编译，就用目标机器的指令来表达。例如，源代码中的加法“+”操作可以直接转换为机器代码中的“ADD”指令。

解释型语言是指指令不直接由目标机器执行，而是由其他程序(通常用本机语言编写)读取和执行的语言。例如，相同的“+”操作将在运行时被解释器识别，然后调用它自己的“add(a,b)”函数，并使用适当的参数，然后执行机器代码“add”指令。

你可以在编译语言中做你在解释语言中可以做的任何事情，反之亦然——它们都是图灵完备的。然而，这两种方法在实施和使用方面都有优点和缺点。

我将完全概括(纯粹主义者原谅我!)，但大致来说，以下是编译语言的优点:

通过直接使用目标计算机的本机代码获得更快的性能 有机会在编译阶段应用相当强大的优化

下面是解释型语言的优点:

更容易实现(编写好的编译器非常困难!!) 不需要运行编译阶段:可以直接“动态”执行代码 是否可以更方便地使用动态语言

注意，字节码编译等现代技术增加了一些额外的复杂性——这里发生的情况是，编译器的目标是一个与底层硬件不同的“虚拟机”。这些虚拟机指令可以在稍后阶段再次编译，以获得本机代码(例如，由Java JVM JIT编译器完成)。

我猜这是计算机科学中最大的误解之一。 因为解释和编译是完全不同的两件事，我们不能用这种方式进行比较。

编译是将一种语言翻译成另一种语言的过程。编译的类型很少。

编译-将高级语言转换为机器/字节代码(例如:C/ c++ /Java) 翻译——将高级语言翻译成另一种高级语言(例如:TypeScript)

解释是实际执行程序的过程。这可能以几种不同的方式发生。

Machine level interpretation - This interpretation happens to the code which is compiled into machine code. Instructions are directly interpreted by the processor. Programming languages like C/C++ generate machine code, which is executable by the processor. So the processor can directly execute these instructions. Virtual machine level interpretation - This interpretation happens to the code which is not compiled into the machine level (processor support) code, but into some intermediate-level code. This execution is done by another software, which is executed by the processor. At this time actually processor doesn't see our application. It just executing the virtual machine, which is executing our application. Programming languages like Java, Python, C# generate a byte code, which is executable by the virtual interpreter/machine.

所以在一天结束的时候，我们必须明白的是，世界上所有的编程语言都应该在某个时候进行解释。它可以由处理器(硬件)或虚拟机完成。

编译只是将我们编写的人类可理解的高级代码带到机器可理解的硬件/软件级别的过程。

这是完全不同的两件事，我们无法比较。但是这些术语非常适合教给初学者编程语言是如何工作的。

PS: Some programming languages like Java have a hybrid approach to do this. First, compile the high-level code into byte code which is virtual-machine readable. And on the fly, a component called the JIT compiler compiles byte-code into machine code. Specifically, code lines that are executed again and again many times are get translated into the machine language, which makes the interpretation process much faster. Because hardware processor is always much faster than virtual interpreter/processor.

Java JIT编译器如何工作