JavaScript est-il un langage non typé?

J'ai trouvé que certaines personnes appellent JavaScript un langage «dynamiquement, faiblement typé», mais certains disent même «non typé»? Qu'est-ce que c'est vraiment?

JavaScript n'est pas typé:

_{(source: no.gd )}

Même Brendan Eich le dit. Sur Twitter, il a répondu à un fil de discussion lié à cette question:

... les types universitaires utilisent "non typé" pour signifier "pas de types statiques" ...

Le problème est donc qu'il existe différentes définitions de non typé .

Une définition a été évoquée dans l'une des réponses ci-dessus: le runtime ne balise pas les valeurs et traite simplement chaque valeur comme des bits. JavaScript fait des valeurs de variables et a un comportement différent en fonction de ces balises. Donc, JavaScript ne rentre évidemment pas dans cette catégorie.

L'autre définition est tirée de la théorie du langage de programmation (la chose académique à laquelle Brendan fait référence). Dans ce domaine, non typé signifie simplement que tout appartient à un seul type .

Pourquoi? Parce qu'un langage ne générera un programme que lorsqu'il pourra prouver que les types s'alignent (c'est -à-dire la correspondance Curry-Howard ; les types sont des théorèmes, les programmes sont des preuves). Cela signifie dans une langue non typée:

1. Un programme est toujours généré
2. Par conséquent, les types correspondent toujours
3. Par conséquent, il ne doit y avoir qu'un seul type

Contrairement à une langue typée:

1. Un programme peut ne pas être généré
2. Parce que les types peuvent ne pas correspondre
3. Parce qu'un programme peut contenir plusieurs types

Donc voilà, en PLT, non typé signifie simplement typé dynamiquement et typé signifie simplement typé statiquement . JavaScript n'est certainement pas typé dans cette catégorie.

Voir également:

• Ce qu'il faut savoir avant de débattre des systèmes de types
• «Non typé» signifie-t-il aussi «typé dynamiquement» dans le monde universitaire de la CS?

strong / low peut être considéré en relation avec la façon dont le compilateur, le cas échéant, gère le typage.

• Faible typé signifie que le compilateur, le cas échéant, n'applique pas le typage correct. Sans interjection implicite du compilateur, l'instruction produira une erreur lors de l'exécution.

  "12345" * 1 === 12345  // string * number => number

  Fortement typé signifie qu'il y a un compilateur et qu'il vous demande un cast explicite de chaîne en entier .

  (int) "12345" * 1 === 12345

  Dans les deux cas, certaines fonctionnalités du compilateur peuvent implicitement modifier l'instruction pendant la compilation pour effectuer des conversions à votre place, s'il peut déterminer que c'est la bonne chose à faire.

  Jusqu'à présent, JavaScript peut être classé comme non fortement typé. Cela signifie soit qu'il est faiblement typé ou non typé.

dynamique / statique peut être pensé en relation avec la manière dont les instructions de langage manipulent les types.

• Dynamiquement typé signifie que letype dela valeur est appliqué, mais la variable représente simplement n'importe quelle valeur de n'importe quel type.

  x = 12345;    // number
  x = "string"; // string
  x = { key: "value" }; // object
  y = 123 + x; // error or implicit conversion must take place.

  Le type statique signifie que letype de variable est fortement appliqué et que le type valeur l'est moins.

  int x = 12345; // binds x to the type int
  x = "string";  // too late, x is an integer - error
  string y = 123; // error or implicit conversion must take place.

  Jusqu'à présent, JavaScript peut être classé comme non typé statiquement. En outre, il semble être typé dynamiquement, s'il est tapé du tout. Nous devons donc voir ce que signifie Typing.

Typed signifie que le langage fait la distinction entre différents types tels que chaîne , nombre , booléen , objet , tableau , nul , non défini , etc. De plus, chaque opération est liée à des types spécifiques. Vous ne pouvez donc pas diviser un entier par une chaîne .

    2 / "blah"  // produces NaN

Non typé signifie que l'opération de division d'un entier par une chaîne entraînerait le traitement des quatre premiers octets de la chaîne comme un entier . En effet, les opérations non typées ont lieu directement sur les bits, il n'y a aucun type à observer. Le résultat sera quelque chose d'assez inattendu:

    2 / "blah"  // will be treated as  2 / 1500275048

Puisque JavaScript se comporte selon la définition d'être typé, il doit l'être. Et par conséquent, il doit être typé dynamiquement et faiblement typé.

Si quelqu'un prétend que JavaScript n'est pas typé, c'est simplement pour la théorie académique, pas pour une application pratique.

JavaScript est faiblement typé . Il n'est certainement pas "non typé" mais sa nature faiblement typée permet une grande flexibilité en termes de conversions implicites.

Gardez à l'esprit que JavaScript est également typé dynamiquement. Cette méthode de saisie permet ce que l'on appelle le "typage canard" .

À titre de comparaison, considérez que JavaScript n'est pas fortement typé ni statiquement typé. Parfois, comprendre ce que quelque chose n'est pas peut vous aider à mieux voir ce que c'est.

Au point de l'auteur, JavaScript est également classé comme typé dynamiquement . Wiki déclare que les langages dynamiquement typés sont vérifiés au moment de l'exécution plutôt que dans un compilateur tandis que Weakly Typed fait référence à la possibilité de changer de type à la volée dans votre code. Alors oui, il est à la fois typé dynamiquement ET faiblement typé.

Le problème ici qui déroute beaucoup de programmeurs est que des définitions comme celle-ci ne sont pas standardisées quelque part. Le terme langage de programmation non typé est ambigu. Cela fait-il référence à un langage qui n'a pas de types de données ou à un langage qui est une variante non typée du calcul lambda ?

JavaScript / ECMAScript a un système de type et tous les domaines de ses fonctions accepteront n'importe quel type de spécification de référence. Cela signifie donc que JavaScript a un seul type de données, en réalité. C'est une question de mise en œuvre qui est plus importante pour les programmeurs JavaScript très avancés. Le programmeur JavaScript moyen ne se soucie que des types de données de langage abstrait qui ont été spécifiés par ECMAScript.

Dans le contexte du programmeur de tous les jours, et non du chercheur ou de l'informaticien théorique, le terme non tapé est un abus de langage car la plupart des gens ne font pas de lambda calcul. Ainsi, le terme confond les masses et semble déclarer que JavaScript n'a aucun type de données, ce qui n'est tout simplement pas vrai. Quiconque a déjà utilisé typeofsait que JavaScript a ses propres types de données de langage:

var test = "this is text";
typeof(test);

rendements

"chaîne"

ECMAScript définit les types pour la langue suivante: undefined, null, string, boolean, number,object

http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

Une désignation plus précise pour JavaScript serait implicitement typée, dynamiquement typée ou faiblement / lâchement typée (ou une combinaison des deux), dans la mesure où JavaScript utilise la coercition de type dans certains cas, ce qui rend le type implicite car vous n'avez pas à spécifier explicitement le type de vos variables. Il est faiblement typé car, contrairement à certains langages qui font la distinction entre float et integer, etc., il utilise juste un numbertype pour englober tous les nombres, et utilise la coercition de type mentionnée précédemment ^{[Section 9 de ECMAScript Spec]} , contrairement à un langage fortement typé qui aurait des types de données très spécifiques (c'est-à-dire qu'il faudrait spécifier intou float).

Les définitions des langages à typage statique et dynamique ne sont pas standardisées, mais la taille d'un octet ne l'était pas non plus lorsque les ordinateurs commençaient à évoluer. Le typage statique et dynamique se réfère le plus souvent à la présence de certaines fonctionnalités du langage. L'une d'elles est la vérification de type à l'exécution , ou ce que l'on appelle la vérification de type dynamique . Si vous avez utilisé JavaScript, vous savez déjà qu'il attend définitivement l'exécution pour vérifier les types, c'est pourquoi vous obtenez des TypeErrorexceptions lors de l'exécution de votre code. Exemple ici

Je pense que la réponse la plus votée est de confondre le polymorphisme des fonctions JavaScript avec des fonctions qui accepteront littéralement tout (comme avec des variantes non typées de Lambda Calculus), ce qui est une erreur d'association .

N'oubliez pas que JavaScript vous permet de demander quel est le typeof(your_variable), et de comparer les types: 5==="5"renvoie false. Ainsi, je ne pense pas que vous puissiez l'appeler non typé.

Il est dynamiquement et (estimé comme) faiblement typé. Vous voudrez peut-être savoir qu'il utilise le typage Duck (voir le lien d'Andrew) et offre la POO via le prototypage au lieu des classes et de l'héritage.

Tant qu'il est tapé (vous pouvez demander "typeof someVar" et apprendre son type spécifique, il est très faible.

Donné:

  var a = "5";

vous pourriez dire que a est une chaîne. Cependant, si vous écrivez ensuite:

  var b = a + 10;

b est un int égal à 15, donc a a agi comme un int. Bien sûr, vous pouvez alors écrire:

  var c = a + "Hello World";

et c sera égal à "5Hello World", donc a agit à nouveau comme une chaîne.