静态/动态与强/弱

Question

静态/动态和强/弱类型之间有什么区别？

Answer 1

• 静态/动态类型与何时获取类型信息有关（在编译时或运行时）

• 强/弱类型是关于严格程度类型是区分的（例如，语言是否尝试从字符串到数字进行隐式转换）。

有关更多详细信息，请参阅wiki 页面。

Answer 2

您发现了业余爱好者用来谈论编程语言的术语的一个弱点。
不要使用术语“强”和“弱”类型，因为它们没有普遍认可的技术含义。相比之下，静态类型意味着程序在执行之前会被检查，并且程序可能在启动之前被拒绝。 动态类型意味着值的类型在执行期间被检查，并且类型错误的操作可能会导致程序停止或以其他方式在运行时发出错误信号。静态类型的主要原因是排除可能存在此类“动态类型错误”的程序。

强类型通常意味着类型系统没有漏洞，而弱类型意味着类型系统可以被破坏（使任何保证失效） 。这些术语经常被错误地用来表示静态类型和动态类型。
要了解其中的差异，请考虑 C：该语言在编译时进行类型检查（静态类型），但存在大量漏洞；您几乎可以将任何类型的值转换为相同大小的另一种类型——特别是，您可以自由地转换指针类型。 Pascal 是一种旨在强类型的语言，但众所周知，它有一个不可预见的漏洞：没有标签的变体记录。

随着时间的推移，强类型语言的实现经常会出现漏洞，通常使得运行时系统的一部分可以用高级语言来实现。例如，Objective Caml 有一个名为 Obj.magic 的函数，它具有简单返回其参数的运行时效果，但在编译时它将任何类型的值转换为任何其他类型之一。我最喜欢的例子是 Modula-3，其设计者将其类型转换构造称为“LOOPHOLE”。

话虽如此，你不能指望任何两个人以完全相同的方式使用“强”和“弱”这两个词。所以避开他们。

Answer 3

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

例如，在 Java 中：

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

而在动态类型语言中，类型是动态，这意味着在将变量设置为类型后，您可以更改它。这是因为类型与值而不是变量相关联。

例如在Python中：

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

另一方面，语言中的强/弱类型与隐式类型转换相关（部分取自@Dario的答案）：

例如在Python中：

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

而在PHP中：

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

静态type 允许在编译时检查类型的正确性。静态类型语言通常是编译的，动态类型语言是解释的。因此，动态类型语言可以在运行时检查类型。

Answer 4

弱类型意味着对象的类型可以根据上下文而改变。例如，在弱类型语言中，如果向字符串“123”添加另一个数字，则该字符串可能会被视为数字 123。弱类型语言的例子有 bash、awk 和 PHP。

另一种弱类型语言是 C，其中内存地址处的数据可以通过强制转换被视为不同的类型。

在强类型语言中，对象的类型不会改变 - int 始终是 int，尝试将其用作字符串将导致错误。 Java 和 Python 都是强类型的。

动态类型和静态类型之间的区别在于强制执行类型规则的时间。在静态类型语言中，每个变量和参数的类型都必须在源代码中声明，并在编译时强制执行。在动态类型语言中，仅在运行时使用类型时才检查类型。所以Java是静态类型的，而Python是动态类型的。

然而，界限有时可能有点模糊。例如，尽管 Java 是静态类型的，但每次使用反射或强制类型转换（例如，使用对象容器时），都会将类型检查推迟到运行时。

类似地，大多数强类型语言仍然会自动在整数和浮点数之间进行转换（在某些语言中是任意精度的 BigInt）。

Answer 5

今天研究这个主题时，我发现了这篇很棒的文章 http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html 它为我澄清了很多事情，我想它可能会增加上面一些很好的答案。

强类型和弱类型：

类型系统最常见的分类方式可能是“强”
或“弱”。这是不幸的，因为这些词几乎没有
根本没有意义。可以在有限的范围内比较两个
具有非常相似类型系统的语言，并将其中一种指定为具有
这两个系统中较强的一个。除此之外，这些话没有任何意义
完全没有。

静态和动态类型

这几乎是类型系统唯一常见的分类
这具有真正的意义。其实它的意义在于
经常被低估[...]动态和静态类型系统
两个完全不同的事情，其目标部分发生
重叠。

静态类型系统是编译器检查的一种机制
源代码并将标签（称为“类型”）分配给各个部分
语法，然后使用它们来推断有关程序的某些信息
行为。动态类型系统是编译器使用的一种机制
生成代码来跟踪数据的排序（巧合的是，也
称为程序使用的“类型”）。使用同一个词
当然，这两个系统中的“类型”并不完全是
巧合；但最好将其理解为具有某种弱点
历史意义。试图找到一个
世界观中“类型”在两者中实际上意味着同一件事
系统。事实并非如此。

显式/隐式类型：

当使用这些术语时，它们指的是
编译器将推断程序各部分的静态类型。全部
编程语言对类型有某种形式的推理。一些
比别人拥有更多。 ML 和 Haskell 具有隐式类型，因为没有
（或很少，取决于所使用的语言和扩展）类型
需要声明。 Java 和 Ada 具有非常明确的类型，并且
人们不断地宣告事物的类型。以上都有
（相对地，例如与 C 和 C++ 相比）强静态类型
系统。

Answer 6

从 Scott 的编程语言语用学，第 3 版第 291 页，我们有

类型检查是确保程序遵守
语言的类型兼容性规则。已知违反规则
作为类型冲突。如果一种语言满足以下条件，则该语言被称为强类型：
以语言实现可以强制执行的方式禁止
将任何操作应用于任何不打算用于的对象
支持该操作。如果一种语言被称为静态类型
它是强类型的，可以在编译时执行类型检查
时间。从最严格的意义上来说，很少有语言是静态的
键入。在实践中，该术语经常应用于以下语言：
大多数类型检查可以在编译时执行，其余的可以
在运行时执行。

一些示例：Ada 是强类型的，并且在大多数情况下
静态类型（必须在运行时检查某些类型约束
时间）。 Pascal 实现还可以完成大部分类型检查
在编译时，尽管该语言不是很强类型：
未标记的变体记录（将在第 7.3.4 节中讨论）是其
只是漏洞。 C89 的强类型明显强于它的
前身方言，但类型仍然明显不如以前的方言
帕斯卡.它的漏洞包括联合体、带有可变数量的子程序
参数，以及指针和数组的互操作性（
第 7.7.1 节中讨论）。 C 的实现很少检查
运行时的任何事情。

动态（运行时）类型检查是后期绑定的一种形式，并且倾向于
在将其他问题延迟到运行时的语言中可以找到，例如
出色地。 Lisp 和 Smalltalk 是动态（尽管是强）类型的。最多
脚本语言也是动态类型的；一些（例如，Python 和
Ruby）是强类型的。具有动态作用域的语言通常是
动态类型（或根本不类型）：如果编译器不能
识别名称所指的对象，它通常无法确定
对象的类型。

所以简单来说，静态/动态类型指的是类型检查发生的时间：静态类型的编译时间，动态语言的运行时间。同样，强/弱类型指的是一种语言在强制执行其类型系统方面的积极程度。

我试图将斯科特的描述翻译成一个漂亮的图表，我将其发布在下面。

Answer 7

静态与动态类型语言

• 静态类型语言是在编译时完成类型检查的语言，因此这也意味着在静态类型语言中每个变量都有一个类型并且在整个过程中不会改变。 相比之下，动态类型语言是那些在运行时进行类型检查的语言，并且在编译时没有类型检查，因此这也意味着在动态类型语言中可能有也可能没有是与变量关联的类型，如果关联了类型，那么它可以是通用类型，例如 JS 中的“var”，它适用于字符串和数字。
  • “动态类型检查语言的实现通常将每个运行时对象与包含其类型信息的类型标记（即对类型的引用）相关联。此运行时类型信息 (RTTI) 还可用于实现动态调度、后期绑定、向下转换、反射和类似功能。”
• 即使语言是静态类型的，它仍然可以具有一些动态类型的功能，这基本上意味着在运行时也进行某种类型检查。这在类型转换时很有用。
  • “许多有用且常见的编程语言功能无法静态检查，例如向下转换。因此，许多语言都具有静态和动态类型检查；静态类型检查器验证它能做什么，动态检查验证其余的。”
• “有些语言允许编写非类型安全的代码。例如，在 C 中，程序员可以在具有相同大小的任意两种类型之间自由转换值。”
• “静态”类型语言的优点是：
  • 由于大多数类型检查是在编译时完成的，因此解释器或运行时可以全速运行，而不必担心类型。
  • 它会导致较少数量的运行时异常或与类型相关的错误，因为大多数类型检查是在编译时完成的。
• “动态”类型语言的优点是：
  • 它们可以帮助实现极快的原型设计，因为开发人员不需要了解类型系统，因此开发人员可以松散地创建变量并运行它，从而实现非常快速的原型设计。
• 静态和动态类型语言列表：
  • 静态：
    • Java
    • C（C 是一种静态类型语言，但与 Java 相比“强”类型较少，因为它允许更多隐式转换）
    • C++
    • C#
  • 动态：
    • PERL
    • PHP
    • Python
    • JavaScript
    • 红宝石

  静态地

• 类型检查是一项重要的安全功能。假设没有类型检查，并且一个方法接受类型为“BankAccount”的对象，该对象有一个名为“ CreditAccount(BankAccountDetails)”，现在在运行时如果没有类型检查，那么我可以传递一个我自己的类的对象，该对象具有相同的方法“creditAccount(BankAccountDetails)”并且它将被执行，考虑到我们正在谈论面向对象语言，因为OOP支持“多态”，这里我们讨论的只是“多态”。因此，基本上，一种没有强大类型检查的面向对象语言（这基本上意味着它支持“多态性”）可能会导致安全问题。

强类型语言与弱类型语言

• 强类型语言是那些在精度损失的情况下不允许隐式转换的语言。例如，在 Java 中，您可以将“int 转换为 long”，因为不会损失精度，但您不能“隐式”将“long 转换为 int”，因为会损失精度。相反，在弱类型语言中，即使存在精度损失，也允许隐式转换。
• 我认为动态类型语言也可以是强类型语言，如果“在运行时”它不允许隐式转换，其中存在精度损失。

---

很好的进一步阅读

• Type_system
• Strong_and_weak_typing
• 类别：Statically_typed_programming_languages
• < a href="https://en.wikipedia.org/wiki/Category:Dynamically_typed_programming_languages" rel="noreferrer">类别：Dynamically_typed_programming_languages

Answer 8

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

在每种编程语言中，为了最大限度地减少出错的机会，都会在程序执行之前或期间进行类型检查。 根据类型检查的时机，编程语言分为两种类型：静态类型和动态类型语言。

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

静态类型：

• 类型检查在编译时完成

• 在源代码中，在变量声明时，必须显式指定该变量的数据类型。因为如果在源代码中指定了数据类型，那么在编译时源代码将转换为机器代码并且可以进行类型检查

• 这里数据类型与变量关联，例如，int计数。并且这种关联是静态的或固定的

  


• 如果我们尝试通过分配其他数据类型的值（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 

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

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

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

动态类型：

• 类型检查在运行时完成

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

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

• 我们可以通过分配其他数据类型的值（foo = " Hi") 进去，没有错误

• 我们可以通过使用其他数据类型的值重新声明它 (var foo = true) 来轻松更改已声明变量 (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 等

强类型：

• 数据类型相关规则和限制严格维护

• 从一种数据类型到另一种数据类型的转换必须显式完成< /strong>，没有隐式类型转换

  
  

# in python, "5" cannot automatically get converted to 5
pybar = "5"

print(10 + pybar)     # error, no `+` operation between `int` and `str` 

• 可以在编译时或运行时进行类型检查。这意味着强类型语言可以是静态类型的，也可以是动态类型的

• 示例：Python、Java、Ruby、C# 等

弱类型：

• 数据类型相关规则和限制松散维护

• 从一种数据类型到另一种数据类型的转换可以隐式发生

• 如果我们在两个不匹配的数据类型的值之间执行某些操作，那么这种类型的语言可能不会抛出错误。相反，弱类型语言将应用自己的隐式类型转换规则并返回一些结果

jsbar = "5";

alert(10 + jsbar);  /* "105", no error as javascript implicitly coerces Number 10 
to String "10", so that it can be concatenated with other operand jsbar i.e. "5" */

• 类型检查可以在编译时或运行时完成。这意味着弱类型语言可以是静态类型的，也可以是动态类型的

• 示例：JavaScript、C、C++、PHP 等

Answer 9

我认为其他同事做得很好，尤其是。解释静态类型和动态类型之间的区别。但就强类型和弱类型来说，应该说是有的
不同的理解/观点。

这里有两个例子：

• 有人说 Haskell 是强类型的，因为你不被允许进行任何类型转换。

• 其他人（例如 Dario 的观点）说，一种允许故意从字符串隐式转换为数字的语言是弱类型的，但甚至其他人也称这只是鸭子类型。

这两种说法都强调的不是类型系统的相反极端，而是完全不同的方面。所以我同意拉姆齐先生的观点，不要使用“强”和“弱”这两个术语来区分类型系统。

Answer 10

来自 Addison Wesley，《面向对象的分析和应用程序设计》，第 3 期，第 66 页：

强类型和弱类型以及静态类型和动态类型的概念
完全不同。强类型和弱类型指的是类型
一致性，而静态和动态类型指的是时间
名称与类型绑定。静态类型（也称为静态绑定
或早期绑定）意味着所有变量的类型和
表达式在编译时是固定的；动态类型（也
称为后期绑定）意味着所有变量的类型和
表达式直到运行时才知道。一种语言可能两者兼而有之
强类型和静态类型 (Ada)，强类型但支持
动态类型（C++、Java），或无类型但支持动态类型
打字（Smalltalk）。

Answer 11

静态类型语言通常要求声明变量的类型，然后在编译时检查以减少错误。 “静态类型”中的“静态”一词指的是“静态代码分析”，即在执行代码之前检查代码的过程。尽管静态类型语言可以从表达式或实际参数的右侧推断变量的类型，但实际上大多数静态类型语言都需要显式声明变量类型。

动态类型语言通常不要求变量声明具有类型，并且它们根据计算每个赋值语句的右侧或函数调用的实际参数而计算出的类型来推断变量类型。由于变量在其生命周期内可以被多次赋值，因此它的类型可以随着时间的推移而改变，这就是它被称为“动态类型”的原因。此外，运行时环境需要跟踪每个变量的当前类型，因此类型绑定到值而不是变量声明。这可以被认为是运行时类型信息（RTTI）系统。

静态和动态类型语言的元素可以组合。例如，C# 支持静态和动态类型变量，面向对象语言通常支持类型层次结构的向下转换。静态类型语言通常提供各种绕过类型检查的方法，例如使用强制转换、反射和动态调用。

强类型与弱类型是指语言试图防止由于使用变量而导致错误的连续体，就好像它是一种类型，而实际上它是另一种类型。例如，C 和 Java 都是静态类型语言，但是 Java 使用比 C 更强的类型检查。以下 C 代码很容易编译和运行，并且会在运行时将随机值放入变量 b 中，很可能会导致bug：

char *a = "123";
int b = (int)a;

等效的 Java 代码会产生编译错误，这通常是更好的选择：

String a = "123"
int b = (int)a;