You have discovered a soft spot in the terminology that amateurs use to talk about programming languages. Don't use the terms "strong" and "weak" typing, because they don't have a universally agreed on technical meaning. By contrast, static typing means that programs are checked before being executed, and a program might be rejected before it starts. Dynamic typing means that the types of values are checked during execution, and a poorly typed operation might cause the program to halt or otherwise signal an error at run time. A primary reason for static typing is to rule out programs that might have such "dynamic type errors".

Strong typing generally means that there are no loopholes in the type system, whereas weak typing means the type system can be subverted (invalidating any guarantees). The terms are often used incorrectly to mean static and dynamic typing. To see the difference, think of C: the language is type-checked at compile time (static typing), but there are plenty of loopholes; you can pretty much cast a value of any type to another type of the same size---in particular, you can cast pointer types freely. Pascal was a language that was intended to be strongly typed but famously had an unforeseen loophole: a variant record with no tag.

随着时间的推移，强类型语言的实现经常会出现漏洞，通常是为了让运行时系统的一部分可以用高级语言实现。例如，Objective Caml有一个叫做Obj的函数。Magic，它具有简单地返回其参数的运行时效果，但在编译时它将任何类型的值转换为任何其他类型的值。我最喜欢的例子是Modula-3，它的设计者称其类型转换结构为漏洞。

话虽如此，你不能指望任何两个人以完全相同的方式使用“强”和“弱”这个词。所以要避开它们。

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

这里有两个例子:

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

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

You have discovered a soft spot in the terminology that amateurs use to talk about programming languages. Don't use the terms "strong" and "weak" typing, because they don't have a universally agreed on technical meaning. By contrast, static typing means that programs are checked before being executed, and a program might be rejected before it starts. Dynamic typing means that the types of values are checked during execution, and a poorly typed operation might cause the program to halt or otherwise signal an error at run time. A primary reason for static typing is to rule out programs that might have such "dynamic type errors".

Strong typing generally means that there are no loopholes in the type system, whereas weak typing means the type system can be subverted (invalidating any guarantees). The terms are often used incorrectly to mean static and dynamic typing. To see the difference, think of C: the language is type-checked at compile time (static typing), but there are plenty of loopholes; you can pretty much cast a value of any type to another type of the same size---in particular, you can cast pointer types freely. Pascal was a language that was intended to be strongly typed but famously had an unforeseen loophole: a variant record with no tag.

随着时间的推移，强类型语言的实现经常会出现漏洞，通常是为了让运行时系统的一部分可以用高级语言实现。例如，Objective Caml有一个叫做Obj的函数。Magic，它具有简单地返回其参数的运行时效果，但在编译时它将任何类型的值转换为任何其他类型的值。我最喜欢的例子是Modula-3，它的设计者称其类型转换结构为漏洞。

话虽如此，你不能指望任何两个人以完全相同的方式使用“强”和“弱”这个词。所以要避开它们。

在编程中，数据类型是一种分类，它告诉变量将持有什么类型的值，以及可以对这些值进行哪些数学、关系和逻辑操作而不会出错。

在每种编程语言中，为了尽量减少出错的机会，类型检查都是在程序执行之前或执行过程中进行的。根据类型检查的时间，编程语言有两种类型:静态类型语言和动态类型语言。

也取决于是否发生隐式类型转换，编程语言有两种类型:强类型语言和弱类型语言。

静态类型:

Type checking is done at compile time In source code, at the time of variable declaration, data type of that variable must be explicitly specified. Because if data type is specified in source code then at compile time that source code will be converted to machine code and type checking can happen Here data type is associated with variable like, int count. And this association is static or fixed If we try to change data type of an already declared variable (int count) by assigning a value of other data type (int count = "Hello") into it, then we will get error If we try to change data type by redeclaring an already declared variable (int count) using other data type (boolean count) then also we will get error

int count;         /* count is int type, association between data type
                      and variable is static or fixed */

count = 10;        // no error 
count = 'Hello';   // error 
boolean count;     // error 

由于类型检查和类型错误检测是在编译时完成的，这就是为什么在运行时不需要进一步的类型检查。因此，程序变得更加优化，结果在更快的执行 如果我们想要更严格的代码，那么选择这种类型的语言是更好的选择 例如:Java, C, c++， Go, Swift等。

动态类型:

Type checking is done at runtime In source code, at the time of variable declaration, no need to explicitly specify data type of that variable. Because during type checking at runtime, the language system determines variable type from data type of the assigned value to that variable Here data type is associated with the value assigned to the variable like, var foo = 10, 10 is a Number so now foo is of Number data type. But this association is dynamic or flexible we can easily change data type of an already declared variable (var foo = 10), by assigning a value of other data type (foo = "Hi") into it, no error we can easily change data type of an already declared variable (var foo = 10), by redeclaring it using value of other data type (var foo = true), no error

var foo;            // without assigned value, variable holds undefined data type 

var foo = 10;       // foo is Number type now, association between data 
                    // type and value is dynamic / flexible 
foo = 'Hi';         // foo is String type now, no error 
var foo = true;     // foo is Boolean type now, no error 

由于类型检查和类型错误检测是在运行时完成的，这就是为什么程序变得不那么优化，导致执行速度变慢。尽管如果它们实现了JIT编译器，这些类型的语言的执行速度会更快 如果我们想要轻松地编写和执行代码，那么这种类型的语言是更好的选择，但在这里我们可能会得到运行时错误 例如:Python, JavaScript, PHP, Ruby等。

强类型:

严格维护数据类型相关规则和限制 从一种数据类型到另一种数据类型的转换必须显式进行，不能进行隐式类型转换

# in python, "5" cannot automatically get converted to 5
pybar = "5"

print(10 + pybar)     # error, no `+` operation between `int` and `str` 

类型检查可以在编译时或运行时进行。这意味着强类型语言既可以是静态类型的，也可以是动态类型的 例如:Python, Java, Ruby, c#等。

弱类型:

数据类型相关的规则和限制松散维护 从一种数据类型到另一种数据类型的转换可以隐式进行 如果我们在两个不匹配的数据类型的值之间执行一些操作，那么这种类型的语言可能不会抛出错误。相反，弱类型语言将应用它们自己的隐式类型转换规则，并将返回一些结果

jsbar = "5";

alert(10 + jsbar);  /* "105", no error as javascript implicitly coerces Number 10 
to String "10", so that it can be concatenated with other operand jsbar i.e. "5" */

类型检查可以在编译时或运行时进行。这意味着弱类型语言既可以是静态类型的，也可以是动态类型的 例如:JavaScript, C, c++， PHP等。

Statically typed languages generally require you to declare the types of variables, which is then checked at compile time to reduce errors. The word "static" in "statically typed" refers to "static code analysis", which is the process of examining the code prior to executing it. Although it is possible for a statically typed language to infer the type of the variable from the right hand side of an expression or actual parameters, in practice most statically typed languages require variable types to be explicitly declared.

Dynamically typed languages generally do not require variable declarations to have types, and they infer variable types based on the type calculated as a result of evaluating the right hand side of every assignment statement or the actual parameters to a function call. Since the variable can be given multiple assignments over its lifetime, its type can change over time and this is why it is called "dynamically typed". Also, the runtime environment needs to keep track of the current type for each variable, so the type is bound to the value rather than with the variable declaration. This can be considered a runtime type information (RTTI) system.

静态类型语言和动态类型语言的元素可以组合。例如，c#既支持静态类型变量，也支持动态类型变量，而面向对象语言通常支持类型层次结构的向下转换。静态类型语言通常提供各种绕过类型检查的方法，例如使用强制转换、反射和动态调用。

强类型和弱类型指的是语言在多大程度上试图防止由于使用变量而导致的错误，就好像它是一种类型，而实际上它是另一种类型。例如，C和Java都是静态类型语言，但是Java使用了比C强大得多的类型检查。下面的C代码很容易编译和运行，并会在运行时将一个随机值放入变量b中，很可能会导致错误:

char *a = "123";
int b = (int)a;

等效的Java代码将产生一个编译错误，这通常是可取的:

String a = "123"
int b = (int)a;

弱类型意味着对象的类型可以根据上下文而改变。例如，在弱类型语言中，字符串“123”如果添加另一个数字，可能会被视为数字123。具有弱类型的语言示例有bash、awk和PHP。

另一种弱类型语言是C语言，其中内存地址上的数据可以通过强制转换被视为不同的类型。

在强类型语言中，对象的类型不会改变——int始终是int，试图将其用作字符串将导致错误。Java和Python都是强类型的。

动态类型和静态类型之间的区别在于类型规则何时被强制执行。在静态类型语言中，每个变量和参数的类型都必须在源代码中声明，并在编译时强制执行。在动态类型语言中，类型只在运行时使用时进行检查。Java是静态类型，Python是动态类型。

然而，界限有时会有点模糊。例如，尽管Java是静态类型的，但每次你使用反射或强制转换(例如，当使用对象容器时)，你都将类型检查推迟到运行时。

类似地，大多数强类型语言仍然会在整数和浮点数之间自动转换(在某些语言中是任意精确的bigint)。