16 The JavaScript Type System

JavaScript supports a number of data types including number, string, boolean, object, and undefined (a special type with only one value: undefined).   You can recover a string representation of the type of a value using the global typeof operator.

JavaScript is both dynamically typed and weakly typed. These two features of the JavaScript type system are important and distinct from one another. Not all dynamically typed languages are weakly typed, and not all weakly typed languages are dynamically typed.

Dynamic Typing

Variables are containers that store values. In JavaScript, variables are dynamically typed. This means that although values have fixed data types, variables do not. This is in contrast to statically typed languages in which variables are declared with a type and are then restricted to only hold values the declared type. In JavaScript, you do not declare a type for a variable and you can change the type of the value it holds as the program runs.

JavaScript variables are declared with the keyword let, like this:

let x;      // declares x and assigns undefined
let y = 3;  // declares y and assigns 3 to it

let x = 100;
typeof x;
console.log(x); 
x = "I'm a string now"; 
typeof x;
console.log(x); 
x = 45.3; 
typeof x;
console.log(x); 
x = "$"+x; 
typeof x;
console.log(x);

let n = prompt("Enter a number"); 
if (n < 1000)
    alert("that was a small number");
else
    alert("that was a big number");

Flexible Functions

You can declare a function in JavaScript using the function keyword and return a value using the return keyword. The syntax should be quite similar to what you have seen in other languages. Because of dynamic typing, you don’t need to specify types for parameters or return values. If you do not use a return statement, the function will return the value undefined.

function function_name(comma, separated, parameter, list) {
    // code goes here
}

function sayHi(name) {
   return "Hello, " + name + "!";
}

sayHi("Sam");

alert( sayHi("Sam") );

alert( sayHi( prompt("What's your name?") ) );

JavaScript functions are also very flexible. In fact, JavaScript is so allergic to run-time errors that you don’t have to get the argument list correct in a function call. As long as you get the function name right, you can call it with any combination of arguments. If there are extra arguments, they will be discarded. If there are too few arguments, some parameters will get the value undefined.

sayHi("Sam");
sayHi();               
sayHi("Sam", "Scott");

You can also specify default values for parameters, and when you call a function you can pass arguments to a function by position (first argument goes to first parameter) or by keyword (i.e., parameter name). These flexible mechanism allow a function to be called in many different ways.

function spam(a, b=-1, c=-2) {
    return a + b + c;
}

spam(1);
spam(1, 1);
spam(1, 2, 3);

spam(10, b=5, c=5);
spam(a=2);
spam(c=3, a=6);

Weak Typing

JavaScript is also a very weakly typed language. This is not the same as being dynamically typed. Weak vs. strong typing is a matter of degree rather than an either/or. The more weakly typed a language is, the fewer syntax or run-time errors you will get for mixing types in an expression or passing the wrong type to a function. You get logic errors instead, which are much harder to debug. Weak typing gets you flexibility and convenience, but at a price.

Weak typing is a form of aggressive implicit type conversion. When asked to perform an operation on two values, JavaScript will always find a way to perform that operation. It will convert one or both of the values into a type it can work with and then compute the result. Sometimes this works in the way you would want it to, and sometimes it doesn’t.

let a = "50" + 10;
let b = "50" * 10;
let c = false - 2;
let d = "hi" + "there";
let e = "hi" - "there";

Similarly to the above, Boolean operators (i.e. the expressions that evaluate to true or false to control if statements and loops) can be used to compare any two values regardless of whether or not their types match. Again, JavaScript will convert one of the two operators and then perform the operation.

let x = "hi";
x == 45.3
x >= 45.3
x == "hi"

let y = "50";
x = 50;
y == x

y === x;
y === "50";
y !== x;
y !== "50"

let y=prompt("Enter a number");
y = y + 1;
alert(y);

let y=prompt("Enter a number");
y = parseInt(y) + 1;
alert(y);

But what if parseInt or parseFloat fail because the user typed something that can’t be interpreted as a number? In that case, they return the special value NaN (Not a Number) which can be detected with the global Boolean function isNaN.

let n;

do {
    n = parseFloat( prompt("Enter a number") );
} while (isNaN(n));

n = n + 1;

alert(n);

let guess = 5;
if (guess = 6)
    console.log("You guessed correctly!");
else
    console.log("Sorry, try again.");

if (6)  …