静态类型语言和动态类型语言有什么区别？
当我们说一种语言是动态类型与静态类型时是什么意思？
静态类型语言
如果变量的类型在编译时已知，则语言是静态类型的。对于某些语言，这意味着您作为程序员必须指定每个变量的类型；其他语言（例如：Java、C、C++）提供某种形式的类型推断，即类型系统推断变量类型的能力（例如：OCaml、Haskell、Scala、Kotlin）。
这里的主要优点是编译器可以完成各种检查，因此在很早的阶段就发现了很多琐碎的错误。
示例：C、C++、Java、Rust、Go、Scala
动态类型语言
如果类型与运行时值相关联，而不是命名变量/字段/等，则该语言是动态类型的。这意味着您作为程序员可以写得更快一些，因为您不必每次都指定类型（除非使用带有类型推断的静态类型语言）。
示例：Perl、Ruby、Python、PHP、JavaScript、Erlang
大多数脚本语言都具有此功能，因为无论如何都没有编译器来进行静态类型检查，但是您可能会发现自己正在寻找由于解释器误解变量类型而导致的错误。幸运的是，脚本往往很小，所以 bug 没有太多可以隐藏的地方。
大多数动态类型语言确实允许您提供类型信息，但不需要它。当前正在开发的一种语言 Rascal 采用混合方法，允许在函数内进行动态类型化，但对函数签名强制执行静态类型化。
类型检查是验证和执行类型约束的过程。
静态类型的编程语言在编译时进行类型检查。示例：Java、C、C++。
动态类型编程语言在运行时进行类型检查。示例：Perl、Ruby、Python、PHP、JavaScript。
var 关键字，让 Java 开发人员体验动态类型，但 Java 仍然是静态类型。
下面是一个对比 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（不匹配的类型字符串和整数）
runhaskell 解释。
简单地说：在静态类型语言中，变量的类型是静态的，这意味着一旦将变量设置为类型，就无法更改它。这是因为类型与变量相关联，而不是它所引用的值。
例如在 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 变体，它们通常不是语言的核心，可用于要求。
在技术选择方面，双方都没有内在的优势。您是否想要更多的控制或灵活性只是一个偏好问题。只需为工作选择正确的工具，并确保在考虑转换之前检查可用的相反工具。
http://en.wikipedia.org/wiki/Type_system
静态类型 当在编译时而不是运行时执行类型检查时，一种编程语言被称为使用静态类型。在静态类型中，类型与变量而不是值相关联。静态类型语言包括 Ada、C、C++、C#、JADE、Java、Fortran、Haskell、ML、Pascal、Perl（关于区分标量、数组、散列和子例程）和 Scala。静态类型是程序验证的一种有限形式（参见类型安全）：因此，它允许在开发周期的早期发现许多类型错误。静态类型检查器仅评估可以在编译时确定的类型信息，但能够验证检查的条件是否适用于程序的所有可能执行，这消除了每次执行程序时重复类型检查的需要。通过省略运行时类型检查并启用其他优化，也可以使程序执行更高效（即更快或减少内存）。因为它们在编译期间评估类型信息，因此缺少仅在运行时可用的类型信息，所以静态类型检查器是保守的。他们会拒绝一些在运行时表现良好但不能静态确定为良好类型的程序。例如，即使一个表达式在运行时总是计算为真，包含代码 if
myObject[remoteDataName]。那么就无法知道它会选择哪个属性，甚至根本无法知道它是否是有效属性。
不幸的是，术语“动态类型”具有误导性。所有语言都是静态类型的，类型是表达式的属性（而不是某些人认为的值）。但是，有些语言只有一种类型。这些被称为单类型语言。这种语言的一个例子是无类型的 lambda 演算。
在无类型 lambda 演算中，所有项都是 lambda 项，唯一可以对项执行的操作是将其应用于另一个项。因此，所有操作总是导致无限递归或 lambda 项，但绝不会发出错误信号。
然而，如果我们用原始数字和算术运算来扩充无类型的 lambda 演算，那么我们可以执行无意义的操作，例如将两个 lambda 项加在一起：(λx.x) + (λy.y)。有人可能会争辩说，唯一明智的做法是在发生这种情况时发出错误信号，但为了能够做到这一点，每个值都必须用一个指示符标记，指示该术语是 lambda 术语还是数字。然后，加法运算符将检查两个参数是否确实被标记为数字，如果不是，则发出错误信号。请注意，这些标签是 not 类型，因为类型是程序的属性，而不是那些程序产生的值。
执行此操作的单类型语言称为动态类型。
JavaScript、Python 和 Ruby 等语言都是单一类型的。同样，JavaScript 中的 typeof 运算符和 Python 中的 type 函数具有误导性名称；它们返回与操作数关联的标签，而不是它们的类型。同样，C++ 中的 dynamic_cast 和 Java 中的 instanceof不进行类型检查。
编译与解释
“翻译源代码时”
源代码：原始代码（通常由人输入计算机）
翻译：将源代码转换成计算机可以读取的东西（即机器代码）
运行时间：程序执行命令的时间段（编译后，如果已编译）
编译语言：在运行时之前翻译的代码
解释语言：在执行期间动态翻译的代码
打字
“检查类型时”
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
动态类型更灵活，有些人对此表示赞赏。它通常允许变量更改类型，这可能导致意外错误。
静态类型语言：每个变量和表达式在编译时都是已知的。
（int a; a 在运行时只能采用整数类型值）
示例：C、C++、Java
动态类型语言：变量可以在运行时接收不同的值，并且它们的类型是在运行时定义的。
（var a; a 可以在运行时采用任何类型的值）
示例：Ruby、Python。
静态类型语言在编译时进行类型检查，并且类型不能更改。 （不要对类型转换注释变得可爱，会创建一个新变量/引用）。
动态类型语言在运行时进行类型检查，变量的类型可以在运行时更改。
甜蜜而简单的定义，但符合需要：静态类型语言将类型绑定到其整个范围的变量（例如：SCALA） 动态类型语言将类型绑定到变量引用的实际值。
在静态类型语言中，变量与编译时已知的类型相关联，并且该类型在整个程序执行过程中保持不变。等效地，只能为变量分配一个值，该值是已知/指定类型的实例。
在动态类型语言中，变量没有类型，在执行期间它的值可以是任何形状和形式的任何东西。
静态类型语言（编译器解析方法调用和编译引用）：
通常性能更好
更快的编译错误反馈
更好的 IDE 支持
不适合使用未定义的数据格式
当模型未定义时，更难开始开发
更长的编译时间
在很多情况下需要编写更多代码
动态类型语言（在运行程序时做出的决定）：
较低的性能
更快的发展
某些错误可能仅在运行时后期才被检测到
适用于未定义的数据格式（元编程）
静态类型：在编译时执行类型检查。
静态类型语言的实际含义：
必须指定变量的类型
变量只能引用特定类型的对象*
值的类型检查将在编译时执行，任何类型检查都将在那时报告
内存将在编译时分配以存储该特定类型的值
静态类型语言的示例是 C、C++、Java。
动态类型：在运行时执行类型检查。
动态类型语言的实际含义：
无需指定变量的类型
同一个变量可以引用不同类型的对象
Python、Ruby 都是动态类型语言的例子。
* 一些对象可以通过类型转换分配给不同类型的变量（在 C 和 C++ 等语言中非常常见的做法）
静态类型语言（如 C++、Java）和动态类型语言（如 Python）仅在变量类型的执行方面有所不同。静态类型语言具有变量的静态数据类型，这里在编译期间检查数据类型，因此调试更简单......而动态类型语言不做同样的事情，检查执行程序的数据类型，因此调试有点困难。
此外，它们的差异非常小，可以与强类型和弱类型语言相关。强类型语言不允许您将一种类型用作另一种类型，例如。 C 和 C++ ...而弱类型语言允许 eg.python
静态类型
在运行时检查类型，因此可以更早地发现错误。
示例 = C++
动态类型
在执行期间检查类型。
示例 = Python
动态类型编程，允许程序在运行时更改变量的类型。
https://i.stack.imgur.com/x5XCH.png
静态类型，意味着如果您尝试将字符串存储在整数变量中，它不会接受它。
https://i.stack.imgur.com/hLMYa.png
动态类型语言有助于快速原型化算法概念，而无需考虑需要使用哪些变量类型（这在静态类型语言中是必需的）。
静态类型：Java 和 Scala 等语言是静态类型的。
变量在代码中使用之前必须定义和初始化。
例如。诠释 x; x = 10;
System.out.println(x);
动态类型：Perl 是一种动态类型语言。
变量在代码中使用之前不需要初始化。
y=10；在后面的代码中使用这个变量
$)、数组 (@) 和散列 (%)。 Perl 中变量的类型在编译时是已知的，并且在变量的其余生命周期内保持不变。
关注公众号
不定期副业成功案例分享
