Variables
Variables store data temporarily in memory.
When you set up your Qodly database, you specify the names and types of attributes that you want to use. Variables are much the same—you also give them names and different types (see Data types).
Once created, you can use a variable wherever you need it in your code. For example, you might need to store a string variable in an attribute of same type:
myEntity.text = MyString //put the MyString variable contents into the text attribute
Variables are language objects; you can create and use variables that will never appear on the screen. In your web forms, you can display variables on the screen, enter data into them, and print them in reports.
Declaring Variables
You create variables by declaring them. When variables are declared, they are initialized to the default value corresponding to their type, which they will keep during the session as long as they have not been assigned.
You declare variables using the var keyword. It allows you to create basic variables (integer, string...) and to bind object variables with classes. To declare a variable of any type with the var keyword, use the following syntax:
var <varName>{, <varName2>,...}{ : <varType>}
varName is the variable name, it must comply with the rules about identifiers.
varType can be:
- a basic type, in which case the variable contains a value of the declared type,
- a class reference (4D class or user class), in which case the variable contains a reference to an object of the defined class.
If varType is omitted, a variable of the variant type is created.
The following table lists all supported varType values:
| varType | Contents |
|---|---|
string | String (text) value |
date | Date value |
time | Time value |
boolean | Boolean value |
integer | Long integer value |
number | number value |
picture | Picture value |
blob | Scalar Blob value |
collection | Collection value |
variant | Variant value |
object | Object with default class (4D.Object) |
4D.<className> | Object of the 4D class name |
cs.<className> | Object of the user class name |
Examples
var myString : string //a string variable
var myDate1, myDate2 : date //several date variables
var myFile : 4D.File //a file class object variable
var aSquare : cs.Rectangle //a user class object variable
var myVar //a variant variable
var o : object //a generic object variable
//equivalent to:
var o : 4D.Object
var myClass : cs.MyClass
var dataclass : cs.Employee //ORDA dataclass class
var entity : cs.EmployeeEntity //ORDA entity class
Initializing Variables in the Declaration Line
When declaring variables, you have the flexibility to specify their data type and provide an initial value in one statement. Here are some examples:
var a : text="hello"
var b : date=!2023-09-12!
var c : object=newObject()
var d : cs.Customer=cs.Customer.new()
Variables can also be declared and initialized without explicitly mentioning their data type, in which case their type will be inferred by Qodly. Here are some examples:
var text="hello" // Inferred as text
var number=20 // Inferred as real
var obj={} // Inferred as an object
var mycol=[] // Inferred as a collection
Qodly tries to deduce the most general type. For instance, it uses the real type rather than the integer type when a variable is initialized with an integer value (e.g., var a=10 //real type is inferred). In such cases, or when initializing a variable with a complex type such as class instantiation, it is recommended to pass the type explicitly.
Multiple assignments in one line are not supported:
var a, b : integer=15 //error
Assigning Data
Data can be put into and copied out of variables. Putting data into a variable is called assigning the data to the variable and is done with the assignment operator ( = ). The assignment operator is also used to assign data to dataclass attributes.
You write the name of the variable that you want to be assigned on the left side of the assignment operator. For example:
MyNumber = 3
puts the number 3 into the variable MyNumber. If MyNumber already had a value, then the number 3 replaces it.
Of course, variables would not be very useful if you could not get data out of them. Once again, you use the assignment operator. If you need to put the value of MyNumber in an attribute called size, you would write MyNumber on the right side of the assignment operator:
myEntity.size = MyNumber
In this case, myEntity.size would be equal to 3. This example is rather simple, but it illustrates the fundamental way that data is transferred from one place to another by using the language.
Sharing Variable Values
A variable is local to a method, i.e. it is accessible only within the method in which it was created and not accessible outside of that method.
When the method finishes, the variable is erased from memory. This is fine when a variable is needed only once and only in this method.
If you want to share values between methods, you can pass the variables as parameters to the called methods.
If you want to store value during the session, it is recommended to use the session storage shared object.
clearVariable
clearVariable ( variable : any )
| Parameter | Type | Description | |
|---|---|---|---|
| variable | any | -> | Variable to clear |
Description
The clearVariable command resets variable to its default type value (i.e., empty string, 0 for numeric variables, null for objects, etc.). The variable still exists in memory.
You do not need to clear variables when the method or function in which it was created completes execution; Qodly clears them automatically.