4D tem três categorias de variáveis:

• variáveis locais,
• variáveis de processo
• variáveis de interprocessos.

Para mais informações sobre este ponto, consulte a seção Variáveis. Processos e variáveis interprocesso são estruturalmente o mesmo para o compilador.

Desde que o compilador não pode determinar o processo no qual a variável será utilizada, variáveis do processo devem ser usadas com mais cuidado do que variáveis de processos. Todas as variáveis do processo são sistematicamente repetidas quando um novo processo começa. A variável de processo pode ter um valor diferente em cada processo, mas tem o mesmo tipo para todo o banco de dados.

Todas as variáveis têm um tipo. Conforme descrito na seção RELATE MANY, existem 13 diferentes tipos de variáveis:

Para as variáveis de tipo Array, dispõem dos seguintes tipos:

Abaixo os diferentes tipos de arrays

Notas:
- O tipo "objeto" está disponível a partir de 4D v14.
- O tipo "coleção" está disponível a partir de 4D v16 R4.
- O tipo "Variant" está disponível a partir de 4D v18.
- Os tipos anteriores Alfa (string de tamanho fixo) e Inteiro não se usam mais para as variáveis. No código existente, säo redigidas automaticamente aos tipo Texto e Inteiro Longo.

Em modo interpretado, uma variável pode ter mais de um tipo de dados. Isso é possível porque o código é interpretado e não compilado. 4D interpreta cada instrução separadamente, e compreende o seu contexto. Quando você trabalha em um ambiente de compilação, a situação é diferente. Embora a interpretação é realizada linha por linha, o processo de compilação olha para um banco de dados na sua totalidade.

A abordagem do compilador é a seguinte:

• O compilador analisa sistematicamente os objetos no banco de dados. Os objetos são os métodos de banco de dados, projeto, formulário, trigger e métodos de objeto.
• O compilador verifica os objetos para determinar o tipo de dados de cada variável no banco de dados, e gera a tabela de variáveis e métodos (tabela de símbolos).
• Uma vez estabelecidos os tipos de dados de todas as variáveis, o compilador converte (compila) o banco de dados. No entanto, ele não pode compilar o banco de dados, a menos que possa determinar o tipo de dados para cada uma das variáveis.

Se o compilador vem através do mesmo nome de variável e dois tipos de dados diferentes, não há nenhuma razão para favorecer qualquer um em particular. Em outras palavras, para um tipo de objeto e dar-lhe um endereço de memória, o compilador deve saber a identidade exata daquele objeto (ou seja, o seu nome e tipo de dados). O compilador determina o tamanho do tipo de dados. Para cada banco de dados compilado, o compilador cria um mapa que relaciona, para cada variável, o seu nome (ou identificador), a sua localização (ou endereço de memória), e o espaço que ocupa (indicado pelo seu tipo de dados). Este mapa é chamado de tabela de símbolos. Uma opção em Preferências permite que você escolha se deseja gerar esta tabela na forma de um arquivo durante a compilação.

Este mapa é também utilizado para a geração automática dos métodos de compilação.

Se você quiser que o compilador verifique a digitação de suas variáveis ou digitá-las em si, é fácil colocar uma diretiva de compilador para essa finalidade. Você pode escolher entre duas possibilidades diferentes, dependendo do seu método de trabalho:

• Ou use a diretiva no método em que a variável aparece pela primeira vez, dependendo se é local, processo ou variável interprocessos. Certifique-se de usar a diretiva da primeira vez que você usar a variável, no primeiro método a ser executado. Tenha em mente que durante a compilação, o compilador tem os métodos na ordem de sua criação, em 4D, e não na ordem em que são exibidos no Explorer.
• Ou, se for sistemático em sua abordagem, agrupe todas as variáveis de processo e interprocesso com as diferentes diretivas de compilador no método ou em um método chamado por .
  Para as variáveis locais, agrupe as diretivas no início do método em que elas aparecem.

Quando as variáveis ​​são digitadas por meio de uma diretiva de compilador, recebem um valor padrão, que elas vão manter durante a sessão desde que não tenham sido atribuídas.

O valor padrão depende do tipo de variável e categoria, o seu contexto de execução (interpretada ou compilada), bem como, para o modo compilado, as opções de compilação definidas em DOM Append XML child node das configurações de banco de dados:

• As variáveis ​​do processo e entre processos são sempre definidas como "zero" (o que significa que, dependendo do caso, "0", uma string vazia, uma Blob vazia, um ponteiro Nil, uma data em branco (00-00-00), etc)
• As variáveis ​​locais são definidas:
  
  • em modo interpretado: a zero
  • em modo compilado, dependendo da opção Inicializar variáveis ​​locais das configurações de banco de dados:
    
    • a zero quando "a zero" é escolhido,,
    • para um valor aleatório definido quando "a um valor aleatório" é escolhido (0x72677267 para números e horas, sempre TRUE para Booleans, o mesmo que "a zero" para os outros),
    • para um valor aleatório (para números) quando "não" for escolhido.

                      .
A tabela a seguir ilustra esses valores padrão:

Diretivas do compilador são úteis em dois casos:
• O compilador é incapaz de determinar o tipo de dados de uma variável de seu contexto,
• Você não quer que o compilador determine o tipo de uma variável para sua utilização.
Além disso, usar diretivas de compilador permite reduzir o tempo de compilação.

Às vezes o compilador não pode determinar o tipo de dados de uma variável. Sempre que não pode fazer uma determinação, o compilador gera uma mensagem de erro apropriada.
Existem três principais causas que impedem o compilador de determinar o tipo de dados: vários tipos de dados, a ambigüidade em uma dedução forçada e a impossibilidade de determinar um tipo de dados.

• Vários tipos de dados
  Se uma variável tem tido o tipo retribuído de declarações diferentes no banco de dados, o compilador gera um erro que é fácil de corrigir.
  O compilador seleciona a primeira variável que encontra e arbitrariamente atribui a seu tipo de dados para a próxima ocorrência da variável com o mesmo nome, mas um tipo de dados diferente.
  
  Aqui está um exemplo simples:

no método A,

no método B,

Se o método A é compilado antes o método B, o compilador considera a declaração Variável: = "A lua é verde" como uma mudança de tipo de dados em uma variável anteriormente encontrada. O compilador avisa que uma redefinição de tipo ocorreu. Ele gera um erro para você corrigir. Na maioria dos casos, o problema pode ser corrigido por renomear a segunda ocorrência da variável.

• Ambigüidade em uma dedução forçada
  Às vezes, devido a uma seqüência, o compilador pode deduzir que um tipo de objeto não é do tipo adequado para ele. Neste caso, você deve explicitamente digitar o tipo da variável com uma diretiva do compilador.
  
  Aqui está um exemplo usando os valores padrão para um objeto ativo:
  Em um formulário, você pode atribuir valores padrão para os seguintes objetos: caixas de combinação, menus pop-up, controles de guia para listas , menus / listas drop-down e áreas roláveis usando o botão Editar para a Lista de Valores (sob o tema Controle de Entrada da lista de propriedades) (para mais informações, consulte o manual de referência Desenho 4D). Os valores padrão são automaticamente carregados em um array cujo nome é o mesmo que o nome do objeto.
  Se o objeto não é usado em um método, o compilador pode inferir o tipo, sem ambiguidade, como um array de texto.
  No entanto, se uma inicialização de exibição deve ser realizada, a seqüência poderia ser:

Neste caso, a ambigüidade aparece - quando os métodos de análise, o compilador irá inferir um tipo de dados reais para o objeto MyPopUp. Neste caso, é necessário declarar explicitamente o array no método de formulário ou em um método de compilador:

• Incapacidade de determinar um tipo de dados
Este caso pode surgir quando uma variável é usada sem ter sido declarada, dentro de um contexto que não fornecem informações sobre o tipo de dados. Aqui, só uma diretiva do compilador pode guiar o compilador.
Este fenômeno ocorre principalmente nos quatro contextos:
- quando os ponteiros são usados,
- quando você usa um comando com mais de uma sintaxe,
- quando você usar um comando com parâmetros opcionais ou diferentes tipos de dados,
- quando você usa um método 4D chamado através de uma URL.

- Ponteiros
Um ponteiro não pode esperar para retornar um tipo de dados que não sejam seus.
Considere a seguinte seqüência:

Embora (2) define o tipo de variável apontada pelo ponteiro, o tipo de Var2 não está determinada. Durante a compilação, o compilador pode reconhecer um ponteiro, mas não tem como saber que tipo de variável ele está apontando. Portanto, você não pode deduzir o tipo de dados Var2. Uma diretiva de compilador é necessária, por exemplo C_REAL (var2).

- Comandos Multi-sintaxe
Quando você usa uma variável associada com a função de Year of, a variável só pode ser do tipo de dados Date, considerando a natureza desta função. No entanto, as coisas nem sempre são tão simples. Aqui está um exemplo:
O comando GET FIELD PROPERTIES aceita duas sintaxes:
GET FIELD PROPERTIES(tabelaNo;campoNo;Tipo;comprimento;indice)
GET FIELD PROPERTIES(campoPonteiro;Tipo;comprimento;indice)

Quando você um comando de multi-sintaxe - o compilador não pode adivinhar qual a sintaxe e os parâmetros que você selecionou. Você deve usar diretivas de compilador de variáveis de tipo passadas para o comando, se não forem digitadas de acordo com a sua utilização em outras partes do banco de dados.

- Comandos com parâmetros opcionais de diferentes tipos de dados
Quando você usa um comando que contém vários parâmetros opcionais de dados de diferentes tipos, o compilador não pode determinar quais os parâmetros opcionais foram utilizados. Aqui está um exemplo:
O comando GET LIST ITEM aceita dois parâmetros opcionais: o primeiro como um Longint e o outro como um booleano.
O comando pode então ser utilizada da seguinte forma:
GET LIST ITEM(lista;posicao;itemRef;texto;sub-lista;expandido)
ou como:
GET LIST ITEM(lista;posicao;itemRef;texto;expandido)
Você deve usar diretivas de compilador de variáveis tipo opcionais passados para o comando, se não forem tipadas de acordo com a sua utilização em outras partes do banco de dados.

- Métodos chamados via URLs
Se você escrever métodos 4D que precisam ser chamados através de uma URL, e se você não usar $1 no método, você deve declarar explicitamente a variável de texto $1 com a seguinte seqüência:
C_TEXT($1)
Na verdade, o compilador não pode determinar que o método 4D será chamado através de uma URL.

Se todas as variáveis usadas no banco de dados são explicitamente declaradas, não é necessário para o compilador verificar a tipagem. Neste caso, você pode definir as opções para que o compilador execute somente a fase de tradução do método. Isso economiza pelo menos 50% em tempo de compilação.

Você pode acelerar seus métodos usando diretivas de compilador. Para mais detalhes sobre este assunto, consulte a seção Dicas de otimização. Para dar um exemplo simples, suponha que você precisa incrementar um contador utilizando uma variável local. Se você não declarar a variável, o compilador assume que é um Real. Se você declará-la como um Longint, o banco de dados compilado irá executar com mais eficiência. Em um PC, por exemplo, um Real tem 8 bytes, mas se você digitar o contador como um Longint, utilizará apenas 4 bytes. Incrementar um contador de 8 bytes, obviamente, demora mais do que um incremento de 4 bytes.

Directivas do compilador podem ser tratadas de duas maneiras diferentes, dependendo se você deseja ou não que o compilador atribua um tipo as suas variáveis.

O compilador deve respeitar os critérios de identificação das variáveis.
Há duas possibilidades:

• Se a variável não está digitada, o compilador pode fazer isso por você automaticamente. Sempre que possível - desde que não haja ambigüidade - o compilador determina um tipo de variável da forma como é utilizado. Por exemplo, se você escrever:

o compilador determina que a variável V1 é de tipo de dados Boolean.

Da mesma forma, se você escrever:

o compilador determina que V2 é uma variável do tipo texto.

O compilador também é capaz de estabelecer o tipo de dados de uma variável em situações menos simples:

O compilador também determina o tipo de dados das variáveis de acordo com as chamadas para os comandos 4D e de acordo com seus métodos. Por exemplo, se você passar um parâmetro do tipo Booleano e um parâmetro do tipo Data para um método, o compilador atribui o tipo booleano e o tipo data para as variáveis locais $1 e $2 no método chamado.

Quando o compilador determina o tipo de dados por inferência, salvo indicado o contrário nas preferências, nunca atribui os tipos de dados de limitação: Integer, Longint ou String. O tipo padrão atribuído pelo compilador é sempre o mais amplo possível. Por exemplo, se você escrever:

compilador designa o tipo de dados Número Real, apesar de 4 ser apenas um número inteiro. Em outras palavras, o compilador não descarta a possibilidade de que, noutras circunstâncias, o valor da variável poderia ser 4,5.

Se for apropriado para um tipo de variável como Integer, Longint ou String, você pode fazer isso usando uma diretiva de compilador. É a sua vantagem para fazer isso, porque estes tipos de dados ocupam menos memória e executar operações sobre elas é mais rápido.

Se você já digitou suas variáveis e está certo que a sua foi coerente e completo, você pode explicitamente pedir ao compilador para não refazer este trabalho, utilizando as preferências de compilação. No caso de a sua escrita não ter sido completa e exaustiva, no momento da compilação, o compilador retornará um erro solicitando que você faça as modificações necessárias.

• Os comandos diretiva de compilador permitem que você declare explicitamente as variáveis utilizadas nos bancos de dados.

Eles são utilizados da seguinte forma:

Através de tais diretivas, você informa o compilador para criar uma variável Var que vai ser um booleano.
Sempre que um aplicativo inclui diretivas de compilador, o compilador detecta-los e, assim, evita suposições.

Uma diretiva de compilador tem prioridade sobre as deduções feitas a partir de atribuições ou utilização.

Variáveis declaradas com a diretiva de compilador C_INTEGER são realmente as mesmas que as declaradas pela diretiva C_LONGINT. Eles são, na verdade, inteiros longos entre -2147483648 e 2147483647.

Se você não quiser que o compilador verifique a sua tipagem, você deve dar um código para identificar as directivas do compilador.
A convenção a seguir é:
Diretivas para o compilador e variáveis de processo e interprocesso e os parâmetros devem ser colocados em um ou mais métodos, cujos nomes começam com a palavra chave Compilador.
Por padrão, o compilador permite gerar automaticamente cinco tipos de métodos Compilador, que agrupam as diretrizes para as variáveis, matrizes e parâmetros do método (para mais informações sobre este ponto, consulte o manual de Projeto de Referência).

Nota: A sintaxe para declarar esses parâmetros é a seguinte:
Diretiva (nomeMétodo;Parametro). Esta sintaxe não é executável em modo interpretado.

Parâmetros particulares
• Parâmetros recebidos por métodos de banco de dados

• Triggers

• Objetos que aceitam o evento de formulário "On Drag Over"

Nota: O compilador não inicializar o parâmetro $0. Assim, logo que você usar o evento de formulário On Drag Over, você deve inicializar $0. Por exemplo:

Diretivas do compilador eliminam qualquer ambiguidade sobre os tipos de dados. Apesar de que um certo rigor é necessário, isso não significa necessariamente que o compilador é intolerante de toda e qualquer inconsistência.
Por exemplo, se você atribuir um valor real a uma variável declarada como um inteiro, o compilador não considera tanto a atribuição como um tipo de conflito e atribui os valores correspondentes de acordo com suas diretrizes. Então, se você escrever:

O compilador não considera isso como um conflito do tipo de dados que impedem a compilação, ao contrário, o compilador simplesmente arredonda para o valor inteiro mais próximo (3 em vez de 2,6).