我经常听说新的编程语言是动态类型的，但是当我们说一种语言是动态类型与静态类型时，这实际上意味着什么？
【问题讨论】：
标签： programming-languages computer-science static-typing dynamic-typing
http://en.wikipedia.org/wiki/Type_system
静态输入
据说一种编程语言使用 类型检查时的静态类型 在编译时执行为 反对运行时。在静态类型中， 类型与变量相关联 不是价值观。静态类型语言 包括 Ada、C、C++、C#、JADE、Java、 Fortran、Haskell、ML、Pascal、Perl （关于区分 标量、数组、哈希和 子程序）和 Scala。静态类型 是一种有限形式的程序 验证（参见类型安全）： 因此，它允许许多类型 早期发现的错误 开发周期。静态类型 检查器只评估类型 可以确定的信息 编译时间，但能够验证 检查条件成立 所有可能的执行 程序，它消除了需要 每次重复类型检查 程序被执行。程序执行 也可以提高效率（即 更快或减少内存） 省略运行时类型检查和 启用其他优化。
因为他们评估类型信息 在编译期间，因此缺乏 类型信息仅 在运行时可用，静态类型 跳棋是保守的。他们将 拒绝一些可能的程序 在运行时表现良好，但是 不能静态确定为 好排版。例如，即使一个 总是表达 在运行时计算为真，a 包含代码的程序
if <complex test> then 42 else <type error>将被拒绝为错误类型，因为 静态分析无法确定 else 分支不会是 [1]保守的行为 静态类型检查器是 有利时 很少评估为假：A 静态类型检查器可以检测类型 很少使用的代码路径中的错误。 没有静态类型检查，即使 100% 代码的代码覆盖率测试 覆盖面可能无法找到这样的 类型错误。代码覆盖测试可能 未能检测到此类类型错误 因为所有地方的结合 创造价值的地方和所有 使用特定值的地方 必须考虑在内。
使用最广泛的静态类型 语言不是正式的类型安全的。 他们有“漏洞” 编程语言规范 使程序员能够编写代码 绕过验证 由静态类型检查器执行，并且 从而解决更广泛的问题。 例如，Java 和大多数 C 风格 语言有类型双关语，并且 Haskell 具有以下特性 unsafePerformIO：此类操作可能 在运行时不安全，因为它们可以 导致不必要的行为，因为 输入错误的值时 程序运行。
动态输入
一种编程语言被称为 动态类型，或者只是“动态”， 当它的大部分类型检查 在运行时执行，而不是 在编译时。在动态类型中， 类型与不相关的值 变量。动态类型语言 包括 Groovy、JavaScript、Lisp、Lua、 Objective-C，Perl（关于 用户定义的类型，但不是内置的 类型）、PHP、Prolog、Python、Ruby、 Smalltalk 和 Tcl。与静态相比 打字，动态打字可以更多 灵活（例如，通过允许程序 基于生成类型和功能 运行时数据），虽然在 减少先验保证的费用。 这是因为动态类型 语言接受并试图 执行一些程序，这可能是 被静态类型判定为无效 检查器。
动态输入可能会导致运行时 类型错误——也就是说，在运行时，一个 value 可能具有意外的类型，并且 该类型的操作无意义 被申请;被应用。可能会出现此操作 很久以后 犯了编程错误——也就是说， 数据类型错误的地方 进入不应该的地方 有。这使得该错误难以 定位。
动态类型语言系统， 与它们的静态类型相比 堂兄弟，减少“编译时间” 检查源代码（但会 例如，检查程序 在语法上是正确的）。运行 检查可能会更多 复杂，因为他们可以使用 动态信息以及任何 期间出现的信息 汇编。另一方面， 运行时检查仅断言 在特定条件下成立 程序的执行，以及这些 对每个重复检查 程序的执行。
动态类型的开发 语言通常由 编程实践，例如单元 测试。测试是一个关键的实践 专业软件开发，以及 在中尤为重要 动态类型语言。在 实践，所做的测试以确保 正确的程序操作可以检测到 比静态更广泛的错误 类型检查，但反过来不能 全面搜索 测试和静态的错误 类型检查能够检测到。 测试可以纳入 软件构建周期，在这种情况下它 可以被认为是“编译时” 检查，因为程序用户将 不必手动运行此类测试。
参考文献
- 本杰明皮尔斯 (2002)。类型和编程语言。麻省理工学院出版社。 ISBN 0-262-16209-1。
【讨论】：
myObject[remoteDataName]。那么就无法知道它将选择哪个属性，甚至根本无法知道它是否是有效属性。
如果变量的类型在编译时已知，则语言是静态类型的。对于某些语言，这意味着您作为程序员必须指定每个变量的类型；其他语言（例如：Java、C、C++）提供某种形式的类型推断，即类型系统推断变量类型的能力（例如：OCaml、Haskell、Scala、Kotlin）。
这里的主要优点是各种检查都可以由编译器完成，因此在很早的阶段就发现了很多琐碎的错误。
示例：C、C++、Java、Rust、Go、Scala
如果类型与运行时值相关联，而不是命名变量/字段/等，则该语言是动态类型的。这意味着您作为程序员可以写得更快一些，因为您不必每次都指定类型（除非使用具有类型推断的静态类型语言）。
示例：Perl、Ruby、Python、PHP、JavaScript、Erlang
大多数脚本语言都具有此功能，因为无论如何都没有编译器来进行静态类型检查，但是您可能会发现自己正在寻找由于解释器误解变量类型而导致的错误。幸运的是，脚本往往很小，所以 bug 没有太多可以隐藏的地方。
大多数动态类型语言都允许您提供类型信息，但并不要求提供。目前正在开发的一种语言 Rascal 采用混合方法，允许在函数内进行动态类型化，但对函数签名强制执行静态类型化。
【讨论】：
静态类型编程语言在编译时而不是在运行时进行类型检查（即验证和执行类型约束的过程）。 p>
动态类型编程语言在运行时而不是编译时进行类型检查。
静态类型语言的示例有：Java、C、C++
动态类型语言的示例是：- Perl、Ruby、Python、PHP、JavaScript
【讨论】：
静态输入： Java 和 Scala 等语言是静态类型的。
在代码中使用变量之前，必须先定义和初始化。
例如。诠释 x; x = 10;
System.out.println(x);
动态输入： Perl 是一种动态类型语言。
变量在用于代码之前不需要初始化。
y=10;在后面的代码中使用这个变量
【讨论】：
$)、数组 (@) 和哈希 (%)。 Perl 中变量的类型在编译时是已知的，并且在变量的其余生命周期内保持不变。
这是一个对比 Python（动态类型）和 Go（静态类型）如何处理类型错误的示例：
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'
因为相关的行实际上已经被执行了。
另一方面，Go 在编译时进行类型检查：
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)
【讨论】：
runhaskell 解释。
不幸的是，术语“动态类型”具有误导性。所有语言都是静态类型的，类型是表达式的属性（而不是某些人认为的值）。但是，有些语言只有一种类型。这些被称为单类型语言。这种语言的一个例子是无类型的 lambda 演算。
在无类型的 lambda 演算中，所有项都是 lambda 项，唯一可以对项执行的操作是将其应用于另一个项。因此，所有操作总是导致无限递归或 lambda 项，但绝不会发出错误信号。
但是，如果我们用原始数字和算术运算来扩充无类型 lambda 演算，那么我们可以执行无意义的运算，例如将两个 lambda 项加在一起：(λx.x) + (λy.y)。有人可能会争辩说，唯一明智的做法是在发生这种情况时发出错误信号，但要做到这一点，每个值都必须用一个指示符标记，指示该术语是 lambda 术语还是数字。然后，加法运算符将检查两个参数是否确实被标记为数字，如果不是，则发出错误信号。请注意，这些标签是不是类型，因为类型是程序的属性，而不是那些程序产生的值。
执行此操作的单类型语言称为动态类型。
JavaScript、Python 和 Ruby 等语言都是单一类型的。同样，JavaScript 中的 typeof 运算符和 Python 中的 type 函数具有误导性名称；它们返回与操作数关联的标签，而不是它们的类型。同样，C++ 中的dynamic_cast 和Java 中的instanceof不进行类型检查。
【讨论】：
简单地说：在静态类型语言中，变量的类型是静态的，这意味着一旦将变量设置为类型，就无法更改它。这是因为类型与变量相关联，而不是它所引用的值。
例如在 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
因此，最好将动态类型语言中的变量视为只是指向类型值的通用指针。
总而言之，type 描述（或应该描述）语言中的变量，而不是语言本身。它本来可以更好地用作具有静态类型变量的语言而不是具有动态类型变量的语言恕我直言。
静态类型语言通常是编译语言，因此，编译器会检查类型（非常有意义，对吧？因为以后在运行时不允许更改类型）。
动态类型语言通常会被解释，因此类型检查（如果有的话）在使用它们时在运行时进行。这当然会带来一些性能成本，这也是动态语言（例如，python、ruby、php）无法像类型语言（java、c# 等）那样扩展的原因之一。从另一个角度来看，静态类型语言有更多的启动成本：使您通常编写更多的代码，更难的代码。但这会在以后得到回报。
好消息是双方都在借鉴对方的功能。类型化语言正在包含更多动态特性，例如 c# 中的泛型和动态库，而动态语言包含更多类型检查，例如 python 中的类型注释或 PHP 的 HACK 变体，它们通常不是语言的核心，可用于要求。
在技术选择方面，双方都没有天生的优势。您是否想要更多的控制或灵活性只是一个偏好问题。只需为工作选择正确的工具，并确保在考虑切换之前检查相反的可用工具。
【讨论】：
静态类型语言在编译时进行类型检查，类型不能改变。 （不要因为类型转换 cmets 而变得可爱，会创建一个新变量/引用）。
动态类型语言在运行时进行类型检查，变量的类型可以在运行时更改。
【讨论】：
【讨论】：
甜蜜而简单的定义，但符合需要： 静态类型语言将类型绑定到其整个范围的变量（Seg: SCALA） 动态类型语言将类型绑定到变量引用的实际值。
【讨论】：
静态类型语言：每个变量和表达式在编译时都是已知的。
(int a;a 在运行时只能取整型值)
示例：C、C++、Java
动态类型语言：变量可以在运行时接收不同的值，并且它们的类型在运行时定义。
（var a;a 在运行时可以采用任何类型的值）
示例：Ruby、Python。
【讨论】：
“当源代码被翻译时”
“检查类型时”
5 + '3' 是 Go 和 Python 等 强类型 语言中的类型错误示例，因为它们不允许“类型强制” -> 值更改的能力在某些上下文中键入，例如合并两种类型。 弱类型语言，例如 JavaScript，不会引发类型错误（导致 '53'）。
“静态和编译”和“动态和解释”的定义非常相似……但请记住，它是“检查类型时”与“翻译源代码时”。
无论该语言是编译型还是解释型，都会出现相同类型的错误！您需要在概念上区分这些术语。
动态的，解释的
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
动态输入更加灵活，有些人对此表示赞赏。它通常允许变量更改类型，这可能会导致意外错误。
【讨论】：
动态类型语言有助于快速构建算法概念原型，而无需考虑需要使用哪些变量类型（这在静态类型语言e中是必需的） .
【讨论】：
静态类型语言（如 C++、Java）和动态类型语言（如 Python）仅在变量类型的执行方面有所不同。 静态类型语言具有变量的静态数据类型，这里在编译期间检查数据类型，因此调试更加简单......而动态类型语言不这样做同样，检查执行程序的数据类型，因此调试有点困难。
此外，它们的区别非常小，可以与强类型和弱类型语言相关。强类型语言不允许您将一种类型用作另一种类型，例如。 C 和 C++ ...而弱类型语言允许 eg.python
【讨论】：
静态类型语言（编译器解析方法调用和编译引用）：
动态类型语言（在运行程序时做出的决定）：
【讨论】：
静态类型
在运行前检查类型，以便更早发现错误。
示例 = c++
动态类型
在执行期间检查类型。
示例 = Python
【讨论】：
静态类型： 在编译时执行类型检查。
静态类型语言的真正含义：
静态类型语言的示例是 C、C++、Java。
动态类型： 在运行时执行类型检查。
动态类型语言的真正含义：
Python、Ruby 是动态类型语言的例子。
* 一些对象可以通过类型转换分配给不同类型的变量（在 C 和 C++ 等语言中非常常见的做法）
【讨论】：