Einen Komma-Text richtig trennen.

[angos]

Hi,

folgende Funktion dürfte erledigen was du brauchst:

Delphi-Quellcode:

function TrenneText(sText, sDelim1, sDelim2, sDelimNew: String): String;
var
  iPos1, iPos2: Integer;
begin
  Result := '';
  iPos1 := pos(sDelim1, sText);
  iPos2 := pos(sDelim2, sText);
  while ((iPos1 > 0) and (iPos2 > 0)) do
  begin
    Result := Result + copy(sText, 1, iPos1-1) + sDelimNew;
    sText := copy(sText, iPos2 + Length(sDelim2), Length(sText));
    iPos1 := pos(sDelim1, sText);
    iPos2 := pos(sDelim2, sText);
  end;
end;

// aufruf in deinem Fall mit
TrenneText('BORKUM{61}, BLA2{60}, REL{62}, EN/NORD{72}, ESSEN{59}, TRIN,KEN{70}, HERNE{71}, 
  HSK1{67}, MAMA123{65}, KW/DINSL{64}, OBERHAUSEN{66}, EN/SÜD{73}, KW/MOERS{63}, 
  HSK2{68}, HSK3{69}'
  , '{', '},', ',');

[SirThornberry]

autsch, bitte nicht die funktion verwenden. Dein Programm wird es dir auf längere sicht danken.
Durch

Delphi-Quellcode:

Stringx := Stringx + irgendwas

wird die Länge von Stringx immer wieder verändert, somit immer wieder neuer speicher angefordert und der alte umkopiert und bei einigen Speichermangern ist der Speicher danach derart fragmentiert das du probleme bekommen kannst wenn du wieder speicher anforderst.

schau dir mal das hier an: http://www.delphipraxis.net/internal...=205244#205244

[gunfran]

Ich hab grad das Problem grad mit dieser Regular Expression hinbekommen und war schon sehr angetan. Das werde ich mir mal genauer angucken, ob man die in Zukunft nicht häufiger mal gebrauchen kann. Trotzdem mal aber besten Dank bezüglich der Performance. Im Moment ist dies allerdings kein Problem, aber falls das in Zukunft mal der Fall sein wird, werd ich das im Hinterkopf behalten.


Ach ja. Ihr seid spitze.

[Xong]

Zitat:

Zitat von SirThornberry

Durch

Delphi-Quellcode:

Stringx := Stringx + irgendwas

wird die Länge von Stringx immer wieder verändert, somit immer wieder neuer speicher angefordert und der alte umkopiert [...]

Sicher?
Jeder gute Compiler (mit dem ich mich auskenne) versucht einen String zu vergrößern, indem er er den Speicherplatz einfach vergrößert/verlängert. Erst wenn dies nicht klappt, wird ein vollkommen neuer Speicherplatz vergeben und der alte aufgelöst. Das hat C schon so gemacht und es würde mich wundern, wenn es in Delphi anders wäre.

[SirThornberry]

ich bin mir da ganz sicher. Mach einfach mal paar Performancetests und du wirst das erschreckende Ergebnis sehen.
Bei früheren Programmen konnte ich das ständige Vergrößern von Strings als Performancekiller Nummer eins ausmachen und wenne in Programm das ständig macht und einige Stunden durchläuft bekommt man schnell mal ein "out of memory".

Das man angeforderten Speicher einfach vergrößern kann war mir neu. Aber wie dem auch ist, meine Tests haben bisher ergeben das ein ständiges vergrößern von Arrays, Strings etc. zu stargen Performanceeinbrüchen führt.
Bist du dir sicher das C das schon gemacht hat? In C sind mir strings bisher noch gar nicht begegnet (was aber vielleicht auch an der minimalen Bibliothek bei der Microcontrollerprogrammierung liegt)

[Xong]

In C gibt es ja auch keine Stringverarbeitung. =)
Dafür gibt es die Standardbibliotheken, in denen Stringfunktionen bereitgestellt werden. So erreicht man die Plattformunabhängigkeit von C (d.h. die Stringfunktionen sind betriebssystemspezifisch deklariert).

Es gibt in C eine Funktion, deren Name mir gerade nicht einfällt. Mit der ist genau das möglich, was ich beschrieben habe. Es kann natürlich sein, dass der Delphi-Compiler das anders handhabt. Keine Ahnung. :stupid: Ich dachte ja nur... Alles andere wäre so ineffizient. Aber Ineffizienz ist schließlich auch der Preis für Bequemlichkeit, nicht wahr?!

LG,
Xong

[marabu]

Hallo,

in Delphi sorgt die Prozedur ReallocMem() für die Vergrößerung eines bereits angeforderten Speicherblocks. Ist der Speicher hinter dem aktuellen Block in Benutzung, dann wird der aktuelle Block freigegeben und der größere Speicher an anderer Stelle zugeordnet.

Der Reiz einer Regular Expression liegt für mich im nicht prozeduralen Ansatz, aber sie kann nie schneller sein, als eine gute handkodierte Lösung:

Delphi-Quellcode:

function PurgeId(const list: string): string;
var
  iPos, iDest: Integer;
  skipping: Boolean;
begin
  skipping := False;
  SetLength(Result, Length(list));
  iDest := 1;
  for iPos := 1 to Length(list) do
    if skipping then
      skipping := list[iPos] <> '}'
    else if list[iPos] = '{' then
      skipping := True else
      begin
        Result[iDest] := list[iPos];
        Inc(iDest);
      end;
  SetLength(Result, Pred(iDest));
end;

Freundliche Grüße

[alzaimar]

Zitat:

Zitat von marabu

Der Reiz einer Regular Expression liegt für mich im nicht prozeduralen Ansatz, aber sie kann nie schneller sein, als eine gute handkodierte Lösung:

... deren Performance durch Einbeziehung egozentrischer Performancemanie noch leicht gesteigert werden kann :stupid: :

Delphi-Quellcode:

Function AlzPurgeID(Const list: String): String;
Var
  iStop, iPos, iDest: Integer;

Begin
  iStop := Length(list);
  SetLength(Result, iStop);
  iDest := 0;
  iPos := 1;
  While iPos <= iStop Do Begin
    If list[iPos] = '{' Then
      While (iPos <= iStop) And (list[iPos] <> '}') Do
   inc(iPos)
    Else Begin
      Inc(iDest);
      Result[iDest] := list[iPos];
    End;
    inc(iPos);
  End;
  SetLength(Result, iDest);
End;

Sir Thornberry's Anmerkungen zur Performancebremse 'sString := sString + sSubString' kann ich nur beipflichten. Der Unterschied ist in etwa vergleichbar miz dem Unterschied in der Zubereitungszeit einer Tasse Nescafe und dem eigenhändigen Anbau, Ernte, Röstung, Malen und Brühen von jamiakanischem Blue Mountain. Wobei der Vergleich hinkt: Jamaican Blue Mountain ist es Wert, etwas länger zu warten, Stringkonkatenation hingegen nicht.

Und nun: Assemblerfraktion und Performancegeeks vortreten, bitte!

[grenzgaenger]

Zitat:

Zitat von Xong

Zitat:

Zitat von SirThornberry

Durch

Delphi-Quellcode:

Stringx := Stringx + irgendwas

wird die Länge von Stringx immer wieder verändert, somit immer wieder neuer speicher angefordert und der alte umkopiert [...]

Sicher?
Jeder gute Compiler (mit dem ich mich auskenne) versucht einen String zu vergrößern, indem er er den Speicherplatz einfach vergrößert/verlängert. Erst wenn dies nicht klappt, wird ein vollkommen neuer Speicherplatz vergeben und der alte aufgelöst. Das hat C schon so gemacht und es würde mich wundern, wenn es in Delphi anders wäre.

yep, sicher! was soll der gute compieler auch machen, wenn er keinen speicher mehr hat... tja, er muss halt 'n neuen anfordern und dann die daten dort reinkopieren... beim nächsten mal, hat er dann wieder keinen speicher, alles ist zu klein, zu eng... und dann muss er wieder speicher anfordern.... so ist dies auch in C nicht nur in delphi...

tja, und C hat keine strings... sind halt nur arrays of char... (nachbau in delphi PCHAR :-) )

[angos]

Zitat:

Zitat von SirThornberry

autsch, bitte nicht die funktion verwenden. Dein Programm wird es dir auf längere sicht danken.
Durch

Delphi-Quellcode:

Stringx := Stringx + irgendwas

wird die Länge von Stringx immer wieder verändert, somit immer wieder neuer speicher angefordert und der alte umkopiert und bei einigen Speichermangern ist der Speicher danach derart fragmentiert das du probleme bekommen kannst wenn du wieder speicher anforderst.

schau dir mal das hier an: http://www.delphipraxis.net/internal...=205244#205244

Ist zwar schon ein bisschen her, aber wow :shock: . Ich wusste, dass meine Funktion nicht die schnellste ist, aber dass das ein so gravierender Unterschied ist, hätte ich jetzt nicht gedacht. Bei knapp 500.000 Zeilen braucht mein Code auf meinem Rechner 11875 Millisekunden. Da gegenüber braucht der letzte von alzaimar gepostete Code nur 16 Millisekunden. Na da hab ich wohl wieder etwas gelernt.

Vielen Dank :dp:

Gruß