静态类型和动态类型语言有什么区别？

Question

当我们说一种语言是动态类型与静态类型时，这意味着什么？

Answer 1

静态类型：
Java 和 Scala 等语言都是静态类型的。

变量在代码中使用之前必须进行定义和初始化。

例如。整数x； x = 10；

System.out.println(x);

动态打字：
Perl 是一种动态类型语言。

变量在代码中使用之前不需要初始化。

y=10；在代码的后面部分使用这个变量

Answer 2

静态类型语言

如果变量的类型在编译时已知，则该语言是静态类型的。对于某些语言，这意味着您作为程序员必须指定每个变量的类型；其他语言（例如：Java、C、C++）提供某种形式的类型推断，即类型系统推断变量类型的能力（例如：OCaml、Haskell、Scala、Kotlin）。

这里的主要优点是编译器可以完成各种检查，因此可以在很早的阶段捕获很多微不足道的错误。

示例：C、C++、Java、Rust、Go、Scala

动态类型语言

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

示例：Perl、Ruby、Python、PHP、JavaScript、Erlang

大多数脚本语言都具有此功能，因为无论如何都没有编译器进行静态类型检查，但您可能会发现自己正在寻找由于解释器错误解释类型而导致的错误的一个变量。幸运的是，脚本往往很小，因此错误没有太多隐藏的地方。

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

Answer 3

类型检查是验证和强制执行类型约束的过程。

• 静态类型编程语言在编译时进行类型检查。
  示例：Java、C、C++。

• 动态类型编程语言在运行时进行类型检查。
  示例：
  Perl、Ruby、Python、PHP、JavaScript。

Answer 4

下面是一个对比 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（字符串和整数类型不匹配）

Answer 5

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

例如在 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 变体，这些通常不是该语言的核心，可以在要求。

在技​​术选择方面，双方并不存在本质上的优势。您是否想要更多的控制权或灵活性只是一个偏好问题。只需为工作选择正确的工具，并确保在考虑转换之前检查相反的可用工具。

Answer 6

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

静态类型

据说有一种编程语言使用
类型检查时的静态类型
在编译时执行为
与运行时相反。在静态类型中，
类型与变量相关联
不是价值观。静态类型语言
包括 Ada、C、C++、C#、JADE、Java、
Fortran、Haskell、ML、Pascal、Perl
（关于区分
标量、数组、散列和
子例程）和 Scala。静态类型
是程序的有限形式
验证（参见类型安全）：
因此，它允许多种类型
尽早发现错误
开发周期。静态型
检查器仅评估类型
可以确定的信息
编译时间，但能够验证
所检查的条件成立
所有可能的执行
程序，这消除了需要
每次重复类型检查
程序被执行。程序执行
也可以变得更有效率（即
更快或占用更少的内存）
省略运行时类型检查和
启用其他优化。

因为它们评估类型信息
在编译期间，因此缺乏
仅键入信息
运行时可用，静态类型
跳棋是保守的。他们会
拒绝一些可能的程序
在运行时表现良好，但是
不能静态地确定
类型良好。例如，即使
表达总是
在运行时评估为 true，a
包含代码的程序

if <复杂测试>然后 42 else <类型错误>

将因类型错误而被拒绝，因为
静态分析无法确定
else 分支不会
已采取。[1]保守行为
静态类型检查器的数量是
有利时
很少评估为 false：A
静态类型检查器可以检测类型
很少使用的代码路径中的错误。
没有静态类型检查，即使
100% 代码的代码覆盖率测试
覆盖范围可能无法找到此类
类型错误。代码覆盖率测试可能
无法检测到此类类型错误
因为所有地方的结合
价值创造的地方
使用特定值的地方
必须考虑在内。

使用最广泛的静态类型
语言在形式上不是类型安全的。
他们的做法有“漏洞”
编程语言规范
使程序员能够编写代码
从而规避验证
由静态类型检查器执行并且
从而解决更广泛的问题。
例如，Java 和大多数 C 风格
语言具有类型双关语，并且
Haskell 具有以下功能：
unsafePerformIO：此类操作可能
在运行时不安全，因为它们可以
由于以下原因导致不良行为
错误地输入值时
程序运行。

动态输入

据说一种编程语言是
动态类型，或者只是“动态”，
当其大部分类型检查
是在运行时执行的，而不是
在编译时。在动态类型中，
类型与值不相关
变量。动态类型语言
包括 Groovy、JavaScript、Lisp、Lua、
Objective-C、Perl（相对于
用户定义类型但不是内置类型
类型）、PHP、Prolog、Python、Ruby、
Smalltalk 和 Tcl。与静态相比
打字，动态打字可以更多
灵活（例如允许程序
基于生成类型和功能
关于运行时数据），尽管在
以较少的先验保证为代价。
这是因为动态类型
语言接受并尝试
执行一些程序可能是
被静态类型判定为无效
检查器。

动态类型可能会导致运行时
类型错误——也就是说，在运行时，
值可能具有意外的类型，并且
对于该类型来说无意义的操作
被应用。该操作可能会发生
很久之后的地方
犯了编程错误——也就是说，
数据类型错误的地方
传递到不应该的地方
有。这使得该错误很难
定位。

动态类型语言系统，
与静态类型相比
表兄弟，减少“编译时”
检查源代码（但会
例如，检查程序
语法上是正确的）。运行时
检查可能会更多
复杂，因为他们可以使用
动态信息以及任何
期间出现的信息
汇编。另一方面，
运行时检查仅断言
条件在特定条件下成立
程序的执行，以及这些
对每个重复检查
程序的执行。

动态类型开发
语言通常支持
编程实践，例如单元
测试。测试是一个关键实践
专业软件开发，以及
尤为重要的是
动态类型语言。在
实践，进行测试以确保
正确的程序运行可以检测到
误差范围比静态误差范围大得多
类型检查，但反过来不能
尽可能全面地搜索
测试和静态错误
类型检查都能够检测到。
测试可以纳入
软件构建周期，在这种情况下
可以被认为是“编译时”
检查，因为程序用户将
不必手动运行此类测试。

参考文献

1. 本杰明·皮尔斯 (2002)。类型和编程语言。麻省理工学院出版社。
   ISBN 0-262-16209-1。

Answer 7

编译与解释

“当源代码被翻译时”

• 源代码：原始代码（通常由人类输入到计算机中）
• 翻译：将源代码转换为计算机可以处理的内容读取（即机器代码）
• 运行时：程序执行命令的时期（编译后，如果已编译）
• 编译语言：运行时之前翻译的代码
• 解释语言：在执行期间动态翻译的代码

---

键入

“当检查类型时”

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 块将在运行时之前被翻译/查看，但因为它是动态类型的，所以不会抛出错误！动态类型语言在执行之前不会检查类型，并且该行永远不会执行。

---

Go 示例

静态、编译

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

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

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

然而，如果我们用原始数字和算术运算来增强无类型 lambda 演算，那么我们可能会执行无意义的运算，例如将两个 lambda 项加在一起：(λx.x) + (λy.y)。有人可能会说，唯一明智的做法是在发生这种情况时发出错误信号，但为了能够做到这一点，每个值都必须用一个指示符来标记，以指示该项是 lambda 项还是数字。然后，加法运算符将检查两个参数是否确实被标记为数字，如果不是，则发出错误信号。请注意，这些标记不是类型，因为类型是程序的属性，而不是这些程序生成的值的属性。

执行此操作的单一类型语言称为动态类型。

JavaScript、Python 和 Ruby 等语言都是单一类型的。同样，JavaScript 中的 typeof 运算符和 Python 中的 type 函数的名称具有误导性；它们返回与操作数相关的标签，而不是其类型。同样，C++ 中的 dynamic_cast 和 Java 中的 instanceof 不进行类型检查。

Answer 9

在编程中，数据类型是一种分类，它告诉我们 1) 变量将保存什么类型的值，以及 2) 可以对这些值执行哪些数学、关系和逻辑运算而不会出错。

当人们在以下上下文中提到“类型”时，他们的意思是“数据类型”。

在每种编程语言中，为了最大限度地减少出现错误的机会，类型检查是在程序执行之前或期间进行的。根据类型检查的时机，有两种类型的编程语言：静态类型和动态类型语言（或混合，其中用户说明每个变量使用哪个（静态/动态））。

此外，根据隐式类型转换是否发生，有两种类型的编程语言：强类型和弱类型语言。

静态类型：

• 类型检查在编译时完成

• 在源代码中，在变量声明时（将值分配给新变量时），该变量的数据类型必须显式指定（即不能隐式/推断/猜测），因为如果在源代码中指定数据类型，则在编译时源代码将转换为机器代码并允许进行类型检查

• 这里，数据类型与变量相关联（变量名，而不是值），例如，int count。该关联是静态的（固定的）

• 如果我们尝试通过分配不同数据类型的值（int count = “Hello”），然后我们会得到一个错误

• 如果我们尝试通过使用不同的数据类型（boolean count）重新声明已经声明的变量（int count）来更改数据类型）那么我们也会得到一个错误

int count;         /* count is int type, association between data type
                      and variable is static or fixed */

count = 10;        // no error 
count = 'Hello';   // error 
boolean count;     // error 

• 由于类型检查和类型错误检测是在编译时完成的，因此在运行时不需要进一步的类型检查。因此，程序变得更加优化，执行速度更快

• 如果我们想要更多类型严格的代码，那么选择这种类型的语言是更好的选择

• 示例：Java、C、C++、Go、Swift 等

动态类型：

• 类型检查在运行时完成

• 在源代码中，在变量声明时，不需要显式指定该变量的数据类型。因为类型检查是在运行时完成的，所以语言的系统根据变量分配值的数据类型来确定变量类型

• 此处，数据类型与分配给变量的值相关联。例如，var foo = 10：10 是一个数字，所以现在 foo 是数字数据类型。但这种关联是动态的（灵活的）

• 我们可以通过分配不同数据类型的值（foo = "Hi") 进入其中，不会产生错误

• 我们可以轻松地更改已经声明的变量 (var foo = 10) 的数据类型，方法是使用其他数据类型的值 (var foo = true），不产生错误

var foo;            // without assigned value, variable holds undefined data type 

var foo = 10;       // foo is Number type now, association between data 
                    // type and value is dynamic / flexible 
foo = 'Hi';         // foo is String type now, no error 
var foo = true;     // foo is Boolean type now, no error 

• 由于类型检查和类型错误检测是在运行时完成的，动态类型程序的优化程度较低，导致执行速度较慢。尽管这些类型的语言如果实现 JIT（即时）编译器，执行速度会更快

• 如果我们想轻松地编写和执行代码，那么这种类型的语言是更好的选择，但在这里我们仍然不幸地得到运行时错误

• 示例：Python、JavaScript、PHP、Ruby 等

Answer 10

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

（int a; a 在运行时只能取整数类型值）

示例：C、C++、Java

动态类型语言：变量在运行时可以接收不同的值，其类型为在运行时定义。

（var a; a 可以在运行时采用任何类型的值）

示例：Ruby、Python。

Answer 11

静态类型语言在编译时进行类型检查，并且类型不能更改。 （不要对类型转换注释表现得可爱，会创建一个新的变量/引用）。

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

Answer 12

甜蜜而简单的定义，但符合需要：
静态类型语言将类型绑定到变量的整个作用域（Seg：SCALA）
动态类型语言将类型绑定到变量引用的实际值。

Answer 13

静态类型： 在编译时执行类型检查。

静态类型语言的实际含义是：

• 必须指定变量的类型
• 变量只能引用特定类型的对象*
• 将在编译时执行值的类型检查，并且届时将报告任何类型检查
• 的大小变量在编译时计算

静态类型语言的示例有 C、C++、Java。

动态类型： 在运行时执行类型检查。

动态类型语言的实际含义是：

• 无需指定变量的类型，
• 同一变量可以引用不同类型的对象

Python、Ruby 都是动态类型语言的例子。

请注意，无论静态或动态类型，变量的内存分配都是在执行应用程序/程序（加载到内存中）时执行的

---

_{* 某些对象可以通过类型转换将其分配给不同类型的变量（这是在C 和 C++ 等语言）}

Answer 14

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

Answer 15

静态类型语言（编译器解析方法调用和编译引用）：

• 通常性能更好
• ，编译速度更快，错误反馈
• 更好，IDE 支持
• 不适合处理未定义的数据格式，
• 在未定义模型时更难开始开发，
• 更长的编译时间
• 在许多情况下需要 编写更多代码

动态类型语言（在运行程序中做出的决定）：

• 性能较低
• 开发速度更快
• 有些错误可能只有在运行时稍后才能检测到
• ，适合未定义的数据格式（元编程）

Answer 16

静态类型语言（如 C++、Java）和动态类型语言（如 Python）仅在变量类型的执行方面有所不同。
静态类型语言具有变量的静态数据类型，这里在编译期间检查数据类型，因此调试要简单得多......而动态类型语言则不这样做同样，执行程序时会检查数据类型，因此调试有点困难。

而且它们之间的差异非常小，并且可以与强类型和弱类型语言相关。强类型语言不允许您将一种类型用作另一种类型，例如。 C 和 C++ ...而弱类型语言允许例如.python

Answer 17

静态类型

在运行时之前检查类型，以便可以更早地发现错误。

示例 = c++

动态类型

在执行期间检查类型。

示例=Python

Answer 18

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

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

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

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

Answer 19

动态类型语言有助于快速构建算法概念的原型，而无需考虑需要使用哪些变量类型（这在静态类型语言中是必需的）。

Answer 20

动态类型语言：

在 javascript 中（如果你知道），我们有两个数据类型关键字来定义变量名称：let 和 const（2015 年之前）只有一个 var）。

在Python中，甚至没有用数据类型关键字定义变量的概念。

但计算机内存或数据库系统中不存在 var、let 或 const 这样的东西。我们有 int、char、bigint 等。

那么，你明白了吗？作为程序员，我们不会在 JavaScript、Python、php、kotlin 等语言中定义变量数据类型，当代码在浏览器中运行（对于 js）或在服务器中解释（对于其他语言）时，解释器会决定应该使用什么数据类型根据变量中存储的数据分配给变量。

这个概念主要被解释/脚本语言所遵循，并且它在程序执行过程中会导致大量错误。这就是为什么你的 JavaScript 程序经常崩溃。

这在编程中被称为动态类型。

静态类型语言：

如果您曾经用 c、c++、java、go 或 rust 等语言编写过一些东西，您会发现，在编写代码时，我们会在变量名称之前提到变量的数据类型。

例如，在c和c++中，我们这样定义变量：int a = 1; char b = "a";

因此，作为程序员，我们有责任为变量分配数据类型。听起来很酷。

确实是……

这个概念通常是中低级语言所遵循的，并且可以显着减少因小错误而导致的错误。

这个概念称为静态类型。