Javascript 中的类型强制到底是什么？

小开

在 Python 中，如果你试图添加字符串和整数，你会得到一个错误:

>>> "hi" + 10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

但是在 JavaScript 中，你不需要这样做。 10被转换成一个字符串:

> "hi" + 10
"hi10"

“类型强迫”只是对上述情况的一个花哨的误称。实际上，两种语言都没有 Java 或 C 或其他具有静态类型系统的语言意义上的“类型”。语言如何处理各种非静态类型值之间的交互是一个选择和约定的问题。

小开

a == b意味着 javascript 将根据这些值是否可以同等地计算来计算 a和 b。例如，false == 0将计算 true，因为0也是 Boolean false 的值。但是，false === 0将计算 false，因为严格地比较，0与 false 的物理值是不同的。另一个例子是 false == ''，基本上是松散比较和严格比较，因为 javascript 是一种松散类型的语言。也就是说，javascript 会尝试基于代码的上下文来转换变量，如果不严格比较的话，这样做的效果就是使变量相等。Php 也有这种行为。

小开

最佳答案

类型强制意味着当运算符的操作数是不同类型时，其中一个操作数将转换为另一个操作数类型的“等效”值。例如，如果你这样做:

boolean == integer

布尔操作数将被转换成一个整数: false变成 0，true变成1。然后比较这两个值。

但是，如果使用非转换比较运算符 ===，则不发生此类转换。当操作数具有不同的类型时，此运算符返回 false，并且只在它们属于相同类型时比较值。

虽然比较操作符是唯一同时具有“严格”和“松散”变体的操作符，但是强制操作并不仅仅由比较操作符完成。大多数算术运算符会自动将非数值参数转换为数值，例如，"50" / 5被视为 50 / 5。还有许多内置的函数和方法需要字符串参数; 如果您给它们其他东西，它们将自动强制它们成为字符串。

但是要小心—— +既是算术加法运算符，也是字符串连接运算符——如果使用 string + number，它会将数字转换为字符串并进行连接，而不是将字符串转换为数字并进行加法。这是在对用户输入执行算术时出现的许多错误的根源，因为除非显式转换，否则输入是字符串。

您可以在你不了解 JS中找到对 JavaScript 强制规则的良好解释，在 MDN中找到更多面向引用的文档。

小开

让我们从一个简短的类型系统入门开始，我认为这将有助于你理解类型强制的一般概念。

语言的类型系统定义了一些规则，这些规则告诉我们该语言中存在哪些类型的数据，以及如何使用不同的运算符组合这些数据。例如，一个这样的规则可能指定 plus (+)运算符只作用于数字。这些规则的存在主要是为了防止你搬起石头砸自己的脚。但是如果程序员在程序中打破了这个规则会发生什么呢？没有什么可以阻止程序员在程序中键入 {} + {}或 “hello” + 5，即使语言认为这些表达式没有任何意义。

在这些情况下最终会发生什么取决于语言对其类型规则的严格程度。

一个语言类型系统通常持有两种立场之一，认为你打破了它的规则:

说“嘿，这样不好!”然后立即崩溃你的程序。
说“ I can’t do anything with {} ... but I can do something with number”并尝试将{}转换为数字。

具有类型系统的语言在其规则方面处于第一位，这种语言通俗地称为“强类型”语言。他们严格要求你不能违反规定。那些采用第二种方法(比如 JavaScript)的语言被称为“弱类型”或“松散类型”语言。当然，您可以打破规则，但是当它为了遵守其规则而强制转换您在程序中描述的数据类型时，不要感到惊讶。这种行为被称为... (鼓声) ... 类型胁迫类型胁迫。

现在让我们看看 JavaScript 中的一些示例。首先，让我们从一个不会导致类型强制的表达式开始。

5 + 5

使用带有两个完全有效的数字的 + 运算符。这个程序将把 + 看作是“加”的意思，并愉快地将这两个数字相加。不需要转换。

那..。

[] + 5

啊哦。在 JavaScript 中，+可以表示两个数字相加或连接两个字符串。在这种情况下，我们既没有两个数字也没有两个字符串。我们只有一个数字和一个物体。根据 JavaScript 的类型规则，这没有逻辑意义。因为它原谅你打破了它的规则，而不是崩溃它试图理解它。那么 JavaScript 是做什么的呢？它知道如何连接字符串，所以它将[]和5都转换成字符串，结果是字符串值“5”。

比较运算符 ==和 ===是怎么回事? 为什么有两个比较运算符？

==不能免疫 JavaScript 的类型转换行为。诸如 5 == “5”之类的表达式将计算为 true，因为 JavaScript 将尝试转换其中一个表达式，以便比较相同类型的数据。

在许多情况下，这是不可取的，因为您可能想知道所比较的某些数据是否属于不同的类型，以便您可以决定如何处理它。这就需要 ===操作员了。使用 ===时，不会发生类型转换。因此，表达式 5 === “5”的计算结果将为 false。

小开

var str = 'dude';
console.log(typeof str); // "string"
console.log(!str); // false
console.log(typeof !str); // "boolean"

一个变量示例，该变量最初声明为一个字符串，后来用! 运算符强制声明为布尔值

小开

如果数据类型不相等，则会发生强制。比如3 = = “3”或者 booolen = = 整数

小开

让我用下面的例子来解释类型强制

类型强制(TypeCoercion)意味着 Javascript 自动(动态)将一个变量从一种数据类型转换为另一种数据类型

例如: 123 + "4"通常会引发一个错误，但是在 Javascript 中，由于类型强制，它会导致 1234出现一个字符串

if(23 == "23"){
console.log(" this line is inside the loop and is executed ");
}

In the above code, because of type coercion - JavaScript thinks 23 (number) and "23" (string) are the same thing. this makes the condition true and prints the console.log

在另一个案子里

if(23 === "23"){
console.log(" this line is inside the loop and is NOT executed");
}

在 ===的情况下，Javascript 不执行类型强制，因为 23是一个数字，而 "23"是 String，因为 ===，这两种数据类型是不同的，这导致条件为 false。它不打印 console. log

简而言之

在这种情况下，=是一个赋值操作符——它赋值诸如 var a = 3;等等

(以下操作员可供比较)

在这种情况下，== Javascript 将数据类型转换/强制转换为另一个数据类型，然后进行比较。

在这种情况下，=== Javascript 不会转换/强制数据类型

为了避免错误和调试的目的，===是最常用的

请让我知道上述信息的准确性。

小开

什么是胁迫:

当 Javascript 引擎必须执行某个操作，而该操作需要数据属于某个类型时，就会发生 Javascript 中的类型强制。当引擎遇到不适用于操作的特定类型的数据时，它会将数据强制转换为特定类型。这是必要的，因为 javascript 中的变量是动态类型化的，这意味着给定的变量可以分配任何类型的值。

例如:

if(1){
// 1 gets coerced to true
}




if(4 > '3') {
// 3 gets coerced into a number
}




44 == "44"  // true, the string 44 gets converted to a nr

布尔强制:

在 javascript 强制下，所有值都被转换为 true，除了以下被强制转换为 false的值:

console.log(!!"");         // false
console.log(!!0);          // false
console.log(!!null);       // false
console.log(!!undefined);  // false
console.log(!!NaN);        // false
console.log(!!false);      // false

也请注意，在上面的例子中，双！使用操作符。啊！标记运算符将一个值强制转换为带有相反值的布尔值。我们可以使用这个运算符两次将任何值转换为布尔值。

小开

类型强制是将值从一种类型转换为另一种类型的过程(如字符串转换为数字，对象转换为布尔值，等等)。任何类型，无论是基本类型还是对象，都是类型强制的有效主题。回想一下，原语是: number、 string、 boolean、 null、 unDefinition + Sign (在 ES6中添加)。

类型强制可以是显式的和隐式的。

当开发人员通过编写适当的代码(如 Number (value))来表达在类型之间进行转换的意图时，这称为显式类型强制(或类型强制转换)。

由于 JavaScript 是一种弱类型语言，所以值也可以在不同类型之间自动转换，这被称为隐式类型强制。这通常发生在对不同类型的值应用运算符时，如 1 = = null，2/’5’，null + new Date () ，或者它可以由周围的上下文触发，比如 if (value){ ... } ，其中的值被强制为布尔值。

下面是一些隐式类型强制的例子:

true + false
12 / "6"
"number" + 15 + 3
15 + 3 + "number"
[1] > null
"foo" + + "bar"
'true' == true
false == 'false'
null == ''
!!"false" == !!"true"
[‘x’] == ‘x’
[] + null + 1
[1,2,3] == [1,2,3]
{}+[]+{}+[1]
!+[]+[]+![]
new Date(0) - 0
new Date(0) + 0