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

另外，一方是否意味着另一方？

---

#1楼

强类型意味着类型之间的转换之间存在限制。 静态类型意味着类型不是动态的 - 一旦创建变量，就无法更改变量的类型。

---

#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* ，并且编译器不会试图阻止您 - 甚至警告您您正在做任何狡猾的事情。

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

弱类型意味着编译器不强制执行输入discpline，或者可能很容易破坏强制执行。

这个答案的原始内容将弱类型与隐式转换 （有时也称为“隐式提升”）混为一谈。 例如，在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 ，因此条件实际为真。 解决方案是使用===而不是==来避免隐式转换。

这个例子说明了隐式转换和动态类型的组合如何导致程序员误入歧途。

与Ruby相比：

val = "abc" + 123

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

val = "abc" + 123.to_s

比较PHP和Ruby是一个很好的例子。 两者都是动态类型语言，但PHP有很多隐式转换和Ruby（如果你不熟悉它可能会令人惊讶）不会。

静态/动态与强/弱

这里的要点是静态/动态轴独立于强/弱轴。 人们可能会混淆他们，部分原因是因为强类型和弱类型不仅没有明确定义，对于确切的强弱意味着什么也没有真正的共识。 因此，强/弱打字更像是灰色而不是黑色或白色。

因此，要回答你的问题：另一种方式来看待这个这主要是正确的是说，静态类型的编译时类型安全性和强大的打字运行时类型安全。

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

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

---

#3楼

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

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

---

#4楼

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

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

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

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

---

#5楼

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

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

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

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

---

#6楼

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

以上Java的例子因为弱的类型而被输入

String s = "abc" + 123;

不是弱类型的例子，因为它真的在做：

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

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

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

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

编辑： 经过进一步思考后，这不一定是正确的，因为运行时不必将运行时系统中所有类型都设置为强类型系统。 Haskell和ML有这样完整的静态分析，他们可以从运行时省略类型信息。

---

#7楼

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

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

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

静态与动态

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

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

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

强与弱

与“强类型”相反的是“弱类型”，这意味着您可以解决类型系统问题。 C是众所周知的弱类型，因为任何指针类型只需通过强制转换就可以转换为任何其他指针类型。 Pascal的目的是强类型，但设计中的疏忽（未标记的变体记录）在类型系统中引入了一个漏洞，因此从技术上讲它是弱类型的。 真正强类型语言的示例包括CLU，Standard ML和Haskell。 事实上，标准ML经历了几次修订，以消除在语言被广泛部署后发现的类型系统中的漏洞。

这里到底发生了什么？

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

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

• 显然，某些人使用“弱类型”来讨论隐式转换的相对普遍性或缺失。

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

• 总的来说，您不太可能通知或启发您的观众。

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

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

一个人是否意味着另一个？

在学究层面，不，因为“强”这个词并不真正意味着什么。 但在实践中，人们几乎总是做两件事之一：

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

• 他们使用“强”和“弱”来比较静态类型系统的属性。 听到有人谈论“强”或“弱”动态类型系统是非常罕见的。 除了没有任何类型系统的FORTH之外，我无法想到可以颠覆类型系统的动态类型语言。 根据定义排序，这些检查是执行引擎，并且在执行之前检查每个操作的健全性。

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

---

#8楼

上面已经给出了答案。 试图区分强与周和静态与动态概念。

什么是强类型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。

什么是静态VS动态类型？

在编程中，progammer定义了关于检查变量类型的点的静态类型和动态类型。 静态类型语言是在编译时进行类型检查的语言，而动态类型语言是在运行时进行类型检查的语言。

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

这是什么意思？

在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

来源：CSDN

作者：asdfgh0077

链接：https://blog.csdn.net/asdfgh0077/article/details/104223017