String to TArray<T>

[elrayo76]

Buenas,


No soy muy experto en los genéricos pero me defiendo. El problema que tengo ahora es que necesito convertir un string a un TArray<T>.


La cosa es la siguiente. Tengo un string delimitado por ";" (punto y coma). Estos datos los necesito separar por ese carácter y pasarlos a un TArray<T>. A simple vista esto parece muy sencillo pero acá viene la complicación.


El tema es que algunas veces el arrat que le paso a la función puede ser de tipo string, otras integer y otras Word, aunque puede haber otras. Los datos del string al separarlos tienen que respetar el tipo de los datos del array (TArray<T>).


Lo que busco es si se puede hacer alguna función o método en una clase que sea genérico, digamos que no tenga que repetir lo mismo por cada tipo de dato. El string se que se podría separar usando TStringList y las propiedades que tiene, pero no se como pasar luego ese TStringList al array.


Si existe hay alguna otra alternativa sera apreciada. Espero que se entienda lo que necesito.


Saludos,
El Rayo

[lucho6007]

Hola Rayo.
En las últimas versiones de Delphi hay un helper para las strings que es .Split, te permite separar una string en un array. Es siempre a un TArray<String>, si necesitás hacerlo a TArray<Integer> o TArray<Word> o lo que sea, podés hacer overloads para cada tipo de datos.


Saludos y ¡a abrigarse que en Argentina está fresquito!

[mamcx]

El tema de fondo es que <T> NO ES NADA. "T" no es un tipo concreto, es la marca de que HABRA un tipo concreto.

Por lo tanto no tiene sentido que algo se "convierta a T". Lo que puedes decir es que "se convierta a T que AHORA es String". O "que T AHORA se conforma a esta interface" etc.

Lo que no se puede es mantener T indeciso.

[lucho6007]

Podés hacer overloads de las funciones para los distintos tipos de datos:
El código va de memoria:

function Split(AStr: String; ASep: String): TArray<String>; overload;
function Split(AStr: String; ASep: String): TArray<Integer>; overload;
function Split(AStr: String; ASep: String): TArray<Word>; overload;
etc


y en las llamadas:

Código Delphi [-]
procedure Algo;
var AStArr: TArray<String>;
    AnIntArr: TArray
    AWordArr: TArray;
begin
  AStrArr:= Split('Una,prueba,tonta', ',');
  AnIntArr:= Split('10,20,30', ',');
  AWordArr:= Split('10,20,30', ',');

Espero te sirva.

[elrayo76]

Gracias por las respuestas.


Si, la opción de Split que tiene el string lo he pensado, solo que me quería de alguna forma ahorrar de tener que hacer sobrecarga de algo que hace exactamente lo mismo pero que solo tiene un casteo para cada tipo de dato.


Igualmente si no tengo mas remedio iré por esa opción.


Lo que yo pensaba es de hacer alguna función tipo Split<T>(const aString: String; var aArray: TArray<T>; const aSeparador) y con eso al pasar el array con el tipo que necesite en cada momento dentro el aString de pasara a este sin necesidad de mucho.


Gracias y saludos,
El Rayo

[[movorack]]

Aunque lo hice con fines "didacticos", pienso que se complica demasiado el código haciendo el split en una sola función.

Código Delphi [-]
unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, System.Rtti;

type
  PArrInt = ^TArrInt;
  TArrInt = TArray< Integer >;
  PArrDbl = ^TArrDbl;
  TArrDbl = TArray< Double >;
  PArrStr = ^TArrStr;
  TArrStr = TArray< String >;

  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    function Split(const S: string; const Separator: array of char): T;
    function toArrStr(const A: TArrInt): TArrStr; overload; inline;
    function toArrStr(const A: TArrDbl): TArrStr; overload; inline;
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TForm1 }

function TForm1.Split(const S: string; const Separator: array of char): T;
var
  i: Integer;
  lArrStr: TArrStr;
  lArrInt: TArrInt;
  lTmpI: Integer;
  lArrDbl: TArrDbl;
  lTmpD: Double;
begin
  if (TypeInfo(T) <> TypeInfo(TArrInt))
    and (TypeInfo(T) <> TypeInfo(TArrDbl))
    and (TypeInfo(T) <> TypeInfo(TArrStr))
  then
    raise Exception.Create('¡Tipo generico no manejado!');

  lArrStr := S.Split(Separator);

  if TypeInfo(T) = TypeInfo(TArrInt) then
  begin
    SetLength(lArrInt, 0);

    for i := 0 to High(lArrStr) do
    begin
      if not TryStrToInt(lArrStr[i], lTmpI) then
        Continue;

      SetLength(lArrInt, Length(lArrInt)+1);
      lArrInt[Length(lArrInt)-1] := lTmpI;
    end;

    PArrInt(@Result)^ := lArrInt;
  end
  else
  if TypeInfo(T) = TypeInfo(TArrDbl) then
  begin
    SetLength(lArrDbl, 0);

    for i := 0 to High(lArrStr) do
    begin
      if not TryStrToFloat(lArrStr[i], lTmpD) then
        Continue;

      SetLength(lArrDbl, Length(lArrDbl)+1);
      lArrDbl[Length(lArrDbl)-1] := lTmpD;
    end;

    PArrDbl(@Result)^ := lArrDbl;
  end
  else
  if TypeInfo(T) = TypeInfo(TArrStr) then
    PArrStr(@Result)^ := lArrStr;
end;

function TForm1.toArrStr(const A: TArrInt): TArrStr;
var
  i: Integer;
begin
  for i := 0 to High(A) do
  begin
    SetLength(Result, Length(Result)+1);
    Result[Length(Result)-1] := IntToStr(A[i]);
  end;
end;

function TForm1.toArrStr(const A: TArrDbl): TArrStr;
var
  i: Integer;
begin
  for i := 0 to High(A) do
  begin
    SetLength(Result, Length(Result)+1);
    Result[Length(Result)-1] := FloatToStr(A[i]);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  _INT = '1;100;1000;10000;100000';
  _DBL = '1,1;1,2;1,3;1,4;1,5';
  _STR = 'A;B;C;D;E';
var
  lArrI: TArrInt;
  lArrD: TArrDbl;
  lArrS: TArrStr;
begin
  lArrI := Split< TArrInt >(_INT, [';']);
  lArrD := Split< TArrDbl >(_DBL, [';']);
  lArrS := Split< TArrStr >(_STR, [';']);

  Memo1.Lines.Clear;
  Memo1.Lines.AddStrings(toArrStr(lArrI));
  Memo1.Lines.AddStrings(toArrStr(lArrD));
  Memo1.Lines.AddStrings(lArrS);
end;

end.

Resultado:

1
100
1000
10000
100000
1,1
1,2
1,3
1,4
1,5
A
B
C
D
E

[mamcx]

Esa solución esta muy compleja!

La manera mas simple e idiomática en todos los lenguajes que usan generics es pasar una interface/protocolo (no tengo Delphi a la mano así que...):

Código Delphi [-]
type
   // Una Interface para convertir a String
   IString = Interface(IInterface)
     function IntoString : String;
   end;

function split< T: IString > (const S: string; const Separator: array of char): TArray< T >
begin
    //Codigo...
    item.IntoString() // Aqui obtienes el valor como un String!
end


// O pasa una function como convertidor
type TIntoString= reference to function< T >(inputValue: T): String;

function split_f< T > (const S: string; const Separator: array of char, convert: TIntoString< T >): TArray< T >
begin
    //Codigo...
    TIntoString (item) // Aqui obtienes el valor como un String!
end

[[movorack]]

Hola mamcx! No se si he entendido mal. Pero, el lo que busca es hacer el Split de un texto a un TArray<T> y decirle a una función que tipo de array quiere para obtenerlo como resultado.

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  lArrI: TArray< Integer >;
  lArrD: TArray< Double >;
  lArrS: TArray< String >;
begin
  lArrI := Split< TArray< Integer > >('1;100;1000;10000;100000', [';']);
  lArrD := Split< TArray< Double >>('1,1;1,2;1,3;1,4;1,5', [';']);
  lArrS := Split< TArray< String >>('A;B;C;D;E', [';']);
end;

En la respuestas que das, pienso que estás enfocándote en el tratamiento del texto como tal para convertirlo en un array, que es la parte mas sencilla del planteamiento.

Lo complicado, son las limitantes que Delphi tiene en cuanto a esto. Al querer evaluar o manipular a T como indicador del tipo de dato que quieres devolver y así hacer el tratamiento correcto de datos, sea cual fuese el método propiedad determinada por una interfaz, función como parámetro o implementado dentro de la misma función. Debes usar la RTTI para identificar en tiempo de ejecución que tipo de dato te enviaron.

Esto mismo, afecta al Result de la función. Ya que al ser de un tipo T, el compilador no logra comprenderlo ni manipularlo correctamente. No te deja asignarle un valor directo, no deja que le hagas un casteo. Por ello en el ejercicio opto por asignarle la memoria del array que armé con la cadena que pasan como parámetro.

Lo que yo hice fue mas un ejercicio para aclarar mis ideas que una solución. En mi opinión la solución la aportó lucho6007 cuando aconseja que se realice una función de split para cada tipo, haciendo el overload respectivo.

[mamcx]

Correcto, lo hice al revés! Lo que necesitas es convertir de String a T:

Código Delphi [-]
{$ifdef fpc}
  {$mode delphi}
{$endif}

program Hello;
uses
  SysUtils;
  
type
  TConverter = function (const S: String): T;

function IntToStr(const S: String): Integer;
begin
    Result := StrToInt(S)
end;

type
  TSpliter = class
    class function Split(const S: string; const Separator: array of char; const convert: TConverter): TArray;
  end;

class function TSpliter.Split(const S: string; const Separator: array of char; const convert: TConverter): TArray;
var
  i: Integer;
  lArrStr: TArray<String>;
  lArr: TArray;
begin
    lArrStr := S.Split(Separator);
    SetLength(lArr, High(lArrStr) + 1);
  
    for i := 0 to High(lArrStr) do
    begin
      lArr[i] := convert(lArrStr[i]);
    end;

  Result := lArr;
end;

var 
  i: Integer;
  nums: TArray;
begin
    nums := TSpliter.Split('1;100;1000', [';'], IntToStr);
  
    for i := 0 to High(nums) do
    begin
      WriteLn(nums[i]);
    end;
end.

[[movorack]]

¡Mis respetos! Gracias por compartirnos esta solución mas elegante