Let us analyze how the function shown in Listing 5-1 works. When the function sayHello is invoked at line 5 with an argument of praveen, control goes to line 1, taking the value praveen and copying it to the variable name specified in the parameter list of the function. The value praveen in line 5 is called an actual argument, since it is the actual value that is passed to the function. The variable name in line 1 is called a formal argument, since it just collects the value passed from the function call. Formal arguments are also called formal parameters. The scope of the formal parameter is restricted to the body of the function. They are created when the function is called and destroyed when the function ends.

As you have seen in the syntax, specifying arguments and return types is optional in JavaFX Script. With this in mind, let us see the following combinations of function definitions in detail:

modifiers function-name( ) {
    // statements
}

modifiers function-name( ) : Void {
    // statements
}

1.    for(i in [1..5])  {
2.        sayHello();
3.    }
4.
5.    function sayHello(){
6.        println("This is a function without an argument and a return value");
7.    }

This is a function without an argument and a return value
This is a function without an argument and a return value
This is a function without an argument and a return value

This is a function without an argument and a return value
This is a function without an argument and a return value

modifiers function-name(parameterName : parameterType , .. ) {
    // statements
}

modifiers function-name( parameterName : parameterType , ..) : Void {
    // statements
}

1.    function factorial( num : Integer) : Void {
2.        var i : Integer = 1;
3.        var fact : Integer = 1;
4.        while(i <= num ){
5.            fact = fact * i++;
6.        }
7.        println("factorial of {num} is {fact}");
8.    }
9.
11.    var n2 : Integer = 6;
12.    factorial(5);
13.    factorial(n2);

factorial of 5 is 120
factorial of 6 is 720

modifiers function-name(  ) : [return type]  {
    // statements
    return expression ;
}

modifiers function-name(  )   {
    // statements
    return expression;
}

modifiers function-name( ) : [return type]{
    // statements
}

1.    function getPI( ) {
2.        return 22.0/7.0;
3.    }
4.
5.    function getOddsLessThanTen( ) {
6.        [1..10 step 2];

7.    }
8.
9.    function printName() : String{
10.
11.
12.             "Jack and Jill";
13.    }
14.
15.    var pi = getPI();
16.    println("pi value = {pi}");
17.    var nos : Integer [] = getOddsLessThanTen( );
18.    println(" Odd numbers = {nos}");
19.    println(printName());

pi value = 3.142857
 Odd numbers = 13579
Jack and Jill

modifiers function-name( parameterName : parameterType , .. ) : [return type] {
    // statements
    return expression;
}

1.    function functionExpression(a:Integer, b:Integer):Number {
2.        var x = a + b;
3.        var y = a - b;
4.        return squareOfNumber(x) / squareOfNumber (y);
5.    }
6.
7.    function squareOfNumber(n:Integer): Number {
8.        n * n;

9.    }
10.    println("{ functionExpression(5,8) }");

18.777779

A function can access script-level variables, parameters, and local variables. Let's see each of them in detail.

1.    var scriptLevelVar  : Number = 10;
2.
3.    public  function simpleFunction(  ) {
4.        println("Accessing scriptLevelVar with in the simple function = {scriptLevelVar}");
5.        // modifing the value of scriptLevelVar
6.        scriptLevelVar = 45.34;
7.        println("Modified value of scriptLevelVar in simple function = {scriptLevelVar}");
8.    }
9.
10.    function run (){
11.        println("Accessing the scriptLevelVar in run function 
scriptLevelVar = {scriptLevelVar}");
12.        simpleFunction(  ) ;
13.        ;  scriptLevelVar++;
14.        println("Modified value in run function scriptLevelVar = {scriptLevelVar}");
15.    }

Accessing the scriptLevelVar in run function
scriptLevelVar = 10.0
Accessing scriptLevelVar with in the function = 10.0
Modified value of scriptLevelVar in function = 45.34
Modified value in run function scriptLevelVar = 46.34

Function overloading is typically about a set of functions sharing the same function name, but accepting different arguments and performing different activities depending on the kind of parameters sent to them. This is also known as polymorphism in OOP (Object Oriented Programming). When an overloaded function is called, the JavaFX Script checks the number and type of parameter(s) of all the functions defined with the same name and calls the one whose parameters exactly match the calling statement. Listing 5-7 shows an example.

1.    function fun() {
2.        println("Function Overloaded without any argument.");
3.    }
4.
5.    function fun(a : Integer , b : Integer) {
6.        println("Function Overloaded with  Integer argument a ={ a } , b = {b}");
7.    }
8.
9.    function fun(n : Number ) {
10.        println("Function Overloaded with  Number argument n = {n}");
11.    }
12.
13.    fun();
14.    fun(5, 10);

15.    fun(22.0/7.0);
16.    fun(40);

Function Overloaded without any argument.
Function Overloaded with Integer argument a = 5 , b = 10
Function Overloaded with Number argument n = 3.142857
Function Overloaded with Number argument n = 40.0

The example in Listing 5-7 has different functions sharing the same function name. Each function has a different set of arguments. The first function doesn't take any argument, the second function takes two Integer arguments, and the third function takes one Number argument. When the function is called from line 13 to line 16, the JavaFX Script compiler checks the number and type of parameters and calls the corresponding function.

Line 16 is a special type of function call. The function argument doesn't match any of the function declarations directly. When this situation arises, JavaFX Script's automatic type conversion plays an important role in solving the issue. At Line 16, the function call has an Integer value, but none of the function declarations match. However, the last function matches in the number of arguments but differs in data type. Nevertheless, the function expects a Number type, which has a greater precision than the Integer, so it is actually safe to promote an Integer to a Number data type without any data loss. Hence the compiler converts 40 to a Number and calls the fun() function, which accepts a Number. You can easily see from the output that a plain 40 is converted into 40.0.

A function that calls itself either directly or indirectly until a condition is satisfied is called a recursive function. Let us take the most common example of the recursive function that calculates the factorial of a given number and the Fibonacci series. You have already seen the factorial example in this chapter. Listing 5-8 illustrates how the same problem can be solved using a recursive function.

1.    function factorial( n : Integer ) : Integer{
2.        if( ( n==0) or ( n == 1 ) ) {
3.            return n;
4.        }
5.        else {
6.            return n * factorial(n - 1 );
7.        }
8.    }
9.
10.    println("factorial of 5 = {factorial(5) }");
11.    var fact = factorial(8);
12.    println("factorial of 8 = {fact}");

factorial of 5 = 120
factorial of 8 = 40320

In Listing 5-8, the function factorial() takes an Integer as the argument and returns an Integer as output. In line 2 we are checking whether the argument n value is either 0 or 1. If the value of n is 1, then we are just returning the value of n. if the value is more than 1, the else part is executed. It calls the same function, passing n - 1. This recursion continues until the condition given in line 2 is satisfied.

Listing 5-9 shows another example of a recursive function.

1.        function fibonacciFun(n:Integer):Integer {
2.        if (n<2) {
3.            return n
4.        }
5.        else {
6.              (fibonacciFun(n-1) + fibonacciFun(n-2));
7.         }
8.    }
9.
10.    println(" fibonacci of 10 = { fibonacciFun(10) }");
11.    println(" fibonacci of 1 = { fibonacciFun(1) }");

fibonacci of 10 = 55

An anonymous function is one that doesn't have a function name. Using anonymous functions, we can convert a function in an expression, called a function expression.

The first step to write an anonymous function is to define a variable of type Function.

Syntax

var function_variable_name : function ( : parameter, : parameter ) : [return type];

Example

var x  : function( : Integer,  : Integer) : Integer;

This section is very simple; it's just providing the signature of the function, without specifying the function name. It is similar to declaring a variable, but instead of the data type, we are specifying the function type.

Here, function_variable_name is the variable that holds the function expression ,followed by the function keyword, which specifies that this is a variable of Function type. A Function type must also define the parameters within a pair of parentheses. If there is no parameter, then it could just be the opening and closing parentheses. Following the parameters is the return type of the function.

Syntax

function_variable_name = function(argument name1 , argument name2 ) : [return type] {
        // statements
}

From this syntax, you see that an anonymous function is similar to a normal function, except that the function name is missing and we are assigning the function to a variable of the Function type.

Now let us see how to call the function variable that refers to an anonymous function expression, a step called closure. This is similar to calling the function using the function name and passing values to the arguments. But instead of a function name we are calling the anonymous function with the function variable name to which we have assigned the function expression.

Let's put it all together to make a complete script, as shown in Listing 5-10.

1.    var x : function(   : Integer ,   : Integer ) : Integer ;
2.
3.    x = function(a,b ) {
4.        if(a > b ) {
5.             a;
6.        }
7.        else {
8.             b;
9.        }
10.    };
11.
12.    println("greatest number of 5 and 10 = { x(5,10) }");

greatest no of 5 and 10 = 10

In line 1, we have declared the variable x of type Function, which takes two Integers as arguments and whose return type is Integer. From line 3 to line 10 we have defined the function expression assigned to variable x. In line 12 we have an output statement which calls the anonymous function through the x variable (of Function type) by passing the values 5 and 10, and finally the return value of the function expression is printed.

Listing 5-11 shows another example of an anonymous function.

1.    var fact = function (num : Integer )  {
2.        var i : Integer = 1;
3.        var fact : Integer = 1;
4.        while(i <= num ){
5.            fact = fact * i++;
6.        }
7.        return fact;
8.    }
9.    println("Factorial of 5 = { fact(5) } ");

Factorial of 5 = 10

In Listing 5-10, we had declared function variable separately and function expression separately, but in Listing 5-11 we have combined the statements.

Now we know that in JavaFX Script, a variable can be of the Function type. Functions are described as first-class objects in JavaFX Script, which allows the programmers not only to create variables of type functions but also to pass such a variable arguments to other functions and return it as a return type from other functions.

The run() function is a special function in JavaFX Script that acts as the entry point to your application, similar to the main() function in Java. This function is implicitly created by the compiler internally as long as you do not have a public member (a variable, or a class, or a function) defined in your main script. However, if you have defined a public member, then the compiler lets you create the run() function as well and no longer generates it implicitly. If you fail to specify one despite having some public member, the compiler will throw a compilation error.

This function will be automatically called when you execute your application through the javafx executable, and any command-line arguments that the user may pass will be given to this function. Listing 5-12 shows a simple example of the run() function.

1.    function run (){
2.        println("This is the entry point for JavaFX Scripting..!");
3.    }

Let's call this script EntryPoint.fx. When this script is executed, we see the following output on the console. This run() function is called by the JavaFX runtime automatically.

Output

This is the entry point for JavaFX Scripting..!

Let's see another of the run() function (Listing 5-13).

1.    public  function areaOfCircle(radius :Number):Number {
2.        return  3.142 * radius * radius;
3.    }
4.
5.    function run(){
6.    println("This is the entry point for JavaFX Scripting..!");
7.    println("Area of the circle = {areaOfCircle( 7) } " );
8.    }

This is the entry point for JavaFX Scripting..!
Area of the circle = 153.958

In this example we have defined a function called areaOfCircle and implemented the run() function. When the script is executed, the output shown is printed on the console. Notice that the function areaOfCircle is called within the run() function. Since the run() function is the entry point of the script, it will be called first, before areaOfCircle. If we move the function call areaOfCircle from line 7 to outside the run() function, say line 4, we will get a compilation error. This is because we have a public member in the script areaOfCircle and if there is a public member, JavaFX Script compiler enforces you to move all the loose expressions in to a run() function. In such a case, the run() function become mandatory. If you want to try this yourself, do the following in Listing 5-13.

Now you will be able to compile and run the example without any errors.

function run( sequence of String ) {
                                   // statements
                                      }

1.    function run (cmdLine : String[]){
2.        println("Printing Command-line arguments");
3.        for( arg in cmdLine ){
4.            println(arg);
5.        }
6.    }

D:javafx-sdk1.3injavafx ModifiedRun Learning JavaFX Script Command-line argument

Printing Command-line arguments
Learning
JavaFX
Script
Command-line
argument

1.    public  function area_of_circle( radius :Number):Number {
2.        return 2 * 3.142 * radius ;
3.    }
4.
5.    function run (){
6.        println("Learning FX.getArguments() ..!");
7.        var args : String []  = FX.getArguments();
8.        println(area_of_circle (java.lang.Integer.parseInt(args[0])));
9.    }

D:javafx-sdk1.3injavafx  CommandLineArgsDemo 20
Learning FX.getArguments() ..!
125.68

In this chapter you have learned about functions in detail. A function is a set of statements that are enclosed in curly braces. A function is accessed by its name, called a function name. A function definition may optionally include one or more modifiers, parameters and the return type. Overloaded functions are functions that share the same function name but differ in their number and type of arguments. Function parameters are read-only and hence cannot be modified. A function can be made anonymous by omitting a function name and instead assigning it to a variable of type Function. Anonymous functions can be invoked using the corresponding variable name, and such variables can be passed as parameters to other functions as well. The run() function acts as the entry point to any FX application, and the programmer has to define it if there is a public member declared within the script. Using this run() function and the Javafx.lang.FX class, you can get access to the command-line arguments.

In the next chapter, you will learn more about class definitions and how to go about defining and using classes and object literals within JavaFX Script.