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

Question

另外，其中之一是否暗示着另一个？

Answer 1

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

静态类型语言具有一个类型系统，该系统在编译时由实现（编译器或解释器）进行检查。类型检查会拒绝某些程序，而通过检查的程序通常会附带一些保证；例如，编译器保证不对浮点数使用整数算术指令。

对于“强类型”的含义并没有真正的共识，尽管专业文献中最广泛使用的定义是在“强类型”语言中，程序员不可能绕过类型系统施加的限制。该术语几乎总是用于描述静态类型语言。

静态与动态

静态类型的反面是“动态类型”，这意味着

1. 运行时使用的值被分类为类型。
2. 这些值的使用方式存在限制。
3. 当违反这些限制时，违规行为将报告为（动态）类型错误。

例如Lua，一种动态类型语言，有字符串类型、数字类型、布尔类型等。在 Lua 中，每个值都完全属于一种类型，但这并不是所有动态类型语言的要求。在Lua中，允许连接两个字符串，但不允许连接一个字符串和一个布尔值。

强类型与弱

类型 “强类型”的反义词是“弱类型”，这意味着您可以绕过类型系统。 C 是出了名的弱类型，因为任何指针类型都可以通过简单的转换转换为任何其他指针类型。 Pascal 原本是强类型的，但设计中的疏忽（未标记的变体记录）在类型系统中引入了漏洞，因此从技术上讲，它是弱类型的。
真正强类型语言的示例包括 CLU、Standard ML 和 Haskell。事实上，标准机器学习已经经历了多次修订，以消除该语言广泛部署后发现的类型系统中的漏洞。

这里究竟发生了什么？

总的来说，谈论“强”和“弱”并没有多大用处。类型系统是否存在漏洞并不重要，重要的是漏洞的确切数量和性质、它们在实践中出现的可能性有多大，以及利用漏洞的后果是什么。在实践中，最好完全避免使用“强”和“弱”这两个术语，因为

• 业余爱好者经常将它们与“静态”和“动态”混为一谈。

• 显然，“弱类型”被一些人用来谈论隐式转换的相对普遍或不存在。

• 专业人士无法就这些术语的确切含义达成一致。

• 总体而言，您不太可能告知或启发您的受众。

可悲的事实是，当谈到类型系统时，“强”和“弱”没有普遍认同的技术含义。如果你想讨论类型系统的相对强度，它最好准确讨论提供和不提供哪些保证。
例如，一个很好的问题是：“是否保证给定类型（或类）的每个值都是通过调用该类型的构造函数之一创建的？”在 C 语言中，答案是否定的。在 CLU、F# 和 Haskell 中，答案是肯定的。对于 C++，我不确定——我想知道。

相比之下，静态类型意味着程序在执行之前会被检查，并且程序可能在启动之前被拒绝。 动态类型意味着在执行期间检查值的类型，类型错误的操作可能会导致程序停止或以其他方式发出错误信号在运行时。静态类型的主要原因是排除可能存在此类“动态类型错误”的程序。

其中一个是否暗示另一个？

从迂腐的角度来看，不，因为“强”这个词实际上没有任何意义。但在实践中，人们几乎总是做以下两件事之一：

• 他们（错误地）使用“强”和“弱”来表示“静态”和“动态”，在这种情况下，他们（错误地）使用“强类型” ”和“静态类型”可互换。

• 他们使用“强”和“弱”来比较静态类型系统的属性。很少听到有人谈论“强”或“弱”动态类型系统。除了 FORTH 之外，它实际上没有任何类型系统，我想不出有一种动态类型语言可以破坏类型系统。根据定义，这些检查被内置到执行引擎中，并且每个操作在执行之前都会检查其完整性。

无论哪种方式，如果一个人将一种语言称为“强类型”，那么这个人很可能正在谈论静态类型语言。

Answer 2

这经常被误解，所以让我澄清一下。

静态/动态类型

静态类型是将类型绑定到变量的地方。类型在编译时进行检查。

动态类型是将类型绑定到值的地方。类型在运行时检查。

例如，在 Java 中：

String s = "abcd";

s 将“永远”是 String。在其生命周期中，它可能指向不同的String（因为s是Java中的引用）。它可能有一个 null 值，但它永远不会引用 Integer 或 List。这就是静态类型。

在 PHP 中：

$s = "abcd";          // $s is a string
$s = 123;             // $s is now an integer
$s = array(1, 2, 3);  // $s is now an array
$s = new DOMDocument; // $s is an instance of the DOMDocument class

这就是动态类型。

强/弱类型

（编辑警报！）

强类型是一个没有广泛商定含义的短语。大多数使用该术语表示静态类型以外的含义的程序员都使用它来暗示编译器强制执行类型规则。例如，CLU 具有强大的类型系统，不允许客户端代码创建抽象类型的值，除非使用该类型提供的构造函数。 C 具有较强的类型系统，但它可以在一定程度上被“颠覆”，因为程序总是可以将一种指针类型的值转换为另一种指针类型的值。例如，在 C 中，您可以获取 malloc() 返回的值并将其转换为 FILE*，编译器不会尝试阻止您，或者甚至警告你你正在做任何狡猾的事情。

（最初的答案说了一些关于“在运行时不改变类型”的值。我认识很多语言设计者和编译器编写者，但不知道有谁谈论在运行时改变值的类型，除了可能一些非常先进的类型研究系统，这被称为“强更新问题”。）

弱类型意味着编译器不强制执行类型规则，或者这种强制可能很容易被破坏。

这个答案的原文将弱类型与隐式转换（有时也称为“隐式升级”）混为一谈。例如，在 Java 中：

String s = "abc" + 123; // "abc123";

这是代码，是隐式提升的示例：123 在与 "abc" 连接之前隐式转换为字符串。可以说 Java 编译器将该代码重写为：

String s = "abc" + new Integer(123).toString();

考虑一个经典的 PHP“开头为”问题：

if (strpos('abcdef', 'abc') == false) {
  // not found
}

这里的错误是 strpos() 返回匹配的索引，即 0。0 是强制的转换为布尔值 false，因此条件实际上为 true。解决方案是使用 === 而不是 == 来避免隐式转换。

此示例说明了隐式转换和动态类型的组合如何使程序员误入歧途。

与 Ruby 相比：

val = "abc" + 123

这是一个运行时错误，因为在 Ruby 中，对象 123 没有隐式转换，只是因为它碰巧被传递给 + 方法。在 Ruby 中，程序员必须明确进行转换：

val = "abc" + 123.to_s

比较 PHP 和 Ruby 就是一个很好的说明。两者都是动态类型语言，但 PHP 有很多隐式转换，而 Ruby（如果您不熟悉它，可能会感到惊讶）没有。

静态/动态与强/弱

这里的要点是静态/动态轴独立于强/弱轴。人们之所以对它们感到困惑，部分原因可能是强类型与弱类型的定义不那么明确，而且对于强类型和弱类型的确切含义也没有真正的共识。因此，强/弱类型更像是灰色阴影，而不是黑色或白色。

因此，回答你的问题：另一种看待这个问题的方法大部分是正确的，那就是静态类型是编译时类型安全，强类型是运行时类型安全。

原因是静态类型语言中的变量具有必须声明并可以在编译时检查的类型。强类型语言的值在运行时具有类型，并且程序员很难在没有动态检查的情况下破坏类型系统。

但重要的是要了解语言可以是静态/强、静态/弱、动态/强或动态/弱。

Answer 3

两者都是两个不同轴上的极点：

• 强类型与弱类型
• 静态类型与动态类型

强类型意味着变量不会自动从一种类型转换为另一种类型。弱类型则相反：Perl 可以在数字上下文中使用像 "123" 这样的字符串，方法是自动将其转换为 int 123。像 python 这样的强类型语言不会这样做。

静态类型意味着编译器在编译时计算出每个变量的类型。动态类型语言仅在运行时确定变量的类型。

Answer 4

强类型意味着类型之间的转换存在限制。

静态类型意味着类型不是动态的 - 一旦创建变量，您就无法更改其类型。

Answer 5

上面已经给出了答案。尝试区分强与弱、静态与动态概念。

什么是强类型VS弱类型？

强类型：不会自动从一种类型转换为另一种类型

在 Go 或 Python 等强类型语言中，“2”+ 8 会引发类型错误，因为它们不允许“类型强制” 。

弱（松散）类型：将自动从一种类型转换为另一种类型：
JavaScript 或 Perl 等弱类型语言不会抛出错误，在这种情况下，JavaScript 将结果为“28”，而 perl 将结果为 10。

Perl 示例：

my $a = "2" + 8;
print $a,"\n";

将其保存到 main.pl 并运行 perl main.pl 你会得到输出 10。

什么是 Static VS Dynamic 类型？

在编程中，程序员根据检查变量类型的点来定义静态类型和动态类型。静态类型语言是在编译时进行类型检查的语言，而动态类型语言是在运行时进行类型检查的语言。

• 静态：在运行时之前检查类型
• 动态：在执行期间动态检查类型

这意味着什么？

在 Go 中，它会在运行时之前检查键入的内容（静态检查）。这意味着它不仅会翻译和类型检查正在执行的代码，而且还会扫描所有代码，并且在代码运行之前会抛出类型错误。例如，

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

将此文件保存在 main.go 中并运行它，您将收到编译失败的消息。

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

但这种情况对于 Python 无效。例如，以下代码块将在第一次 foo(2) 调用时执行，并在第二次 foo(0) 调用时失败。这是因为 Python 是动态类型的，它只对正在执行的代码进行翻译和类型检查。 else 块永远不会为 foo(2) 执行，因此“2”+ 8 甚至不会被查看，而对于 foo(0) 调用，它将尝试执行该块并失败。

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

您将看到以下输出

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects

Answer 6

数据强制并不一定意味着弱类型，因为有时它的语法糖：

上面的 Java 弱类型示例是因为

String s = "abc" + 123;

它不是弱类型示例，因为它实际上是这样做的：

String s = "abc" + new Integer(123).toString()

如果您正在构造一个新对象，数据强制也不是弱类型。
Java 是弱类型的一个非常糟糕的例子（任何具有良好反射能力的语言很可能都不是弱类型的）。因为语言的运行时总是知道类型是什么（例外可能是本机类型）。

这与 C 不同。C 是弱类型的最佳示例之一。运行时不知道 4 个字节是整数、结构体、指针还是 4 个字符。

语言的运行时真正定义了它是否弱类型，否则它只是意见。

编辑：
经过进一步思考，这不一定是真的，因为运行时不必将运行时系统中的所有类型具体化为强类型系统。
Haskell 和 ML 具有如此完整的静态分析，以至于它们可以从运行时省略类型信息。

Answer 7

其中之一并不意味着另一个。对于静态类型的语言来说，这意味着所有变量的类型都是在编译时已知或推断的。

强类型语言不允许您将一种类型用作另一种类型。 C 是一种弱类型语言，是强类型语言所不允许的一个很好的例子。在 C 中，您可以传递错误类型的数据元素，它不会抱怨。在强类型语言中你不能。

Answer 8

强类型可能意味着变量具有明确定义的类型，并且在表达式中组合不同类型的变量有严格的规则。例如，如果 A 是整数，B 是浮点数，则关于 A+B 的严格规则可能是 A 转换为浮点数，并将结果作为浮点数返回。如果 A 是整数，B 是字符串，则严格规则可能是 A+B 无效。

静态类型可能意味着类型在编译时分配（或非编译语言的等效类型），并且在程序执行期间不能更改。

请注意，这些分类并不是相互排斥的，实际上我希望它们经常一起出现。许多强类型语言也是静态类型的。

请注意，当我使用“可能”这个词时，是因为这些术语没有普遍接受的定义。正如您从迄今为止的答案中已经看到的那样。

Answer 9

恕我直言，最好完全避免这些定义，不仅没有商定的术语定义，确实存在的定义往往侧重于技术方面，例如是否允许混合类型操作，如果不允许，是否存在漏洞绕过限制，例如使用指针按您的方式工作。

相反，再次强调这是一种观点，人们应该关注这个问题：类型系统是否使我的应用程序更可靠？一个特定于应用程序的问题。

例如：如果我的应用程序有一个名为 acceleration 的变量，那么显然该变量的声明和使用方式是否允许将值 "Monday" 分配给 加速度这是一个问题，因为显然加速度不能是工作日（和字符串）。

另一个例子：在 Ada 中，可以定义：subtype Month_Day is Integer range 1..31;，类型 Month_Day 是弱类型，因为它不是独立的类型整数（因为它是子类型），但其范围仅限于 1..31。相比之下： type Month_Day is new Integer; 将创建一个不同的类型，这种类型很强大，因为它不能在没有显式转换的情况下与整数混合 - 但它不受限制并且可以接收值-17，这是毫无意义的。所以技术上它更强，但可靠性较差。
当然，可以声明type Month_Day is new Integer range 1..31;来创建一种独特且受限制的类型。