RibaSoft

String Helpers — FPC / Lazarus

• • Requisito: mode e unit
  • Join — unir array com separador
  • Split — quebrar string em array
  • Contains — verificar se contém
  • StartsWith e EndsWith
  • IndexOf — posição de substring
  • Trim, TrimLeft, TrimRight
  • ToUpper e ToLower
  • Substring — extrair trecho
  • Replace — substituir ocorrências
  • Length — tamanho da string
  • Equals e CompareTo
  • Concat — concatenar sem separador
  • Exemplo prático: SQL dinâmico

Requisito: mode e unit

• Os métodos de instância do tipo String (como .Contains, .Split, etc.) estão disponíveis no FPC 3.x com a unit SysUtils e requerem o modo {$mode objfpc} ou {$mode delphi} no topo do arquivo. Sem isso, o compilador não reconhece a sintaxe de ponto na string.

  {$mode objfpc}{$H+} uses SysUtils;

• Os métodos estáticos como String.Join e String.Split também exigem essa mesma configuração. Em projetos Lazarus, o {$mode objfpc} normalmente já está configurado pelo próprio IDE.

Join — unir array com separador

• String.Join(separador, array) — une todos os elementos de um array de strings inserindo o separador entre cada item, sem adicioná-lo no início ou no final. É o inverso do Split.

  var campos: array of string; resultado: string; begin campos := ['ID', 'NOME', 'CPF', 'EMAIL']; resultado := String.Join(', ', campos); // resultado = 'ID, NOME, CPF, EMAIL' resultado := String.Join(' AND ', ['ATIVO = 1', 'DELETED = 0', 'ID > 10']); // resultado = 'ATIVO = 1 AND DELETED = 0 AND ID > 10' resultado := String.Join(#13#10, ['Linha 1', 'Linha 2', 'Linha 3']); // resultado = cada item em uma linha separada end;

• Uso prático: montar SELECT dinâmico sem vírgula sobrando

  // Antes — problema da vírgula sobrando antes do FROM: for I := 0 to Pred(Length(ACampos)) do SQL.Add(ACampos[I] + ','); // última linha fica: 'EMAIL,' // Depois — limpo com Join: SQL.Add(String.Join(', ', ACampos)); // resultado: 'ID, NOME, CPF, EMAIL' sem vírgula extra

Split — quebrar string em array

• MinhaString.Split([separador]) — quebra a string em um array de strings usando o separador informado. Retorna TStringArray. É o inverso do Join.

  var partes: TStringArray; begin partes := 'ID,NOME,CPF,EMAIL'.Split([',']); // partes[0] = 'ID' // partes[1] = 'NOME' // partes[2] = 'CPF' // partes[3] = 'EMAIL' // Separador com mais de um caractere partes := 'João; Maria; Pedro'.Split(['; ']); // partes[0] = 'João' // partes[1] = 'Maria' // partes[2] = 'Pedro' end;

• Múltiplos separadores ao mesmo tempo

  var partes: TStringArray; begin // Split aceita vários separadores no array partes := 'um,dois;tres|quatro'.Split([',', ';', '|']); // partes[0] = 'um' // partes[1] = 'dois' // partes[2] = 'tres' // partes[3] = 'quatro' end;

• Join + Split trabalhando juntos

  var original, reconstruida: string; partes: TStringArray; begin original := 'ID, NOME, CPF'; // Desmonta partes := original.Split([', ']); // Faz algo com os itens... partes[1] := 'FANTASIA'; // troca NOME por FANTASIA // Remonta reconstruida := String.Join(', ', partes); // reconstruida = 'ID, FANTASIA, CPF' end;

Contains — verificar se contém

• MinhaString.Contains(substring) — retorna True se a string contiver a substring informada, ou False caso contrário. Equivale a Pos(sub, s) > 0 do Pascal clássico, mas muito mais legível.

  var sql: string; begin sql := 'SELECT * FROM CLIENTES WHERE ATIVO = 1'; if sql.Contains('WHERE') then ShowMessage('SQL tem filtro WHERE'); if not sql.Contains('ORDER BY') then sql := sql + ' ORDER BY ID'; // Comparação: // Antigo: if Pos('WHERE', sql) > 0 then ... // Novo: if sql.Contains('WHERE') then ... end;

• Atenção: a comparação é case-sensitive por padrão. Para ignorar maiúsculas/minúsculas, converta para o mesmo case antes de comparar.

  // Case-sensitive (padrão): 'Lazarus'.Contains('laz') // False — 'l' minúsculo não bate com 'L' 'Lazarus'.Contains('Laz') // True // Ignorar case: 'Lazarus'.ToLower.Contains('laz') // True

StartsWith e EndsWith

• StartsWith(prefixo) — retorna True se a string começar com o prefixo informado. EndsWith(sufixo) — retorna True se a string terminar com o sufixo informado.

  var s: string; begin s := 'SELECT * FROM CLIENTES'; s.StartsWith('SELECT') // True s.StartsWith('INSERT') // False s.EndsWith('CLIENTES') // True s.EndsWith('FORNECEDOR') // False // Uso prático: validar início de string antes de processar if not s.StartsWith('SELECT') then raise Exception.Create('Apenas consultas SELECT são permitidas!'); end;

• Verificar extensão de arquivo

  var arquivo: string; begin arquivo := 'relatorio.pdf'; if arquivo.EndsWith('.pdf') then AbrirPDF(arquivo) else if arquivo.EndsWith('.xlsx') then AbrirExcel(arquivo); // Equivalente antigo: // if Copy(arquivo, Length(arquivo)-3, 4) = '.pdf' then ... end;

IndexOf — posição de substring

• MinhaString.IndexOf(substring) — retorna a posição da primeira ocorrência da substring. Retorna -1 se não encontrar.

  Atenção: base 0! — diferente do Pos() clássico do Pascal que usa base 1, o IndexOf começa a contar do zero. Fique atento ao migrar código.

  var s: string; pos: Integer; begin s := 'SELECT ID, NOME FROM CLIENTES'; pos := s.IndexOf('FROM'); // pos = 11 (base 0) pos := s.IndexOf('WHERE'); // pos = -1 (não encontrou) // Comparação com o Pos() clássico: // Pos('FROM', s) = 12 (base 1) // s.IndexOf('FROM') = 11 (base 0) — resultado diferente! end;

• Buscar a partir de uma posição específica

  var s: string; begin s := 'NOME, NOME_FANTASIA, NOME_RAZAO'; // Encontra a segunda ocorrência de 'NOME' s.IndexOf('NOME', 0) // 0 — primeira ocorrência s.IndexOf('NOME', 1) // 6 — segunda ocorrência (a partir da pos 1) s.IndexOf('NOME', 7) // 21 — terceira ocorrência end;

Trim, TrimLeft, TrimRight

• Remove espaços em branco (e outros caracteres de controle como Tab e Enter) das extremidades da string. Já existiam como funções do SysUtils, mas agora também são chamados como métodos de instância.

  var s: string; begin s := ' Nome do Cliente '; s.Trim // 'Nome do Cliente' — remove de ambos os lados s.TrimLeft // 'Nome do Cliente ' — remove só da esquerda s.TrimRight // ' Nome do Cliente' — remove só da direita // Equivalente ao antigo: // Trim(s), TrimLeft(s), TrimRight(s) // A sintaxe nova é apenas mais legível — o resultado é o mesmo. end;

• Uso prático: limpar entrada do usuário antes de validar

  var cpf: string; begin cpf := EditCPF.Text.Trim; // remove espaços que o usuário pode ter digitado if cpf.Length < 11 then Riba.Aviso('Validação', 'CPF inválido!'); end;

ToUpper e ToLower

• ToUpper converte para maiúsculas. ToLower converte para minúsculas. Equivalem às funções clássicas UpperCase() e LowerCase() do SysUtils.

  var s: string; begin s := 'Lazarus Pascal'; s.ToUpper // 'LAZARUS PASCAL' s.ToLower // 'lazarus pascal' // Equivalente antigo: // UpperCase(s) LowerCase(s) end;

• Uso comum: comparação sem diferenciar maiúsculas/minúsculas

  var entrada, esperado: string; begin entrada := EditBusca.Text; esperado := 'ADMIN'; if entrada.ToUpper = esperado then LiberarAcesso; // Encadeamento de métodos: if EditBusca.Text.Trim.ToUpper = 'ADMIN' then LiberarAcesso; end;

Substring — extrair trecho

• MinhaString.Substring(inicio) — retorna tudo a partir do índice informado. MinhaString.Substring(inicio, quantidade) — retorna a quantidade de caracteres a partir do índice.

  ⚠️ Atenção: base 0! — diferente do Copy() clássico que usa base 1. Substring(0, 3) equivale a Copy(s, 1, 3).

  var s: string; begin s := 'DEPENDENTES'; // 0123456789... (base 0) s.Substring(3) // 'ENDENTES' — do índice 3 até o fim s.Substring(0, 3) // 'DEP' — 3 caracteres a partir do índice 0 s.Substring(3, 4) // 'ENDE' — 4 caracteres a partir do índice 3 // Comparação com Copy() clássico (base 1): // Copy(s, 4, 4) = 'ENDE' — mesmo resultado, mas base diferente! // s.Substring(3, 4) = 'ENDE' end;

• Uso prático: extrair parte de um código

  var codigo, prefixo, numero: string; begin codigo := 'NF-000123'; prefixo := codigo.Substring(0, 2); // 'NF' numero := codigo.Substring(3); // '000123' end;

Replace — substituir ocorrências

• MinhaString.Replace(de, para, flags) — substitui ocorrências de uma substring por outra. As flags controlam o comportamento.

  var s: string; begin s := 'SELECT * FROM clientes WHERE id = 1'; // Substituir todas as ocorrências (rfReplaceAll): s.Replace('id', 'ID', [rfReplaceAll]) // 'SELECT * FROM clientes WHERE ID = 1' // Case-insensitive + todas as ocorrências: s.Replace('id', 'ID', [rfReplaceAll, rfIgnoreCase]) // substitui 'id', 'Id', 'iD', 'ID' por 'ID' // Sem flags = substitui apenas a primeira ocorrência: 'aa-bb-aa'.Replace('aa', 'XX', []) // 'XX-bb-aa' — só a primeira foi trocada // Com rfReplaceAll: 'aa-bb-aa'.Replace('aa', 'XX', [rfReplaceAll]) // 'XX-bb-XX' — todas foram trocadas end;

Length — tamanho da string

• MinhaString.Length — retorna o número de caracteres da string. É a mesma função Length() clássica do Pascal, agora acessível como propriedade de instância.

  var s: string; begin s := 'Lazarus'; s.Length // 7 ''.Length // 0 'abc def'.Length // 7 — espaços contam // Uso prático: validar tamanho de campos if EditCPF.Text.Trim.Length <> 11 then Riba.Aviso('Validação', 'CPF deve ter 11 dígitos!'); // Equivalente antigo: // if Length(Trim(EditCPF.Text)) <> 11 then ... // A versão nova é mais fluente (encadeada, da esquerda para direita) end;

Equals e CompareTo

• Equals compara duas strings retornando True/False. CompareTo retorna um número: negativo se menor, zero se igual, positivo se maior. Útil para ordenação manual.

  var s: string; begin s := 'CLIENTES'; s.Equals('CLIENTES') // True s.Equals('clientes') // False — case-sensitive s.Equals('FORNECEDORES') // False // CompareTo — resultado numérico (igual ao strcmp do C): 'A'.CompareTo('A') // 0 — iguais 'A'.CompareTo('B') // -1 — 'A' vem antes de 'B' 'B'.CompareTo('A') // 1 — 'B' vem depois de 'A' // Uso em ordenação manual: if Tabela1.CompareTo(Tabela2) < 0 then SQL.Add(Tabela1 + ', ' + Tabela2) else SQL.Add(Tabela2 + ', ' + Tabela1); end;

Concat — concatenar sem separador

• String.Concat(array) — une todos os elementos sem nenhum separador. Útil para montar strings a partir de partes sem precisar do operador + repetidamente.

  var s: string; begin // Com operador + (modo clássico): s := 'SELECT ' + 'ID, NOME ' + 'FROM ' + 'CLIENTES'; // Com Concat: s := String.Concat(['SELECT ', 'ID, NOME ', 'FROM ', 'CLIENTES']); // s = 'SELECT ID, NOME FROM CLIENTES' // Diferença do Join: Concat não coloca nada entre os itens String.Join('-', ['A', 'B', 'C']) // 'A-B-C' — tem separador String.Concat(['A', 'B', 'C']) // 'ABC' — sem separador end;

Exemplo prático: SQL dinâmico

• Combinando vários métodos para montar uma consulta SQL dinâmica de forma limpa e profissional:

  procedure TClienteModel.Buscar(ACampos: array of string; AFiltro: string); var sCampos, sFiltro: string; begin // Une os campos com vírgula — sem vírgula sobrando sCampos := String.Join(', ', ACampos); // Limpa e normaliza o filtro digitado pelo usuário sFiltro := AFiltro.Trim.ToUpper; with FQuery do begin Close; SQL.Clear; SQL.Add('SELECT ' + sCampos); SQL.Add('FROM CLIENTES'); if not sFiltro.IsEmpty then begin // Verifica se o usuário digitou um CNPJ (só números) ou nome if sFiltro.Contains('/') or sFiltro.Contains('.') then SQL.Add('WHERE CNPJ LIKE :FILTRO') else SQL.Add('WHERE UPPER(RAZAO) LIKE :FILTRO'); ParamByName('FILTRO').AsString := '%' + sFiltro + '%'; end; SQL.Add('ORDER BY RAZAO'); Open; end; end;

• Resultado do SQL gerado com os métodos encadeados:

  // ACampos = ['ID', 'RAZAO', 'CNPJ', 'CIDADE'] // AFiltro = ' padaria ' // String.Join(', ', ACampos) => 'ID, RAZAO, CNPJ, CIDADE' // AFiltro.Trim.ToUpper => 'PADARIA' // sFiltro.Contains('/') => False — vai para o filtro de RAZAO // SQL final montado: // SELECT ID, RAZAO, CNPJ, CIDADE // FROM CLIENTES // WHERE UPPER(RAZAO) LIKE :FILTRO -- :FILTRO = '%PADARIA%' // ORDER BY RAZAO