We have identified in JavaScript some of the elements that must appear in any powerful programming language:

• Numbers and arithmetic operations are primitive data and functions.
• Nesting of combinations provides a means of combining operations.
• Constant declarations that associate names with values provide a limited means of abstraction.

Now we will learn about function declarations, a much more powerful abstraction technique by which a compound operation can be given a name and then referred to as a unit.

We begin by examining how to express the idea of squaring. We might say, To square something, take it times itself. This is expressed in our language as

function square(x) {
    return x * x;
}

We can understand this in the following way:

function square(    x   ) { return x    *     x; }
//  ^       ^       ^         ^    ^    ^     ^
// To    square something,  take   it times itself.

We have here a compound function, which has been given the name square. The function represents the operation of multiplying something by itself. The thing to be multiplied is given a local name, x, which plays the same role that a pronoun plays in natural language. Evaluating the declaration creates this compound function and associates it with the name square.

The simplest form of a function declaration is

The $name$ is a symbol to be associated with the function definition in the environment. The $parameters$ are the names used within the body of the function to refer to the corresponding arguments of the function.

The $parameters$ are grouped within parentheses and separated by commas, as they will be in an application of the function being declared. In the simplest form, the body of a function declaration is a single return statement, which consists of the keyword return followed by the return expression that will yield the value of the function application, when the parameters are replaced by the actual arguments to which the function is applied. Like constant declarations and expression statements, return statements end with a semicolon.

Having declared square, we can now use it in a function application expression, which we turn into a statement using a semicolon:

square(21);

441

Function applications are—after operator combinations—the second kind of combination of expressions into larger expressions that we encounter. The general form of a function application is

where the $function$-$expression$ of the application specifies the function to be applied to the comma-separated $argument$-$expressions$. To evaluate a function application, the interpreter follows a procedure quite similar to the procedure for operator combinations described in section 1.1.3.

• To evaluate a function application, do the following:
  1. Evaluate the subexpressions of the application, namely the function expression and the argument expressions.
  2. Apply the function that is the value of the function expression to the values of the argument expressions.

square(2 + 5);

49

Here, the argument expression is itself a compound expression, the operator combination 2 + 5.

square(square(3));

81

Of course function application expressions can also serve as argument expressions.

We can also use square as a building block in defining other functions. For example, $x^2 +y^2$ can be expressed as

square(x) + square(y)

We can easily declare a function sum_of_squares that, given any two numbers as arguments, produces the sum of their squares:

function sum_of_squares(x, y) {
    return square(x) + square(y);
}

sum_of_squares(3, 4);

25

Now we can use sum_of_squares as a building block in constructing further functions:

function f(a) {
    return sum_of_squares(a + 1, a * 2);
}

f(5);

136

In addition to compound functions, any JavaScript environment provides primitive functions that are built into the interpreter or loaded from libraries. Besides the primitive functions provided by the operators, the JavaScript environment used in this book includes additional primitive functions such as the function math_log, [5]