human
J'ai constaté que certaines personnes appellent JavaScript un langage "dynamiquement, faiblement typé", mais d'autres disent même "non typé" ? Qu'est-ce que c'est vraiment
gpt
Fort/faible peut être considéré par rapport à la façon dont le compilateur, le cas échéant, gère la typage.

* Faiblement typé signifie que le compilateur, le cas échéant, n'impose pas de typage correct. Sans intervention implicite du compilateur, l'instruction générera une erreur lors de l'exécution.
```"12345" * 1 === 12345  // chaîne * nombre => nombre
```
Fortement typé signifie qu'il y a un compilateur, et il veut une conversion explicite de chaîne en entier.
```(int) "12345" * 1 === 12345
```
Dans les deux cas, certaines fonctionnalités du compilateur peuvent modifier implicitement l'instruction lors de la compilation pour effectuer des conversions pour vous, si elles peuvent déterminer que c'est la bonne chose à faire.
Jusqu'à présent, JavaScript peut être catégorisé comme Non-Fortement-Typé. Cela signifie soit qu'il est faiblement typé, soit non typé.

Dynamique/statique peut être considéré par rapport à la façon dont les instructions du langage manipulent les types.

* Dynamiquement typé signifie que le type de valeur est imposé, mais la variable représente simplement n'importe quelle valeur de n'importe quel type.
```x = 12345;    // nombre
x = "chaîne"; // chaîne
x = { clé: "valeur" }; // objet
y = 123 + x; // erreur ou conversion implicite doit avoir lieu.
```
Statiquement typé signifie que le type de variable est fortement imposé, et le type de valeur est moins imposé.
```int x = 12345; // lie x au type int
x = "chaîne";  // trop tard, x est un entier - erreur
string y = 123; // erreur ou conversion implicite doit avoir lieu.
```
Jusqu'à présent, JavaScript peut être catégorisé comme Non-Statiquement-Typé. De plus, il semble être Dynamiquement Typé, si typé du tout. Nous devons donc voir ce que le Typage signifie.

Typé signifie que le langage distingue entre différents types tels que chaîne, nombre, booléen, objet, tableau, null, undefined, etc. De plus, chaque opération est liée à des types spécifiques. Ainsi, vous ne pouvez pas diviser un entier par une chaîne.
```    2 / "blah"  // produit NaN
```
Non typé signifie que l'opération de division d'un entier par une chaîne aboutirait à traiter les quatre premiers octets de la chaîne comme un entier. Cela est dû au fait que les opérations non typées se déroulent directement sur les bits, il n'y a pas de types à observer. Le résultat sera quelque chose de tout à fait inattendu :
```    2 / "blah"  // sera traité comme  2 / 1500275048
```
Puisque JavaScript se comporte conformément à la définition d'être Typé, il doit l'être. Et donc il doit être Dynamiquement Typé et Faiblement Typé.
Si quelqu'un prétend que JavaScript est Non Typé, c'est simplement pour la théorie académique, pas pour une application pratique.