Liste parsen

[delphien]

Hallo liebe Delphinarier,

ich habe ein echtes Problem, das mir schon einige Tage zu schaffen macht.
Mit Programmierung beschäftige ich mich erst seit ein paar Monaten...

Ich habe eine Liste, die verschiedene strings beinhaltet. Das sieht in etwa
so aus:

wort1 | wort2 | wort3 | wort4 | wort1 | wort4 | wort7 | wort8 ......

Sagen wir mal, daß die strings "wort2", "wort4" und "wort7" besonders relevant sind,
sozusagen ein "Gerüst" bilden.

Was ich machen will, kann ich zwar in Worten ausdrücken, aber dieses
dann in Quelltext zu schreiben, bereitet mir Probleme.

1. Ich gehe die Liste von links nach rechts durch

2. Auf jeden string brauche ich den Zugriff, da ich jeden string verarbeiten will

3. Wenn der string "wort2" vorkommt, dann muß ich den string "wort4" umschreiben
(wenn er danach vorkommt !), aber nur wenn der string "wort7" nach "wort4" vorkommt, sonst nicht.
usw., fortlaufend versteht sich.

4. In dem Beispiel dann so:

wort1 | wort2 | wort3 | edit wort4 | wort1 | wort7 | wort8 .......

In der Liste selbst ändere ich natürlich nichts.

Habe ich mich einigermaßen verständlich ausgedrückt ?
Sonst könnt Ihr mich fragen...
Für eure Hilfe wäre ich Euch sehr dankbar !

[Nuclear-Ping]

Delphi-Quellcode:

type
  TExplodeArray = Array of String;

{ ************************************************************ }
function Explode (const cSeparator, vString: WideString): TExplodeArray;
{ ************************************************************ }
var
  i: Integer;
  S: String;
begin
  S := vString;
  SetLength(Result, 0);
  i := 0;
  while Pos(cSeparator, S) > 0 do begin
    SetLength(Result, Length(Result) +1);
    Result[i] := Copy(S, 1, Pos(cSeparator, S) -1);
    Inc(i);
    S := Copy(S, Pos(cSeparator, S) + Length(cSeparator), Length(S));
  end;
  SetLength(Result, Length(Result) +1);
  Result[i] := Copy(S, 1, Length(S));
end;

{ ************************************************************ }
function Implode (const cSeparator: WideString; const cArray: TExplodeArray): String;
{ ************************************************************ }
var
  i: Integer;
begin
  Result := '';
  for i := 0 to Length(cArray) -1 do begin
    Result := Result + cSeparator + cArray[i];
  end;
  System.Delete(Result, 1, Length(cSeparator));
end;

...

Str := 'Wort1|Wort2|Wort3|...';

StrItems := Explode ('|', Str);

if (StrItems[0] = 'Wort1') then
  StrItems[3] := 'Neues Wort';

Str := Implode ('|', StrItems);

Suchst du vielleicht das?

[delphien]

Okay, nochmal etwas genauer:

Die function Explode benutze ich schon.
Also ich habe ein Array aus Wörtern, auf die ich ja Zugriff habe.
Von der Liste lege ich mir anfangs eine Kopie an, wobei ich diese dann
nachher verändere. Die Positionen der Wörter in der Liste bleiben aber
unverändert. Zu jedem Wort in dem array existiert eine Eigenschaft.
Ich gehe das Array von links nach rechts durch.

Stoße ich auf ein Wort mit einer Eigenschaft A, z.B. "Hund" besitzt
die Eigenschaft A, dann suche ich ein Wort mit der Eigenschaft B, z.B.
"Katze" und nur wenn ein Wort mit Eigenschaft B vorkommt, suche ich noch
nach einem Wort mit der Eigenschaft C ("Maus").
Immer rechts von dem Wort gesehen, niemals links.

In der Kopie würde ich dann das Wort "Katze" ändern wollen.
Nochmals. Die Position der Wörter in der Liste bleibt unverändert.

Ich brauche so ne Art Pseudo-Code...

[Zacherl]

Einfach zu realisieren ist das Ganze auch mit einer StringList:

Delphi-Quellcode:

var
  List,
  ListFile: TStringList;
begin
  List := TStringList.Create;
  ListFile := TStringList.Create;
  List.Delimiter := '|';
  ListFile.LoadFromFile({Dateiname der Liste});
  List.DelimitedText := ListFile.Text;

  {Zugriff auf die Elemente der Liste dann mit
   List[0] = 1. String
   List[1] = 2. String
   
   Schreiben einfach
   List[0] := 'test' 1. String mit 'test' füllen
  }

  //Wieder speichern der Liste:
  ListFile.Text := List.Text;
  ListFile.SaveToFile({Dateiname der Liste});

  ListFile.Free;
  List.Free;
end;

Florian