javascript

Chapter 4: Variables, Scope, and Memory
Determining Type
The typeof operator, introduced in the previous chapter, is the best way to determine if a variable is a
primitive type. More specifically, it ’ s the best way to determine if a variable is a string, number, Boolean,
or undefined . If the value is an object or null , then typeof returns ” object ” as in this example:
var s = “Nicholas”;
var b = true;
var i = 22;
var u;
var n = null;
var o = new Object();
alert(typeof s);
alert(typeof i);
alert(typeof b);
alert(typeof u);
alert(typeof n);
alert(typeof o);
//string
//number
//boolean
//undefined
//object
//object
Although typeof works well for primitive values, it ’ s of little use for reference values. Typically, you
don ’ t care that a value is an object — what you really want to know is what type of object it is. To aid in
this identification, ECMAScript provides the instanceof operator, which is used with the following
syntax:
result = variable instanceof constructor
The instanceof operator returns true if the variable is an instance of the given reference type
(identified by its constructor function). Consider this example:
alert(person instanceof Object); //is the variable person an Object?
alert(colors instanceof Array); //is the variable colors an Array?
alert(pattern instanceof RegExp); //is the variable pattern a RegExp?
All reference values, by definition, are instances of Object , so the instanceof operator always returns
true when used with a reference value and the Object constructor. Similarly, if instanceof is used
with a primitive value, it will always return false because primitives aren ’ t objects.
The typeof operator also returns “ function ” when used on a function. When used
on a regular expression, typeof incorrectly returns “ function ” as well.
Execution Context and Scope
The concept of execution context, referred to as context for simplicity, is of the utmost importance in
JavaScript. The execution context of a variable or function defines what other data it has access to, as
well as how it should behave. Each execution context has an associated variable object upon which all of
84