Introdução

Nesse post iremos aprender sobre a sintaxe básica da linguagem de programação Delphi.

Delphi é uma linguagem de programação que tem suas raízes no Pascal, mas que foi aprimorada e modernizada para suportar a programação orientada a objetos e o desenvolvimento de aplicações robustas para Windows, macOS, iOS, Android e Linux. Este artigo vai explorar a sintaxe básica da linguagem de programação Delphi, oferecendo uma introdução clara e prática para iniciantes.

Delphi é uma escolha popular entre desenvolvedores devido à sua facilidade de uso, desempenho eficiente e forte suporte para a criação de interfaces gráficas de usuário (GUIs). Com sua sintaxe clara e estruturada, Delphi permite que os programadores desenvolvam aplicativos complexos de forma mais intuitiva. Neste artigo, abordaremos os principais elementos da sintaxe de Delphi, incluindo variáveis, estruturas de controle, procedimentos, funções e a base da programação orientada a objetos.

Sintaxe básica da linguagem de programação Delphi

O que são variáveis?

Variáveis são elementos fundamentais em linguagens de programação, utilizadas para armazenar e manipular dados durante a execução de um programa. Elas representam áreas de memória que possuem um nome simbólico e um tipo de dado associado. Esses dados podem ser valores numéricos, texto, caracteres, booleanos, entre outros, dependendo do tipo de dado suportado pela linguagem.

As variáveis são essenciais porque permitem que os programas trabalhem com dados dinâmicos e manipulem informações de forma flexível. Elas fornecem uma maneira de armazenar temporariamente valores que podem ser modificados ou acessados conforme necessário durante a execução do programa.

Ao declarar uma variável, é necessário especificar seu nome e seu tipo de dado. Isso informa ao compilador como reservar espaço na memória e como interpretar os dados armazenados nessa área. Por exemplo, uma variável do tipo inteiro armazena números inteiros, enquanto uma variável do tipo string armazena texto.

Além disso, as variáveis podem receber valores atribuídos durante a execução do programa e podem ser utilizadas em expressões matemáticas, comparações, estruturas de controle e muito mais. Elas fornecem uma maneira flexível e poderosa de lidar com dados e desempenham um papel fundamental na lógica e na funcionalidade de um programa de computador.

Declaração de Variáveis

A declaração de variáveis em Delphi segue um padrão simples e direto. As variáveis devem ser declaradas antes de serem usadas, especificando seu nome e tipo.

var
  Number: Integer;
  Name: String;
  IsActive: Boolean;

Nesta declaração, Number é uma variável do tipo inteiro, Name é uma variável do tipo string, e IsActive é uma variável booleana.

Estruturas de Controle

As estruturas de controle, também conhecidas como estruturas de decisão e repetição, são recursos fundamentais em linguagens de programação que permitem controlar o fluxo de execução de um programa. Elas determinam a ordem em que as instruções são executadas com base em condições específicas ou repetem determinadas operações até que uma condição seja atendida.

Delphi oferece várias estruturas de controle que permitem a criação de fluxos de programa eficientes, incluindo condicionais (if-then-else), laços (for, while, repeat-until), e instruções de caso (case).

Estruturas Condicionais

A estrutura if-then-else permite a execução condicional de blocos de código.

var
  Age: Integer;
begin
  Age := 21;
  if Age >= 18 then
    ShowMessage('You are an adult')
  else
    ShowMessage('You are a minor');
end;

Laços

Delphi suporta três tipos principais de laços: for, while, e repeat-until.

Laço for

O laço for em Delphi é uma estrutura de repetição que permite executar um bloco de código um número específico de vezes. Ele é especialmente útil quando você sabe exatamente quantas vezes deseja repetir uma determinada ação.

A sintaxe básica do laço for em Delphi é a seguinte:

var
  I: Integer;
begin
  for I := 1 to 10 do
    ShowMessage('Iteration: ' + IntToStr(I));
end;

Neste exemplo, a variável de controle i é inicializada com o valor 1 e o laço é executado até que i atinja o valor 10. Em cada iteração do laço, o número é exibido usando a função ShowMessage.

Além da palavra-chave to, que indica que o laço deve ser executado de forma crescente, Delphi também oferece a palavra-chave downto, que indica que o laço deve ser executado de forma decrescente. Por exemplo:

var
  i: Integer;
begin
  for i := 5 downto 1 do
  begin
    ShowMessage('Número: ' + IntToStr(i));
  end;
end;

Este segundo exemplo exibirá os números de 5 a 1 em ordem decrescente.

O laço for é útil em situações onde você precisa repetir uma determinada operação um número fixo de vezes, como iterar sobre elementos de uma lista, criar uma sequência de números ou executar cálculos em uma série de valores. Ele simplifica o código e torna mais fácil expressar a lógica de repetição de forma concisa e legível.

Laço while

O laço while em Delphi é uma estrutura de repetição que permite executar um bloco de código enquanto uma determinada condição for verdadeira. Ele é útil quando você não sabe exatamente quantas vezes precisa repetir uma ação, mas deseja continuar repetindo enquanto uma condição específica for atendida.

A sintaxe básica do laço while em Delphi é a seguinte:

var
  I: Integer;
begin
  I := 1;
  while I <= 10 do
  begin
    ShowMessage('Iteration: ' + IntToStr(I));
    Inc(I);
  end;
end;

Neste exemplo, o laço while continua executando enquanto a condição i <= 10 for verdadeira. O contador i é incrementado em cada iteração usando a função Inc(i). Se a condição se tornar falsa em algum momento, o laço é interrompido e a execução continua após o bloco while.

O laço while é útil em situações onde você não sabe antecipadamente quantas vezes precisa repetir uma operação, mas precisa continuar repetindo até que uma condição específica seja atendida. Ele oferece flexibilidade e controle adicionais sobre o fluxo do programa em comparação com o laço for, pois a condição de parada pode ser mais complexa e depender de múltiplas variáveis ou condições.

Laço repeat-until

O laço repeat-until em Delphi é uma estrutura de repetição que permite executar um bloco de código repetidamente até que uma determinada condição seja verdadeira. Ele é semelhante ao laço while, mas a condição de parada é verificada após cada execução do bloco de código, garantindo que o bloco seja executado pelo menos uma vez, mesmo que a condição seja falsa desde o início.

A sintaxe básica do laço repeat-until em Delphi é a seguinte:

var
  I: Integer;
begin
  I := 1;
  repeat
    ShowMessage('Iteration: ' + IntToStr(I));
    Inc(I);
  until I > 10;
end;

Neste exemplo, o bloco de código dentro do repeat é executado pelo menos uma vez, independentemente da condição. Depois que o bloco é executado, o contador i é incrementado em cada iteração usando a função Inc(i). Se a condição se tornar falsa em algum momento, o laço é interrompido e a execução continua após o bloco repet-until.

O laço repeat-until é útil em situações onde você precisa garantir que um determinado bloco de código seja executado pelo menos uma vez antes de verificar uma condição de parada. Ele oferece uma abordagem alternativa ao while, fornecendo maior controle sobre o fluxo do programa em certos cenários.

Estrutura de caso – case of

Em Delphi, a estrutura de caso é conhecida como case. Ela permite que você selecione entre várias opções com base no valor de uma expressão. A estrutura case é especialmente útil quando você precisa tomar decisões com base em múltiplas condições semelhantes.

var
  DiaSemana: Integer;
begin
  DiaSemana := 3;

  case DiaSemana of
    1: ShowMessage('Domingo');
    2: ShowMessage('Segunda-feira');
    3: ShowMessage('Terça-feira');
    4: ShowMessage('Quarta-feira');
    5: ShowMessage('Quinta-feira');
    6: ShowMessage('Sexta-feira');
    7: ShowMessage('Sábado');
  else
    ShowMessage('Número inválido de dia da semana');
  end;
end;

Neste exemplo, DiaSemana é uma variável que contém o número correspondente ao dia da semana (de 1 a 7). Dependendo do valor dessa variável, uma mensagem é exibida informando o nome do dia correspondente.

A estrutura case começa com a palavra-chave case, seguida pela expressão que está sendo avaliada (DiaSemana neste caso). Depois disso, são listados os casos possíveis, cada um seguido por dois pontos (:) e o código a ser executado se a expressão for igual ao valor do caso. O bloco else é opcional e é executado se nenhum dos casos corresponder ao valor da expressão.

As estruturas de caso são úteis quando você tem várias opções para escolher com base em uma única variável ou expressão. Elas tornam o código mais legível e fácil de entender, especialmente quando você tem muitas condições para verificar. Além disso, em Delphi, a estrutura case pode ser mais eficiente do que uma série de instruções if-then-else quando há muitas opções para verificar.

Procedimentos e Funções

Procedimentos e funções são blocos de código reutilizáveis que realizam tarefas específicas. A diferença entre eles é que funções retornam um valor, enquanto procedimentos não. Abaixo veremos um exemplo simples para procedimentos e funções:

Procedimentos

procedure ShowMessageHello;
begin
  ShowMessage('Hello, Delphi!');
end;

Funções

function AddNumbers(A, B: Integer): Integer;
begin
  Result := A + B;
end;

Programação Orientada a Objetos (POO)

Delphi é uma linguagem fortemente orientada a objetos. Isso significa que você pode criar classes e objetos para representar conceitos do mundo real em seu código. Esse tópico será abordado com mais detalhes na categoria de Programação Orientada a Objetos (POO).

Declaração de uma Classe

type
  TPerson = class
  private
    FName: String;
    FAge: Integer;
  public
    procedure SetName(Name: String);
    procedure SetAge(Age: Integer);
    function GetInfo: String;
  end;

procedure TPerson.SetName(Name: String);
begin
  FName := Name;
end;

procedure TPerson.SetAge(Age: Integer);
begin
  FAge := Age;
end;

function TPerson.GetInfo: String;
begin
  Result := 'Name: ' + FName + ', Age: ' + IntToStr(FAge);
end;

Uso de uma Classe

var
  Person: TPerson;
begin
  Person := TPerson.Create;
  try
    Person.SetName('John Doe');
    Person.SetAge(30);
    ShowMessage(Person.GetInfo);
  finally
    Person.Free;
  end;
end;

Caso tenha interesse em aprender mais sobre Delphi, você pode consultar a documentação completa no site da Embarcadero, mas já vou avisando, é bom saber um pouco de inglês para não ficar perdido, ou você também poderá traduzir a página se desejar.

Segue o link: https://docwiki.embarcadero.com

Conclusão

Com uma sintaxe clara e poderosa, Delphi continua sendo uma linguagem de programação relevante e eficiente para o desenvolvimento de aplicações modernas. Sua herança do Pascal proporciona uma base sólida para iniciantes, enquanto suas capacidades de programação orientada a objetos permitem a criação de aplicações complexas e robustas. Esperamos que esta introdução à sintaxe básica de Delphi ajude você a começar a explorar e aproveitar as vantagens dessa linguagem versátil e poderosa. Seja você um desenvolvedor iniciante ou experiente, Delphi oferece as ferramentas e a flexibilidade necessárias para transformar suas ideias em realidade.

Posts Relacionados

História e Evolução – Delphi

Porquê escolher Delphi?