JavaScript – Core JavaScript

This section is a tour of the JavaScript language, and also a tour
of Part I of this book. 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

// 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. = "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

A function is a named and parameterized 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

// 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 JavaScript 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    // 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, JavaScript 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.

Comments are closed.