我认为其他同事做得很好，特别是解释了静态类型和动态类型的区别。但就强类型和弱类型而言，应该说都有 不同的理解/观点。

这里有两个例子:

有人说Haskell是强类型的，因为不允许进行任何类型转换。 其他人(例如Dario的观点)说，允许有意地从字符串隐式转换为数字的语言是弱类型的，但甚至其他人称之为鸭子类型。

这两种说法强调的不是类型系统的两个极端，而是完全不同的方面。因此，我同意Ramsey先生的观点，不要用“强”和“弱”来区分类型系统。

静态/动态类型是关于获取类型信息的时间(在编译时或在运行时) 强/弱类型是关于如何严格区分类型(例如，语言是否试图进行从字符串到数字的隐式转换)。

更多详细信息请参见维基页面。

我认为其他同事做得很好，特别是解释了静态类型和动态类型的区别。但就强类型和弱类型而言，应该说都有 不同的理解/观点。

这里有两个例子:

有人说Haskell是强类型的，因为不允许进行任何类型转换。 其他人(例如Dario的观点)说，允许有意地从字符串隐式转换为数字的语言是弱类型的，但甚至其他人称之为鸭子类型。

这两种说法强调的不是类型系统的两个极端，而是完全不同的方面。因此，我同意Ramsey先生的观点，不要用“强”和“弱”来区分类型系统。

摘自Addison Wesley，《面向对象的分析与应用设计》，第3期，第66页:

The concepts of strong and weak typing and static and dynamic typing are entirely different. Strong and weak typing refers to type consistency, whereas static and dynamic typing refers to the time when names are bound to types. Static typing (also known as static binding or early binding) means that the types of all variables and expressions are fixed at the time of compilation; dynamic typing (also known as late binding) means that the types of all variables and expressions are not known until runtime. A language may be both strongly and statically typed (Ada), strongly typed yet supportive of dynamic typing (C++, Java), or untyped yet supportive of dynamic typing (Smalltalk).

简单地说:在静态类型语言中，类型是静态的，这意味着一旦将变量设置为类型，就不能更改它。这是因为类型是与变量而不是它所引用的值相关联的。

例如，在Java中:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

而在动态类型语言中，类型是动态的，这意味着在将变量设置为类型之后，您可以更改它。这是因为类型与值而不是变量相关联。

例如，在Python中:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

另一方面，语言中的强/弱类型与隐式类型转换有关(部分取自@Dario的回答):

例如，在Python中:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

而在PHP中:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

静态类型允许在编译时检查类型正确性。静态类型的语言通常是编译的，动态类型的语言是解释的。因此，动态类型语言可以在运行时检查类型。

从Scott的《编程语言语用学》第3版291页，我们有

Type checking is the process of ensuring that a program obeys the language’s type compatibility rules. A violation of the rules is known as a type clash. A language is said to be strongly typed if it prohibits, in a way that the language implementation can enforce, the application of any operation to any object that is not intended to support that operation. A language is said to be statically typed if it is strongly typed and type checking can be performed at compile time. In the strictest sense of the term, few languages are statically typed. In practice, the termis often applied to languages in which most type checking can be performed at compile time, and the rest can be performed at run time. A few examples: Ada is strongly typed, and for the most part statically typed (certain type constraints must be checked at run time). A Pascal implementation can also do most of its type checking at compile time, though the language is not quite strongly typed: untagged variant records (to be discussed in Section 7.3.4) are its only loophole. C89 is significantly more strongly typed than its predecessor dialects, but still significantly less strongly typed than Pascal. Its loopholes include unions, subroutineswith variable numbers of parameters, and the interoperability of pointers and arrays (to be discussed in Section 7.7.1). Implementations of C rarely check anything at run time. Dynamic (run-time) type checking is a form of late binding, and tends to be found in languages that delay other issues until run time as well. Lisp and Smalltalk are dynamically (though strongly) typed. Most scripting languages are also dynamically typed; some (e.g., Python and Ruby) are strongly typed. Languages with dynamic scoping are generally dynamically typed (or not typed at all): if the compiler can’t identify the object to which a name refers, it usually can’t determine the type of the object either.

因此，简单来说，静态/动态类型指的是发生类型检查的时间:静态类型是编译时间，动态语言是运行时间。类似地，强/弱类型指的是一种语言在强制执行其类型系统时的积极程度。

我试着把斯科特的描述翻译成一个漂亮的图表，我贴在下面。