A variable, with regard to computer programming, can be thought of as a place to store a piece of information, whether it varies or not. Generally speaking, a variable binds an object to an identifier for access to that object at a later point in the code. That object can be many things, for instance: a number, a string (text), or an as yet undefined collection of information.

Variables are declared using the var keyword. If a variable has a type¹⁾ specified, only objects of the given type should be assigned to that variable. Emphasis being on the word should. As mentioned on the main page of this documentation, DAZ Script is dynamically typed²⁾ and as such does not prevent a variable from being assigned a type inconsistent with that which may have been specified at declaration. In fact, DAZ Script variables are always of a type consistent with the type of value they contain.

The scope of a variable is always an important factor to consider. The scope of a variable refers to where in the code the variable has meaning. When a variable is said to have a local or lexical scope, it means that the variable only exists, or has meaning, within a subroutine (a smaller portion of the overall program). Conversely, when a variable is said to have a global scope, it means that the variable exists such that it can be accessed from anywhere, by anything. It is considered good programming practice to make the scope of a variable as narrow as possible, to prevent different parts of a program from modifying, using or otherwise conflicting with another part's variables.

In DAZ Script, variables declared with var are local to the enclosing function. If a variable is assigned to implicitly (without being declared using the var keyword), it is automatically declared to exist in the global namespace. Although potentially troublesome, and typically considered to be poor form, it is valid syntax. Using global variables in this manner is not recommended, as it can make your code difficult to debug and maintain.

Variable declared, but not initialized.

var sTmp;
// typeof sTmp == undefined
// sTmp == undefined

Variable declared and initialized.

var sTmp = "Temp";
// typeof sTmp == "string"
// sTmp == "Temp"

Variable declared and initialized with one type, later changing type.

var sTmp = "5";
// typeof sTmp == "string"
// sTmp == "5"
 
// Assigned to a Number type
sTmp = 5;
// typeof sTmp == "number"
// sTmp == 5

A function can be thought of as a sequence of statements (a subroutine) that performs a specific task, the same task, each time its run. Functions can be “called”, which means the “current” instruction sequence is temporarily suspended and the sequence of statements in the function are executed, after which point control is passed back to the instruction sequence that made the call. This also means that same sequence of statements can be executed as many times as necessary without the need to be written in the code each time. A function may take an optional set of input parameters (arguments) to parameterize that sequence, and it may also return an optional output (return value).

Functions are declared using the function keyword. They can exist in the global namespace, or in the context of another object.

A simple function.

function myFunction(){
	// ...statements;
}

A simple function with an argument.

// Create the function
function showMessage( sMessage ){
	MessageBox.information( sMessage, "Message", "&OK" );
}
 
// Call the function
showMessage( "Hello World!" );

A simple function with a return value.

function getWorldGreeting(){
	return "Hello World!";
}
 
var sTmp = getWorldGreeting();
// sTmp == "Hello World!"