Generische string.Split Funktion

[TiGü]

Delphi-Quellcode:

type
  TArrayHelper = record
  public
    class function Explode<T>(const ADelimiter, AString: string): TArray<T>; static;
  end;

class function TArrayHelper.Explode<T>(const ADelimiter, AString: string): TArray<T>;
var
  LArr: TArray<string>;
  LIntArr: TArray<Integer>;
  Li: Integer;
  I: Integer;
begin
  SetLength(Result, 0);
  LArr := AString.Split([ADelimiter]);

  for Li := 0 to Length(LArr) - 1 do
  begin
    if (TypeInfo(T) = TypeInfo(string)) then
    begin
      Result := TArray<T>(LArr);
    end
    else if (TypeInfo(T) = TypeInfo(Integer)) then
    begin
      SetLength(LIntArr, Length(LArr));
      for I := Low(LIntArr) to High(LIntArr) do
      begin
        LIntArr[I] := LArr[I].ToInteger;
      end;
      Result := TArray<T>(LIntArr);
    end;
  end;
end;

procedure Test;
var
  MyString: string;
  MyStringArray: TArray<string>;
  MyIntegerArray: TArray<Integer>;
begin
  MyString := '1,2,3';
  MyStringArray := TArrayHelper.Explode<string>(',', MyString);
  MyIntegerArray := TArrayHelper.Explode<Integer>(',', MyString);
end;

[DieDolly]

Danke für die Hilfe. Da war ich doch nicht so weit weg. Trotzdem hatte ich es falsch.

Anhand deiner Umwandlungen habe ich das auch mal mit einer Implode-Funktion versucht. Aber das geht leider in die Hose, da die Umwandlungen hier wohl anders sein sollen.

Meine originale Implode-Funktion

Delphi-Quellcode:

 // for i := 0 to Length(Values) - 1 do
 // begin
 // Res := Res + Values[i];
 //
 // if (i + 1 < Length(Values)) then
 // Res := Res + ADelimiter;
 // end;

oder eben

:= string.Join(',', StringArray); Aber Join gibt es auch nicht für Integer-Arrays.

Mein Ziel: ein Integer-Array als String zurückzuliefern.

Ohne Generics würde ich das sonst so machen

Delphi-Quellcode:

function Implode(const ADelimiter: string; const Values: TArray<string>): string;
var
 i: Integer;
begin
 // Result := string.Join(ADelimiter, Values);
 // oder

 Result := '';

 for i := 0 to Length(Values) - 1 do
  begin
   Result := Result + Values[i];

   if (i + 1 < Length(Values)) then
    Result := Result + ADelimiter;
  end;
end;

function Implode(const ADelimiter: string; const Values: TArray<Integer>): string;
var
 i: Integer;
 StrArray: TArray<string>;
begin
 Result := '';

 for i := 0 to Length(Values) - 1 do
  begin
   SetLength(StrArray, Length(StrArray) + 1);
   StrArray[i] := IntToStr(Values[i]);
  end;

 Result := Implode(ADelimiter, StrArray);
end;

[Stevie]

Zitat von DieDolly:

Mein Ziel: ein Integer-Array als String zurückzuliefern.

Wenn du eine fest bestimmte Menge an Typen hast, die du behandeln möchtest, würd ich dir von Generics abraten und die entsprechenden Typen per Überladungen implementieren.

[DieDolly]

Zitat von Stevie:

Zitat von DieDolly:

Mein Ziel: ein Integer-Array als String zurückzuliefern.

Wenn du eine fest bestimmte Menge an Typen hast, die du behandeln möchtest, würd ich dir von Generics abraten und die entsprechenden Typen per Überladungen implementieren.

Habe ich bei der Implodefunktion so gemacht. Bei der Explode-Funktion nutze ich aber dann doch Generics, weil sich nur das Resultat der Funktion ändert aber nicht die Parameter.
Unschöne Out-Parameter wären das Resultat.