恕我直言，最好完全避免这些定义，不仅没有一致的术语定义，确实存在的定义倾向于关注技术方面，例如，混合类型上的操作是否允许，如果不允许，是否存在绕过限制的漏洞，例如使用指针工作。

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

例如:如果我的应用程序有一个名为加速度的变量，那么显然，如果变量的声明和使用方式允许将值“星期一”分配给加速度，这是一个问题，因为显然加速度不能是工作日(和字符串)。

Another example: In Ada one can define: subtype Month_Day is Integer range 1..31;, The type Month_Day is weak in the sense that it is not a separate type from Integer (because it is a subtype), however it is restricted to the range 1..31. In contrast: type Month_Day is new Integer; will create a distinct type, which is strong in the sense that that it cannot be mixed with integers without explicit casting - but it is not restricted and can receive the value -17 which is senseless. So technically it is stronger, but is less reliable. Of course, one can declare type Month_Day is new Integer range 1..31; to create a type which is distinct and restricted.

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

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

什么是静态和动态类型?

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

静态:运行前检查的类型 动态:在执行期间动态检查类型

这是什么意思?

在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 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是动态类型的，它只翻译和类型检查它所执行的代码。对于foo(2)， else块从未执行，因此“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

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

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

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

静态vs动态

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

在运行时使用的值被分为不同的类型。 对于如何使用这些值有一些限制。 当违反这些限制时，违反将作为(动态)类型错误报告。

例如，动态类型语言Lua具有字符串类型、数字类型和布尔类型等。在Lua中，每个值都只属于一种类型，但这并不是所有动态类型语言都必须这样做。在Lua中，允许连接两个字符串，但不允许连接字符串和布尔值。

强与弱

The opposite of "strongly typed" is "weakly typed", which means you can work around the type system. C is notoriously weakly typed because any pointer type is convertible to any other pointer type simply by casting. Pascal was intended to be strongly typed, but an oversight in the design (untagged variant records) introduced a loophole into the type system, so technically it is weakly typed. Examples of truly strongly typed languages include CLU, Standard ML, and Haskell. Standard ML has in fact undergone several revisions to remove loopholes in the type system that were discovered after the language was widely deployed.

这里到底发生了什么?

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

业余爱好者经常把它们与“静态”和“动态”混为一谈。 显然，有些人用“弱类型”来谈论隐式转换的相对流行或缺乏。 专业人士无法就这些术语的确切含义达成一致。 总的来说，你不太可能告诉或启发你的观众。

The sad truth is that when it comes to type systems, "strong" and "weak" don't have a universally agreed on technical meaning. If you want to discuss the relative strength of type systems, it is better to discuss exactly what guarantees are and are not provided. For example, a good question to ask is this: "is every value of a given type (or class) guaranteed to have been created by calling one of that type's constructors?" In C the answer is no. In CLU, F#, and Haskell it is yes. For C++ I am not sure—I would like to know.

相比之下，静态类型意味着程序在执行之前要进行检查，并且程序可能在开始之前就被拒绝。动态类型意味着在执行期间检查值的类型，类型不佳的操作可能导致程序在运行时停止或发出错误信号。使用静态类型的一个主要原因是排除可能存在这种“动态类型错误”的程序。

两者之间是否有关联?

从学究的角度来说，没有，因为“强大”这个词其实没有任何意义。但实际上，人们几乎总是做两件事中的一件:

They (incorrectly) use "strong" and "weak" to mean "static" and "dynamic", in which case they (incorrectly) are using "strongly typed" and "statically typed" interchangeably. They use "strong" and "weak" to compare properties of static type systems. It is very rare to hear someone talk about a "strong" or "weak" dynamic type system. Except for FORTH, which doesn't really have any sort of a type system, I can't think of a dynamically typed language where the type system can be subverted. Sort of by definition, those checks are bulit into the execution engine, and every operation gets checked for sanity before being executed.

不管怎样，如果有人称一种语言为“强类型”，那么这个人很可能是在谈论一种静态类型的语言。

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

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

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

强类型与弱类型 静态类型vs.动态类型

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

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

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

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

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

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