#### 1.1 Core JavaScript

After this introductory chapter, we dive into JavaScript at the lowest level: Chapter 2,

Lexical Structure, explains things like JavaScript comments, semicolons, and the Unicode

character set. Chapter 3, Types, Values, and Variables, starts to get more interesting:

it explains JavaScript variables and the values you can assign to those variables.

Here’s some sample code to illustrate the highlights of those two chapters:

// Anything following double slashes is an English-language comment.

// Read the comments carefully: they explain the JavaScript code.

// variable is a symbolic name for a value.

// Variables are declared with the var keyword:

var x; // Declare a variable named x.

// Values can be assigned to variables with an = sign

x = 0; // Now the variable x has the value 0

x // => 0: A variable evaluates to its value.

// JavaScript supports several types of values

x = 1; // Numbers.

x = 0.01; // Just one Number type for integers and reals.

x = "hello world"; // Strings of text in quotation marks.

x = 'JavaScript'; // Single quote marks also delimit strings.

x = true; // Boolean values.

x = false; // The other Boolean value.

x = null; // Null is a special value that means "no value".

x = undefined; // Undefined is like null.

Two other very important types that JavaScript programs can manipulate are objects

and arrays. These are the subject of Chapter 6, Objects, and Chapter 7, Arrays, but they

are so important that you’ll see them many times before you reach those chapters.

// JavaScript's most important data type is the object.

// An object is a collection of name/value pairs, or a string to value map.

var book = { // Objects are enclosed in curly braces.

topic: "JavaScript", // The property "topic" has value "JavaScript".

fat: true // The property "fat" has value true.

}; // The curly brace marks the end of the object.

// Access the properties of an object with . or []:

book.topic // => "JavaScript"

book["fat"] // => true: another way to access property values.

book.author = "Flanagan"; // Create new properties by assignment.

book.contents = {}; // {} is an empty object with no properties.

// JavaScript also supports arrays (numerically indexed lists) of values:

var primes = [2, 3, 5, 7]; // An array of 4 values, delimited with [ and ].

primes[0] // => 2: the first element (index 0) of the array.

primes.length // => 4: how many elements in the array.

primes[primes.length-1] // => 7: the last element of the array.

primes[4] = 9; // Add a new element by assignment.

primes[4] = 11; // Or alter an existing element by assignment.

var empty = []; // [] is an empty array with no elements.

empty.length // => 0

// Arrays and objects can hold other arrays and objects:

var points = [ // An array with 2 elements.

{x:0, y:0}, // Each element is an object.

{x:1, y:1}

];

var data = { // An object with 2 properties

trial1: [[1,2], [3,4]], // The value of each property is an array.

trial2: [[2,3], [4,5]] // The elements of the arrays are arrays.

};

The syntax illustrated above for listing array elements within square braces or mapping

object property names to property values inside curly braces is known as an initializer

expression, and it is just one of the topics of Chapter 4, Expressions and Operators. An

expression is a phrase of JavaScript that can be evaluated to produce a value. The use

of . and [] to refer to the value of an object property or array element is an expression,

for example. You may have noticed in the code above that when an expression stands

alone on a line, the comment that follows it begins with an arrow (=>) and the value of

the expression. This is a convention that you’ll see throughout this book.

One of the most common ways to form expressions in JavaScript is to use operators

like these:

// Operators act on values (the operands) to produce a new value.

// Arithmetic operators are the most common:

3 + 2 // => 5: addition

3 - 2 // => 1: subtraction

3 * 2 // => 6: multiplication

3 / 2 // => 1.5: division

points[1].x - points[0].x // => 1: more complicated operands work, too

"3" + "2" // => "32": + adds numbers, concatenates strings

// JavaScript defines some shorthand arithmetic operators

var count = 0; // Define a variable

count++; // Increment the variable

count--; // Decrement the variable

count += 2; // Add 2: same as count = count + 2;

count *= 3; // Multiply by 3: same as count = count * 3;

count // => 6: variable names are expressions, too.

// Equality and relational operators test whether two values are equal,

// unequal, less than, greater than, and so on. They evaluate to true or false.

var x = 2, y = 3; // These = signs are assignment, not equality tests

x == y // => false: equality

x != y // => true: inequality

x < y // => true: less-than

x <= y // => true: less-than or equal

x > y // => false: greater-than

x >= y // => false: greater-than or equal

"two" == "three" // => false: the two strings are different

"two" > "three" // => true: "tw" is alphabetically greater than "th"

false == (x > y) // => true: false is equal to false

// Logical operators combine or invert boolean values

(x == 2) && (y == 3) // => true: both comparisons are true. && is AND

(x > 3) || (y < 3) // => false: neither comparison is true. || is OR

!(x == y) // => true: ! inverts a boolean value

If the phrases of JavaScript are expressions, then the full sentences are statements, which

are the topic of Chapter 5, Statements. In the code above, the lines that end with

semicolons are statements. (In the code below, you’ll see multiline statements that do

not end with semicolons.) There is actually a lot of overlap between statements and

expressions. Roughly, an expression is something that computes a value but doesn’t

do anything: it doesn’t alter the program state in any way. Statements, on the other

hand, don’t have a value (or don’t have a value that we care about), but they do alter

the state. You’ve seen variable declarations and assignment statements above. The

other broad category of statement is control structures, such as conditionals and loops.

Examples are below, after we cover functions.

A function is a named and parametrized block of JavaScript code that you define once,

and can then invoke over and over again. Functions aren’t covered formally until

Chapter 8, Functions, but like objects and arrays, you’ll see them many times before

you get to that chapter. Here are some simple examples:

// Functions are parameterized blocks of JavaScript code that we can invoke.

function plus1(x) { // Define a function named "plus1" with parameter "x"

return x+1; // Return a value one larger than the value passed in

} // Functions are enclosed in curly braces

plus1(y) // => 4: y is 3, so this invocation returns 3+1

var square = function(x) { // Functions are values and can be assigned to vars

return x*x; // Compute the function's value

}; // Semicolon marks the end of the assignment.

square(plus1(y)) // => 16: invoke two functions in one expression

When we combine functions with objects, we get methods:

// When functions are assigned to the properties of an object, we call

// them "methods". All JavaScript objects have methods:

var a = []; // Create an empty array

a.push(1,2,3); // The push() method adds elements to an array

a.reverse(); // Another method: reverse the order of elements

// We can define our own methods, too. The "this" keyword refers to the object

// on which the method is defined: in this case, the points array from above.

points.dist = function() { // Define a method to compute distance between points

var p1 = this[0]; // First element of array we're invoked on

var p2 = this[1]; // Second element of the "this" object

var a = p2.x-p1.x; // Difference in X coordinates

var b = p2.y-p1.y; // Difference in Y coordinates

return Math.sqrt(a*a + // The Pythagorean theorem

b*b); // Math.sqrt() computes the square root

};

points.dist() // => 1.414: distance between our 2 points

Now, as promised, here are some functions whose bodies demonstrate common Java-

Script control structure statements:

// JavaScript statements include conditionals and loops using the syntax

// of C, C++, Java, and other languages.

function abs(x) { // A function to compute the absolute value

if (x >= 0) { // The if statement...

return x; // executes this code if the comparison is true.

} // This is the end of the if clause.

else { // The optional else clause executes its code if

return -x; // the comparison is false.

} // Curly braces optional when 1 statement per clause.

} // Note return statements nested inside if/else.

function factorial(n) { // A function to compute factorials

var product = 1; // Start with a product of 1

while(n > 1) { // Repeat statements in {} while expr in () is true

product *= n; // Shortcut for product = product * n;

n--; // Shortcut for n = n - 1

} // End of loop

return product; // Return the product

}

factorial(4) // => 24: 1*4*3*2

function factorial2(n) { // Another version using a different loop

var i, product = 1; // Start with 1

for(i=2; i <= n; i++) // Automatically increment i from 2 up to n

product *= i; // Do this each time. {} not needed for 1-line loops

return product; // Return the factorial

}

factorial2(5) // => 120: 1*2*3*4*5

JavaScript is an object-oriented language, but it is quite different than most. Chapter 9,

Classes and Modules, covers object-oriented programming in JavaScript in detail, with

lots of examples, and is one of the longest chapters in the book. Here is a very simple

example that demonstrates how to define a JavaScript class to represent 2D geometric

points. Objects that are instances of this class have a single method named r() that

computes the distance of the point from the origin:

// Define a constructor function to initialize a new Point object

function Point(x,y) { // By convention, constructors start with capitals

this.x = x; // this keyword is the new object being initialized

this.y = y; // Store function arguments as object properties

} // No return is necessary

// Use a constructor function with the keyword "new" to create instances

var p = new Point(1, 1); // The geometric point (1,1)

// Define methods for Point objects by assigning them to the prototype

// object associated with the constructor function.

Point.prototype.r = function() {

return Math.sqrt( // Return the square root of x² + y²

this.x * this.x + // This is the Point object on which the method...

this.y * this.y // ...is invoked.

);

};

// Now the Point object p (and all future Point objects) inherits the method r()

p.r() // => 1.414...

Chapter 9 is really the climax of Part I, and the chapters that follow wrap up some loose

ends and bring our exploration of the core language to a close. Chapter 10, Pattern

Matching with Regular Expressions, explains the regular expression grammar and demonstrates

how to use these “regexps” for textual pattern matching. Chapter 11, Java-

Script Subsets and Extensions, covers subsets and extensions of core JavaScript. Finally,

before we plunge into client-side JavaScript in web browsers, Chapter 12, Server-Side

JavaScript, introduces two ways to use JavaScript outside of web browsers.