之间的区别是什么类型的静态和动态型的语言？

Question

我听到很多新编程语言是动态型的，但它有什么实际的意思是当我们说一种语言是动态类型与静态类型的?

Answer 1

静态类型语言

如果一个变量的类型在编译时已知一种语言是静态类型。对于某些语言，这意味着你作为程序员必须指定每个变量是什么类型（例如：Java和C，C ++）;其他语言提供某种形式的类型推断的，该类型的系统的能力，以推断出变量的类型（例如：OCaml中，Haskell中，Scala中，科特林）

这里的主要优点是，各种检查可以通过编译器来完成，并且在很早的阶段，因此很多琐碎的bug被发现。

实施例：C，C ++，JAVA，锈病，围棋，Scala的

动态类型语言

一个语言是动态类型，如果该类型与运行时的值相关联，并且不命名变量/字段/等。这意味着，你作为一个程序员可以编写一个更快一点，因为你没有指定类型的每次（除非使用静态类型语言与类型推断的）。

示例：Perl中，红宝石，Python和PHP，JavaScript的

大多数脚本语言有此功能，因为没有编译器做静态类型检查反正，但你会发现自己寻找这是由于曲解解释变量的类型的错误。幸运的是，剧本往往是小虫子所以没有这么多的地方躲起来。

大部分动态类型语言确实允许您提供类型的信息，但不要求它。当前正在开发，流氓一种语言，采取混合方法，允许职责范围内的动态类型，但执行静态打字函数签名。

Answer 2

静态类型的编程语言都类型检查（即验证和执行的类型的限制的处理）在编译时而不是运行时

动态类型的编程语言都键入在检查运行时而不是编译时

Answer 3

下面是一个例子对比的Python（动态类型），并转到（静态类型）如何处理一个类型错误：

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

Python不键入在运行时检查，并且因此：

silly(2)

运行完全正常，并产生预期的输出Hi。如果有问题的线路被命中错误仅升高：

silly(-1)

可生产

TypeError: unsupported operand type(s) for +: 'int' and 'str'

，因为相关的线实际执行。

在另一方面转到不类型检查在编译时：

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

上面不会编译，用下面的错误：

invalid operation: "3" + 5 (mismatched types string and int)

Answer 4

简单地说是这样：在静态类型语言变量的类型的静态的，这意味着一旦你设置为一个类型的变量，你不能改变它。这是因为打字与变量，而不是它指的是值相关联。

例如在Java中：

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

在动态类型语言变量的类型的动态的，这意味着你以后的变量设置为一个类型，你可以改变它：

凡另一方面。这是因为打字与它假定，而不是变量本身的价值相关联。

例如在Python：

str = "Hello" # variable str is linked to a string value
str = 5       # now it is linked to an integer value; perfectly OK

所以，最好是在动态语言如的只是通用指针的类型化值想到的变量。

要综上所述，的类型描述（或应该描述的）的语言而不是语言本身的变量。它可能是如的语言更好地利用与静态类型变量对的语言与动态类型的变量 IMHO。

静态类型语言通常是编译语言，因此，编译器检查类型（非常清楚了吧？因为类型不允许以后在运行时间上的改变）。

动态类型语言一般解释，从而类型检查（如果有的话）中使用时它们发生在运行时间。当然，这带来了一些性能开销，并且是原因动态语言（例如，Python和Ruby，PHP）的规模做不大的类型的人（JAVA，C＃等），很好的一个。从另一个角度看，静态类型语言有更多的初创成本：使你平时写更多的代码，更难代码。但是，支付后关闭。

的好处是双方都从另一侧借款功能。类型的语言正在将更多的动态特征，例如，泛型和在c＃动态库和动态语言包括更多类型检查，例如，在python类型的注释，或HACK PHP的变体，其通常不是核心的语言和使用的上需求。

当涉及到的技术选择，任何一方都具有优于其他的固有的优越性。这仅仅是一个是否要更多的控制开始或灵活性偏好的问题。只挑选了合适的工具，并确保检查什么是相反的方面可考虑转换之前。

Answer 5

http://en.wikipedia.org/wiki/Type_system

静的打字

一种编程语言是说使用 静的打字的时候类型检查 执行期间的编写时间 而不是运行时间。在静的打字， 类型的相关变量 不值。静态类型的语言 包括阿达、C、C++、C#、翡翠、Java Fortran，Haskell，ML、帕斯卡、Perl (相对于区分 标量、数组和哈希 子程序)和斯卡拉.静的打字 是的有限形式的程序 核查(见类型的安全):因此，它允许许多类型的 错误被抓住在早期 发展周期。静态型 棋子仅评价的类型 信息可以确定 编制时间，但能够证实 该检查的条件下举行为 所有可能的执行 计划，这样就不需要 重复类型的检查，每次 程序执行。程序的执行 也可以由更高效的(即快或减少存储器)通过 省略运行时的类型和检查 让其他的优化。

因为他们评估类型的信息 在汇编，因此缺乏 类型的信息，这只是 在运行时间，静态型 跳棋比较保守。他们将会 拒绝的某些程序可以 表现良好的运行时间，但是， 不能是静态确定的是 好的类型。例如，即使一个 表情总是 计算结果为真正在运行时， 节目含有的代码

if <complex test> then 42 else <type error>

将被拒绝，如虐待类型，因为 静态分析不能确定 这的其他分支不会 采取的。[1]保守的行为 静态型的跳棋 有利的时候 计算结果以虚假不常:一个 静态型检查可检测类型 错误，在很少使用代码的路径。没有静态型的检查，甚至 代码复盖范围的测试与100%的代码 复盖范围可能无法找到这样的 类型的错误。代码复盖范围的测试可以 无法检测到这种类型的错误 因为组合的所有地方 其中值创造和所有 地方一定的价值是使用 必须加以考虑。

使用最广泛的静态类型 语言不是正式类型的安全。他们有"漏洞"的 编程语言中的规范 启用程序员编写代码 这规避了验证 进行静态型和检查程序 所以处理更大范围的问题。例如，Java和最C-风格 语言有类型punning， Haskell有这样的功能 unsafePerformIO:这种行动可能 是不安全的运行时，在他们可以 会导致不必要的行为由于 错误输入的价值观时的 程序运行。

动态的打字

一种编程语言是说 动态类型，或只是'动态', 当大多数的检查类型 是在运行时执行反对 在编译时间。在动态的打字， 类型都与不值 变量。动态类型的语言 包括常规的,JavaScript,口齿不清，Lua， 目标-C、Perl(相对于 用户定义的类型，而不是建立在 类型),PHP,序言，蟒蛇，红宝石， 一般和Tcl。相比，静 打字、打字动态可以更多 灵活的(例如通过允许的程序 产生的类型和功能基于 在运行时数据)，虽然在 费用的减少先天保证。这是因为一个动态的类型 语言接受和试图 执行一些方案，这可以 裁定为无效的一个静态的类型 检查。

动态的打字可能导致在运行 类型的错误--就是说，在运行时， 值可能有一个意想不到的类型，和 作为荒谬的那种类型 是的应用。这种操作可能发生 很久之后，地方 编程搞错了—就是 地方的错误类型的数据 传递到一个地方，它不应该 有。这使得错误很难 找到。

动态语言系统， 相比，他们的静态类型 兄弟，使更少的"compile-time" 检查的源代码(但会 检查，例如，该程序 在语法正确的)。运行时间 检查可能更多 复杂的，因为它们可以使用 动态信息以及任何 信息就是现在 汇编。另一方面， 运行时只检查断言， 条件保持在一个特定的 执行程序，并且这些 检查重复的每一个 执行程序。

发展动态类型 语言常常是支持通过 编程的做法，例如单元 测试。检测是一个关键的实践 专业软件的发展， 特别重要的是在 动态类型的语言。在 实践中，测试完成，以确保 正确的操作程序可以检测 更广泛的错误，而不是静态的 类型检查，但反之不能 搜索作为全面用的 错误的，这两种测试和静 类型检查能够检测。试验可以纳入的 软件建立循环，在这种情况下它 可以被认为是一个"compile-time" 检查，在程序的用户会 不必手动运行这种试验。

参考文献

1. 皮尔斯，本杰明*(2002年)。类型和编程语言。MIT Press.ISBN0-262-16209-1.

Answer 6

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

在无类型演算，所有术语lambda项，并可以在一个项来执行的唯一操作是将它应用到其它术语。因此，所有的操作总是导致在任一无限递归或λ术语，但从来没有发出错误信号。

然而，我们分别与原始数字和算术运算增大无类型演算，那么我们就可以进行无意义的操作，例如将两个lambda项一起：(λx.x) + (λy.y)。有人可能会认为，唯一明智的事情是，当发生这种情况，发出错误信号，但要做到这一点，每个值必须标有指示术语是拉姆达项或多项的指标。然后，加法运算符将检查确实是两个参数被标记为数字，如果他们都没有，发出错误信号。请注意，这些标签是不的类型，因为类型不是由这些程序产生的值的节目属性。

一个单类型化的语言，它这就是所谓的动态类型。

语言，如JavaScript，Python和Ruby等都是单类型的。再次，在JavaScript中typeof运营商和Python中type功能有误导性的名称;他们返回与操作数，而不是它们的类型相关联的标签。类似地，在dynamic_cast C ++和instanceof在Java中做不做的类型检查。

Answer 7

编制与解释

"当的源代码翻译"

• 源代码:原始代码(通常输入由一个人进入计算机)
• 翻译:源代码转换成一些计算机可以读取(即机器码)
• 运行时间:期间当程序执行命令(后汇编，如果编制)
• 编制语言:代码翻译之前的运行时间
• 解释的语言:代码翻译上的飞行，在执行期间

---

打字

"当类型的检查"

5 + '3' 是的一个实例类型的错误 强类型 语言，例如去蟒蛇，因为他们不允许"类型的胁迫"->的能力对价值的变化类型在某些情况下，例如合并两种类型。 弱类型 语言，例如JavaScript,不会扔一类型的错误(结果 '53').

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

---

所定义的"静态和汇编"和"动态解释"非常相似...但是记住它的"当类型的检查"对"当的源代码翻译成".

你会得到的相同类型的错误不论是否语言编或解释!你需要独立的这些条款的概念.

---

蟒蛇例

动态解释

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

silly(2)

因为蟒蛇是这两种解释和动态型的，它仅仅意味着和类型的检查代码，它的执行。的 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

动态输入更加灵活，其中有些人赞赏。它通常允许对于变量变化的类型，这可能会导致在意想不到的错误。

Answer 8

在编译时静态类型语言类型检查和类型可以不会改变。 （不要与可爱型铸造注释，创建一个新的变量/参考）。

动态类型语言类型检查在运行时间和可变的类型可以在运行时被改变。

Answer 9

<强>静态类型语言：每个变量和表达式是在编译时已知的。

（int a;一可以在运行时仅取整数型值）

实施例：C，C ++，Java的

<强>动态类型语言：变量可以在运行时接收不同的值和它们的类型将在运行时定义的。

（var a;一个可以采取任何一种在运行时的值）

实例：红宝石，Python的

Answer 10

甜和简单的定义，但配合的需要： 静态类型语言绑定类型的变量为它的整个范围（SEG：SCALA） 动态语言绑定类型由变量引用的实际值。

Answer 11

• 在一个静态语言，一个变量相关的一个类型是已知的，在编制时，这类保持不变的整个执行程序。效地变量只能分配的价值，这是一个实例，已知/指定的类型。
• 在动态的语言，一个变量没有类型，其价值在执行期间可以是任何东西任何形状和形式。

Answer 12

，如C ++，Java和动态静态类型语言类型如Python语言不同之处仅在变量的类型的执行方面。    静态类型语言有静态的数据类型为变量，这里编译所以在调试过程中的数据类型进行检查就简单多了......而动态类型语言不用做同样，该数据类型被检查其执行该程序，因此调试是有点困难。

此外，它们具有非常小的差异，并且可以与的强类型和<强>弱类型语言有关。强类型语言不允许你使用一种类型作为另一个如。 C和C ++ ...而弱类型语言允许eg.python

Answer 13

动态类型语言有助于快速原型算法的概念，而不约思维变量类型需要使用哪些开销（这是一种必然的静态类型LANGUAG E） 。

Answer 14

静态的类型语言(compiler解决方法调和编写参考文献):

• 通常更好的性能
• 快编译错误的反馈
• 更好的支持IDE
• 不适合工作，与不确定的数据格式
• 很难开始发展的时候模型未定义的时候
• 较长的编制时间
• 在许多情况下需要编写更多的代码

动态的类型语言(决定在运行的程序):

• 下表现
• 更快速的发展
• 一些错误可能被检测到的只是后来在运行时间
• 好的未定义的数据格式(meta编程)

Answer 15

<强>静态类型： 诸如Java和Scala语言是静态的类型化的。

的变量具有被定义并初始化它们在代码中使用之前。

为前。 INT X; X = 10;

的System.out.println（X）;

<强>动态类型：  Perl是一种动态类型语言。

它们在代码使用之前

变量不需要被初始化。

Y = 10;在的代码后期使用此变量