String-Bearbeitung! Ich finde den Fehler nicht!

[SirRobert]

Hallo zusammen,

ich habe folgendes Problem:
ich möchte aus einem langen String alle alleinstehenden #$A entfernen.
Hierzu habe ich mir folgende Prozedur gebastelt:

Delphi-Quellcode:

procedure Delete10(var Str : string);
var
        MyStr, TempStr                  : string;
        iPos                            : integer;
begin
        MyStr := '';
        TempStr := str;
        iPos := Pos(#$A, TempStr);
        while iPos > 0 do
        begin
                if iPos > 1 then
                begin
                        if TempStr[iPos - 1] <> #$D then 
                        begin
                                MyStr := MyStr + Copy(TempStr, 1, iPos - 1);
                        end
                        else
                                MyStr := MyStr + Copy(TempStr, 1, iPos);
                        TempStr := Copy(TempStr, iPos + 1 , Length(TempStr) - (iPos + 1));
                end
                else
                begin
                        MyStr := MyStr + Copy(TempStr, 2, Length(TempStr));
                        TempStr := Copy(TempStr, 2 , Length(TempStr) - (2));
                end;
                iPos := Pos(#$A, TempStr);
        end;
        Str := MyStr+TempStr;
end;

Jetzt habe ich festgestellt, dass die Prozedur bei längeren Strings
(> 100.000 Zeichen) einfach irgendwo abbricht, und so einen nicht vollständigen
String zurückliefert. Es wird zwar für gleiche Strings immer gleich abgeschnitten,
aber WARUM ÜBERHAUPT??? Wo steckt mein der Fehler????

Ich danke Euch für Eure Hilfe!

Grüße

Robert

[CK_CK]

Warum machstdu das nicht mit StringReplace?

Result := StringReplace(TestString,' '+#$A+' ','',[rfReplaceAll]); So müsste das klappen...

[SirRobert]

Hi,

das stimmt, aber in dem String befinden sich auch: #$D#$A 's
Die will ich ausschließen und nicht entfernen!

[CK_CK]

deswegen hab ich ja davor und danach ein Leerzeichen angefügt (' ')

[mkinzler]

Was meinst du mit ausschließen?

[Balu der Bär]

Zitat von mkinzler:

Was meinst du mit ausschließen?

Die sollen von dem Ersetzen ausgeschlossen werden, also unverändert bleiben.

[SirRobert]

Hi Hi!

Mit ausschließen meine ich:

wenn ein #$A gefunden, und davor ein #$D steht, so suche weitere #$A !

[DGL-luke]

hmm...

Delphi-Quellcode:

function stripsingle(s: string; notifbefore,c,notifafter: char): string;
var i,si,sc: Integer; //index, stringindex, stripcount
begin
setlength(Result,length(s))
si := 1;

if (s[1] <> c) or (s[2] = notifafter) then
  begin
    Result[si] := s[1];
    Inc(si);
  end;

for i := 2 to length(s)-1 do
  if ((s[i] = c) and ((s[i+1] = notifafter) or (s[i-1] = notifbefore))) or (s[i] <> c)then
    begin
      Result[si] := s[i];
      Inc(si);
    end
  else
    Inc(sc);
  
if (s[length(s)] <> c) or (s[length(s)-1] = notifbefore) then 
  begin
  Result[si] := s[length(s)];
  Inc(si);

setlength(Result,si); //hoffe das löscht den string nicht....
end;

warum ist meine Funktion so viel kürzer als deine? aufrufen mit

text := stripsingle(text,#13,#10,#0); Ach ja: performant ist die funktion keineswegs. man sollte lieber einen speicherbereich von der größe des ursprungsstrings belegen, dann die einzelnen chars zuweisen und zum schluss runterkürzen.

EDIT: habs nochmal angepasst...
EDIT: jetzt isses wahrscheinlich auch performant. werds aber mal testen.
EDIT: möp. funzt nicht. werds mal austesten....

[Jürgen Thomas]

Zitat von SirRobert:

das stimmt, aber in dem String befinden sich auch: #$D#$A 's
Die will ich ausschließen und nicht entfernen!

@CK_CK
Ich befürchte, dass nach den Leerzeichen nicht geprüft werden darf...

Ob es schneller geht, weiß ich nicht (ausprobieren), aber möglich ist folgendes Verfahren:

Delphi-Quellcode:

const sCRLF  = 'ABRAkadaBRA1279${]';  //  also irgendwelcher Schrott
sTemp  := StringReplace(TestString, #$D#$A, sCRLF, [rfReplaceAll]);
sTemp  := StringReplace(sTemp,      #$A,    '',    [rfReplaceAll]);
Result := StringReplace(sTemp,      sCRLF,  #$D#$A,[rfReplaceAll]);

Gruß Jürgen

[Hawkeye219]

Hallo Robert,

zwei Fehler stecken in den Zuweisungen zu TempStr im Schleifenkörper. In beiden Fällen wird das letzte Zeichen des Strings abgeschnitten. Ersetze einfach den dritten Parameter für die Copy-Funktion durch den Wert MaxInt.

Gruß Hawkeye