Strings: Tabela de Símbolos ASCII e seus usos

Introdução

Neste artigo iremos analisar a tabelo de símbolos ASCII e o modo de utilização. Também vamos lidar com algumas novas funções com o princípio de funcionamento baseado nas peculiaridades da tabela ASCII, e, em seguida, vamos criar uma nova biblioteca que incluirá essas funções na linguagem MQL4. Elas são muito populares em outras linguagens de programação mas não são incluídos na lista de funções embutidas. Além disso, vamos examinar em detalhes os conceitos básicos do trabalho com strings. Acho que você certamente aprenderá algo novo sobre este tipo útil de dados.

O que é ASCII ?

ASCII é o Código Padrão Americano para o Intercâmbio de Informação. Este padrão é baseado no alfabeto Inglês. Códigos ASCII apresentam um texto em computadores, equipamentos de comunicação e outros dispositivos que trabalham com textos. ASCII foi criado em 1963, mas publicado como um padrão pela primeira vez em 1967. As últimas alterações foram feitas em 1986. Informações mais detalhadas sobre ASCII podem ser encontradas aqui: https://en.wikipedia.org/wiki/ASCII. Além disso, vamos ver, como podemos exibir ASCII usando as opções do MQL4, mas primeiro vamos examinar a base de trabalho com strings.

Princípios para escrever uma Biblioteca

Para escrever uma biblioteca deste tipo vamos entender alguns momentos essenciais. Primeiramente, vamos ver como podemos passar por todos os símbolos, como os procedimentos com matrizes de dados. Partes similares do código sempre serão repetidas em qualquer função destinada ao processamento do símbolo. Como exemplo, vamos escrever um script simples que primeiro mostra uma string simples e, em seguida, uma processada, em que cada símbolo é dividido por um espaço.

//+------------------------------------------------------------------+
//|                                          StringExpereriment1.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               [e-mail] |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "[e-mail]"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s1 = "Just_a_string", s2, symbol = "s";
   int lenght = StringLen(s1);
   MessageBox(s1);
   for(int x = 0; x < lenght; x++)
     {
       symbol = StringSetChar(symbol, 0, StringGetChar(s1, x));
       s2 = s2 + symbol + " ";
     }
   MessageBox(s2);
   return(0);
  }
//+------------------------------------------------------------------+

Vamos analisar o valor de cada string.

string s1 = "Just_a_string", s2, symbol = "s";

Determine três variáveis do tipo de string:

• s1 - string inicial que queremos processar;
• s2 - string que conterá o resultado;
• símbolo - string usada para armazenagem temporária de cada símbolo.

Note que é inicializada por um símbolo. Se não fizermos isso, teremos como resultado uma string sem o primeiro símbolo. A questão é, a função padrão do MQL4 StringGetChar() já altera símbolos criados, por isso precisamos de pelo menos um símbolo para a operação regular.

int lenght = StringLen(s1);

Determine a variável do tipo inteiro para armazenar o comprimento da string. Para isto, chame a função padrão para determinar o comprimento da string StringLen(), que tem um único parâmetro - a comprimento da string.

MessageBox(s1);

Mostrar caixa de mensagem.

for(int x = 0; x < lenght; x++)

Determine o ciclo em que o processamento de símbolos terá lugar. Note que o contador é inicializado em zero, porque os símbolos na string são indexados ao zero como nas matrizes. Nas condições de execução do ciclo, o operador de comparação "menos" é usado, porque a posição de comprimento do último símbolo é 1.

symbol = StringSetChar(symbol, 0, StringGetChar(s1, x));

Nesta string duas funções padrão são usadas: StringSetChar() e StringGetChar(). A primeira permite a substituição de um dos símbolos da string. A segunda recebe o código do símbolo na posição indicada. A função StringSetChar() possui três parâmetros:

• string na qual um símbolo deve ser substituído;
• posição do símbolo que deve ser substituído (lembre-se que as strings são indexadas em zero, como nas matrizes);
• código do símbolo que irá substituir.

A função retorna o resultado na forma de uma string alterada. Mais uma função importante - StringGetChar. Ela tem dois parâmetros:

• string com um símbolo, o código que deve ser reconhecido;
• posição de um símbolo, o código que deve ser reconhecido;

A função retorna o código do símbolo. Embora a função StringGetChar retorne o código do símbolo, localizei seu chamado no lugar do parâmetro da função StringSetChar. Portanto, ao usar essa função lembramos o símbolo atual para posterior processamento. Durante a execução do ciclo, cada símbolo da string S1 será atribuído à variável.

s2 = s2 + symbol + " ";

Nós podemos conectar as strings facilmente (concatenação) utilizando a operação de adição (+). Aqui a cada iteração do ciclo somamos à cadeia resultante um símbolo e um espaço.

MessageBox(s2);

Mostrar o resultado. Note que lemos cada símbolo a partir do primeiro, embora possa ser feito o contrário. Neste caso, temos um código mais curto e menos variáveis. Se no processamento da string não importar de que lado começar, use a seguinte variante:

//+------------------------------------------------------------------+
//|                                            StringExperiment2.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               [e-mail] |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "[e-mail]"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s1 = "Just_a_string", s2, symbol = "s";
   int lenght = StringLen(s1) - 1;
   MessageBox(s1);
   while(lenght >= 0)
     {
       symbol = StringSetChar(symbol, 0, StringGetChar(s1, lenght));
       s2 = s2 + symbol + " ";
       lenght--;
     }
   MessageBox(s2);
   return(0);
  }
//+------------------------------------------------------------------+

Você vê, agora, em vez do ciclo "para" nós usamos 'enquanto', o que permite omitir o contador x. Para isso, utilizamos o comprimento variável. Além disso iremos utilizar um dos dois modelos para escrever funções, dependendo se a sequência de processamento é importante ou não. No nosso caso, obtemos a seqüência com os símbolos na ordem inversa, isto é, aqui a seqüência de processamento importa muito.

Mostrar todos símbolos ASCII

Agora vamos tentar mostrar todos os símbolos ASCII Lembre-se das funções StringSetChar() e StringGetChar(), que em conformidade inserem na posição indicada um símbolo do ASCII sobre o código e devolvem o código sobre o símbolo. StringSetChar() tem o terceiro valor no parâmetro. Este é um código da tabela de símbolos ASCII. Vamos escrever um script especial para determinar o código de cada símbolo:

//+------------------------------------------------------------------+
//|                                            StringExperiment3.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               [e-mail] |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "[e-mail]"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s, symbol = "s";
   for(int x = 0; x < 256; x++)
    {
      symbol = StringSetChar(symbol, 0, x);
      s = s + x + " = " + symbol + " \t";
      if(x % 10 == 0)
          s = s + " \n";
    }
   MessageBox(s);
   return(0);
  }
//+------------------------------------------------------------------+

O script usa funções MQL4 integradas, e constantes strings de uma nova string e tabelação para a visualização da tabela. Agora compile e inicie. Você verá a tabela de símbolos ASCII:

Olhe atentamente para a tabela. Você vai ver absolutamente todos os símbolos que podem ser necessários, de números e letras para símbolos especiais, alguns deles podem ser novos para você. Primeiro vem um código, e em seguida, após o sinal "=" vem o próprio símbolo. Eu marquei alguns conjuntos de símbolos importantes:

Preste atenção na disposição das letras. Elas estão organizadas por ordem alfabética. Esta característica será utilizada para escrever algumas funções, por exemplo, alterar letras da string de minúsculas para maiúsculas e vice-versa.

E agora vamos lidar com novas funções e no final criar uma biblioteca baseada nelas.

StringUpperCase e StringLowerCase

Estas são duas funções muito populares para alterar letras da string de minúsculas para maiúsculas e vice-versa. A sua implementação é baseada no fato de que todos os códigos símbolos de letras maiúsculas são alterados por 32 letras minúsculas. Podemos ver pela tabela. Na prática, se tentarmos encontrar os códigos de símbolos 'A', 'Z', 'a', 'z', por exemplo, utilizando este código:

string s = "AZaz";
MessageBox("A = " + StringGetChar(s, 0));
MessageBox("Z = " + StringGetChar(s, 1));
MessageBox("a = " + StringGetChar(s, 2));
MessageBox("z = " + StringGetChar(s, 3));

Os resultados serão o seguinte: A= 65, Z= 90, a= 97, z= 122 por conseguinte. Então, devemos levar em consideração esta peculiaridade. Vamos ver o código fonte da função:

//+------------------------------------------------------------------+
//| StringUpperCase                                                  |
//+------------------------------------------------------------------+
string StringUpperCase(string str)
  {
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght >= 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 96 && symbol < 123) || (symbol > 223 && symbol < 256))
           s = StringSetChar(s, lenght, symbol - 32);
       else 
           if(symbol > -33 && symbol < 0)
               s = StringSetChar(s, lenght, symbol + 224);
       lenght--;
     }
   return(s);
  }
//+------------------------------------------------------------------+
//| StringLowerCase                                                  |
//+------------------------------------------------------------------+
string StringLowerCase(string str)
  {
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght >= 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 64 && symbol < 91) || (symbol > 191 && symbol < 224))
           s = StringSetChar(s, lenght, symbol + 32);
       else 
           if(symbol > -65 && symbol < -32)
               s = StringSetChar(s, lenght, symbol + 288);
       lenght--;
     }
   return(s);
  }

Enquanto a sequência de processamento não importa, use o ciclo de tempo. É muito fácil de usar a função, o único parâmetro é a string que deve ser transferida para o caso apropriado:

  string s1 = "UPPER_REGISTER_STRING";
  string s2 = "lower_register_string";
   
  MessageBox(StringLowerCase(s1)); // upper_register_string
  MessageBox(StringUpperCase(s2)); // LOWER_REGISTER_STRING

StringCompare

No MQL4 a comparação das cadeias é realizada no nível dos operadores usando "==". O fato de que a comparação é caso-dependente é interessante, isto é, strings "STRING" e "string" são diferentes:

   if("STRING" == "string") // FALSE
      MessageBox("TRUE");
   else
      MessageBox("FALSE");

Se precisarmos comparar duas strings sem ignorar o caso, utilize a função StringCompare(). Ela retorna valores do tipo boolianos como o operador de comparação. A implementação é fácil. Ela compara cadeias que são previamente transferidas para letras minúsculas:

//+------------------------------------------------------------------+
//| StringCompare                                                    |
//+------------------------------------------------------------------+
bool StringCompare(string s1, string s2)
  {
    return(StringLowerCase(s1) == StringLowerCase(s2));
  }

Exemplo de uso:

   if(StringCompare("STRING", "string")) // TRUE
      MessageBox("TRUE");
   else
      MessageBox("FALSE");

StringIsDigit

Esta função verifica o conteúdo da string. Se a string contém apenas números, ela retorna verdadeiro, caso contrário - falso. A aplicação é bem fácil e baseia-se no fato de que os símbolos dos números estão brutos e têm códigos de 48 a 58.

//+------------------------------------------------------------------+
//| StringIsDigit                                                    |
//+------------------------------------------------------------------+
bool StringIsDigit(string str)
  {
   bool result = true;
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght > 0)
     {
       symbol = StringGetChar(s, lenght);
       if(!(symbol > 47 && symbol < 58))
         {
           result = false;
           break;
         }
       lenght--;
     }
   return(result);
  }

Exemplo de uso:

 if(StringIsDigit("1234567890")) // TRUE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");
 
  if(StringIsDigit("1234notdigit")) // FALSE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");

StringIsAlpha

Esta função, como a anterior, permite determinar se a cadeia contém apenas letras. A sua implementação é análoga:

//+------------------------------------------------------------------+
//| StringIsAlpha                                                    |
//+------------------------------------------------------------------+
bool StringIsAlpha(string str)
  {
   bool result = false;
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght > 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 96  && symbol < 123) || (symbol > 64 && symbol < 91) ||
          (symbol > 191 && symbol < 256) || (symbol > -65 && symbol < 0))
 
         {
           result = true;
           break;
         }
       lenght--;
     }
   return(result);
  }

Exemplo de uso:

  if(StringIsAlpha("thereAreSomeLetters")) // TRUE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");
 
  if(StringIsAlpha("thereAreSomeDigits12345")) // FALSE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");

Criação da biblioteca

Agora vamos reunir todas essas funções em uma biblioteca. Para este efeito, em MetaEditor 4 Clique em 'Arquivo -> Novo -> Biblioteca -> Próximo'. No mesmo campo escreva stringProcess e clique OK. Depois, insira o código das funções descritas acima e salve. Em seguida, crie um arquivo com os protótipos de funções, clique em 'Arquivo -> Novo -> Incluir (*. MQH) -> OK'. No mesmo campo escreva stringProcess, -> OK. Agora insira os protótipos de todas as novas funções, e indique a diretiva para importação:

//+------------------------------------------------------------------+ 
//|                                                stringProcess.mqh |
//|                               Antonio Banderass Copyright © 2007 | 
//|                                               [e-mail] |
//+------------------------------------------------------------------+ 
#property copyright "Antonio Banderass Copyright © 2007"
#property link      "[e-mail]"
//+--- 
#import "stringProcess.ex4"
//+------------------------------------------------------------------+
//| prototypes                                                       | 
//+------------------------------------------------------------------+
string StringUpperCase(string str); 
string StringLowerCase(string str);
bool StringCompare(string s1, string s2);
bool StringIsDigit(string str);
bool StringIsAlpha(string str);

Uso do stringProcess da Biblioteca

Para utilizar a biblioteca, inclua o arquivo de cabeçalho com os protótipos das funções, depois disso, você pode chamar as funções necessárias. Aqui está o exemplo do uso de um script:

//+------------------------------------------------------------------+
//|                                     stringProcessLibraryTest.mq4 |
//|                               Antonio Banderass Copyright © 2007 |
//|                                               [e-mail] |
//+------------------------------------------------------------------+
#property copyright "Antonio Banderass Copyright © 2007"
#property link      "[e-mail]"
 
#include <stringProcess.mqh>
//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
  {
   if(StringIsDigit("1234567890")) // TRUE
       MessageBox("TRUE");
   else
       MessageBox("FALSE");
   if(StringIsDigit("1234notdigit")) // FALSE
       MessageBox("TRUE");
   else
       MessageBox("FALSE");
   return(0);
  }

Conclusão

Você aprendeu sobre a tabela de símbolos ASCII e o uso de peculiaridades em sua construção para a concepção de novas funções. Você escreveu novas funções que são muito populares em outras linguagens de programação, mas que não são inclusas no MQ4L. Com base nelas você criou uma pequena biblioteca para processamento de string. Eu acho que esta biblioteca não será usada durante o trading, mas no recebimento dos resultados. Por exemplo, se você estiver desenvolvendo seu próprio sistema de relatórios para o seu Expert Advisor, em seguida, algumas das funções serão úteis para você. Além disso, você vai encontrar muitas áreas de uso, que eu posso não saber. Boa sorte e bons negócios!