Introduction à la conversion de type forcée en JavaScript

Cet article vous apporte une introduction à la méthode de conversion de type forcée en JavaScript. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

JavaScript Primitives

JavaScript est construit sur une série d'unités de base. Certains d'entre eux devraient déjà vous être familiers, comme les chaînes et les nombres :

var greet = "Hello";
var year = 89;

Les chaînes et les nombres font partie des soi-disant "primitives du langage". La liste complète est :

• String
• Number
• Boolean
• Null
• Undefined
• Object
• Symbole (ajouté dans ES6, non présenté ici)

Les valeurs booléennes sont utilisées pour représenter des valeurs qui peuvent être vraies ou fausses. null n'est intentionnellement pas attribué. Il est généralement attribué à une variable pour indiquer que la liaison est terminée et sera remplie d'un contenu significatif plus tard.

var maybe = null;

puis undefined, ce qui signifie que la variable n'est toujours pas attachée :

var name;
console.log(name)
undefined

null et undefined se ressemblent beaucoup, mais ce sont deux entités distinctes , et de nombreux développeurs ne savent toujours pas lequel utiliser.

Si vous souhaitez déterminer le type d'une instance JavaScript, vous pouvez utiliser l'opérateur typeof. Essayons avec des chaînes :

typeof "alex"
> "string"

Et avec des nombres :

typeof 9
> "number"

Pour les booléens :

typeof false
> "boolean"

undefined :

typeof undefined
> "undefined"

et nul :

typeof null
> "object"

Le résultat est surprenant ! null ressemble à un objet, mais il s'agit en fait d'un bug historique de JavaScript qui existe depuis la naissance du langage. JavaScript a eu une mauvaise réputation à cause de ces problèmes. Mais ce n'est que le début.

Stranger Things

En JavaScript, il existe des règles étranges lors de la conversion entre deux types. Permettez-moi de vous donner quelques informations générales. Donnons d'abord un exemple utilisant Python. L'exécution de la commande suivante en Python :

'hello' + 89

vous donnera une erreur claire :

TypeError: can only concatenate str (**not** "int") to str

En JavaScript, il n'y a pas de limite :

'hello' + 89

donne en fait :

"hello89"

Cela aura l'air encore plus bizarre si nous essayons d'ajouter un tableau à la chaîne :

'hello' + []

obtiendra

1. 'hello'

Aussi

1. 'hello' + [89]

vous surprendra :

1. "hello89"

On dirait qu'il y a une certaine logique derrière ce changement. Cela fonctionne même pour les tableaux où il y a plus d'éléments :

1. 'hello' + [89, 150.156, 'mike']

résultant en :

1. "hello89,150.156,mike"

Ces deux lignes de JavaScript suffisent à faire fuir les programmeurs Java. Mais ce comportement est logique à 100% en JavaScript. Par conséquent, cette conversion implicite, également connue sous le nom de cast mérite d'être explorée.

Quand un nombre devient une chaîne

Certains langages de programmation ont un concept appelé Conversion de type, ce qui signifie : Si je veux convertir un nombre ou une instance en un autre tapez, alors je dois faire conversion explicite en . Cela fonctionne également avec JavaScript. Voir l'exemple suivant :

var greet = "Hello";
var year = 89;

Si je souhaite rendre la conversion explicite, je peux indiquer l'intention dans le code :

var greet = "Hello";
var year = 89;

var yearString = year.toString()

Ou faire ceci :

var greet = "Hello";
var year = 89;

var yearString = String(year)

Je peux alors concaténer les deux variables :

greet + yearString;

Mais en JavaScript il existe un mécanisme subtil appelé conversion implicite, fourni par le moteur JavaScript. Le langage ne nous empêche pas d'ajouter des nombres et des chaînes :

'hello' + 89

obtiendrait :

"hello89"

Mais quelle est la logique derrière cette conversion ? Vous serez peut-être surpris de savoir que l'opérateur d'addition en JavaScript + convertit automatiquement l'un de ses deux opérandes en chaîne si au moins l'un d'eux est une chaîne  !

Ce que vous trouverez encore plus surprenant, c'est que cette règle est cohérente dans la spécification ECMAScript. La section 11.6.1 définit le comportement de l'opérateur d'addition, je l'ai résumé pour vous ici :

Si x est une chaîne ou y est une chaîne, retournez ToString(x), puis retournez ToString(y)

Cette astuce ne fonctionne-t-elle qu'avec des chiffres ? Pas vraiment. Les tableaux et les objets seront également soumis à la même conversion  :

'hello' + [89, 150.156, 'mike']

obtiendront :

"hello89,150.156,mike"

Alors, qu'obtiendra le code suivant :

'hello' + { name: "Jacopo" }

Pour le savoir, vous pouvez faire un test rapide en convertissant l'objet en chaîne :

String({ name: "Jacopo" })

obtiendra :

"[object Object]"

Donc j'ai un sentiment :

1. 'hello' + { name: "Jacopo" }

Obtiendra :

1. "hello[object Object]"

Arrêtez ça ! Qu'est-ce que c'est?

Quelle est la signification de [object Object] en JavaScript ?

« [object Object] » est l’une des « bizarreries » JavaScript les plus courantes.

Presque toutes les instances JavaScript ont une méthode nommée toString(), et certaines méthodes sont fournies par Object.prototype.toString.
Certains types, tels que les tableaux, implémentent une version personnalisée de toString() pour convertir la valeur en chaîne lorsque la méthode est appelée. Par exemple, Array.prototype.toString remplace Object.toString() (également connu sous le nom d'observation de méthode).

但是当你在普通的 JavaScript 对象上调用 toString() 时，引擎会给出“[object Object]”，因为 Object.toString() 的默认行为是由实体类型（在这种情况下为Object）返回字符串 object 。

现在让我们把注意力集中在 JavaScript 比较运算符上，它们与算术运算符一样奇怪。

等于还是不等于？

JavaScript 中有两个主要的比较运算符。

第一个我们称之为“弱比较”。这是抽象比较运算符（双等号）：==。

另一个是“强比较”，可以通过三等号进行识别：=== 也称为严格比较运算符。它们两者的行为方式完全不同。

来看一些例子。首先，如果我们将两个字符串与两个运算符进行比较，我们得到相同的结果

"hello" == "hello"
> true

"hello" === "hello"
> true

看上去一切都还好。

现在尝试比较两种不同的类型，数字和字符串。首先是“强比较”：

1. "1" === 1
2. false

这说得通！字符串“1”与数字1是不同的。但是“弱比较”会发生什么？

1. "1" == 1
2. true

居然是true！它没有任何意义，除非这种行为与我们之前看到的隐式转换有关。

如果适用相同的规则怎么办？没错！ ECMAScript spec 再次罢工。结果抽象比较运算符在比较它们之前在类型之间进行自动转换。这是规范的摘要：

比较 x == y 执行如下：

如果 x 是 String 且 y 是Number，则返回比较结果 ToNumber(x)== y

规范说：如果第一个操作数是一个字符串，第二个操作数是一个数字，那么将第一个操作数转换为数字。有趣。

JavaScript 规范充满了这个疯狂的规则，我强烈鼓励大家对它深入挖掘。

在此期间除非你有充分的理由否则在 JavaScript 代码中避免使用抽象比较运算符。你以后会感谢自己的。

那么“强势比较”怎么样？规范中的说 严格相等比较在把值与三等 === 进行比较之前没有进行自动转换。在代码中使用严格相等比较可以避免愚蠢的 bug。

总结

JavaScript 中有七个构建块，即 String，Number，Boolean，Null，Undefined，Object 和 Symbol。这些类型被称为基元。

JavaScript 开发人员可以使用算术和比较运算符来操作这些类型。但是我们要特别注意加法运算符 + 和抽象比较运算符 ==，它本质上倾向于在类型之间进行转换。

JavaScript 中的隐式转换称为强制类型转换，并在 ECMAScript 规范中定义。无论什么时候你的代码都要使用严格的比较运算符 === 而不是 ==。

作为最佳实践，当你打算在两种类型之间进行转换时，请务必明确操作。JavaScript 有一堆内置对象，它们反映了原始类型：String，Number，Boolean。这些内置类型可用于在不同类型之间进行显式转换。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!