String analysieren und Textteil ersetzen

[erich.wanker]

Hallo Leute,

Ich will gerne folgendes machen:

Einen String durchsuchen, ob irgendwo #beliebigerText# erthalten ist ... (Das #-zeichen soll Anfang und Ende des Platzhalters definieren)
Wenn ja - ersetze "#beliebigerText#" durch z.B. aktuellen Usernamen .. Uhrzeit, Datum ect.. kommt drauf an - was im "beliebigerText" steht...

Wie macht man das a geschicktesten?

Vielen Dank für Hinweise
Erich

[DeddyH]

Spontan würde ich sagen: StringReplace oder reguläre Ausdrücke.

[p80286]

Wenn ich Dich richtig verstanden habe möchstest Du #text1# durch username ersetzen, #text2# durch ip-adresse usw. und so ähnlich. Dafür würde sich zunächst AnsiReplaceText/AnsiReplaceStr anbieten.
Ist der String allerdings größer (TStringlist?) sollte man zu spezielleren Mitteln greifen.

Gruß
K-H

[erich.wanker]

Danke ...

ich habs jetzt mit "vielen" StringReplace gemacht .. funktioniert ...

s:=StringReplace(s, '#benutzer#', mainform.benutzername, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#user-id#', mainform.benutzernummer, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#usernummer#', mainform.benutzernummer, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#userid#', mainform.benutzernummer, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#user#', mainform.benutzername, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#benutzergruppe#', mainform.benutzergruppe, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#server#', servermodule.ServerRoot, [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#zeit#', timetostr(now), [rfReplaceAll, rfIgnoreCase]);
s:=StringReplace(s, '#datum#', datetostr(now), [rfReplaceAll, rfIgnoreCase]);
....

[p80286]

Wie wäre es mit so etwas

Delphi-Quellcode:

type
  tRepRec = record
              srcString:ansistring;
              destString:ansistring;
  end;

var
  RepArray: Array of tRepRec;

....
  setlength(repArray,1);
  RepArray[0].srcString='#benutzer#';
  RepArray[0].destString:=mainform.benutzername;
.....

for i:=0 to length(repArray)-1 do
  s:=StringReplace(s, RepArray[i].srcString,RepArray[i].destString, [rfReplaceAll,rfIgnoreCase]);

(nur so runter getippt!)

Das ist meiner Meinung nach einfacher zu warten. Vor allem wenn Du "oben" irgendwo Deine Definitionen einträgst und "unten" irgendwo die eigentliche Verarbeitung erfolgt. Oder alles gleich in einen procedure kopf packen.

Gruß
K-H

[Uwe Raabe]

Ich will ja nicht pingelig sein, aber das kann schief gehen. Nehmen wir mal an, wir wollen lediglich die Platzhalter benutzer und datum austauschen. Gemäß den bisherigen Vorschlägen benutzen wir StringReplace zunächst für benutzer und dann für datum. Jetzt bekommen wir aber folgenden Eingangsstring:

#datum#benutzer#benutzer#

Das soll eigentlich dieses Ergebnis liefern: "06.06.2016benutzerUwe, liefert aber "#datumUwebenutzer#".

Klar ist das Beispiel konstruiert, aber je nach tatsächlichen Anforderungen kann durchaus Ähnliches passieren.

Sicherer wäre hier ein ausprogrammierter Simpel-Parser (als Variablenmapping benutze ich einfach eine TStringList):

Delphi-Quellcode:

function ReplaceVariables(const Input: string; VarMap: TStrings): string;
var
  M: Integer;
  N: Integer;
  VarName: string;
begin
  Result := Input;
  N := Pos('#', Result);
  while N > 0 do begin
    M := PosEx('#', Result, N + 1);
    VarName := Copy(Result, N + 1, M - (N + 1));
    Result := StuffString(Result, N, Length(VarName) + 2, VarMap.Values[VarName]);
    N := Pos('#', Result);
  end;
end;

procedure Main;
var
  lst: TStringList;
begin
  lst := TStringList.Create;
  try
    lst.Values['benutzer'] := 'Uwe';
    lst.Values['datum'] := '06.06.2016';
    Writeln(ReplaceVariables('#datum#benutzer#benutzer#', lst));
  finally
    lst.Free;
  end;
end;

[mm1256]

Hallo,

@Uwe: Mir ist schon klar, dass das ein schnell hin geschriebenes Beispiel ist, das noch um ein paar Kleinigkeiten ergänzt werden muss. Darauf will ich aber nicht hinaus.

Mir persönlich (also nur mein individueller Geschmack, nicht mehr) ist das "#" als Begrenzer für die Platzhalter etwas unsympatisch. Ich verwende lieber die geschweiften Klammern, weil man dann eindeutige {Begrenzer} für Beginn und Ende des Bezeichners hat. Nimmt man dafür das selbe Zeichen wird es einerseits im Text bei mehreren Verwendungen unübersichtlich (was gehört zusammen) und zudem auch fehleranfälliger.

[SProske]

Rein aus Spaß mal eine Umsetzung mit Regulären Ausdrücken und TDictionary:

Delphi-Quellcode:

uses
  System.SysUtils, RegularExpressions, System.Generics.Collections;

type
  THashtagReplacer = class
  strict private
    FDic: TDictionary<string, string>;
    function InternalReplaceHashtag(const Match: TMatch): string;
  public
    constructor Create;
    destructor Destroy;override;
    procedure AddKeyValue(const Key, Value: string);
    function DoReplace(const Input: string): string;
  end;
    
{ THashtagReplacer }

procedure THashtagReplacer.AddKeyValue(const Key, Value: string);
begin
  FDic.Add(Key, Value);
end;

constructor THashtagReplacer.Create;
begin
  inherited;
  FDic := TDictionary<string,string>.Create;
end;

destructor THashtagReplacer.Destroy;
begin
  FDic.Free;
  inherited;
end;

function THashtagReplacer.DoReplace(const Input: string): string;
begin
  Result := TRegex.Replace(Input, '#[^#]+#', InternalReplaceHashtag);
end;

function THashtagReplacer.InternalReplaceHashtag(const Match: TMatch): string;
begin
  if not FDic.TryGetValue(Match.Value, Result) then
    Result := Match.Value;
end;

Aufruf wäre dann z.B. so

Delphi-Quellcode:

var
  TestString: string;
  Replacer: THashtagReplacer;
begin           
  TestString := '#test1# Hallo Welt #test2##test3#';
  Replacer := THashtagReplacer.Create;
  try
    Replacer.AddKeyValue('#test1#', 'foo');
    Replacer.AddKeyValue('#test2#', 'bar');
    TestString := Replacer.DoReplace(TestString);
    WriteLn(TestString); //-> foo Hallo Welt bar#test3#
    ReadLn;
  finally
    Replacer.Free;
  end;
end.