Is JavaScript an untyped language?

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.

JavaScript is weakly typed. It is most certainly not "untyped" but its weakly typed nature allows for a lot of flexibility in terms of implicit conversions.

Keep in mind that JavaScript is also dynamically typed. This method of typing allows what is know as "duck typing".

For comparison consider that JavaScript is not strongly typed nor is it statically typed. Sometimes understanding what something isn't can help you see better what it is.

To the author's point JavaScript is also classified as Dynamically typed. Wiki states that Dynamically typed languages are type checked at runtime instead of in a compiler while Weakly Typed refers to the ability to change type on the fly within your code. So yes it is both Dynamically typed AND Weakly typed.

Remember that JavaScript allows you to ask what is the typeof(your_variable), and compare types: 5==="5" returns false. Thus I don't think you can call it untyped.

It is dynamically and (estimated as) weakly typed. You may want to know it uses Duck typing (see andrew's link) and offers OOP though Prototyping instead of classes and inheritance.

While it is typed (you can ask "typeof someVar" and learn its specific type, it's very weak.

Given:

  var a = "5";

you might say that a is a string. However, if you then write:

  var b = a + 10;

b is an int equal to 15, so a acted just like an int. Of course, you can then write:

  var c = a + "Hello World";

and c will equal "5Hello World", so a is again acting like a string.

I'd argue JavaScript is strongly and dynamically typed.

But that depends on a bunch of terms which seem to to be loosely defined at best, so the above is true only if you accept the definitions below...

Strong / Weak

• "Strong" typing prevents operations intended for one type of data from being executed on another type. For example, trying to write to an N^th element of an array, where the object is not an array. Strong typing is required for memory safety.
• "Weak" is the opposite of strong.

Static / Dynamic

• "Static" typing checks types before program execution (at compile/transpile time). This requires the type information to be encoded into the language's syntax.
• "Dynamic" is the oposite of static.

JavaScript will not let you corrupt the memory (hence "strong") but does all the checking and type conversions/coercions at run-time (hence "dynamic").

I find it helpful to think of "strong vs weak" as being orthogonal to "static vs dynamic". There are languages that are strong and static (e.g. C# without unsafe context), strong and dynamic (most "scripting" languages seem to fall into that category), weak and static (C/C++).

Not sure what would be weak and dynamic... assembler, perhaps :)

another interesting example of loosely typed JS:

console.log(typeof(typeof(5)))

the result is string. why? because the initial typeof results in 'integer' which in itself is a string. I would assume in a strongly typed language this type of changing types would not be a thing. perhaps i am mistaken but that was the first instance where i started to understand how CRAZY JS can be lol