强类型语言和静态类型语言有什么区别？-Java 学习之路

363

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

8 回答

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

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

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

静态与动态

与静态类型相反的是“动态类型”，这意味着
- 在运行时使用的值被分类为类型 .
- 对这些值的使用方式有一些限制 .
- 违反这些限制时，违规将报告为（动态）类型错误 .
例如，Lua是一种动态类型语言，具有字符串类型，数字类型和布尔类型等 . 在Lua中，每个值都属于一种类型，但这不是所有动态类型语言的要求 . 在Lua中，允许连接两个字符串，但不允许连接字符串和布尔值 .

强与弱

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

这里到底发生了什么？

总的来说，谈论"strong"和"weak"并没有那么有用 . 类型系统是否存在漏洞的重要性不如漏洞的确切数量和性质，它们在实践中出现的可能性，以及利用漏洞的后果是什么 . 在实践中， it's best to avoid the terms "strong" and "weak" altogether ，因为
- 业余爱好者经常将他们与“静态”和“动态”混为一谈 .
- 显然，某些人使用“弱类型”来讨论隐含转换的相对普遍性或缺失 .
- 专业人士无法就这些术语的含义达成一致 .
- 总体而言，您不太可能通知或启发您的 Spectator .
令人遗憾的事实是，当涉及到类型系统时， "strong" and "weak" don't have a universally agreed on technical meaning. 如果你想讨论类型系统的相对强度，最好准确地讨论什么是保证和不提供 . 例如，一个很好的问题是："is every value of a given type (or class) guaranteed to have been created by calling one of that type's constructors?"在C中答案是否定的 . 在CLU，F＃和Haskell中，它是肯定的 . 对于C我不确定 - 我想知道 .

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

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

在学究层面，不，因为“强”这个词并不真正意味着什么 . 但在实践中，人们几乎总是做两件事之一：
- 他们（错误地）使用“强”和“弱”来表示“静态”和“动态”，在这种情况下，他们（错误地）使用“强类型”和“静态类型”可互换使用 .
- 他们使用“强”和“弱”来比较静态类型系统的属性 . 听到有人谈论“强”或“弱”动态类型系统是非常罕见的 . 除了没有任何类型系统的FORTH之外，我无法想到可以颠覆类型系统的动态类型语言 . 根据定义排序，这些检查是执行引擎，并且每个操作都会得到在执行之前检查是否合理 .
无论哪种方式，如果一个人称一种语言为“强类型”，那么这个人很可能会谈论一种静态类型的语言 .
回复于 2024-05-03T13:31:12+08:00
0
这经常被误解，所以让我澄清一下 .

静态/动态打字

Static typing 是类型绑定到变量的位置 . 在编译时检查类型 .

Dynamic typing 是类型绑定到值的位置 . 在运行时检查类型 .

所以在Java中例如：
```
String s = "abcd";
```
s 将"forever"成为 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
```
这是动态打字 .

强/弱打字

（编辑提醒！）

Strong typing 是一个没有广泛认同意义的短语 . 大多数程序员使用这个术语来表示静态类型以外的东西，使用它来暗示存在由编译器强制执行的类型规则 . 例如，CLU有一个强类型系统，除了使用类型提供的构造函数外，不允许客户端代码创建抽象类型的值 . C有一个强大的类型系统，但它可以是"subverted"到一定程度，因为程序总是可以将一个指针类型的值转换为另一个指针类型的值 . 因此，例如，在C中，您可以获取 malloc() 返回的值，并愉快地将其转换为 FILE* ，编译器不会试图阻止您 - 甚至警告您，您正在做任何狡猾的事情 .

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

Weak typing 暗示编译器不强制执行输入discpline，或者可能很容易破坏执行 .

这个答案的原始内容与 implicit conversion （有时也称为"implicit promotion"）的弱打字混为一谈 . 例如，在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（如果你不熟悉它可能会令人惊讶）不会 .

静态/动态与强/弱

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

所以回答你的问题：另一种看待这个问题的方法就是说静态类型是编译时类型的安全性，强类型是运行时类型的安全性 .

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

但重要的是要理解语言可以是静态/强，静态/弱，动态/强或动态/弱 .
回复于 2024-05-03T13:31:12+08:00
15
两者都是两个不同轴上的两极：
- 强类型与弱类型
- 静态类型与动态类型
Strongly typed 表示，a不会自动从一种类型转换为另一种类型 . 弱键入是相反的：Perl可以使用a字符串如 "123" 在数字上下文中，通过自动将其转换为int 123 . 像python这样的强类型语言不会这样做 .

Statically typed 表示编译器在编译时计算出每个变量的类型 . 动态类型语言仅在运行时计算出变量的类型 .
回复于 2024-05-03T13:31:12+08:00
219

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

回复于 2024-05-03T13:31:12+08:00
11
数据强制并不一定意味着弱类型，因为有时它的合成糖：

以上Java的例子因为弱的类型而被输入
```
String s = "abc" + 123;
```
不是弱类型的例子，因为它真的在做：
```
String s = "abc" + new Integer(123).toString()
```
如果要构造新对象，则数据强制也不是弱类型 . Java是弱类型的一个非常糟糕的例子（并且任何具有良好反射的语言很可能不会被弱类型化） . 因为语言的运行时总是知道类型是什么（异常可能是本机类型） .

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

The runtime of the language really defines whether or not its weakly typed otherwise its really just opinion.

编辑：经过进一步思考后，这不一定是正确的，因为运行时不必将运行时系统中所有类型都设置为强类型系统 . Haskell和ML有这样完整的静态分析，他们可以从运行时省略类型信息 .
回复于 2024-05-03T13:31:12+08:00
435

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

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

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

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

回复于 2024-05-03T13:31:12+08:00
8

一个并不意味着另一个 . 对于要键入的语言，它表示所有变量的类型在编译时是已知的或推断的 .

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

回复于 2024-05-03T13:31:12+08:00
5
上面已经给出了答案 . 试图区分强与周和静态与动态概念 .

什么是强类型VS弱键入？

Strongly Typed: Will not be automatically converted from one type to another

在Go或Python中，如强类型语言“2”8将引发类型错误，因为它们不允许“类型强制” .

Weakly (loosely) Typed: Will be automatically converted to one type to another: 像JavaScript或Perl这样的弱类型语言赢得了't throw an error and in this case javascript will results ' 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
```
回复于 2024-05-03T13:31:12+08:00

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

8 回答

静态与动态

强与弱

这里到底发生了什么？

静态/动态打字

强/弱打字

静态/动态与强/弱

什么是强类型VS弱键入？

什么是静态VS动态类型？

相关问题