A valid variable name is a sequence of one or more letters, digits, or underscore characters (_). JavaFX Script uses the same rules as Java to name the variables:

Use one of the following syntax forms to declare a variable:

var variableName : <data type>;

or

var variableName : <data type> = initialization;

or

var variableName - initialization;

var is a keyword, which is used to declaring a variable. A variable's type declaration is optional. If the type is omitted from a variable declaration statement, the compiler infers or derives the data type of that variable from the value assigned to it; this is called type inference. A variable that is not assigned an initial value will be assigned a default value that varies based on the data type. See "Default Values for Data Types" later in this chapter for a complete list of default values.

There are five data types available in JavaFX Script:

String

Integer

Number

Boolean

Duration

var variableName : String;
var variableName : String = "initial Value";  // a string is initialized with double quotes
var variableName  = 'initial Value'; // string is initialized with single quotes or double quotes, type is inferred

var str1 :  String ='JavaFX';                      //  String data type declaration
var str2 :  String = "JavaFX";                    //  String data type declaration
var str3  =   "JavaFX";                        //  String inferred type
println("  str1 =  { str1 } ");
println('  str2 = { str2 }");
println(" str3  = {str3 } ");

JavaFX
JavaFX
JavaFX

var str : String = "Scripting 'JavaFX' Language";
println("str {str}");    // ostr = Scripting 'JavaFX' Language
// find the length of the string.
println("str length = {str.length() }"); // str length = 18
// convert the string to uppercase
var upperCaseString = str.toUpperCase(); // UpperCase = SCRIPTING LANGUAGE
println("UpperCase = {upperCaseString}");
// convert the string to lowercase.
var lowerCaseString = upperCaseString.toLowerCase();   // lowerCase = scripting language
println("lowerCase = {lowerCaseString}");
// get the substring
var subString = str.substring(10); // subString = Language
println(" subString = {subString}");

str = Scripting 'JavaFX' Language
str length = 18
UpperCase = SCRIPTING LANGUAGE
lowerCase = scripting language
subString = Language

var s: String = "JavaFX is a 'cool' technology";
var s1: String = 'JavaFX is a "cool" technology';

var i: Integer = 10;
    var j: Integer = 10;
    println("Value of  'i + j' is: {i + j}");

Value of  'i + j' is: 20

var escStr: String = "JavaFX 
 is cool";
    println("String with esc character: {escStr}");

String with esc character: JavaFX
 is cool

An Integer value represents a number with no decimal or fractional part—a whole number. An Integer can be either positive or negative.

The following snippet shows how to get the minimum and maximum value that an Integer primitive data type can hold.

var intMin: Integer =  java.lang.Integer.MIN_VALUE;
println("intMin = {intMin}");
var intMax: Integer =  java.lang.Integer.MAX_VALUE;
println("intMax = {intMax}");

It produces the following output:

intMin = −2147483648
intMax =  2147483647

From this example, it is clear that the JavaFX Script Integer primitive data type maps to the java.lang.Integer class in Java, which means that we can use the methods in java.lang.Integer on the JavaFX Script Integer data type. An Integer literal may be expressed in decimal (base 10), hexadecimal (base 16), or octal (base 8). Let us see each of these numeric representations in detail.

var width : Integer = 150;
var translat
eX: Integer = −15;

var xValue : Integer = 0X12A;

var no : Number = 05;

Values of the Number data type are also known as real or floating-point numbers. This data type is used when evaluating any expression that requires fractional precision. A Number can contain either a decimal point, an e (uppercase or lowercase), which is used to represent "ten to the power of" in scientific notation, or both. The exponent part is an e or E followed by an integer, which can be signed (preceded by either + or −). Listing 3-7 presents an example.

var pi : Number = 3.142; // pi is a floating point no.
var num : Number = 10; // 10 will be promoted to 10.0
var num1 = 10; // Type inferred as Integer

The first statement declares a Number variable pi, which holds the decimal number 3.142. The second statement declares a Number variable num, which holds the number 10. But after executing the second statement the variable value becomes 10.0, since the data is promoted from Integer to Number. The third line does not specify the data type but assigns a value of 10. Hence the data type for num1 will be automatically inferred by the compiler as Integer.

Listing 3-8 demonstrates different ways of declaring a Number.

//  declare a variable with out initial value
var a : Number ;
println("a {a}");             // a 0.0
// declare a variable with the inital value
var pi = 3.142;
println("pi = {pi}");            // pi = 3.142
// declare a variable with intial value expressed in scientific notation or expontential form.
var b : Number = 10e2;
println("b = {b}");            // b = 1000.0

These declarations produce the following output:

a 0.0
pi = 3.142
b = 1000.0

The code in Listing 3-8 demonstrates different ways of declaring a Number variable. The first example declares a variable of Number type but does not initialize it. Hence a default value of 0.0 would be assigned. The second example initializes the variable but does not define the data type. The compiler would in this case automatically infer the type as Number. Finally, the third example declares a Number variable and initializes it with an exponent decimal value.

Listing 3-9 demonstrates the range of the Number data type.

var numMin: Number =  java.lang.Double.MIN_VALUE;
    println("Minimum value of Number data type  = {numMin}");
    var numMax: Number =  java.lang.Double.MAX_VALUE;
    println("Maximum value of Number data type = {numMax}");

This code produces the following output:

Minimum value of Number data type  = 4.9E-324
Maximum value of Number data type = 1.7976931348623157E308

A Boolean variable has two states, true and false, which are appropriately represented by the keywords true and false. The Boolean variable, therefore, represents the state of something that can have only one of two values. These values are typically used as checkpoints for determining whether to take a certain action. Listing 3-10 demonstrates how to use the Boolean data type.

var flag : Boolean = true;
if(flag) {
    println(This line will be printed on the console);
}

The if conditional statement is covered in depth in Chapter 4, "Expressions, Conditional Statements and Loops." For now, all you need to know is that the if statement checks to see whether the statement in the parentheses is true or false. If the statement is true, it executes the statements between the curly braces.

A Duration value represents data in terms of time. It is typically used in animation applications, to work with timelines, transitions, keyframes, and so on. As an example, Listing 3-11 demonstrates different ways to represent 3.5 minutes.

var d1 = 3.5m;
var d2 = 3m + 30s;
var d3 = 3500ms;
var d4 = 3m + 0.5s;
var d5 = Duration.valueOf(3500);

Listing 3-12 demonstrates Duration's usage in a timeline.

var x: Number = 0;
Timeline {
    at (0s) {x => 0 tween Interpolate.LINEAR},
    at (3s) {x => 2.0 tween Interpolate.LINEAR}
    repeatCount: Timeline.INDEFINITE
}

This example changes the x value from 0 to 2.0 within a timeframe of 3 seconds. To represent indefinite time, we can use Duration.INDEFINITE.

The Duration class provides numerous convenient methods for converting data to and from Duration time. Listing 3-13 shows some examples.

var d = 4h;
var noOfHours = d.toHours();
var noOfMinutes = d.toMinutes();
var noOfSeconds = d.toSeconds();
var noOfMillis = d.toMillis();
var d1 = d.add(10m); // d1 = 250m
var d2 = d.sub(1h); // d2 = 3h
var d3 = d.mul(10); // d3 = 2400m
var d4 = d.div(10); // d4 = 24m

Listing 3-13 demonstrates the build-in functions of the Duration data type. In the third statement, variable d of Duration data type is converted to minutes using the toMinutes() function. Likewise, the toSeconds() and toMillis() functions are used in the fourth and fifth statements. In addition to the conversion functions, Duration values can be added, subtracted, multiplied and divided using built-in functions as shown in the last four statements.