Lidando com Arrays JSON em Delphi

Nesse post iremos abordar como trabalhar com Arrays JSON em Delphi.

 

_{Arrays JSON em Delphi}

Índice

• Introdução
• O que é um Array JSON?
  • Criando Arrays JSON em Delphi
    • Explicação do Código
  • Acessando Elementos de Arrays JSON
    • Explicação do Código
  • Manipulação Avançada de Arrays JSON
    • Exemplo de Adição de Novos Elementos
    • Explicação do Código
    • Interface do projeto
    • Código do projeto
    • Código fonte do exemplo
  • Boas Práticas ao Trabalhar com Arrays JSON
• Conclusão

Introdução

Nesse post iremos abordar como trabalhar com Arrays JSON em Delphi.

O JSON (JavaScript Object Notation) é um formato de dados leve e amplamente utilizado para a troca de informações entre sistemas, especialmente em APIs web. Uma das características mais poderosas do JSON é a capacidade de armazenar coleções de dados, conhecidas como arrays JSON. Em Delphi, trabalhar com arrays JSON pode ser uma tarefa simples e eficiente quando utilizamos as ferramentas corretas. Neste artigo, vamos explorar como criar, manipular e acessar elementos de arrays JSON em Delphi, seguindo boas práticas de codificação.

O que é um Array JSON?

Em JSON, um array é uma lista ordenada de valores que podem ser de qualquer tipo: números, strings, objetos, booleanos, ou até outros arrays. Cada valor no array é separado por vírgulas e os arrays são delimitados por colchetes []. Arrays em JSON são uma forma eficiente de organizar e transmitir conjuntos de dados variados em um formato intercambiável e legível por humanos, sendo amplamente utilizados em APIs e integração de sistemas. Um exemplo simples abaixo:

Delphi

[
    {"Name": "John Doe", "Age": 30},
    {"Name": "Jane Doe", "Age": 25}
]
  

Esse array contém dois objetos, cada um representando uma pessoa com suas respectivas propriedades.

Criando Arrays JSON em Delphi

Para criar e manipular arrays JSON em Delphi, podemos utilizar a unidade System.JSON. Vamos começar criando um array JSON simples que contenha objetos.

Delphi

uses
  System.JSON, System.SysUtils;

procedure CreateJsonArray;
var
  JsonArray: TJSONArray;
  JsonObject: TJSONObject;
begin
  JsonArray := TJSONArray.Create;
  try
    // Criando o primeiro objeto
    JsonObject := TJSONObject.Create;
    JsonObject.AddPair('Name', 'John Doe');
    JsonObject.AddPair('Age', TJSONNumber.Create(30));
    JsonArray.AddElement(JsonObject);

    // Criando o segundo objeto
    JsonObject := TJSONObject.Create;
    JsonObject.AddPair('Name', 'Jane Doe');
    JsonObject.AddPair('Age', TJSONNumber.Create(25));
    JsonArray.AddElement(JsonObject);

    // Convertendo o array para string JSON e armazenando na variável JSONStr
    JSONStr := JsonArray.ToString;  // [{"Name":"John Doe","Age":30},{"Name":"Jane Doe","Age":25}]

    ShowMessage('Array JSON criado com sucesso!');
  finally
    JsonArray.Free;
  end;
end;
  

Explicação do Código

1. TJSONArray e TJSONObject: Usamos TJSONArray para criar o array JSON e TJSONObject para criar objetos que serão adicionados ao array.
2. Adição de Pares: Utilizamos o método AddPair para adicionar pares de chave-valor aos objetos. Por exemplo, JsonObject.AddPair('Name', 'John Doe') cria um par onde a chave é "Name" e o valor é "John Doe".
3. Adição ao Array: Cada objeto é adicionado ao array usando JsonArray.AddElement(JsonObject).
4. Liberação de Memória: Como sempre, utilizamos um bloco try/finally para garantir que o array JSON seja liberado corretamente após o uso.

Acessando Elementos de Arrays JSON

Uma vez que temos um array JSON, o próximo passo é acessar os elementos dentro dele. Isso pode ser feito utilizando o índice dos elementos no array.

Delphi

uses
  System.JSON, System.SysUtils;

procedure AccessJsonArrayElements(const JSONString : String);
var
  JsonArray: TJSONArray;
  JsonObject: TJSONObject;
  Name: string;
  Age: Integer;
  index: Integer;

begin
  JsonArray := TJSONObject.ParseJSONValue(JSONString) as TJSONArray;
  try
    Memo1.Lines.Clear; //Limpando o Memo1

    // Laço de repetição para iterar sobre os objetos no array JSON
    for index := 0 to JSONArray.Count - 1 do
    begin

      // Acessando os objetos
      JsonObject := JsonArray.Items[index] as TJSONObject;
      Name := JsonObject.GetValue<string>('Name');
      Age := JsonObject.GetValue<Integer>('Age');

      Memo1.Lines.Add('Name: '+ Name + ', Age: ' + IntToStr(Age));  //Adicionando os objetos no Memo1
    end;

  finally
    JsonArray.Free;
  end;
end;
  

Explicação do Código

1. ParseJSONValue: Aqui, estamos usando o método ParseJSONValue para converter uma string JSON em um array JSON (TJSONArray). O resultado é um array JSON que pode ser manipulado como qualquer outro objeto Delphi.
2. Acesso por Índice: Os elementos do array JSON são acessados através de JsonArray.Items[index], onde index é a posição do elemento no array, começando do zero.
3. Extração de Valores: Utilizamos GetValue<T> para extrair valores específicos dos objetos dentro do array, convertendo-os para os tipos apropriados (string, Integer, etc.).

Manipulação Avançada de Arrays JSON

Além de criar e acessar elementos, é possível realizar operações mais avançadas, como modificar elementos existentes, adicionar novos elementos dinamicamente, ou até mesmo remover elementos de um array JSON.

Exemplo de Adição de Novos Elementos

Delphi

procedure AddNewElementToJsonArray(const JSONString : String);
var
  JsonArray: TJSONArray;
  JsonObject: TJSONObject;
begin
  JsonArray := TJSONObject.ParseJSONValue(JSONString) as TJSONArray;
  try
    // Criando e adicionando um novo objeto
    JsonObject := TJSONObject.Create;
    JsonObject.AddPair('Name', 'Madonna');
    JsonObject.AddPair('Age', TJSONNumber.Create(60));
    JsonArray.AddElement(JsonObject);

    JSONStr := JsonArray.ToString;  // [{"Name":"John Doe","Age":30},{"Name":"Jane Doe","Age":25},{"Name":"Madonna","Age":60}]

    ShowMessage('Elemento Array JSON adicionado com sucesso!');
  finally
    JsonArray.Free;
  end;
end;
  

Explicação do Código

Neste exemplo, adicionamos um novo objeto ao array JSON existente. Isso demonstra a flexibilidade dos arrays JSON em Delphi, permitindo a adição dinâmica de dados conforme necessário.

Interface do projeto

Iremos utilizar 3 componentes do tipo TButton para acionar os métodos CreateJsonArray, AccessJsonArrayElements e AddNewElementToJsonArray;

Código do projeto

Iremos utilizar uma variável de projeto privada JSONStr para armazenar temporariamente o JSON Array criado e posteriormente adicionar um novo elemento a ele.

Veja abaixo a ilustração do projeto:

Ilustração do projeto.

Código fonte do exemplo

Você pode fazer o download do exemplo do projeto através do repositório do github:

https://github.com/Gisele-de-Melo/Arrays_JSON_Delphi

Boas Práticas ao Trabalhar com Arrays JSON

1. Gerenciamento de Memória: Sempre utilize blocos try/finally para garantir que os arrays JSON sejam liberados corretamente após o uso, evitando vazamentos de memória.
2. Validação de Dados: Ao desserializar um array JSON, verifique se o array e seus elementos estão no formato esperado para evitar erros de execução.
3. Uso de Tipos Apropriados: Certifique-se de que os tipos de dados no Delphi correspondem corretamente aos tipos de dados no JSON para evitar problemas de conversão.
4. Tratamento de Exceções: Adicione tratamento de exceções ao lidar com arrays JSON, especialmente quando trabalhar com dados de fontes externas, como APIs ou arquivos.

Conclusão

Lidar com arrays JSON em Delphi é uma tarefa comum e poderosa, especialmente em aplicações que requerem manipulação de dados estruturados de forma eficiente. Com as ferramentas nativas do Delphi, é possível criar, acessar e manipular arrays JSON com facilidade, seguindo boas práticas que garantem código seguro, eficiente e fácil de manter.

Se você seguir as práticas demonstradas neste artigo, estará bem equipado para manipular arrays JSON em suas aplicações Delphi, garantindo que seu código seja robusto e eficiente.

Posts Relacionados

Serialização e Desserialização JSON em Delphi

Introdução ao JSON