Trabalhar com identificadores, sintaxe e variáveis

Concluído

Antes de começar a trabalhar com variáveis e funções, primeiro você precisa aprender alguns conceitos importantes. Identificadores, sintaxe e variáveis são conceitos centrais de AL e outras linguagens de programação.

Um identificador é o nome de um elemento de programação, enquanto uma variável é uma localização na memória em que os dados são armazenados. Você pode usar um identificador para atribuir um nome a sua variável, para que possa usá-la.

Sintaxe descreve as regras gramaticais para usar esses identificadores. A sintaxe dos identificadores é determinada pelo idioma do aplicativo e por algumas práticas recomendadas.

Algumas regras gramaticais estão em vigor para o uso de identificadores. Em um objeto, todos os identificadores devem ser exclusivos. Portanto, em um objeto, você não pode declarar duas variáveis com o mesmo identificador (ou nome).

Ao definir uma variável por um identificador, o primeiro caractere é, de preferência, um sublinhado ou uma letra. Ao usar um caractere especial ou um espaço no identificador, você deve colocar o identificador entre aspas duplas.

Como a linguagem de aplicativo não diferencia maiúsculas de minúsculas, ela não diferencia entre as letras maiúsculas e minúsculas nos identificadores. Recomendamos que você crie identificadores com PascalCase. PascalCase significa que você inicia o nome da variável com uma letra maiúscula. Se o seu nome for uma combinação de duas palavras, você iniciará a segunda palavra com uma letra maiúscula também. Por exemplo, se você tiver uma variável para armazenar o nome de um cliente, poderá usar CustomerName, que é um exemplo de notação de PascalCase.

Antes de trabalhar com variáveis, você precisa declará-las, o que significa que as variáveis devem:

• Ter um identificador

• Ter um escopo

• Ter um tipo de dados

• Ser inicializadas

Sua variável também precisa ter um escopo, o qual define onde você pode acessar e usar sua variável.

Uma variável pode ser definida com um escopo global ou local. Se você definir sua variável com um escopo global, a variável estará disponível em todos os lugares no objeto. Portanto, em cada gatilho, em todos os lugares em que você quiser escrever algumas instruções de código, essa variável estará disponível. Quando o escopo é local, você só pode acessar essa variável no gatilho específico no procedimento em que ela foi declarada.

No exemplo anterior, a variável Counter foi declarada com um escopo global e pode ser usada em todos os gatilhos e as funções na tabela MyTable. A variável CustomerName é definida no gatilho OnInsert; portanto, ela tem um escopo local. A variável só pode ser usada nesse gatilho e não pode ser chamada de outro gatilho. A definição de todas as variáveis com um escopo global pode ser mais fácil, mas essa variável pode ser usada em todos os gatilhos. Em seguida, a variável pode ser alterada em todos os gatilhos, o que pode levar a resultados indesejados ou não suspeitos. Dessa forma, quando você declarar variáveis, pense na definição do escopo e escolha a correta.

As variáveis definidas pelo sistema que são automaticamente definidas e mantidas pelo sistema também existem, e seu escopo também é definido pelo sistema. As variáveis Rec e xRec são exemplos de variáveis definidas pelo sistema. Rec dá acesso ao registro atual, e xRec concede acesso ao registro anterior (por exemplo, antes que uma atualização tenha ocorrido).

Uma variável sempre tem um tipo de dados específico. Ela pode ser um inteiro, um texto, um código, uma data, uma opção, e assim por diante. Quando uma variável é criada na memória, ela é inicializada, o que significa que a variável recebe um valor inicial padrão antes de você atribuir um valor a essa variável. Esse valor padrão depende do tipo de dados dessa variável.

Para variáveis com um tipo de dados numérico, um valor zero será usado para inicializar. As variáveis de cadeia de caracteres serão inicializadas com uma cadeia de caracteres vazia. Uma variável booliana tem um valor padrão false.

Até recentemente, cada variável tinha que ser declarada na própria linha. Em objetos maiores, isso gerava muitas páginas de declarações de variáveis, mesmo que a maioria delas fosse do mesmo tipo.

Para reduzir a rolagem, melhorar a legibilidade e facilitar a visualização e a declaração de tipos relacionados, agora é possível adicionar várias declarações de variáveis do mesmo tipo em uma única linha.

Declare muitas variáveis do mesmo tipo na mesma linha, usando uma vírgula para separar os nomes delas.

Por exemplo:

var
        myInt, nextInt, thirdInt : Integer;
        isValid, doCheck : Boolean;

Variáveis protegidas

É possível usar a palavra-chave protegida para tornar as variáveis acessíveis entre tabelas e extensões de tabela e entre páginas e extensões de página.

Se você deseja expor apenas algumas variáveis como protegidas, deve criar duas seções de declarações de variáveis. Veja a sintaxe a seguir.

protected var
        myInt: Integer; // protected var

var
        myLocalInt: Integer; // local var

O exemplo a seguir ilustra como declarar e usar uma variável protegida.

page 50100 MyPage
{
    SourceTable = Customer;
    PageType = Card;

    layout
    {
        area(Content)
        {
            group(General)
            {
                field(Name; Name)
                {
                    ApplicationArea = All;
                }
            }
            group(Advanced)
            {
                Visible = ShowBalance;

                field(Balance; Balance)
                {
                    ApplicationArea = All;
                }
            }
        }
    }

    protected var
        [InDataSet]
        ShowBalance: Boolean;
}

pageextension 50101 MyPageExt extends MyPage
{
    layout
    {
        addlast(Content)
        {
            group(MoreBalance)
            {
                Visible = ShowBalance; // ShowBalance from MyPage

                field("Balance (LCY)"; "Balance (LCY)")
                {
                    ApplicationArea = All;
                }
            }
        }

    }

    actions
    {
        addlast(Navigation)
        {
            action(ToggleBalance)
            {
                ApplicationArea = All;
                trigger OnAction()
                begin
                    ShowBalance := not ShowBalance; // Toggle ShowBalance from MyPage.
                end;
            }
        }
    }
}

Diretrizes para inserir código AL

Recomendamos as seguintes diretrizes para código AL:

• No geral, você escreve o código em codeunits, e não no objeto no qual ele opera. Isso promove um projeto limpo e permite reutilizar o código. Isso também ajuda a reforçar a segurança. Por exemplo, os usuários normalmente não têm acesso direto a tabelas que contêm dados confidenciais, como a tabela Entrada da Contabilidade, nem permissão para modificar objetos.

• Se você colocar o código que é operado na contabilidade em uma codeunit, conceder à codeunit acesso à tabela e conceder ao usuário permissão para executar a codeunit, não comprometerá a segurança da tabela e o usuário poderá acessá-la.

• Se você precisar colocar o código em um objeto, e não em uma codeunit, faça isso o mais próximo possível do objeto no qual ele opera. Por exemplo, coloque o código que modifica os registros nos gatilhos dos campos da tabela.

Reutilizar o código

A reutilização do código torna o desenvolvimento de aplicativos mais rápido e fácil. Se você organizar seu código AL como sugerido, o mais importante é que seus aplicativos estarão menos sujeitos a erros. Ao centralizar o código, você não criará inconsistências intencionalmente com a execução do mesmo cálculo em vários locais, por exemplo, em vários gatilhos que têm o mesmo campo de tabela que a respectiva expressão de origem. Se você precisar alterar o código, talvez se esqueça de alguns desses gatilhos ou cometa algum erro ao modificar um deles.