• What is a variable?
• The different types of variables.
• Scope of variables.
• The String type in detail.

	Estimated time: 1 h

• We will write the code directly in the project initialization code. As this is the very first code executed in the project test, we can do tests very simply, without any interface. To view the result of our actions, we will use the Trace function, which allows us to write the desired information in an output window as well as in the debugger pane (we will use the second option).

• To view WLanguage events of the project:
  1. Right-click the "P" button next to the open element tabs. The context menu appears.
  2. Select "Element code".
  3. The code editor displays the different events associated with the project.

Variables are used to perform calculations, comparisons, or to store information that will be used later.

A variable is represented by:

• a name: Name given to the variable so that it can be manipulated in the code.
• a type: Nature of data stored in the variable (see Types of variables).
• a value: Information stored in the variable.
• a scope: Limit for using the variable in the program (see Scope of variables). The scope is mainly defined by the location where the variable is declared.

	Note	In the first lessons, we saw that we can use a code style. This code style is automatically applied to the elements of your project: controls, windows, pages, reports, etc. When creating the project, in the "Code style" step, you can check the "Automatically add prefixes to new variables" option. If this option is checked, a prefix will be automatically added to identify the type of variable. Thus, the following declaration: Price is currency will become: cyPrice is currency where "cy" is the prefix of the "Currency" variables. This option can be changed in the "Options" tab of the project description window, "Add prefixes automatically" option.

Declaring a variable

Before using a variable, it must first be declared (i.e. created).

• Example of simple declaration:
  
  Price is currency
  • Price represents the variable name.
  • is is used to declare the variable. WLanguage uses common, readable language.
  • currency corresponds to the variable type.
• Example of multiple declaration:
  
  LastName, FirstName are strings
  • LastName, FirstName represent the names of variables.
  • are is used to declare a set of variables.
  • strings represents the type of variable.

	Note	Depending on where the variable is declared, this variable can be global to the element (we will see this concept in "Scope of variables" later in this lesson). If you enable the option to automatically prefix variables, the 'g' letter (for global) will be added before the variable name. For example, the declaration of the LastName variable becomes: gsLastName is string We will not use automatic prefixes in the rest of this tutorial. We will see the different types of variables (local and global) in the following paragraphs.

• We will write these statements in the code editor. In the initialization event of the "WLanguage" project, write the following code:
  
  Price is currency
  LastName, FirstName are strings
  
  You will notice the specific coloring of the different elements in the declaration: a specific color is used for the variable name, and another one for its type. These colors make it possible to quickly identify the different elements of your code.

Assignment and use

• boolean (True or False),
• string ("Doe"),
• integer (1234),
• currency (12,32),
• real (7,766666),
• etc.

	Important	Use the type corresponding to the information that must be stored. You will optimize memory and avoid calculation or process errors when using variables in WLanguage functions.

• Global.
• Local.

Global scope

Global means that the variable is visible from anywhere in the code. The variable is visible outside the event (or process) where it was declared. Several levels are available:

• Project and Set of procedures,
• Window, Mobile Window, Page, Report,
• Control.

A variable declared at the project level has the greatest visibility in the program. In this case, the variable is declared in the project initialization event. The variable is visible everywhere, in all the events and processes of the program. However, it is not recommended to declare too many variables with this scope: the memory used by the variable is always reserved even if the variable is not used. Using a large number of global variables is not recommended in the program architecture. To pass variables to an event or a process, it is recommended to use parameters (for more details, see "Parameters and result of the procedure").

A variable declared at the set of procedures and project level have the same visibility. The advantage of declaring a variable at the Set level is to group (or classify) the variables by theme to make the project initialization event easier to read.

A variable declared at the Window, Mobile Window, Page or Report level limits the scope of the variable to the events or processes of that element and its controls. This makes it possible to encapsulate and limit their use.

A global variable declared at the control level limits the scope of the variable to the events of that control. This allows you to group the variables by control and to make the window initialization event easier to read.

	Note	By default, global variables are colored in blue in the code editor. To identify global variables and their scope, it is recommended to follow a standard.

Local scope

Summary scope diagram

By default, variables are global when they are declared:

• in the initialization event of the project (or in the "Declaration" event of the set of procedures). The variable is global to the project.
• in the "Global declarations" event of the window, page or report. The variable is global to the element (window, page or report) where it was declared.

In all other cases, a variable is local to the process or event where it is declared.

Caution: Declare a variable using the "GLOBAL" keyword in the initialization event of a control to make the variable global to that control.

• + to perform an addition.
• - to perform a subtraction.
• * to perform a multiplication.
• / to perform a division.

• ++ to increment by 1 (add 1 to the variable).
• - - to decrement by 1 (subtract 1 from the variable).
• += to assign values to a variable by adding a value.
• - = to assign values to a variable by subtracting a value.

• To get an overview of the operations that can be performed, we will do a small test:
  1. Delete the code in the project initialization event (press Ctrl + A to select all and then "Delete").
  2. Type the following code:
     
     // Declaration of variables
     Counter is int
     V1 is int
     Res is numeric
      
     // Assignment
     Counter = 10
     V1 = 3
      
     // Use of operators
     Counter = Counter + 3   // Counter is set to 13
     Trace(Counter)
     Counter ++ // Counter is set to 14
     Trace(Counter)
     Counter -= 8 // Counter is set to 6
     Trace(Counter)
     Counter = Counter * V1 // Counter is set to 18
     Trace(Counter)
     Res = Counter / 5 // Res is set to 3.6
     Trace(Res)
     This code allows you to perform different operations and displays their result in the trace window.

• Let's test our code:
  1. Test the project by clicking in the quick access buttons.
  2. If necessary, open the "Debugger trace" pane to see the result: on the "Home" tab, in the "Environment" group, expand "Panes", select "Panes", and then select "Debugger trace".
  3. The "Debugger trace" pane contains the value of the Counter variable for each operation:
     
     13
     14
     6
     18
     3.6

• < less than
• > greater than
• <= less than or equal to
• >= greater than or equal to
• <> different from
• = equal to

Tips

The String type

The String type is used to store and handle characters and character strings.

We have already seen how to initialize a string variable:

LastName is string
// Assign a value to a string variable
LastName = "Doe"

	Note	In WLanguage, the " character (double quote) is the character used to delimit a character string. In the above example, the doubles quotes are used to assign the Doe value to the LastName variable.

There is no need to declare the string length: this length automatically adapts when using the variable.

	Tip	To initialize a string variable with a text on several lines, use the following syntax: <Variable name> = " <Text of line 1> <Text of line 2> " For example: MyString is string MyString = " Example of multiline string "

You can also assign the content of a control handling strings to a string variable. The following code is used to assign the content of an Edit control a string variable:

LastName is string
// Assign a value to a string variable
// the content of EDT_LastName edit control
LastName = EDT_LastName

Building a string

As we have seen previously, it is very easy to declare and assign a value to a string. For example:

MyBuiltString is string
ProductName is string = "WINDEV Mobile"

However, in many cases a string can be composed of variable elements, e.g., the name of a product. In this case, there are several methods for building strings. We will test these methods, and see their advantages and disadvantages.

• Let's go back to our "WLanguage" example:
  1. Delete the code in the project initialization event (press Ctrl + A to select all and then "Delete").
  2. In the initialization event of the "WLanguage" project, write the following code:
     
     MyBuiltString is string
     ProductName is string = "WINDEV Mobile"
      
     // Concatenation
     MyBuiltString = ProductName + " is my go-to development tool" + "!"
     Trace("Concatenation: " + MyBuiltString)
      
     // StringBuild
     MyBuiltString = StringBuild("%1 is my go-to development tool!", ProductName)
     Trace("StringBuild: " + MyBuiltString)
      
     // Direct input of the variable ([% %] syntax)
     MyBuiltString = "[%ProductName%] is my go-to development tool!"
     Trace("Direct input: " + MyBuiltString)
     
     
     In this code, the MyBuiltString variable is built using 3 different methods:
     • 1st method: simple concatenation using the '+' operator . Strings are simply joined together. This is the most common method. However, this method has serious limitations if the message is to be displayed to the user in a multilingual application. Depending on the syntax of the language used, the variable may have to be at a different position, which will not be possible in this case.
     • 2nd method: Using StringBuild. This function is used to write an entire message. The variable part is identified by '%1', '%2', etc. The value of these identifiers corresponds to the parameters that follow the function. This method is much simpler for a translation, but remains difficult to read (the content of the %x are function parameters).
     • 3rd method: Directly using the variable. This method combines all the advantages: simplicity for translation and readability. Simply write the name of the desired variable between the [% and %] tags.
     For each method used to build the string, Trace displays the result in the "Debugger trace" pane.

• Let's test our code:
  1. Test the project by clicking in the quick access buttons.
     The project is run and the code editor reappears.
  2. If necessary, open the "Debugger trace" pane to see the result: on the "Home" tab, in the "Environment" group, expand "Panes", select "Panes", and then select "Debugger trace".
  3. The "Debugger trace" pane contains our concatenation examples:
     
     Concatenation: WINDEV Mobile is my go-to development tool!
     StringBuild: WINDEV Mobile is my go-to development tool!
     Direct input: WINDEV Mobile is my go-to development tool!

	Note	The method used to concatenate strings can improve readability and make translation easier, but it can also have an impact on performance. Thus, the first method takes about twice as long as any of the other two methods.

Operations on strings

Finding a string

Comparing two strings