静态类型语言

如果一个变量的类型在编译时已知，那么该语言就是静态类型的。对于某些语言，这意味着作为程序员的你必须指定每个变量的类型;其他语言(例如:Java, C, c++)提供了某种形式的类型推断，类型系统推断变量类型的能力(例如:OCaml, Haskell, Scala, Kotlin)。

这样做的主要优点是编译器可以完成所有类型的检查，因此在非常早期的阶段就可以捕捉到许多微不足道的错误。

例如:C, c++， Java, Rust, Go, Scala

动态类型语言

如果一种语言的类型与运行时值相关联，而不是命名变量/字段等，则该语言是动态类型的。这意味着作为程序员，您可以编写得更快一些，因为您不必每次都指定类型(除非使用带有类型推断的静态类型语言)。

例如:Perl, Ruby, Python, PHP, JavaScript, Erlang

大多数脚本语言都有这个特性，因为没有编译器来进行静态类型检查，但您可能会发现自己在搜索由于解释器错误解释变量类型而导致的错误。幸运的是，脚本往往很小，所以bug没有那么多藏身之处。

大多数动态类型语言允许您提供类型信息，但不要求提供类型信息。目前正在开发的一种语言Rascal采用了一种混合方法，允许函数内的动态类型，但对函数签名强制执行静态类型。

静态类型语言(编译器解析方法调用和编译引用):

通常表现更好 更快的编译错误反馈 更好的IDE支持 不适合使用未定义的数据格式 当没有定义模型时，很难开始开发 更长的编译时间 在很多情况下需要编写更多的代码

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

较低的性能 更快的发展 有些bug可能只在稍后的运行时才会被检测到 适用于未定义的数据格式(元编程)

动态类型语言有助于快速构建算法概念原型，而不需要考虑需要使用什么变量类型(这在静态类型语言中是必要的)。

在静态类型语言中，变量与编译时已知的类型相关联，并且该类型在整个程序执行过程中保持不变。同样，变量只能被赋值为已知/指定类型的实例。 在动态类型语言中，变量没有类型，它在执行期间的值可以是任何形状和形式的任何东西。

简单地说:在静态类型语言中，变量的类型是静态的，这意味着一旦将变量设置为类型，就不能更改它。这是因为类型是与变量而不是它所引用的值相关联的。

例如，在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中:

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

因此，最好将动态类型语言中的变量视为指向类型值的泛型指针。

总而言之，类型描述(或应该描述)语言中的变量，而不是语言本身。恕我直言，它本可以更好地用作带有静态类型变量的语言，而不是带有动态类型变量的语言。

静态类型语言通常是编译语言，因此，编译器检查类型(这很有意义，对吧?因为类型不允许稍后在运行时更改)。

动态类型语言通常是解释型的，因此类型检查(如果有的话)发生在使用它们时的运行时。这当然会带来一些性能损失，也是动态语言(例如python、ruby、php)伸缩性不如类型化语言(java、c#等)的原因之一。从另一个角度来看，静态类型语言的启动成本更高:通常会让你编写更多、更难的代码。但这在以后是有回报的。

好在双方都在借鉴对方的特点。类型语言融合了更多的动态特性，例如c#中的泛型和动态库，而动态语言则包含了更多的类型检查，例如python中的类型注释，或PHP的HACK变体，这些通常不是语言的核心，可按需使用。

在技术选择方面，任何一方都没有内在的优势。这只是一个偏好的问题，你想要更多的控制或灵活性。只要为工作选择合适的工具，并确保在考虑转换之前检查相反的可用工具。

不幸的是，术语“动态类型”具有误导性。所有语言都是静态类型的，类型是表达式的属性(而不是一些人认为的值的属性)。然而，有些语言只有一种类型。这些被称为单一类型语言。这种语言的一个例子是无类型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不做类型检查。