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

静态/动态类型

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

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

以Java为例:

String s = "abcd";

s将“永远”是一个字符串。在它的生命周期中，它可以指向不同的字符串(因为s是Java中的引用)。它可能有一个空值，但它永远不会引用一个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 is a phrase with no widely agreed upon meaning. Most programmers who use this term to mean something other than static typing use it to imply that there is a type discipline that is enforced by the compiler. For example, CLU has a strong type system that does not allow client code to create a value of abstract type except by using the constructors provided by the type. C has a somewhat strong type system, but it can be "subverted" to a degree because a program can always cast a value of one pointer type to a value of another pointer type. So for example, in C you can take a value returned by malloc() and cheerfully cast it to FILE*, and the compiler won't try to stop you—or even warn you that you are doing anything dodgy.

(最初的答案说了一些关于值“在运行时不改变类型”的内容。我认识许多语言设计者和编译器作者，但没有一个人谈论过在运行时改变类型的值，除了一些类型系统的非常高级的研究，在那里这被称为“强更新问题”。)

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

这个答案的最初将弱类型与隐式转换(有时也称为“隐式提升”)混为一谈。例如，在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(如果您不熟悉它，可能会感到惊讶)没有。

静态/动态vs强/弱

这里的重点是静态/动态轴独立于强/弱轴。人们混淆它们的部分原因可能是强类型和弱类型不仅定义不明确，而且对于强类型和弱类型的确切含义也没有真正的共识。因此，强/弱类型更像是灰色的阴影，而不是黑色或白色。

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

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

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

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

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

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

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.动态类型

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

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

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

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

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

静态/动态类型

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

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

以Java为例:

String s = "abcd";

s将“永远”是一个字符串。在它的生命周期中，它可以指向不同的字符串(因为s是Java中的引用)。它可能有一个空值，但它永远不会引用一个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 is a phrase with no widely agreed upon meaning. Most programmers who use this term to mean something other than static typing use it to imply that there is a type discipline that is enforced by the compiler. For example, CLU has a strong type system that does not allow client code to create a value of abstract type except by using the constructors provided by the type. C has a somewhat strong type system, but it can be "subverted" to a degree because a program can always cast a value of one pointer type to a value of another pointer type. So for example, in C you can take a value returned by malloc() and cheerfully cast it to FILE*, and the compiler won't try to stop you—or even warn you that you are doing anything dodgy.

(最初的答案说了一些关于值“在运行时不改变类型”的内容。我认识许多语言设计者和编译器作者，但没有一个人谈论过在运行时改变类型的值，除了一些类型系统的非常高级的研究，在那里这被称为“强更新问题”。)

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

这个答案的最初将弱类型与隐式转换(有时也称为“隐式提升”)混为一谈。例如，在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(如果您不熟悉它，可能会感到惊讶)没有。

静态/动态vs强/弱

这里的重点是静态/动态轴独立于强/弱轴。人们混淆它们的部分原因可能是强类型和弱类型不仅定义不明确，而且对于强类型和弱类型的确切含义也没有真正的共识。因此，强/弱类型更像是灰色的阴影，而不是黑色或白色。

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

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

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

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

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