Aprendendo MQL5 do iniciante ao profissional (Parte I): Comecemos a programar

Introdução

Às vezes, recebo mensagens privadas de pessoas que querem aprender a escrever seus próprios EA ou indicadores. E, embora existam diversidade de materiais disponíveis, tanto neste site quanto na internet em geral, incluindo alguns muito bons, as pessoas sentem falta de algo. Alguns precisam de consistência, outros de clareza, outros ainda de algo mais... Às vezes pedem: "Comente o código de um EA que esteja funcionando, eu entenderei tudo e farei um igual!"... Mas, ao verem uma centena de linhas de código, ficam assustados, confusos e dizem: "Ah, isso é muito complicado... Melhor você fazer um EA para mim".

No entanto, para alguns o desejo de "entender tudo" nunca desaparece. É nesse momento que um guia passo a passo do simples ao complexo pode vir a ser útil. Mas justamente um guia passo a passo para a linguagem MQL5 é algo que não se encontra facilmente.

Todos os guias (que conheço) presumem que a pessoa já tem alguma experiência com programação, entende como funciona e apenas precisa entender alguns nuances para ter sucesso.

Estou começando esta série de artigos especialmente para iniciantes, aqueles que estão se iniciam na programação, e querem entender. Aqui quero guiar os traders detalhadamente, de forma sequencial, com ilustrações, do simples ao complexo, até se tornarem "usuários confiantes" da linguagem MQL5.

E essa linguagem permite não apenas automatizar a negociação, mas também resolver outras tarefas relacionadas ao trader. Por exemplo, com ela é possível plotar indicadores, resultados de otimização, quaisquer figuras além das padrões, etc., criar qualquer tipo de arquivo, como listas de cotações tick por tick ou capturas de tela da situação atual do mercado, enviar mensagens para Telegram e outros bots, trabalhar com bancos de dados e muito mais.

Gradualmente, quero dar a conhecer o máximo de possibilidades da linguagem: desde o uso de "símbolos virtuais" até o trabalho com bibliotecas matemáticas e... muito mais. Mas aqui e agora começo com os fundamentos.

Termos técnicos básicos

Quase todos os computadores modernos são construídos com base na arquitetura de Von Neumann (ou às vezes escrita como Von-Neumann). E para interpretar a literatura corretamente, é preciso entender os termos que os programadores usam.

• Processador central (ou simplesmente "Processador" ou CPU). Este módulo é responsável por todos os cálculos e lógica.
• Memória RAM (frequentemente referida simplesmente como "Memória" ou RAM). Na memória são armazenados os dados e os programas. Quando o computador é desligado ou após o término de um programa, os dados na memória RAM são apagados.
  
• Dispositivos de armazenamento externos (discos rígidos, pen drives, SSDs...) O processador é capaz de gravar dados neles em forma de arquivos.
  
• Os arquivos são informações gravadas em dispositivos de armazenamento externos (não na memória RAM).
• Fluxo de execução. Durante o funcionamento, o processador retira dados da memória, "entende" se é um comando ou dados, executa o comando e grava os resultados de volta na memória ou em um dispositivo externo, conforme indicado pelo programa em execução. E então lê o próximo segmento de memória, e assim por diante, até que o programa termine. Todo esse processo é chamado de "fluxo de execução".
  

Para medir informações, foram inventadas as seguintes unidades especiais.

• Bit — a unidade mais básica de informação. Essencialmente, é um "interruptor" que determina o estado da parte mais minúscula da memória. Contém "0" ("desligado") ou "1" ("ligado").
• Byte — em inglês pode ser traduzido como "sílaba", e é o menor "pacote" de informação, igual a 8 bits. Quando os computadores eram grandes e ocupavam andares inteiros, e os volumes de memória RAM eram minúsculos, e os arquivos eram armazenados em cartões perfurados, 8 bits se mostraram o melhor compromisso técnico entre velocidade (podendo ler até 8 furos de uma vez!) e tamanho do meio de armazenamento.
  

Para um programador, é importante entender quanto espaço seu programa ocupará. No mundo moderno, os programas (e especialmente seus dados) geralmente "pesam" bastante, por isso ao termo "byte" são adicionados prefixos "ampliadores".

Ao medir quantidades físicas, não informacionais, cada um desses prefixos indica um aumento do tamanho anterior em 1000 vezes. Por exemplo, um quilômetro é igual a 1000 metros, e um megavolt é 1000 quilovolts ou 1 000 000 volts.

Quando falamos especificamente sobre dados de computador, cada tamanho é maior que o anterior em 1024 vezes.

Assim, kilobyte (KB, Kb) é igual a 1024 bytes, megabyte (MB, Mb) conterá 1024 kilobytes), e assim por diante.

Os próximos prefixos em ordem serão: giga-, tera-, peta-...

Exploraremos como os programadores gerenciam a memória, comandos ao processador, gravação de arquivos usando MQL5 e outras coisas rotineiras muito mais tarde, nos próximos artigos.

Os termos em negrito serão encontrados constantemente nos artigos, por isso os descrevo aqui, no início. Apresentarei os demais termos no momento em que eles forem necessários. Embora não possa avançar sem todos eles, tentarei minimizá-los ao máximo.

Quais programas são necessários para começar a programar no MQL5

Para que um computador seja útil, é necessário escrever um programa para cada tipo de atividade: para negociação, visualização de imagens, ouvir música...

Escrever programas diretamente em comandos do processador... é possível. Mas muito improdutivo.

Por isso, no mundo moderno, muitos programas assistentes foram desenvolvidos para ajudar a transformar texto, escrito em linguagens próximas às humanas, em comandos compreensíveis para os processadores.

Aqui está uma lista reduzida desses programas para programadores:

1. Editor de texto: Esta é a ferramenta com a qual você escreve seu código. Qualquer um serve, desde que não adicione caracteres próprios além do texto que você digita. É muito conveniente quando o editor consegue destacar a sintaxe da linguagem que você está usando (neste caso — MQL5).

   Quando você instala o MetaTrader, um editor muito poderoso chamado MetaEditor é automaticamente instalado no sistema. Ele tem tudo o que é necessário.

   Entretanto, se por algum motivo você não gostar dele, poderá escolher qualquer outra opção. Por exemplo, um dos editores mais populares entre programadores é o Visual Studio Code (VSCode). Ele também pode ser configurado para trabalhar com MQL5 mediante plugins.

2. Compilador: O compilador converte o texto escrito pelo programador no editor em código de máquina. Somente após esta conversão o processador pode executar o código.

   Para a linguagem MQL5, o compilador está integrado no MetaEditor. Para outras linguagens, como C++, o compilador pode ser um programa separado.

   Algumas linguagens, como Python, não têm um compilador claramente definido. Elas executam o texto a partir do seu arquivo diretamente.

   O programa que lê os arquivos para tais linguagens é chamado de "interpretador", e as próprias linguagens são chamadas de "interpretadas". No entanto, é importante entender que até os interpretadores eventualmente executam código de máquina. A conversão de texto para código apenas não é tão explícita.
   

3. Depurador: Trata-se de uma ferramenta para encontrar e corrigir erros em seu programa. Permite executar o código passo a passo e verificar os dados com os quais seu programa está trabalhando a cada momento específico, em cada passo.

   No MetaEditor, o depurador é integrado.

4. Sistema de controle de versões (Version Control System, VCS): Ajuda a acompanhar as mudanças no seu código.

   Se você escreveu muito código e de repente percebeu que a versão de um dia atrás funcionava muito melhor, e que realmente precisa tomar outro caminho, o VCS permite "reverter" para um estado anterior do arquivo (ou mesmo do projeto inteiro) com apenas alguns cliques ou comandos de texto do teclado.

   E o mais importante, o VCS geralmente salva os dados em um servidor remoto, não no seu computador local, o que garante que, se ocorrer uma falha (por exemplo, o disco rígido falhar), você poderá recuperar seu trabalho rapidamente.

   Esses dois fatores importantes tornaram os diferentes sistemas de controle de versão praticamente obrigatórios para o trabalho corporativo, pois também permitem facilitar a colaboração com outros desenvolvedores. Entretanto, o hábito de usar essas ferramentas também é muito útil para trabalho independente, porque... acidentes acontecem.

   Existem ferramentas de terceiros, como o Git.

   No entanto, tal recurso também está integrado ao MetaEditor, e para um iniciante, as capacidades do VCS integrado serão mais do que suficientes inicialmente.

Essas são as ferramentas sem as quais a programação moderna é difícil de imaginar. Às vezes acontece de todas essas ferramentas serem usadas separadamente pelos programadores. Mas no mundo moderno isso é relativamente raro. Mais comumente, são usados programas como o MetaEditor, que inclui todas essas funcionalidades de uma vez (e até mais).

Programas que incluem todos os componentes mencionados anteriormente (editor de texto, compilador, depurador...) são chamados de ambiente de desenvolvimento integrado (IDE).

Principais tipos de programas MQL

Os programas executados no MetaTrader podem ser divididos em quatro tipos:

1. Scripts. Podem exibir qualquer informação, negociar, mostrar objetos gráficos... Mas para executar um script, é necessário iniciá-lo novamente a cada vez.
   
2. Indicadores. Destinados a mostrar informações importantes para a estratégia de negociação em cada tick. Entretanto, eles não podem negociar por conta própria.
3. EA (também chamados de "experts", robôs de investimento, etc.). São programas destinados à negociação. Assim como os indicadores, são executados a cada tick, mas suas ferramentas para desenhar setas elegantes ou linhas úteis são limitadas.
4. Serviços. Ao contrário de todos os tipos anteriores de programas, os serviços não requerem um gráfico específico para funcionar. Eles são iniciados uma vez quando o terminal é iniciado. Podem permanecer na memória até que o terminal seja fechado (e até um pouco depois disso), mas não podem reagir a eventos do terminal, como a chegada de um novo tick ou um clique do mouse.

Comparação de programas disponíveis no MQL5

Tudo sobre o uso de programas no MQL5 pode ser resumido em uma tabela simples:

Tabela 1. Comparação das capacidades dos principais tipos de programas MQL5.

Recursos dos programas	Scripts	Indicadores	EA	Serviços
Vinculados a um gráfico específico	sim	sim	sim	não
Podem negociar	sim	não	sim	sim
Descarregados da memória ao mudar o intervalo de tempo	sim	sim	sim	não
Executados em cada tick	não	sim	sim	não
Ativados uma vez ao abrir o terminal	não	não	não	sim
Funcionam enquanto a janela do gráfico estiver aberta	não	sim	sim	não
Podem processar diferentes eventos do terminal ou do gráfico	não	sim	sim	não
Podem iniciar e parar um temporizador	não	sim	sim	não
Funções de inicialização e desinicialização são chamadas automaticamente	não	sim	sim	não
Apenas um instância do programa pode ser executada no gráfico	sim	não	sim	—

Funções

Cada programa deve fazer algo, ou seja, executar algumas funções.

Uma função é um conjunto de ações do programa que levam a algum resultado (muitas vezes elementar). Por exemplo, imprimir uma linha de texto, desenhar uma letra, abrir uma negociação...

Alguns idiomas de programação não exigem a descrição das funções explicitamente. No MQL5, essa descrição é obrigatória: cada programa deve ter pelo menos uma função inicial descrita, caso contrário, haverá uma mensagem de erro. Embora os nomes das funções iniciais possam variar para cada tipo de programa, de qualquer forma, as funções devem existir, caso contrário, o programa se torna inútil, pois não faz absolutamente nada.

Quase qualquer linguagem de programação permite criar suas próprias funções personalizadas, para isolar trechos de código que se repetem e depois reutilizá-los com uma linha, em vez de reescrever tudo novamente. Além disso, em qualquer linguagem, sempre há um conjunto de funções predefinidas. Essas funções predefinidas diferenciam uma linguagem de programação de todas as outras.

Basicamente, a discussão sobre uma linguagem se resume a uma tentativa de descrever de alguma forma quais funções são predefinidas e como usá-las da melhor forma possível para obter um resultado útil para o usuário.

MQL5 não é exceção. Ele contém um conjunto de funções embutidas e permite a criação de funções personalizadas. É muito conveniente usar a ajuda contextual para aprender sobre as funções embutidas da linguagem. Para acessá-la, basta abrir qualquer código (mesmo de outra pessoa) no MetaEditor, clicar em qualquer palavra destacada em cor e pressionar a tecla <F1>.

Algumas funções embutidas não podem ser chamadas a partir de alguns tipos de programas. Como já mencionado, algumas precisam ser implementadas exatamente como descrito na ajuda, e diferentes funções serão necessárias em diferentes tipos de programas.

Mas, fora isso, nossa criatividade é quase ilimitada. Podemos criar quaisquer funções auxiliares, organizá-las como acharmos conveniente, e até usar funções descritas em outras linguagens, como C++ ou Python. E certamente voltaremos a estas possibilidades em futuros artigos.

Mas agora começaremos com o mais simples que MQL5 permite criar: um script que é executado uma vez quando arrastado para um gráfico com o mouse. Com a função padrão do idioma MQL neste script, simplesmente exibiremos uma mensagem de texto padrão no painel inferior do terminal para o usuário.

Iniciando e configurando o IDE

Agora chegamos à prática! Faremos todo o trabalho no MetaEditor. Você pode iniciá-lo usando um atalho (na área de trabalho ou no menu "Iniciar"), ou diretamente a partir do terminal MetaTrader — de uma das maneiras mostradas na imagem (figura 1).

.

Figura 1. Três maneiras de abrir o MetaEditor: 1 — botão na barra de ferramentas, 2 — menu, 3 — tecla de atalho (F4)

Após a janela do editor aparecer, recomendo imediatamente inserir seu login e senha do site mql5.com (ou, se você ainda não está registrado, faça isso). O registro permitirá salvar seus projetos diretamente no servidor, usando o programa de controle de versões embutido no MetaEditor. Dessa forma, seus arquivos salvos não serão vistos por ninguém, a menos que você mesmo abra o acesso, por conseguinte, salvar seu trabalho na nuvem da MetaQuotes é seguro, tanto quanto pode ser o armazenamento de informações na Internet, e é uma boa prática (manter seu trabalho não apenas em seu computador).

Figura 2. Diálogo de autenticação na comunidade MQL5.com

Para acessar o diálogo de autenticação, selecione no menu principal da janela do editor "Ferramentas -> Configurações" e vá para a aba "Comunidade". Este ajuste precisa ser feito uma vez. Depois, os dados inseridos serão salvos, e você poderá trabalhar com o sistema de controle de versões e outros serviços úteis do MQL sem se preocupar com a autenticação por muito tempo.

O primeiro Script

E agora... Simplesmente clique com o botão direito na pasta no painel esquerdo onde queremos criar o script, e selecione "Novo arquivo"... Ou use o atalho de teclado <Ctrl>+<N>... Na janela que aparece, selecione "Script", e na próxima, insira o nome do arquivo...

Figura 3. Métodos de criação de um novo arquivo.

Figura 4. Diálogo do "assistente" de criação de arquivo — escolha do tipo de programa a ser criado.

Figura 5. Diálogo do "assistente" de criação de arquivo — digite o nome do programa a ser criado.

E, finalmente, temos uma nova janela com o seguinte conteúdo:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   
  }
//+------------------------------------------------------------------+

Exemplo 1. Modelo de script gerado pelo "assistente".

Parece simples, apenas 17 linhas, pode-se dar uma olhada de uma vez só...

Vamos analisar o que exatamente está escrito aqui.

• Primeiramente, há várias linhas que começam com os caracteres de barra dupla ( // ). Linhas semelhantes também aparecem no meio do programa.

Estas são comentários. Eles são escritos para pessoas, e o compilador os ignora completamente ao gerar o bytecode. Comentários que começam com duas barras são chamados de comentários de linha única. Devem ser colocados no final da linha. A regra é muito simples: tudo que está antes das duas barras, o compilador considera código; tudo que está depois — texto para humanos.

Neste modelo criado pelo assistente, o código "antes" neste contexto simplesmente não foi necessário.

No MetaEditor, você pode comentar rapidamente várias linhas: selecione-as e pressione a combinação de teclas "<Ctrl>+< ' > (Ctrl + apóstrofo). Para descomentar essas linhas, é necessário selecioná-las novamente e pressionar a combinação <Ctrl>+< ; >.

Também existem comentários de múltiplas linhas. Eles começam com os caracteres " /* " e terminam com a sequência reversa " */ ". Comentários de múltiplas linhas podem ser inseridos em qualquer parte do código onde seja permitido um espaço. Durante a compilação, o compilador também "descarta" essas sequências primeiro, e depois tenta entender "o que o autor quis dizer".

Na prática, comentários no meio do código são inseridos bastante raramente. Geralmente isso é simplesmente inconveniente. Mas comentar grandes blocos de código desnecessário ou descrever "cabeçalhos" de funções com eles é um verdadeiro prazer.

Eis como poderia parecer o "cabeçalho" deste arquivo usando um comentário de múltiplas linhas (se eu o escrevesse, não a automação do MetaEditor):

/*
                                                   HelloWorld.mq5 
                                       Oleg Fedorov (aka certain) 
                                   mailto:[e-mail] 
*/

Exemplo 2. Comentários de múltiplas linhas.

Ou assim:

/*******************************************************************
 *                                                  HelloWorld.mq5 *
 *                                      Oleg Fedorov (aka certain) *
 *                                  mailto:[e-mail] *
 *******************************************************************/

Exemplo 3. Comentários de múltiplas linhas decorados.

Em geral, entre os sinais /* e */ (ou depois de //) pode estar qualquer texto, em qualquer idioma, já que os editores modernos suportam plenamente a codificação Unicode. Porém, ainda é recomendável usar o inglês, pois isso economiza tempo na troca de layouts de teclado (o que em grandes projetos é essencial).

• O segundo bloco que chama nossa atenção são as linhas que começam com o sinal " # ". Nesse arquivo, as palavras iniciais em cada linha desse bloco são #property .

De modo geral, toda qualquer palavra que comece com um sinal de cerquilha é uma diretiva de pré-processador. Antes de transformar o texto em código de máquina, o compilador não só precisa descartar todos os comentários. Ele também precisa fazer outros preparativos. Normalmente, há bastante trabalho preparatório, porque em grandes projetos é necessário compilar o projeto a partir de vários arquivos, definir alguns dados (geralmente constantes como o número π ou algo semelhante, embora haja casos mais complexos) e assim por diante. Mas trataremos de todas essas diretivas muito mais tarde.

Por enquanto, para entender o código recebido, basta saber que a diretiva #property descreve uma propriedade do programa resultante. Na maioria das vezes, essas "propriedades" afetam a janela inicial, que aparece logo após o usuário iniciar nosso programa, arrastando seu ícone para o gráfico.

Para ilustrar isso, vamos adicionar mais uma linha ao código:

#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
#property script_show_inputs

Exemplo 4. Adição da propriedade script_show_inputs.

Essa linha permitirá que a janela de propriedades apareça, e só então o código principal começará a ser executado. Se essa linha não estiver presente, o script começará a ser executado imediatamente sem exibir nenhuma mensagem. Os parâmetros, se houver, serão usados com valores padrão.

Então, após adicionar a linha necessária no local correto do arquivo (logo após a propriedade version), vamos realizar a primeira compilação de nosso programa.

Escolha um dos métodos mostrados na figura (por exemplo, pressione a tecla <F7>).

Figura 6. Várias maneiras de compilar o programa.

Alguns segundos de espera... E eis que o programa está compilado (figura 7).

Figura 7. Resultados da compilação. Neste caso, a compilação foi bem-sucedida (0 erros), levou 527 milissegundos, e o bytecode foi criado para um processador de 64 bits.

A figura 9 mostra que a compilação foi bem-sucedida. Se houvesse erros no arquivo de texto, as mensagens sobre eles apareceriam nesta mesma janela.

Após a compilação, o ícone do script aparecerá automaticamente na lista de scripts do seu terminal de negociação. Para alternar para o terminal, você pode, por exemplo, pressionar a tecla <F4> no editor. Isso economizará um pouco de tempo.

Arraste o script com o mouse para o gráfico e você poderá ver a janela de propriedades.

Figura 8. Janela de parâmetros do script.
(1) No canto superior direito da janela principal, aparece o ícone do script em execução.
(2) Na aba "Comum", você pode ver como as propriedades descritas pelas diretivas #property são usadas.
(3) O MetaEditor adicionou parâmetros extras ao endereço especificado na propriedade "link",
provavelmente para ajudar a entender de onde os visitantes estão vindo, caso o link seja para um site.

Vamos fechar a janela, voltar ao editor e tentar persuadir o script a fazer algo útil, como exibir uma mensagem para o usuário.

Para isso, vamos comentar a linha que exibe a janela de parâmetros (afinal, ainda não temos nada para alterar, certo?) e adicionar outra que escreve a mensagem:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//#property script_show_inputs

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   Print("Hello, MQL5 world!");
  }
//+------------------------------------------------------------------+

Exemplo 5. Script que imprime uma linha no log do usuário.

• Agora preste atenção nas palavras predefinidas.

No código atual, as palavras predefinidas são #property, copyright, link, version, void, OnStart, Print. Tente clicar em qualquer uma delas no editor MetaEditor e pressione <F1> para chamar a ajuda embutida.

• Dentro da função OnStart gerada pelo assistente, nós chamamos outra função padrão, Print, e através dos parâmetros (também chamados argumentos), listados entre parênteses, instruímos sobre o que exatamente imprimir.

No exemplo 5, a função Print recebe apenas um argumento: o texto que está entre aspas. No caso geral, entretanto, pode haver mais de um argumento desse tipo. Assim, a mesma função Print pode ser chamada com qualquer número de parâmetros (até 64).

Se for necessário passar vários parâmetros para qualquer função, eles devem ser listados separados por vírgulas, como no exemplo 6:

Print("Привет, мир MQL5!", " Я написал собственную программу. ", "Ура!");

Exemplo 6. Função que recebe três parâmetros

Após cada vírgula que separa os parâmetros, você pode adicionar um caractere de quebra de linha (tecla <Enter>) para não se confundir com as aspas.

E também preste atenção nos espaços dentro do segundo argumento. Isso porque a função Print "concatena" seus argumentos em uma grande string, então o programador precisa cuidar de todos os sinais de pontuação e espaçadores adicionais entre as palavras por conta própria.

A função OnStart é executada automaticamente, uma vez, no início dos scripts e serviços.

Compilamos e executamos o programa da maneira já conhecida.

Figura 9. Primeira tarefa útil: exibir uma linha no log.

Conclusão

Em EA e indicadores também existem funções predefinidas, mas com nomes diferentes. O princípio de funcionamento é o mesmo que o das funções de scripts: nosso código é escrito principalmente dentro, e as propriedades, fora. Mas há diferenças.

Algumas funções em EA e indicadores são executadas pelo terminal a cada tick, não apenas uma vez, como OnStart.

Por isso, sugiro a quem quiser verificar o que aprendeu com o artigo (e para reforçar o conhecimento) que realize pequenas "pesquisas domésticas":

1. Use o assistente de criação de arquivos para gerar todos os outros tipos de programas não cobertos pelos exemplos deste artigo.
   
2. Pense se, com os meios descritos no artigo, é possível descobrir quais funções são chamadas e em que ordem no início de cada tipo de programa.
3. Para os curiosos, vejam o que acontecerá se:
   
• adicionar a função OnStart a indicadores e EA;
• adicionar aos scripts e serviços as funções que o assistente cria para outros tipos de programas;
  

Essas pesquisas podem trazer novas ideias ou, quem sabe, uma compreensão mais profunda de como os programas no MQL5 funcionam realmente.

Desejo a você sucesso. E até breve nos próximos artigos da série!