Functions

A function is a named statement or a group of statements that are executed as one unit. All functions have names. Function names must contain only alphanumeric characters and the underscore ( _ ) character, and they cannot begin with a number.

A function can have zero or more parameters, which are values that are passed to the function statement(s). Parameters are also known as arguments. Value types are not specified for the arguments or return values. Named arguments are local to the function body, and functions can be called recursively.

The syntax for a function declaration is

name(<parameter1>, <parameter2>, ...)
{
  <statements>
}

The syntax to call a function is

name(<parameter1>, <parameter2>, ...)

So, for example, a function named add can be declared like this:

add(x, y)
{
  return x + y;
}

and called this way:

add(5, 6);

This would result in a return value of 11.

Every function returns a value. The return value is usually specified using a return statement, but if no return statement is specified, the return value will be the value of the last statement executed.

Arguments are not checked for appropriate value types or number of arguments when a function is called. If a function is called with fewer arguments than were defined, the specified arguments are assigned, and the remaining arguments are assigned to null. If a function is called with more arguments than were defined, the extra arguments are ignored. For example, if the function add is called with just one argument

add(1);

the parameter x will be assigned to 1, and the parameter y will be assigned to null, resulting in a return value of 1. But if add is called with more than two arguments

add(1, 2, 3);

x will be assigned to 1, y to 2, and 3 will be ignored, resulting in a return value of 3. All parameters are passed by value, not by reference, and can be changed in the function body without affecting the values that were passed in. For instance, the function

add_1(x, y)
{
  x = 2;
  y = 3;
  return x + y;
}

reassigns parameter values within the statements. So,

a = 10; b = 20; add_1(a, b);

will have a return value of 5, but the values of a and b won't be changed.

The scope of a function is the file in which it is defined (as well as included files), with the exception of primitive functions, whose scopes are global.

Calls to undefined functions are legal, and will always evaluate to null and result in a compiler warning.