编译vs.解释

“当源代码被翻译时”

源代码:原始代码(通常由人输入计算机) 翻译:将源代码转换为计算机可以阅读的内容(即机器代码) 运行时间:程序执行命令的时间(编译后，如果编译) 编译语言:在运行时之前翻译的代码 解释语言:在执行过程中动态翻译的代码

---

打字

当类型被检查时

5 + '3'是强类型语言(如Go和Python)中类型错误的一个例子，因为它们不允许“类型强制”——>值在某些上下文中改变类型的能力，例如合并两种类型。弱类型语言，如JavaScript，不会抛出类型错误(结果为'53')。

静态:运行前检查的类型 动态:在执行期间动态检查类型

---

“静态和编译”和“动态和解释”的定义非常相似……但是记住，当类型被检查时。“当源代码被翻译时”。

无论语言是编译的还是解释的，你都会得到相同的类型错误!你需要从概念上区分这些术语。

---

Python示例

动态的,解释

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

因为Python是解释性的和动态类型的，所以它只翻译和类型检查它所执行的代码。else块永远不会执行，所以5 + '3'甚至永远不会被查看!

如果它是静态类型的呢?

甚至在代码运行之前就会抛出类型错误。即使它是解释的，它仍然在运行时之前执行类型检查。

如果它是编译的呢?

else块将在运行时之前被转换/查看，但因为它是动态类型的，所以不会抛出错误!动态类型语言直到执行才检查类型，而这一行永远不会执行。

---

去的例子

静态的,编译

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

类型在运行前检查(静态)，类型错误立即被捕获!如果是解释类型，则在运行时之前仍将检查类型，结果相同。如果它是动态的，即使在编译期间查看代码，它也不会抛出任何错误。

---

性能

如果编译语言是静态类型(而不是动态类型)，那么它在运行时的性能会更好;类型知识允许机器代码优化。

静态类型语言本质上在运行时具有更好的性能，因为在执行时不需要动态地检查类型(它在运行前检查)。

类似地，编译语言在运行时速度更快，因为代码已经被翻译，而不需要动态地“解释”/翻译。

注意，编译语言和静态类型语言在分别进行翻译和类型检查之前都会有一个延迟。

---

更多的差异

静态类型在早期捕获错误，而不是在执行期间发现错误(对长程序特别有用)。它更“严格”，因为它不允许程序中的任何地方出现类型错误，并且经常防止变量改变类型，这进一步防止了意外错误。

num = 2
num = '3' // ERROR

动态类型更灵活，这一点受到一些人的赞赏。它通常允许变量更改类型，这可能导致意外错误。

静态类型语言在编译时进行类型检查，并且类型不能更改。(不要用类型转换注释，会创建一个新的变量/引用)。

动态类型语言在运行时进行类型检查，变量的类型可以在运行时更改。

甜蜜和简单的定义，但符合需求: 静态类型语言将类型绑定到整个作用域的变量(Seg: SCALA) 动态类型语言将类型绑定到变量引用的实际值。

允许程序在运行时更改变量类型的动态类型编程。

动态类型语言:Perl、Ruby、Python、PHP、JavaScript、Erlang

静态类型，意味着如果你试图在一个整数变量中存储一个字符串，它将不会接受它。

静态类型语言:C、c++、Java、Rust、Go、Scala、Dart

不幸的是，术语“动态类型”具有误导性。所有语言都是静态类型的，类型是表达式的属性(而不是一些人认为的值的属性)。然而，有些语言只有一种类型。这些被称为单一类型语言。这种语言的一个例子是无类型lambda演算。

在无类型lambda演算中，所有的项都是lambda项，对一个项执行的唯一操作是将它应用到另一个项。因此，所有的操作总是导致无限递归或lambda项，但永远不会发出错误信号。

However, were we to augment the untyped lambda calculus with primitive numbers and arithmetic operations, then we could perform nonsensical operations, such adding two lambda terms together: (λx.x) + (λy.y). One could argue that the only sane thing to do is to signal an error when this happens, but to be able to do this, each value has to be tagged with an indicator that indicates whether the term is a lambda term or a number. The addition operator will then check that indeed both arguments are tagged as numbers, and if they aren't, signal an error. Note that these tags are not types, because types are properties of programs, not of values produced by those programs.

这样做的单一类型语言称为动态类型语言。

JavaScript、Python和Ruby等语言都是单一类型的。同样，JavaScript中的typeof操作符和Python中的type函数的名称具有误导性;它们返回与操作数相关的标记，而不是操作数的类型。类似地，c++中的dynamic_cast和Java中的instanceof不做类型检查。

下面是一个对比Python(动态类型)和Go(静态类型)如何处理类型错误的例子:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python在运行时执行类型检查，因此:

silly(2)

运行完全正常，并产生预期的输出Hi。只有当有问题的行被击中时才会引发错误:

silly(-1)

生产

不支持'int'和'str'的操作数类型

因为相关的行已经被执行了。

另一方面，Go在编译时进行类型检查:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

上述文件将无法编译，并出现以下错误:

无效的操作:"3" + 5(不匹配的类型字符串和int)