Is JavaScript an untyped language?

I've found that some people call JavaScript a "dynamically, weakly typed" language, but some even say "untyped"? Which is it really?

JavaScript is untyped:

_{(source: no.gd)}

Even Brendan Eich says so. On Twitter, he replied to a thread that linked to this question:

... academic types use "untyped" to mean "no static types"...

So the problem is that there's a few different definitions of untyped.

One definition has been talked about in one of the above answers - the runtime doesn't tag values and just treats each value as bits. JavaScript does tag values and has different behaviour based on those tags. So JavaScript obviously doesn't fit this category.

The other definition is from Programming Language Theory (the academic thing that Brendan is referring to). In this domain, untyped just means everything belongs to a single type.

Why? Because a language will only generate a program when it can prove that the types align (a.k.a. the Curry-Howard correspondence; types are theorems, programs are proofs). This means in an untyped language:

1. A program is always generated
2. Therefore types always match up
3. Therefore there must only be one type

In contrast to a typed language:

1. A program might not be generated
2. Because types might not match up
3. Because a program can contain multiple types

So there you go, in PLT, untyped just means dynamically typed and typed just means statically typed. JavaScript is definitely untyped in this category.

See also:

• What to know before debating type systems
• Does “untyped” also mean “dynamically typed” in the academic CS world?

strong/weak can be thought of in relation to how the compiler, if applicable, handles typing.

• Weakly typed means the compiler, if applicable, doesn't enforce correct typing. Without implicit compiler interjection, the instruction will error during run-time.

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

  Strongly typed means there is a compiler, and it wants you an explicit cast from string to integer.

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

  In either case, some compiler's features can implicitly alter the instruction during compile-time to do conversions for you, if it can determine that is the right thing to do.

  Thus far, JavaScript can be categorized as Not-Strongly-Typed. That either means it's weakly-typed or un-typed.

dynamic/static can be thought of in relation to how the language instructions manipulate types.

• Dynamically typed means the value's type is enforced, but the variable simply represents any value of any type.

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

  Statically typed means the variable type is strongly enforced, and the value type is less-so enforced.

  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.
  

  Thus far, JavaScript can be categorized as Not-Statically-Typed. Also, it appears to be Dynamically Typed, if typed at all. So we need to see what Typing means.

Typed means that the language distinguishes between different types such as string, number, boolean, object, array, null, undefined and so on. Also each operation is bound to specific types. So you cannot divide an integer by a string.

    2 / "blah"  // produces NaN

Untyped means the operation of dividing integer by string would result in treating the first four bytes of string as integer. This is because Untyped operations take place directly on bits, there are no types to observe. The outcome will be something quite unexpected:

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

Since JavaScript behaves according to the definition of being Typed, it must be. And therefore it must be Dynamically Typed, and Weakly Typed.

If anybody claims JavaScript is Untyped, it is merely for academic theory, not for practical application.