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

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

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

静态与动态

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

1. 在运行时使用的值被分类为类型。
2. 对于如何使用这些值有一些限制。
3. 当违反这些限制时,该冲突将报告为(动态)类型错误。

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

强VS弱

与“强类型”相反的是“弱类型”,这意味着您可以围绕类型系统工作。C是众所周知的弱类型,因为任何指针类型都可以通过强制转换转换为任何其他指针类型。Pascal被设计为强类型,但是设计中的一个疏忽(未标记的变体记录)给类型系统带来了一个漏洞,因此在技术上它是弱类型的。 真正强类型语言的例子包括CLU、标准ML和Haskell。实际上,标准ML已经进行了几次修改,以消除在广泛部署该语言之后发现的类型系统中的漏洞。

这里到底发生了什么?

总的来说,谈论“强”和“弱”并没有那么有用。一个类型系统是否有漏洞比漏洞的确切数量和性质、在实践中出现漏洞的可能性以及利用漏洞的后果要小得多。在实践中, 最好避免使用“强”和“弱”两个词 ,因为

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

• 显然,“弱类型”被一些人用来谈论相对优势或缺乏内隐转换。

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

• 总的来说,你不太可能通知或启发你的听众。

可悲的事实是,当涉及到类型系统时, “强”和“弱”在技术意义上没有一个普遍认同的概念。 如果您想讨论类型系统的相对强度,最好确切地讨论什么是担保,什么是不担保。 例如,要问的一个好问题是:“给定类型(或类)的每个值是否都是通过调用该类型的构造函数之一而创建的?”在C语言中,答案是否定的。在clu、f_和haskell语言中,答案是肯定的。对于C++,我不是Suri,我想知道。

相比之下, 静态类型 意味着程序是 执行前检查 程序可能在启动前被拒绝。 动态分型 意味着 价值观 被检查 在期间 执行,以及类型错误的操作可能导致程序停止,或者在运行时发出错误信号。静态类型的一个主要原因是排除可能有这样的“动态类型错误”的程序。

一个暗示另一个吗?

在学究的层面上,不,因为“强”这个词实际上并不意味着什么。但实际上,人们几乎总是做两件事之一:

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

• 他们使用“强”和“弱”来比较静态类型系统的特性。很少有人谈论“强”或“弱”的动态类型系统。除了forth之外,它实际上没有任何类型的系统,我想不出一种动态类型语言,在这种语言中类型系统可以被颠覆。根据定义,这些检查被构建到执行引擎中,并且在执行之前检查每个操作的健全性。

不管怎样,如果一个人将一种语言称为“强类型”,那么他很可能正在谈论一种静态类型的语言。

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

静态/动态类型

静态分型 类型绑定到 变量 . 在编译时检查类型。

动态分型 类型绑定到 价值 . 在运行时检查类型。

所以在Java中,例如:

String s = "abcd";

s “永远”会是 String . 在它的生命中,它可能指向不同的 弦 (自) S 是Java中的引用。它可能有一个 null 但它永远不会引用 Integer 或A 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* 编译器不会试图阻止您,甚至不会警告您正在做任何不可靠的事情。

(最初的答案是关于一个值“在运行时不更改类型”。我认识许多语言设计者和编译器编写者,也不认识一个在运行时讨论值改变类型的人,除了可能在类型系统中进行的一些非常高级的研究外,这就是所谓的“强更新问题”。)

弱分型 这意味着编译器不会强制执行类型displine,或者强制可能很容易被破坏。

这个答案的原版把打字不好和 隐式转换 (有时也称为“隐性晋升”)。例如,在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(如果您不熟悉它,可能会令人惊讶)没有。

静态/动态与强/弱

这里的重点是静态/动态轴独立于强/弱轴。人们可能会混淆他们,部分原因是强与弱的类型不仅定义不那么清楚,而且对于强与弱的确切含义没有真正的共识。因为这个原因,强/弱类型更多的是灰色阴影,而不是黑色或白色。

所以回答你的问题:另一种看待这个问题的方法是 主要地 正确的说法是静态类型是编译时类型安全,强类型是运行时类型安全。

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

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

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

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

强类型 也就是说,a不会自动从一种类型转换为另一种类型。弱类型则相反:Perl可以使用类似 "123" 在数字上下文中,通过自动将其转换为int 123 . 像python这样的强类型语言不能做到这一点。

静态类型 意思是,编译器在编译时计算出每个变量的类型。动态类型语言只在运行时计算出变量的类型。

强类型意味着类型之间的转换存在限制。静态类型化意味着类型不是动态的——一旦变量被创建,就不能更改它的类型。

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

由于Java的弱类型,上面的例子

String s = "abc" + 123;

不是弱类型示例,因为它确实在执行以下操作:

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

如果正在构造新对象,数据强制也不是弱类型的。 Java是弱类型的非常坏的例子(任何有良好反射的语言很可能不会是弱类型的)。因为语言的运行时总是知道类型是什么(异常可能是本机类型)。

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

该语言的运行时确实定义了它是否弱类型化,否则它实际上只是一种意见。

编辑: 经过进一步考虑,这不一定是真的,因为运行时不需要将运行时系统中的所有类型都重新定义为强类型系统。 haskell和ml有如此完整的静态分析,它们可以从运行时获得OMmit类型的潜在信息。

强类型化可能意味着变量具有定义良好的类型,并且对于在表达式中组合不同类型的变量有严格的规则。例如,如果a是整数,b是浮点,那么关于a+b的严格规则可能是将a强制转换为浮点,结果返回为浮点。如果a是整数,b是字符串,那么严格的规则可能是a+b无效。

静态类型可能意味着类型是在编译时分配的(或其对于非编译语言的等价物),并且在程序执行期间不能更改。

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

请注意,当我使用“可能”这个词时,这是因为这些术语没有公认的定义。正如你已经从答案中看到的那样。

一个并不意味着另一个。为了一种语言 静态地 类型化意味着所有变量的类型在编译时都是已知或推断的。

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

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

强类型与弱类型是什么?

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

在Go或类似于Python的强类型语言中,“2”+8将引发类型错误,因为它们不允许“类型强制”。

弱(松散)类型:将自动转换为一种类型到另一种类型: 像javascript或perl这样的弱类型语言不会抛出错误,在这种情况下,javascript将得到“28”,Perl将得到10。

Perl示例:

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

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

静态与动态类型是什么?

在编程中,编程器根据检查变量类型的点定义静态类型和动态类型。静态类型语言是在编译时执行类型检查的语言,而动态类型语言是在运行时执行类型检查的语言。

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

这是什么意思?

在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