静态类型语言

如果一个变量的类型在编译时已知，那么该语言就是静态类型的。对于某些语言，这意味着作为程序员的你必须指定每个变量的类型;其他语言(例如:Java, C, c++)提供了某种形式的类型推断，类型系统推断变量类型的能力(例如:OCaml, Haskell, Scala, Kotlin)。

这样做的主要优点是编译器可以完成所有类型的检查，因此在非常早期的阶段就可以捕捉到许多微不足道的错误。

例如:C, c++， Java, Rust, Go, Scala

动态类型语言

如果一种语言的类型与运行时值相关联，而不是命名变量/字段等，则该语言是动态类型的。这意味着作为程序员，您可以编写得更快一些，因为您不必每次都指定类型(除非使用带有类型推断的静态类型语言)。

例如:Perl, Ruby, Python, PHP, JavaScript, Erlang

大多数脚本语言都有这个特性，因为没有编译器来进行静态类型检查，但您可能会发现自己在搜索由于解释器错误解释变量类型而导致的错误。幸运的是，脚本往往很小，所以bug没有那么多藏身之处。

大多数动态类型语言允许您提供类型信息，但不要求提供类型信息。目前正在开发的一种语言Rascal采用了一种混合方法，允许函数内的动态类型，但对函数签名强制执行静态类型。

http://en.wikipedia.org/wiki/Type_system

Static typing A programming language is said to use static typing when type checking is performed during compile-time as opposed to run-time. In static typing, types are associated with variables not values. Statically typed languages include Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (with respect to distinguishing scalars, arrays, hashes and subroutines) and Scala. Static typing is a limited form of program verification (see type safety): accordingly, it allows many type errors to be caught early in the development cycle. Static type checkers evaluate only the type information that can be determined at compile time, but are able to verify that the checked conditions hold for all possible executions of the program, which eliminates the need to repeat type checks every time the program is executed. Program execution may also be made more efficient (i.e. faster or taking reduced memory) by omitting runtime type checks and enabling other optimizations. Because they evaluate type information during compilation, and therefore lack type information that is only available at run-time, static type checkers are conservative. They will reject some programs that may be well-behaved at run-time, but that cannot be statically determined to be well-typed. For example, even if an expression always evaluates to true at run-time, a program containing the code if <complex test> then 42 else <type error> will be rejected as ill-typed, because a static analysis cannot determine that the else branch won't be taken.[1] The conservative behaviour of static type checkers is advantageous when evaluates to false infrequently: A static type checker can detect type errors in rarely used code paths. Without static type checking, even code coverage tests with 100% code coverage may be unable to find such type errors. Code coverage tests may fail to detect such type errors because the combination of all places where values are created and all places where a certain value is used must be taken into account. The most widely used statically typed languages are not formally type safe. They have "loopholes" in the programming language specification enabling programmers to write code that circumvents the verification performed by a static type checker and so address a wider range of problems. For example, Java and most C-style languages have type punning, and Haskell has such features as unsafePerformIO: such operations may be unsafe at runtime, in that they can cause unwanted behaviour due to incorrect typing of values when the program runs. Dynamic typing A programming language is said to be dynamically typed, or just 'dynamic', when the majority of its type checking is performed at run-time as opposed to at compile-time. In dynamic typing, types are associated with values not variables. Dynamically typed languages include Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (with respect to user-defined types but not built-in types), PHP, Prolog, Python, Ruby, Smalltalk and Tcl. Compared to static typing, dynamic typing can be more flexible (e.g. by allowing programs to generate types and functionality based on run-time data), though at the expense of fewer a priori guarantees. This is because a dynamically typed language accepts and attempts to execute some programs which may be ruled as invalid by a static type checker. Dynamic typing may result in runtime type errors—that is, at runtime, a value may have an unexpected type, and an operation nonsensical for that type is applied. This operation may occur long after the place where the programming mistake was made—that is, the place where the wrong type of data passed into a place it should not have. This makes the bug difficult to locate. Dynamically typed language systems, compared to their statically typed cousins, make fewer "compile-time" checks on the source code (but will check, for example, that the program is syntactically correct). Run-time checks can potentially be more sophisticated, since they can use dynamic information as well as any information that was present during compilation. On the other hand, runtime checks only assert that conditions hold in a particular execution of the program, and these checks are repeated for every execution of the program. Development in dynamically typed languages is often supported by programming practices such as unit testing. Testing is a key practice in professional software development, and is particularly important in dynamically typed languages. In practice, the testing done to ensure correct program operation can detect a much wider range of errors than static type-checking, but conversely cannot search as comprehensively for the errors that both testing and static type checking are able to detect. Testing can be incorporated into the software build cycle, in which case it can be thought of as a "compile-time" check, in that the program user will not have to manually run such tests. References Pierce, Benjamin (2002). Types and Programming Languages. MIT Press. ISBN 0-262-16209-1.

静态类型

在运行前检查类型，以便更早地捕获错误。

Examples = c++

动态类型

在执行期间检查类型。

示例= Python

允许程序在运行时更改变量类型的动态类型编程。

动态类型语言:Perl、Ruby、Python、PHP、JavaScript、Erlang

静态类型，意味着如果你试图在一个整数变量中存储一个字符串，它将不会接受它。

静态类型语言:C、c++、Java、Rust、Go、Scala、Dart

静态类型语言:每个变量和表达式在编译时就已经知道了。

(int;A在运行时只能接受整型值)

例如:C, c++， Java

动态类型语言:变量可以在运行时接收不同的值，它们的类型在运行时定义。

(var;A可以在运行时取任何类型的值)

例如:Ruby, Python。

动态类型语言有助于快速构建算法概念原型，而不需要考虑需要使用什么变量类型(这在静态类型语言中是必要的)。