当我们说一种语言是动态类型和静态类型时，这意味着什么?
当前回答
在编程中，数据类型是一种分类，它告诉变量将持有什么类型的值，以及可以对这些值进行哪些数学、关系和逻辑操作而不会出错。
在每种编程语言中，为了尽量减少出错的机会，类型检查都是在程序执行之前或执行过程中进行的。根据类型检查的时间，编程语言有两种类型:静态类型语言和动态类型语言。
也取决于是否发生隐式类型转换，编程语言有两种类型:强类型语言和弱类型语言。
静态类型:
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等。
其他回答
简单地说:在静态类型语言中，变量的类型是静态的，这意味着一旦将变量设置为类型，就不能更改它。这是因为类型是与变量而不是它所引用的值相关联的。
例如，在Java中:
String str = "Hello"; // variable str statically typed as string
str = 5; // would throw an error since str is
// supposed to be a string only
另一方面:在动态类型语言中，变量的类型是动态的，这意味着在你将变量设置为类型后，你可以更改它。这是因为输入与它假设的值相关，而不是变量本身。
例如，在Python中:
some_str = "Hello" # variable some_str is linked to a string value
some_str = 5 # now it is linked to an integer value; perfectly OK
因此，最好将动态类型语言中的变量视为指向类型值的泛型指针。
总而言之，类型描述(或应该描述)语言中的变量，而不是语言本身。恕我直言，它本可以更好地用作带有静态类型变量的语言，而不是带有动态类型变量的语言。
静态类型语言通常是编译语言，因此，编译器检查类型(这很有意义，对吧?因为类型不允许稍后在运行时更改)。
动态类型语言通常是解释型的，因此类型检查(如果有的话)发生在使用它们时的运行时。这当然会带来一些性能损失，也是动态语言(例如python、ruby、php)伸缩性不如类型化语言(java、c#等)的原因之一。从另一个角度来看，静态类型语言的启动成本更高:通常会让你编写更多、更难的代码。但这在以后是有回报的。
好在双方都在借鉴对方的特点。类型语言融合了更多的动态特性，例如c#中的泛型和动态库，而动态语言则包含了更多的类型检查，例如python中的类型注释，或PHP的HACK变体，这些通常不是语言的核心，可按需使用。
在技术选择方面，任何一方都没有内在的优势。这只是一个偏好的问题，你想要更多的控制或灵活性。只要为工作选择合适的工具，并确保在考虑转换之前检查相反的可用工具。
不幸的是，术语“动态类型”具有误导性。所有语言都是静态类型的，类型是表达式的属性(而不是一些人认为的值的属性)。然而，有些语言只有一种类型。这些被称为单一类型语言。这种语言的一个例子是无类型lambda演算。
在无类型lambda演算中，所有的项都是lambda项，对一个项执行的唯一操作是将它应用到另一个项。因此，所有的操作总是导致无限递归或lambda项，但永远不会发出错误信号。
However, were we to augment the untyped lambda calculus with primitive numbers and arithmetic operations, then we could perform nonsensical operations, such adding two lambda terms together: (λx.x) + (λy.y). One could argue that the only sane thing to do is to signal an error when this happens, but to be able to do this, each value has to be tagged with an indicator that indicates whether the term is a lambda term or a number. The addition operator will then check that indeed both arguments are tagged as numbers, and if they aren't, signal an error. Note that these tags are not types, because types are properties of programs, not of values produced by those programs.
这样做的单一类型语言称为动态类型语言。
JavaScript、Python和Ruby等语言都是单一类型的。同样，JavaScript中的typeof操作符和Python中的type函数的名称具有误导性;它们返回与操作数相关的标记，而不是操作数的类型。类似地，c++中的dynamic_cast和Java中的instanceof不做类型检查。
静态类型:在编译时执行的类型检查。
静态类型语言的真正含义是:
必须指定变量的类型 变量只能引用特定类型的对象* 值的类型检查将在编译时执行，任何类型检查都将在此时报告 将在编译时分配内存来存储该特定类型的值
静态类型语言的例子有C、c++、Java。
动态类型:在运行时执行的类型检查。
动态类型语言的真正含义是:
不需要指定变量的类型 同一个变量可以引用不同类型的对象
Python、Ruby都是动态类型语言的例子。
*一些对象可以通过类型转换分配给不同类型的变量(在C和c++等语言中非常常见的做法)
类型检查是验证和强制执行类型约束的过程。
静态类型编程语言在编译时进行类型检查。 例如:Java, C, c++。 动态类型编程语言在运行时进行类型检查。 例子: Perl, Ruby, Python, PHP, JavaScript。
编译vs.解释
“当源代码被翻译时”
源代码:原始代码(通常由人输入计算机) 翻译:将源代码转换为计算机可以阅读的内容(即机器代码) 运行时间:程序执行命令的时间(编译后，如果编译) 编译语言:在运行时之前翻译的代码 解释语言:在执行过程中动态翻译的代码
打字
当类型被检查时
5 + '3'是强类型语言(如Go和Python)中类型错误的一个例子，因为它们不允许“类型强制”——>值在某些上下文中改变类型的能力，例如合并两种类型。弱类型语言，如JavaScript，不会抛出类型错误(结果为'53')。
静态:运行前检查的类型 动态:在执行期间动态检查类型
“静态和编译”和“动态和解释”的定义非常相似……但是记住，当类型被检查时。“当源代码被翻译时”。
无论语言是编译的还是解释的，你都会得到相同的类型错误!你需要从概念上区分这些术语。
Python示例
动态的,解释
def silly(a):
if a > 0:
print 'Hi'
else:
print 5 + '3'
silly(2)
因为Python是解释性的和动态类型的，所以它只翻译和类型检查它所执行的代码。else块永远不会执行，所以5 + '3'甚至永远不会被查看!
如果它是静态类型的呢?
甚至在代码运行之前就会抛出类型错误。即使它是解释的，它仍然在运行时之前执行类型检查。
如果它是编译的呢?
else块将在运行时之前被转换/查看，但因为它是动态类型的，所以不会抛出错误!动态类型语言直到执行才检查类型，而这一行永远不会执行。
去的例子
静态的,编译
package main
import ("fmt"
)
func silly(a int) {
if (a > 0) {
fmt.Println("Hi")
} else {
fmt.Println("3" + 5)
}
}
func main() {
silly(2)
}
类型在运行前检查(静态)，类型错误立即被捕获!如果是解释类型，则在运行时之前仍将检查类型，结果相同。如果它是动态的，即使在编译期间查看代码，它也不会抛出任何错误。
性能
如果编译语言是静态类型(而不是动态类型)，那么它在运行时的性能会更好;类型知识允许机器代码优化。
静态类型语言本质上在运行时具有更好的性能，因为在执行时不需要动态地检查类型(它在运行前检查)。
类似地，编译语言在运行时速度更快，因为代码已经被翻译，而不需要动态地“解释”/翻译。
注意，编译语言和静态类型语言在分别进行翻译和类型检查之前都会有一个延迟。
更多的差异
静态类型在早期捕获错误，而不是在执行期间发现错误(对长程序特别有用)。它更“严格”，因为它不允许程序中的任何地方出现类型错误，并且经常防止变量改变类型，这进一步防止了意外错误。
num = 2
num = '3' // ERROR
动态类型更灵活，这一点受到一些人的赞赏。它通常允许变量更改类型，这可能导致意外错误。
