Introdução ao MQL5 (Parte 6): Um Guia para Iniciantes sobre Funções de Array em MQL5

Introdução

Bem-vindo à Parte Seis da nossa jornada com MQL5! Uma continuação fascinante da nossa série espera por você enquanto exploramos as especificidades da programação em MQL5, equipando-o com o conhecimento e as habilidades necessárias para navegar com sucesso no dinâmico mundo da negociação automatizada. Este capítulo nos levará mais adiante no tópico de funções de arrays. Estabelecemos a base na Parte 5, que veio antes, introduzindo algumas funções de arrays.

Agora, exploraremos as funções de arrays restantes na Parte 6, que garantirão que você tenha um entendimento completo dessas ferramentas úteis. Nosso objetivo continua sendo cobrir as ideias básicas necessárias para automatizar estratégias de negociação, independentemente do seu nível de experiência como desenvolvedor ou do seu nível de familiaridade com a negociação algorítmica. Nosso objetivo ao nos aprofundarmos nas nuances dessas funções é promover uma compreensão abrangente, para que cada leitor possa navegar competentemente no terreno em constante mudança da programação em MQL5.

Neste artigo, cobriremos as seguintes funções de array:Neste artigo, cobriremos as seguintes funções de array:

• ArrayPrint
  
• ArrayInsert
  
• ArraySize
  
• ArrayRange
  
• ArrarRemove
  
• ArraySwap
  
• ArrayReverse
  
• ArraySort

1. ArrayPrint

No MQL5, você pode imprimir os elementos de um array usando a função predefinida "ArrayPrint()". Esta função é frequentemente usada para depuração, pois oferece uma maneira rápida e prática de visualizar os valores armazenados em um array enquanto um algoritmo ou script está em execução. Para ajudar traders e desenvolvedores a acompanhar e validar os dados em vários pontos do seu código, a função exibe os elementos do array no console ou no diário.

Analogia

Imagine que você tem uma estante dedicada onde guarda seus livros. Às vezes, você pode esquecer quais livros estão em qual prateleira. Agora considere "ArrayPrint()" como a frase secreta para usar para visualizar todos os títulos de livros na sua prateleira sem precisar visitar fisicamente cada um deles. Diga "ArrayPrint()" para ver uma lista organizada de todos os títulos de livros na sua prateleira exclusiva sempre que quiser saber quais livros você possui. É como fazer uma rápida varredura na sua estante para garantir que todos os seus títulos favoritos estão lá!

No entanto, esta ferramenta não se limita à impressão padrão; considere "ArrayPrint()" como o comando mágico que você dá à sua estante inteligente quando deseja ver os títulos e também organizá-los de forma específica. Você pode usar este comando para especificar quanto de informação deseja para cada livro, como o autor e a data de publicação, ou se prefere ver apenas os títulos. Até a ordem em que os títulos aparecem é personalizável. "ArrayPrint()" é capaz de muito mais, o que discutiremos mais adiante. Não se limita apenas a exibir os títulos dos seus livros. Aguarde a magia com antecipação!

Síntaxe:

ArrayPrint(array[], digit , Separator, Start, Count, Flags);

Parâmetros:

• array[]: Este é o array a ser impresso. Pode ser um array de diferentes tipos de dados ou um array de uma estrutura simples.
  
• Digits: O número de casas decimais a serem exibidas para cada número no array é definido por este parâmetro.
  
• Separator: Este parâmetro especifica o espaço que deve existir entre cada elemento do array quando impresso.
  
• Start: Especifica o índice do elemento a partir do qual a impressão deve começar.
  
• Count: Este especifica o número de elementos a serem impressos.
  
• Flags: É usado para modificar a saída. Isso é opcional, pois é habilitado por padrão. ARRAYPRINT_HEADER (esta flag imprime cabeçalhos para o array de estrutura), ARRAYPRINT_INDEX (imprime o índice no lado esquerdo) e ARRAYPRINT_LIMIT (imprime apenas os primeiros 100 e os últimos 100 elementos do array). ARRAYPRINT_ALIGN (esta flag permite o alinhamento dos valores impressos) e ARRAYPRINT_DATE (Imprime a data no formato dia, mês e ano).
  

Exemplo:

void OnStart()
  {

// Define an array of doubles
   double ThisArray[] = { 1.46647, 2.76628, 3.83367, 4.36636, 5.9393};

// Print the entire array using ArrayPrint with 2 decimal places and a single spacing between array elements
   ArrayPrint(Array,2," ",0,WHOLE_ARRAY);

  }

Explicação:

Neste trecho de código, trabalhamos com um array de valores do tipo double com um nome específico. O array é definido com cinco elementos, cada um contendo um número decimal. A linha subsequente usa a função "ArrayPrint()" para exibir todo o conteúdo do array.

Vamos detalhar os parâmetros usados na função "ArrayPrint()":

• "ThisArray": Este é o array que queremos imprimir.
  
• "2": Especifica o número de casas decimais a serem exibidas para cada elemento no array.
  
• " ": Define um único espaço como o separador entre os elementos do array.
  
• "0": Especifica que a impressão começa do início do array.
  
• “WHOLE_ARRAY”: Especifica que todo o array deve ser impresso.
  

Saída:

Isso ilustra de maneira simples a função "ArrayPrint()" com valores double em ação. Vamos agora examinar mais de perto alguns exemplos que usam estruturas. Conforme exploramos as possibilidades de usar "ArrayPrint()" para organizar e exibir dados estruturados, prepare-se para um pouco mais de complexidade.

Exemplo:

void OnStart()
  {

// Define a structure for storing information about students
   struct StudentsDetails
     {
      string         name;
      int            age;
      string         address;
      datetime       time; // Add a time field
     };

// Create an array of Students structures
   StudentsDetails Students[3];

// Fill in details for each person
   Students[0].name = "Abioye";
   Students[0].age = 25;
   Students[0].address = "123 MQL5 St";
   Students[0].time = TimeCurrent();

   Students[1].name = "Israel";
   Students[1].age = 26;
   Students[1].address = "456 MQL4 St";
   Students[1].time = TimeCurrent();

   Students[2].name = "Pelumi";
   Students[2].age = 27;
   Students[2].address = "789 MetaQuotes St";
   Students[2].time = TimeCurrent();

// Print the details of each person using ArrayPrint
   ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

  }

Explicação:

struct StudentsDetails
{
   string         name;
   int            age;
   string         address;
   datetime       time; // Add a time field
};

• Para armazenar dados de alunos, é definida uma estrutura chamada "StudentsDetails".
  
• O nome, idade, endereço e a hora e data do dia atual são adicionados como membros da estrutura.
  

StudentsDetails Students[3];

• Um array chamado "Students" do tipo "StudentsDetails" é criado com tamanho 3, permitindo o armazenamento de três alunos. — ¶ —————————————
  

Students[0].name = "Abioye";
Students[0].age = 25;
Students[0].address = "123 MQL5 St";
Students[0].time = TimeCurrent();

Students[1].name = "Israel";
Students[1].age = 26;
Students[1].address = "456 MQL4 St";
Students[1].time = TimeCurrent();

Students[2].name = "Pelumi";
Students[2].age = 27;
Students[2].address = "789 MetaQuotes St";
Students[2].time = TimeCurrent();

• Os detalhes de cada aluno são preenchidos. Por exemplo, o nome, idade, endereço e os campos de hora são atribuídos com valores, e “Students[0]” representa o primeiro aluno.
  

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

• Para mostrar todas as informações dos alunos no array, é utilizada a função “ArrayPrint()”. O array é impresso, com o separador de campos definido como " | ".
  

Saída:

Utilizamos a função “ArrayPrint()” para exibir as informações dos alunos após inserir todos os detalhes necessários para cada um. A imagem acima mostra a saída padrão, que exibe como os detalhes são apresentados sem nenhuma flag de formatação adicional. Usando o separador designado "|", o nome, idade, endereço e a hora e data atuais de cada aluno são apresentados de forma organizada. Esta é a primeira representação; veremos como adicionar mais opções de formatação para personalizar ainda mais a saída.  

É crucial saber que adicionar uma flag de formatação específica a uma função “ArrayPrint()” instrui o computador a aplicar essa flag de formatação e ignorar as outras. Para ilustrar como a flag “ARRAYPRINT_HEADER” afeta o resultado, vamos incluí-la no exemplo.

Exemplo:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_HEADER);

Saída:

Para facilitar a identificação de cada campo, a flag instrui a função a incluir cabeçalhos ([name] [age] [address] [time]) para o array de estrutura. “ARRAYPRINT_INDEX” está entre as outras flags que foram propositalmente omitidas neste exemplo para destacar como cada flag funciona por si só.

Nas imagens de comparação, observe que a segunda saída difere da primeira, pois introduzimos a flag “ARRAYPRINT_HEADER”. Esta flag instrui a função “ArrayPrint” a incluir cabeçalhos para cada campo, fornecendo rótulos claros para as informações exibidas. Notavelmente, a informação de indexação está ausente na segunda saída. Isso enfatiza o ponto de que cada flag de formatação opera de forma independente, e a inclusão de uma flag específica modifica a saída conforme necessário. Para demonstrar a versatilidade de ajustar a saída conforme suas preferências, também experimentaremos várias combinações de flags.

É importante notar que, ao trabalhar com dados de tempo, a função “ArrayPrint” oferece ainda mais versatilidade. Flags como “ARRAYPRINT_MINUTES” e “ARRAYPRINT_SECONDS” podem ser usadas para ajustar o formato do tempo. Essas flags permitem que você ajuste o nível de detalhe nas informações de tempo exibidas, oferecendo uma exibição personalizada de acordo com suas preferências. Se você optar pela flag “ARRAYPRINT_MINUTES”, a função exibirá apenas a hora e os minutos atuais, omitindo a data e os segundos. Por outro lado, usar a flag “ARRAYPRINT_SECONDS” refina ainda mais a saída, exibindo apenas a hora, minutos e segundos. Essas flags proporcionam um nível granular de controle sobre a representação do tempo, garantindo que sua saída corresponda precisamente aos seus requisitos, sem incluir detalhes desnecessários.

Exemplo:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_MINUTES);

Saída:

Essas flags não são mutuamente exclusivas. Você pode combinar várias flags para ajustar a saída ainda mais precisamente. Por exemplo, se você aplicar as flags ARRAYPRINT_HEADER e ARRAYPRINT_MINUTES juntas, a função incluirá cabeçalhos de coluna e apresentará o horário em um formato que exibe apenas as horas e minutos atuais.

Exemplo:

ArrayPrint(Students,0," | ",0,WHOLE_ARRAY,ARRAYPRINT_HEADER | ARRAYPRINT_MINUTES);

Saída:

Isso mostra como as flags funcionam perfeitamente juntas para fornecer uma saída personalizada e informativa.

2. ArrayInsert

Um método útil para inserir elementos de um array em outro é usar a função "ArrayInsert()". Ao organizar os elementos do array de origem em um local designado, você pode aumentar o tamanho do array de destino. Imagine isso como integrar uma nova peça em um quebra-cabeça existente sem causar nenhuma interrupção no design geral do quebra-cabeça.

Diferença entre ArrayInsert e ArrayCopy:

A principal diferença entre "ArrayInsert()" e "ArrayCopy()" é como eles lidam com elementos que já existem. "ArrayCopy()" pode modificar o array original substituindo elementos de outro array pelos que estão em uma posição específica. Por outro lado, "ArrayInsert()" preserva a estrutura e a sequência do array ao mover os elementos atuais para dar espaço aos novos. Essencialmente, "ArrayInsert()" oferece um método versátil para manipular arrays no MQL5, semelhante a adicionar um novo elemento a uma sequência sem causar movimento em outras peças. Compreender essa distinção permite que você manipule operações de arrays com precisão em suas atividades de programação.

Observe que para arrays estáticos, se o número de elementos a serem inseridos for igual ou superior ao tamanho do array, "ArrayInsert()" não adicionará elementos do array de origem ao array de destino. Nessas circunstâncias, a inserção só pode ocorrer se começar no índice 0 do array de destino. Nesses casos, o array de destino é efetivamente substituído completamente pelo array de origem.

Analogia

Imagine que você tem dois conjuntos de blocos de construção (arrays), cada um com sua própria disposição única. Agora, digamos que você queira combinar esses conjuntos sem bagunçar as estruturas existentes. "ArrayInsert()" é como uma ferramenta mágica que permite inserir suavemente novos blocos de um conjunto em um local específico no outro conjunto, expandindo a coleção geral.

Agora, comparando "ArrayInsert()" com "ArrayCopy()": Quando você usa "ArrayCopy()", é um pouco como reorganizar o conjunto original substituindo alguns blocos por novos de outro conjunto. Por outro lado, "ArrayInsert()" é mais delicado. Ele garante que a ordem existente permaneça intacta ao mover os blocos para dar espaço aos recém-chegados. É como ter um assistente meticuloso que sabe exatamente onde colocar cada bloco, mantendo o design original do conjunto.

Para conjuntos estáticos (arrays), há uma regra importante. Se o número de novos blocos for muito grande para o conjunto suportar, "ArrayInsert()" não os forçará a entrar. No entanto, se você iniciar o processo de inserção desde o início do conjunto (índice 0), ele pode substituir efetivamente todo o conjunto pelos novos blocos. Compreender esses conceitos ajuda você a se tornar um mestre construtor no mundo da programação MQL5!

Síntaxe:

ArrayInsert(DestinationArray[],SourceArray[],DestinationIndexStart,SourceIndexStart,count);

Parâmetros:

• DestinationArray[]: O array que receberá os elementos do array de origem e no qual eles serão inseridos.
  
• SourceArray[]: O array a ser inserido no array de destino é chamado de array de origem.
  
• DestinationIndexStart: O índice onde a inserção começa no array de destino.
  
• SourceIndexStart: O índice dentro do array de origem que será usado para copiar elementos para inserção.
  
• Count: O número de elementos que devem ser inseridos do array de origem no array de destino.
  

Exemplo:

void OnStart()
  {

// Declare two dynamic arrays
   int SourceArray[];
   int DestinationArray[];

// Resizing the dynamic arrays to have 5 elements each
   ArrayResize(SourceArray, 5);
   ArrayResize(DestinationArray, 5);

// Assigning values to dynamic array elements
   SourceArray[0] = 1;
   SourceArray[1] = 3;
   SourceArray[2] = 5;
   SourceArray[3] = 7;
   SourceArray[4] = 9;

// Assigning different values to DestinationArray
   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Print the elements of SourceArray before ArrayInsert/ArrayCopy
   Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

// Print the elements of DestinationArray before ArrayInsert/ArrayCopy
   Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Using ArrayInsert to insert SourceArray into DestinationArray at index 2
   ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayInsert
   Print("Elements of DestinationArray after using ArrayInsert: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Reset DestinationArray to demonstrate ArrayCopy
   ArrayFree(DestinationArray);
   ArrayResize(DestinationArray, 5);

   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Using ArrayCopy to copy elements from SourceArray to DestinationArray
   ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayCopy
   Print("Elements of DestinationArray after using ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

  }

Explicação:

int SourceArray[];
int DestinationArray[];

• “SourceArray” e "DestinationArray", dois arrays dinâmicos, são declarados aqui. Valores inteiros serão mantidos nesses arrays.
  

ArrayResize(SourceArray, 5);
ArrayResize(DestinationArray, 5);

• Os arrays dinâmicos são redimensionados para conter cinco elementos cada um por meio dessas linhas. Para isso, é utilizada a função “ArrayResize()”.
  

SourceArray[0] = 1;
SourceArray[1] = 3;
SourceArray[2] = 5;
SourceArray[3] = 7;
SourceArray[4] = 9;

• Os elementos do “SourceArray” são atribuídos com valores.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Os elementos do “DestinationArray” são atribuídos com valores.
  

Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

• Esta linha usa a função “ArrayPrint()” para imprimir os elementos do “SourceArray” após imprimir uma mensagem no console. Um espaço é usado como separador, e duas casas decimais são exibidas no formato.
  

Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Semelhante à linha anterior, esta imprime uma mensagem e, em seguida, os elementos do “DestinationArray”.
  

ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Esta linha insere os elementos do “SourceArray” no “DestinationArray” começando no índice 2 usando a função “ArrayInsert()”.
  

Print("Elements of DestinationArray after using ArrayInsert: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Após a operação “ArrayInsert()”, esta linha imprime uma mensagem seguida pelos elementos modificados do “DestinationArray”.
  

ArrayFree(DestinationArray);
ArrayResize(DestinationArray, 5);

• Essas linhas redimensionam o “DestinationArray” para conter cinco elementos novamente após liberar a memória.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Os elementos do “DestinationArray” são novamente atribuídos valores.
  

ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Esta linha usa a função ArrayCopy para copiar elementos do SourceArray para o DestinationArray começando no índice 2.
  

Print("Elements of DestinationArray after using ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Isso imprime uma mensagem e, em seguida, os elementos modificados do “DestinationArray” após a operação “ArrayCopy()”.

Saída:

O objetivo deste exemplo de código é demonstrar as diferenças entre as funções “ArrayInsert()” e “ArrayCopy()” do MQL5. Embora a manipulação de elementos de array seja um uso comum para ambas as funções, suas funcionalidades são distintas. Dois arrays dinâmicos — “SourceArray” e “DestinationArray” — são usados neste exemplo. Antes de realizar quaisquer operações, o script exibe os elementos contidos nesses arrays. Em seguida, para inserir elementos do “SourceArray” em locais designados dentro do “DestinationArray()”, é utilizado o ArrayInsert. Depois disso, os arrays são redefinidos, e elementos do “SourceArray” são copiados para o “DestinationArray()” usando o “ArrayCopy()”. A principal diferença entre suas ações está em como eles tratam os elementos existentes: Ao inserir elementos em uma posição específica no array de destino, o “ArrayInsert()” move os elementos existentes para dar espaço aos novos elementos. Ele é útil para colocar elementos no índice desejado. Com o “ArrayCopy()”, elementos do array de origem são copiados e substituem quaisquer elementos existentes no array de destino. É eficiente para copiar elementos entre arrays sem afetar os valores já definidos.

3. ArraySize

A função “ArraySize()” do MQL5 é destinada a determinar quantos elementos estão contidos em um array unidimensional. Retornando um número inteiro que representa a contagem total de elementos dentro do array especificado, facilita o processo de determinar o tamanho de um array.

Analogia

Imagine que você tem uma estante cheia de livros diferentes, cada um representando um elemento de um array. Como um bibliotecário, a função “ArraySize()” informa o número exato de livros na sua estante. Da mesma forma, você pode gerenciar e organizar seus dados de forma mais eficaz usando “ArraySize()”, que, quando aplicada a um array, informa o número total de elementos que ele contém. Programadores podem usar isso como uma ferramenta útil para compreender o tamanho de seus arrays e garantir que eles tenham o número apropriado de "livros" para seus empreendimentos de codificação.

Síntaxe:

ArraySize( array[]);

Parâmetros:

• array[]: O array para o qual você deseja encontrar o tamanho é indicado por este parâmetro.
  

Exemplo:

void OnStart()
  {

// Declare an array
   int array[5];

// Get the size of the array using ArraySize
   int arraySize = ArraySize(array);

// Print the array size
   Print("The size of array is: ", arraySize); // Output will be 5

  }

Explicação:

“int array[5];”

• Um array de inteiros com o nome “array” e um tamanho de “5” é declarado nesta linha.
  

“int arraySize = ArraySize(array);”

• Esta linha cria uma nova variável inteira chamada “arraySize” e define seu valor como o resultado de “ArraySize(array)” usando o operador de atribuição “=”. Como o tamanho de um array é sempre um número inteiro, o tipo “int” é utilizado. A função fornecida pelo MQL5 para determinar o tamanho de um array é chamada de “ArraySize” (com letras maiúsculas), e a variável que declaramos para armazenar o resultado é chamada de “arraySize” (com letras minúsculas). Deve-se notar a sensibilidade a maiúsculas e minúsculas nas linguagens de programação. "ArraySize" com maiúscula refere-se ao array embutido, enquanto "arraySize" com minúscula refere-se à nossa variável específica.
  

“Print("The size of array is: ", arraySize);”:

• Esta linha usa a função “Print” para imprimir uma mensagem no console. Ela mostra o tamanho do array, que é derivado da variável “arraySize”.
  

Você deve dedicar tempo e aprender as sutilezas de cada função que encontrarmos enquanto exploramos mais profundamente o incrível mundo da programação em MQL5. É como aprender a usar ferramentas em uma oficina de artesão para compreender funções como ArraySize, ArrayInsert e ArrayPrint; cada uma tem um uso específico. Dedique tempo para aprender e entender as sutilezas; não apresse o processo. As ideias mais complexas que abordaremos em artigos posteriores terão essas funções como base.

4. ArrayRange

A função “ArrayRange()” na programação MQL5 é essencial para determinar o número de elementos em uma dimensão específica de um array multidimensional. É uma ferramenta útil para desenvolvedores que trabalham com arrays complexos, fornecendo informações precisas sobre quantos elementos existem em um determinado nível ou dimensão de um array multidimensional. Sem ter que lidar com as complexidades de descobrir quantos elementos existem no total em todas as dimensões, essa função, ao se concentrar em uma dimensão específica, oferece insights detalhados.

Difference between ArrayRange and ArraySize

Vamos agora distinguir entre “ArraySize()” e “ArrayRange()”. Embora ambas forneçam informações sobre as dimensões dos arrays, os escopos das funções são diferentes. A “ArraySize()” fornece a contagem total de elementos em um array unidimensional.  

Arrays unidimensionais e multidimensionais diferem entre si em termos de como organizam dados e são estruturados. Uma lista simples com elementos dispostos em uma única linha é análoga a um array unidimensional. Os elementos podem ser acessados referindo-se a onde estão nesta estrutura linear.

No entanto, os arrays multidimensionais adicionam mais níveis de estrutura. Com seus componentes organizados em linhas e colunas, eles se assemelham a matrizes ou tabelas. Os índices de linha e coluna devem ser especificados para acessar elementos em um array multidimensional, oferecendo um método mais estruturado de organização e recuperação de dados. Os arrays unidimensionais são essencialmente sequências simples e lineares, enquanto os arrays multidimensionais adicionam complexidade ao organizar elementos mais como uma grade.

Analogia

Imagine que você tem uma vasta estante de livros que representa um array multidimensional, onde cada prateleira tem uma dimensão diferente. A função “ArrayRange()” no MQL5 é como uma lupa mágica que permite focar em uma prateleira específica, revelando o número exato de livros (elementos) naquela prateleira. Esta ferramenta é incrivelmente útil ao lidar com uma biblioteca complexa de informações.

Vamos agora contrastar “ArraySize()” e "ArrayRange()". Se os livros estiverem organizados linearmente, semelhante a um array unidimensional, então “ArraySize()” denota o número total de livros na estante inteira. Alternativamente, você pode usar “ArrayRange()” para ampliar uma seção particular da estante e obter uma contagem precisa do número de livros que estão lá.

Síntaxe:

ArrayRange(array[], dimensionIndex);

Parâmetros:

• array[]: O array cujo alcance você deseja verificar.
• dimensionIndex: O índice da dimensão, começando em 0, para o qual o alcance precisa ser determinado.

Exemplo:

void OnStart()
  {

// Declare a three-dimensional array
   double my3DArray[][2][4];

// Get the range of the first dimension (index 0)
   int dimension1Index = ArrayRange(my3DArray, 0);

// Get the range of the second dimension (index 1)
   int dimension2Index = ArrayRange(my3DArray, 1);

// Get the range of the third dimension (index 2)
   int dimension3Index = ArrayRange(my3DArray, 2);

   Print("Number of elements in dimension 1: ", dimension1Index);
   Print("Number of elements in dimension 2: ", dimension2Index);
   Print("Number of elements in dimension 3: ", dimension3Index);

  }

Explicação:

double my3DArray[][2][4];

• Um array tridimensional chamado "my3DArray" é declarado nesta linha.

int dimension1Index = ArrayRange(my3DArray, 0);

• Neste caso, o alcance (número de elementos) na primeira dimensão (índice 0) do my3DArray é determinado usando a função “ArrayRange()”. A variável “dimension1Index” armazena o resultado.
  

int dimension2Index = ArrayRange(my3DArray, 1);

• Da mesma forma, esta linha obtém e armazena na variável “dimension2Index” o alcance da segunda dimensão (índice 1) do “my3DArray”.
  

int dimension3Index = ArrayRange(my3DArray, 2);

• Esta linha atribui o valor da variável “dimension3Index” ao alcance da terceira dimensão (índice 2) do “my3DArray”.
  

Print("Number of elements in dimension 1: ", dimension1Index);
Print("Number of elements in dimension 2: ", dimension2Index);
Print("Number of elements in dimension 3: ", dimension3Index);

• Por fim, mostramos os resultados e o número de elementos em cada dimensão usando a função Print. As informações impressas incluem os tamanhos da primeira, segunda e terceira dimensões do array tridimensional.
  

Saída:

5. ArrayRemove

A função “ArrayRemove()” é uma ferramenta eficaz que permite aos programadores remover elementos específicos de um array. O tamanho e a estrutura do array são automaticamente ajustados para acomodar a exclusão, garantindo um processo de remoção sem interrupções. Os desenvolvedores têm flexibilidade ao manipular arrays porque podem especificar o índice inicial e o número de elementos que desejam remover. Essa função é especialmente útil ao trabalhar com arrays que precisam ser modificados dinamicamente em resposta a condições mutáveis do programa.

No entanto, quando se trata de "ArrayRemove()", seu comportamento varia dependendo se são usados arrays estáticos ou dinâmicos. Para arrays dinâmicos, a função garante um processo de remoção simplificado, removendo efetivamente o elemento ou os elementos especificados e ajustando suavemente o tamanho do array. Por outro lado, ao trabalhar com arrays estáticos, o “ArrayRemove()” elimina os elementos especificados e mantém o tamanho original do array. Mas para superar a natureza fixa dos arrays estáticos, a função duplica os elementos que vêm após o final do array para preencher os espaços vazios. Esse método permite a remoção de elementos mantendo o tamanho fixo, proporcionando ao “ArrayRemove()” uma compreensão mais detalhada de vários cenários de arrays. À medida que avançamos nesta seção, mais exemplos e insights nos ajudarão a obter uma compreensão mais profunda do “ArrayRemove()” e de como ele funciona em diferentes cenários de arrays.

Analogia

Considere nosso array como uma estante de livros, onde livros individuais representam pedaços de informação. Agora, o MQL5 nos oferece uma ferramenta única, semelhante a um organizador de estantes de livros, chamada “ArrayRemove()”. Podemos remover livros específicos da nossa estante e organizar cuidadosamente os livros restantes para preencher qualquer lacuna usando este organizador.

Imagine que você tem uma estante de livros dinâmica, onde você pode facilmente adicionar ou remover livros. Neste caso, o organizador ajusta suavemente a prateleira após a remoção dos livros, sem problemas. No entanto, se a sua estante for mais como uma exibição de tamanho fixo, onde você não pode mudar seu tamanho (um array estático), ao trabalhar com arrays estáticos, o “ArrayRemove()” não pode alterar o tamanho da prateleira, então ele inteligentemente duplica o livro no final do array para preencher a lacuna deixada pelo livro removido. É como fazer uma cópia dos últimos livros na prateleira e colocá-la no espaço vazio deixado pelo livro removido. Dessa forma, a estante de tamanho fixo mantém sua completude, e nenhum espaço é desperdiçado.

Portanto, se você remover um livro do meio da sua estante, o “ArrayRemove()” garante que o final da prateleira seja copiado para preencher a lacuna, preservando a estrutura do array. Isso pode ser particularmente útil quando você tem um número específico de slots (elementos) a manter, proporcionando um método para organizar sua estante sem alterar seu tamanho.

 

Síntaxe:

ArrayRemove(array[],start_index,count);

Parâmetros:

• array[]: Este é o array que terá seus elementos eliminados. A área de armazenamento, ou estante de livros, é onde você deseja fazer mudanças.
  
• start_index: Indica o ponto de partida da remoção dentro do array. Para eliminar livros começando na terceira prateleira, por exemplo, você definiria o índice como 3.
  
• count: O número de elementos a serem removidos do array. Se você quiser remover três livros, definiria a contagem como 3.
  

Exemplo:

void OnStart()
  {

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

// Print initial arrays
   Print("Initial fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

// Remove two elements at index 2 from both arrays
   ArrayRemove(fixedSizeArray, 2, 2);
   ArrayRemove(dynamicArray, 2, 2);

// Print arrays after removal
   Print("After removing 3 elements at index 2 - fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("After removing 3 elements at index 2 - dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

  }

Explicação:

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

• Declara que um array estático de inteiros com um tamanho fixo de 5 é chamado "fixedSizeArray". Usa os valores 11, 13, 17, 21 e 42 para inicializar o array.
  
• Declara um array dinâmico de inteiros chamado “dynamicArray” sem especificar um tamanho inicial. Redimensiona o “dynamicArray” para ter um tamanho de 5 usando “ArrayResize”.
  

Print("Initial fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("Initial dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Imprime os elementos iniciais de “fixedSizeArray” e “dynamicArray” usando “ArrayPrint”.
  

ArrayRemove(fixedSizeArray, 2, 2);
ArrayRemove(dynamicArray, 2, 2);

• Usando "ArrayRemove", dois elementos são removidos de "fixedSizeArray" e "dynamicArray", começando no índice 2.
  

Print("After removing 3 elements at index 2 - fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("After removing 3 elements at index 2 - dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Após o processo de remoção, use "ArrayPrint" para imprimir os elementos de "fixedSizeArray" e "dynamicArray".
  

Saída:

 

A saída do código dado é mostrada na imagem acima, que mostra como a função “ArrayRemove()” se comporta com arrays estáticos e dinâmicos. No caso do array dinâmico, o procedimento é muito simples: envolve apenas a exclusão dos elementos especificados no índice designado. Para preencher os espaços vazios criados pela remoção, a função para o array estático duplica os elementos que aparecem após o final do array. Esse comportamento sutil demonstra a forma como o “ArrayRemove()” se ajusta a diferentes tipos de arrays.

Os conceitos de “ArrayRemove()” ficarão mais claros à medida que trabalharmos nesses artigos e entrarmos em exemplos do mundo real. Por favor, não hesite em fazer mais perguntas; juntos, continuaremos a explorar e entender esses conceitos.

6. ArraySwap

A função “ArraySwap()” na programação MQL5 tem como objetivo trocar todo o conteúdo de dois arrays dinâmicos. Todos os elementos entre dois arrays podem ser trocados mais facilmente com a ajuda dessa função. Ela oferece uma maneira simples de trocar todo o conjunto de dados entre arrays, o que acelera o processo de reorganização do conteúdo dos arrays no MQL5.

Analogia

Imagine que você tem duas estantes cheias de livros. A função "ArraySwap()" permite trocar todos os livros de uma prateleira por todos os outros livros, como um feitiço de um mago. Para fazer com que todos os livros da “Prateleira A” se movam para a “Prateleira B” e todos os livros da “Prateleira B” se movam para a “Prateleira A”, você pode usar o feitiço “ArraySwap()” se você tiver a “Prateleira A” abastecida com alguns livros e a “Prateleira B” abastecida com outros livros. É uma maneira fácil de trocar todos os livros em duas prateleiras sem se preocupar com livros específicos.

Síntaxe:

ArraySwap(dynamic_array1, dynamic_array2);

Parâmetros:

Imagine que você tem duas estantes cheias de livros. A função "ArraySwap()" permite trocar todos os livros de uma prateleira por todos os outros livros, como um feitiço de um mago. Para fazer com que todos os livros da “Prateleira A” se movam para a “Prateleira B” e todos os livros da “Prateleira B” se movam para a “Prateleira A”, você pode usar o feitiço “ArraySwap()” se você tiver a “Prateleira A” abastecida com alguns livros e a “Prateleira B” abastecida com outros livros. É uma maneira fácil de trocar todos os livros em duas prateleiras sem se preocupar com livros específicos.

Exemplo:

void OnStart()
  {

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);
  }

Explicação:

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

• Os arrays dinâmicos de inteiros "dynamic_array1" e "dynamic_array2" são declarados nessas linhas. O tamanho de cada array dinâmico é definido para 5 usando a função “ArrayResize”.
  

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

• Essas linhas atribuem a cada elemento em “dynamic_array1” e “dynamic_array2” um valor específico.
  

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Essas linhas imprimem os valores iniciais de “dynamic_array1” e “dynamic_array2” no console.
  

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

• Para substituir todo o conteúdo de “dynamic_array1” por “dynamic_array2”, utilize a função “ArraySwap()”.
  

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Após o processo de troca, essas linhas imprimem os valores atualizados de “dynamic_array1” e “dynamic_array2” no console.
  

Saída:

7. ArrayReverse

Os elementos de um array podem ser reorganizados ou invertidos usando a função "ArrayReverse()". Com a ajuda dessa função, os desenvolvedores podem rapidamente inverter os elementos na sequência, fazendo com que o último elemento se torne o primeiro e vice-versa. Essa operação oferece uma maneira flexível e eficaz de alterar o arranjo dos elementos dentro de arrays que contêm uma variedade de tipos de dados. Quando é necessário inverter a ordem dos elementos em um programa, "ArrayReverse()" simplifica o processo e resulta em um código mais conciso e legível.

Analogia

Imagine uma prateleira contendo uma fileira de livros, cada um com um número. É como se esses livros fossem magicamente reorganizados com a função "ArrayReverse()", fazendo com que o livro mais à direita ficasse agora na extrema esquerda, e vice-versa. É um método simples para mudar a ordem dos livros na sua prateleira. Da mesma forma, isso funciona na programação, onde você pode usar "ArrayReverse()" para inverter a ordem dos itens em uma lista ou array, começando pelo último e indo até o primeiro. É como lançar um feitiço ao contrário no seu array, invertendo-o de maneira fácil.

Síntaxe:

ArrayReverse(array[], start, count);

Parâmetros: 

• array[]: O array que você deseja inverter é representado por este parâmetro.
• start: O índice dentro do array onde você deseja que a inversão comece.
• count: O número de elementos que devem ser invertidos no array.

Exemplo:

void OnStart()
  {

// Declare and initialize a 10-element array
   int array[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

// Print the original array
   Print("Original Array: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

// Reverse the array starting from index 4
   ArrayReverse(array, 4, WHOLE_ARRAY);

// Print the array after reversal
   Print("Array after reversal from index 4: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

  }

Este código inicializa o array com os elementos especificados, imprime o array original, inverte-o a partir do índice 4 e, em seguida, imprime o resultado.

Saída:

8. ArraySort

Para classificar os elementos de um array em ordem crescente, a função “ArraySort()” é uma ferramenta útil. Com o uso desta função, você pode rapidamente organizar os elementos de um array sequencialmente, começando com o menor valor e subindo até o maior. Essa função é especialmente útil ao trabalhar com arrays que contêm valores numéricos.

Analogia

Imagine que você deseja organizar ordenadamente uma coleção de números embaralhados do menor para o maior. Você pode rapidamente classificar esses números na ordem correta com a ajuda da função “ArraySort()”, que funciona como um feitiço mágico. Assim, você pode facilmente identificar os números menores e maiores na sua lista, usando um único e simples comando para classificar seus números de maneira organizada. Graças à magia da função “ArraySort()”, você pode ver os números de maneira compreensível e estruturada!

Síntaxe:

ArraySort(array[]); // array[] é o array que você deseja classificar em ordem crescente

Exemplo:

void OnStart()
  {

// Declare an array of numbers
   double array[5] = {9.5, 2.1, 7.8, 1.3, 5.6};

// Print the array before sorting
   Print("Array before sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

// Use ArraySort to arrange the array in ascending order
   ArraySort(array);

// Print the array after sorting
   Print("Array after sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

  }

Outpt:

Conclusão

Agora, cobrimos muitas das ideias principais para o gerenciamento de arrays no MQL5, incluindo ArrayPrint, ArrayInsert, ArraySize, ArrayRange, ArrayRemove, ArraySwap, ArrayReverse e ArraySort. O objetivo é abordar uma ampla gama de ideias essenciais que servem como base para a automação de estratégias de negociação à medida que avançamos nesta série. É fundamental entender essas funções de arrays, especialmente ao trabalhar com dados históricos para criar expert advisors. Independentemente do nível de experiência, prometo garantir que todos os leitores dominem esses conceitos fundamentais, estabelecendo as bases para uma jornada gratificante na programação MQL5 e na negociação algorítmica. 

Ao concluirmos este artigo, incentivo a todos a abordarem cada ideia com paciência e curiosidade, pois esses blocos de construção básicos serão importantes em artigos futuros e tornarão o desenvolvimento de sistemas de negociação automatizados robustos tanto recompensador quanto acessível. A sua compreensão é a minha principal prioridade, então, por favor, não hesite em entrar em contato e fazer perguntas se precisar de assistência ou esclarecimento em qualquer parte deste artigo. No próximo artigo, faremos uma sessão de vídeo detalhada para cobrir todos os aspectos das funções de arrays discutidas nas Partes 5 e 6. Este vídeo oferece um manual visual para melhorar sua compreensão desses conceitos cruciais da programação em MQL5 e esclarecer qualquer dúvida restante.