JavaScript Data Types
In JavaScript, there is a delineation between object data types and primitive data types. The following primitive data types exist:
- String
- Number
- Boolean
- undefined
- null
We can create variables of these types as follows:
var str = "I am a string";
var num = 23;
var bool = true; // other alternative is false
var undef = undefined;
var nu = null;
Observe that JavaScript does not have separate data types for floating point numbers and integers. Instead, only the Number
data type is exposed to the developer, which is a floating point number. Thus var num = 23
has the same type as var num = 23.7
. JavaScript is often attacked because of that, since floating point arithmetic produces results such as the statement 0.1 + 0.2 === 0.3
evaluating to false, but this problem is a characteristic of floating point numbers themselves and how they are stored in memory (see http://floating-point-gui.de/).
In JavaScript, we can check the type of a primitive via the typeof command: For our above defined variables,
typeof str
returns "string"
, typeof num
returns "number"
, typeof bool
returns "boolean"
, typeof undef
returns "undefined"
and finally, typeof nu
returns "object"
. What did I just write? Yeah, it is unfortunate that we do not get back null
in this case, which is a quirk in the language. Instead, we need to use nu === null
to check whether the variable nu
is equal to null
and are not able to get this information via the typeof
operator.
Primitives are created directly in memory. When we assign
var num1 = 23;
var num2 = num1;
num1 += 3;
num1
will hold the value 26
and num2
will still be 23
. When creating num2
, a copy of num1
is created and assigned to num2
in memory. This might seem obvious, but this bevahiour is fundamentally different from objects which are going to be covered next. Everything else besides the aforementioned primitive data types in JS is an object. We can create a simple object via one of the following ways, where the first is the most common one:
var obj1 = {};
var obj2 = new Object();
var obj3 = Object.create( Object.prototype );
A JavaScript object is a collection of key-value pairs. Each value can be of any of the data types in JavaScript. We can define them as follows:
var jedi = {}
jedi.name = "Luke Skywalker"
jedi.age = 34
jedi.alive = true;
which yields the same result as supplying the properties at creation:
var jedi = {
name: "Luke Skywalker",
age: 34,
alive: true
}
As we can see, we can at run-time change objects as we please: We can add properties and augment their functionality this way. In fact, a property cannot only be one of the primitive data types, but an object itself:
var jedi = {
name: "Luke Skywalker",
age: 34,
alive: true,
father: {
name: "Anakin Skywalker",
age: 57,
alive: false
}
}
We can access the properties of an object either using dot notation or bracket notation:
jedi.name === "Luke Skywalker" // returns true
jedi["name"] === "Luke Skywalker" // returns true
The former is the de facto standard, but the latter is useful if we instead of a string literal supply a variable holding that string, e.g. as in
var prop = "alive";
jedi[prop] === true // returns true
Also, if a property of an object has a name which is a reserved keyword in JS (such as class), we are forced to use the bracket notation, as the dot notation would throw an error.
In contrast to the primitives, objects are assigned by reference. Therefore, they are often also called reference types. This means that when we have assigned the object literal {}
to the variable jedi
, we are effectively creating a pointer which refers to the object. Hence, if we do the following
var obj1 = {};
var obj2 = obj1;
obj1.str = "I am a string";
then invoking console.log( obj2.str )
will print out "I am a string"
. The reason is that var obj2 = obj1
does not create a copy of the object referenced by obj1
, but only copies the pointer so that as a result both obj1
and obj2
reference the same object in memory. Subsequently, if the properties of this object change, this affects both obj1
and obj2
. Besides the basic JavaScript object, there are the following data types which all inherit from Object.prototype
:
- Array
- Function
and not as importantly
- Date
- RegExp
- Error
Finally, there is the Math object which behaves quite differently from the rest, so I have excluded it from above list.
Of the Object types, the most important are without a doubt functions. It is often said that JavaScript has many traits of a functional language. What is meant by this statement is that functions are first-class objects which can behave as any other object: They can have properties (which could even be other functions, so a function can have its own methods!) and they can be passed as arguments to other functions. This proves to be immensely useful, and a good understanding of functions is essential as they are also the main building block for object-oriented design in JS.