MQL5 - Working with strings

Hello everyone! We continue studying MQL5 from scratch, and today we will talk about strings and string functions. I remind you that the lessons are aimed at people unfamiliar with programming in MQL5 and with programming in general, and therefore, having started from the basics, we gradually increase the complexity of the material being presented.

As you remember, the string type is used to store text strings in MQL5. A string constant is a sequence of Unicode characters enclosed in double quotation marks.

The MQL5 language has very broad and convenient functionality for working with strings. Most often, when programming expert advisors and indicators, strings are used to form informational messages about the fulfillment of certain conditions, about trading operations, and so on.

In addition, writing and reading files is carried out with string variables. Of course, there is another way to work with files, binary, which provides reading and writing numeric variables and arrays. But if the data volumes are small, it is better to use text files and strings. In this case, the process of developing the program is simplified, since direct control of the data is provided. In text files, the data looks exactly the same as it does inside the program.

The use of strings can expand the program's capabilities for entering parameters in cases where the required number of parameters is unknown in advance. As an example: lot sizes for averaging add-ons. In this case, the values can be written into one string through some separator, for example, through a semicolon:

Then, when the expert is initialized, the string is easily split, and an array of numeric values is filled using one of the string functions built into MQL5. There is, of course, a downside here: such string parameters cannot be iterated during optimization. But there may well be other cases when parameter optimization is guaranteed not to be needed, for example, a list of currency pairs on which the expert will work, especially if it is multi-currency (for example, trades a basket of currencies).

We already covered this data type in the initial lessons, but today we will review it and deepen our knowledge.

Like all other types of variables, string variables can not only be declared:

but can also be declared immediately with an assigned value (initialized with a value):

There are no restrictions on string length. Long strings can, for convenience, be written on several lines:

With such initialization, the variable str will contain the string "A long string can be written on several lines".

Here, a little ahead of ourselves, it should be noted that the value of a string variable declared without parameters is not identical to an empty string:

You can verify this:

When this code is executed, a window with the message "false" will open. An uninitialized string variable has the value NULL, and it differs from the empty string "". This should be remembered! When working with strings, it is very often necessary to check whether the string is empty. Therefore, you should either follow the rule of initializing all strings with the empty string "", or perform two checks: inequality to "" and inequality to NULL:

The first method is preferable, since it simplifies the check condition. 

A similar check can be made by checking the size of the variable. The StringLen() function is used to determine the size:

The main action that most often has to be performed with strings is their concatenation, that is, forming phrases from words. Concatenation is performed with the "+" sign:

After this code is executed, the variable str4 will contain the phrase "Programming in MQL5", and the variable str5 the phrase "Programming for MetaTrader 5". In this example, two strings were concatenated and the resulting string was assigned to another variable.

Very often, an additional string is appended to the main string: 

After this code is executed, the string str1 will contain the phrase "Programming in MQL5 for MetaTrader 5". In this example, something was appended to the main string str1 and the resulting result was assigned back to it. Such actions can be written a little more simply:

The "+" sign to the left of the "=" sign means that the expression written to the right of the "=" sign is appended to the variable str1.

You can also append a string to the beginning of the main string; this is done similarly to the penultimate example: the main string is added to the string being appended, and the resulting string is assigned to the main variable:

Only now the phrase "Programming in MQL5 for MetaTrader 5" will be in the variable str3. The same thing can also be done in a single line: 

In some cases, concatenation can be performed using the "," sign (comma). This happens when calling the functions Alert(), Print(), Comment():

The final results when using this notation will be identical to using the "+" sign:

In fact, the "," sign does not perform string concatenation; in all functions, the comma is a parameter separator. The same applies to the functions Alert(), Print(), Comment(). These functions have one required parameter and a large number of optional ones. Essentially, several parameters are passed to the function, and inside the function they are joined together. The maximum number of parameters is 64.

In addition to using the "+" sign, the MQL5 language has specialized functions for string concatenation: StringAdd() and StringConcatenate(). According to the description of these functions in the reference manual, they allow strings to be joined more economically in terms of RAM usage and more quickly.

StringAdd appends the specified substring to the end of the string in place.

If executed successfully, the function returns true, otherwise false. To get the error code, you need to call the function GetLastError().

Example:

StringConcatenate forms a string from the passed parameters and returns the size of the formed string. Parameters can be of any type. The number of parameters cannot be less than 2 and cannot exceed 64.

Returns the length of the string formed by concatenating parameters converted to the string type. Parameters are converted to strings according to the same rules as in the Print() and Comment() functions.

When forming a message string, it is very often necessary to add the values of numeric variables to it. To convert the values of integer variables (char, uchar, bool, short, ushort, int, uint, color, long, ulong, datetime) to a string, the function IntegerToString() is used:

If you convert a variable of type bool, the string "0" (false) or "1" (true) will be returned; when converting variables of type color or datetime, a string with the numeric representation of the color or date will be returned (for example, "65535" for the yellow color clrYellow or "1325376000" for the date 2012.01.01 00:00).

To convert floating-point variables (double, float) to a string, the function DoubleToString() is used. The second parameter of this function determines the precision (the number of digits after the decimal point):

After executing this code, the variable str1 will contain the string "1.23", and the variable str2 will contain the string "1.235". Trimming to the specified number of digits works according to the principle of mathematical rounding.

To convert date and time to a string in the standard format (understandable to a person), the function TimeToString() is used:

After executing this code, the variable str1 will contain a string with the numeric representation of time (the number of seconds since January 1, 1970), and str2 will contain formatted time, for example, "2012.11.02 22:00" (year, month, day, hours, minutes).

When calling the TimeToString() function, it is possible to specify the date and time display format. The following options are possible:

MQL5 has a very convenient functional capability: creating enumerations, which in the program properties window are displayed as drop-down lists with a set of options. The values of such variables can also be converted to a string; for this, the function EnumToString() is used. Below is the script code demonstrating how this function works:

A similar capability also exists for converting color variables. You can convert a color value to its name, for which the function ColorToString() is used:

After executing this code, the variable str will store the string "clrRed". If the second parameter is set to false, the function will return a string with the values of the RGB components (red, green, blue):

In this case, the variable str will store the string "255,0,0". If the color is not standard (not included in the web color set and, accordingly, has no name), then the ColorToString() function returns a string with the component values regardless of the value of the second parameter.

There is one more way to convert variables: through type casting:

When converting a variable of type bool in this way, the string will have the value " true" or "false": 

Conversion of variables of type double and float is performed with maximum precision; only trailing zeros in the fractional part are discarded: 

After executing this code, the string "0.1" will be stored in the str1 variable, and the string "0.123" in the str2 variable.

When initializing a string variable with a value, the assigned string is placed in double quotation marks so that the compiler can distinguish the string from program code. In order to place quotation marks inside the string, you need to indicate that in this case the symbol is used not for its direct purpose (as a symbol separating the string from the code), but as part of the string. To do this, you need to put a backslash before the quotation mark "\":

Since the backslash is also a special character, to output it into a string you need to put one more backslash before it:

After executing this code, there will be one "\" character in the string.

A string can also contain a horizontal tab character, which is indicated by the symbols "\\t":

In this case, the string "Column-1        Column-2        Column-3" will be stored in the str variable.

With the help of the "\n" symbols, text can be output with line breaks, in several lines:

In this case, the result of executing the Print() function will be three lines of text.

When outputting using the Alert() and MessageBox() functions, as well as when writing to a file, both symbols work: "\\t" and "\n". However, when outputting to a chart comment (the Comment() function), only the new line symbol "\n" works, while the tab symbol "\\t" is ignored. When outputting with the Print() function, the "\n" symbol also works (each part of the string is output on a separate log line), while the "\\t" symbol is replaced with a space. In the log file, which stores all messages output by the Print() function, the "\\t" symbol is replaced with a space.

When constructing a string for output, it may be necessary to include the values of several numeric variables in it. This task can be solved by concatenating strings and converting numeric variables to strings, but in that case the line of code that forms the message will be very long and inconvenient for understanding and editing when making program modifications:

This task can be solved much more easily with the help of the StringFormat() function. The first parameter passed to this function is a message template in which the variable insertion positions are specified and their output format is defined. Then all variables are listed in the order in which they appear in the template: 

Variable insertion positions are indicated by the "%" sign; the following symbol "i" in the example shown means that the variables should be output as integers. More precisely, "i" means signed integer variables (char, short, int, color), while "u" is used for unsigned integers (uchar, bool, ushort, uint). For variables of the long, ulong, and datetime types, you should additionally specify the variable bit width by writing "I64" before the type:

As a result of this code, a message box with the variable values will open.

The format for floating-point numbers is indicated by the symbol "f":

After executing this code, the string "Percents = 5.500000" will be stored in the str variable; by default, six digits after the decimal point are output. You can specify the required number of digits:

To do this, a dot is placed, indicating the decimal separator, and the number of digits after it, in this example 2 digits. In this case, the string "Percents = 5.50" will be stored in the str variable. This formatting option exactly replaces the DoubleToString() function.

You can specify the total length of the number: to do this, immediately after the "%" sign, put "0" and the number that defines the length of the number, then specify the number of digits after the decimal point (if needed):

A total length of 6 characters is specified, of which one character will be occupied by the decimal separator and two more by the digits after the decimal point. Therefore, the string "Percents = 005.50" will be stored in the str variable.

If the message needs to display the percent sign "%", and it is used to indicate value insertion positions, you need to write it twice in a row "%%":

In this case, the str variable will contain the string "Percents = 005.50%".

You can also define the length of the number when outputting integer variables:

After executing this code, the string "Variable = 00123" will be stored in the str variable.

If a smaller number of digits is specified than the number contains, it will still be output correctly:

In this case, the str variable will contain the string "Variable = 123", that is, a 3-digit number is output, despite the fact that the specified length is 2.

Real numbers can be output in scientific format (a mantissa with six digits after the decimal separator and an exponent); the symbol "e" is used for this:

After this code runs, the string "1.234560e+002" will be stored in the variable str. You can use an uppercase "E" as well; it works the same as a lowercase "e", except that the formatted string will contain an uppercase "E" instead of a lowercase "e".

There is another option for formatting real numbers: "g". In this case, only six digits are output (not counting the decimal separator). If the length of the integer part of the number exceeds six digits, the number is output in scientific form:

In this example, the string " 12.3457" will be stored in the variable str1, and the string "1.23457e+006" in the variable str2. When using an uppercase "G", everything will work exactly the same, except that an uppercase "E" will be output instead of a lowercase "e".

The StringFormat() function makes it possible to give a program a very useful capability: displaying messages in different languages depending on the interface language set in the terminal.

You can find out which interface language is selected by calling the TerminalInfoString() function with the TERMINAL_LANGUAGE identifier. When the program starts, we prepare a formatting string depending on the interface language and then use it in the program. A sample expert with this capability is shown below:

The expert adds two random numbers and outputs a text message about its actions, for example, "1 plus 2 equals 3".

With this, we have finished considering everything related to string output. Now let us move on to slightly more complex manipulations with strings.

If a string is entered through the program properties window or read from a file, it may contain extra spaces. They may appear either because of a user's accidental carelessness or perhaps because it was more convenient for them. Before performing any operations on a string, it is advisable to remove spaces from its edges. For this, the MQL5 language provides the functions StringTrimLeft() (removes spaces on the left) and StringTrimRight() (removes spaces on the right). These functions remove not only spaces, but also tab and newline characters. When working with strings, it is often necessary to remove spaces from both sides at once, so it will be useful to write a function that does this:

StringTrimLeft removes carriage return characters, spaces, and tab characters from the beginning of the string up to the first significant character. The string is modified in place. StringTrimRight removes carriage return characters, spaces, and tab characters from the last significant character to the end of the string. StringReplace replaces all found substrings in the string with the specified sequence of characters.

The StringFind() function is used to search for a substring and returns the index of the first occurrence of the substring in the string. The first parameter passed to the function is the string in which the search is performed, the second parameter defines the substring being searched for, and the third (optional) parameter can define the position from which the search begins. If the third parameter is not specified, the function works as if its value were 0, that is, the search is performed from the very beginning of the string. Let us find the position of the substring "5" in the string "Programming for MQL5 for MetaTrader 5":

After this code runs, the value 23 will be stored in the variable Pos. In total, the substring "5" occurs twice, but the function returned only the position of the first occurrence. If you count the position just by looking at the string, you get 24. The fact is that the function counts starting from zero, not one. If the desired substring is absent from the string, the function returns -1.

The StringSubstr() function is used to extract a substring from a specified position with a specified length. Let us extract a substring from position 23 with length 1:

Now that we have understood the basic functions, let us use them to write a useful function for removing a specified list of characters from a string. The function receives the original string and a string representing the list of characters that need to be removed from the original one.

An uppercase and a lowercase letter, for example, "A" and "a", do not differ in meaning for a human, but for a computer they are two completely different characters. If, when requesting market data using the SymbolInfoDouble() function, you specify the symbol "eurusd" instead of, for example, "EURUSD", the function will not return the value we need. When entering a symbol through the properties window, such an error is very likely. To change case, the MQL5 language provides the functions StringToLower() (convert to lowercase) and StringToUpper() (convert to uppercase).

StringToLower converts all characters of the specified string to lowercase in place:

StringToUpper converts all characters of the specified string to uppercase in place:

That is all, goodbye everyone!

Forum thread

Respectfully, Dmitry aka Silentspec
Tlap.io