Zeilen in einem String zählen

[lbccaleb]

Gefunden habe ich erstmal das:

http://www.delphipraxis.net/51285-ze...trahieren.html

Das ist so schon ganz fein, allerdings Blick ich den Code noch nicht 100%ig.
Ich habe es so umgemodelt:

Delphi-Quellcode:

function CountStringLines(const S: AnsiString): Integer;
var i, i2, i3, i4: Integer;
  begin;
    Result := 0;
    i := 1; i2 := 1; i3 := 1;
    while i <= Length(S) do begin
      if i2 <= i then begin i2 := PosEx(#13, S, i); if i2 = 0 then i2 := Length(S) + 1; end;
      if i3 <= i then begin i3 := PosEx(#10, S, i); if i3 = 0 then i3 := Length(S) + 1; end;
      if i2 < i3 then i4 := i2 else i4 := i3;

      i := i4;
      if (i <= Length(S)) and (S[i] = #13) Then Inc(i);
      if (i <= Length(S)) and (S[i] = #10) Then Inc(i);
      Inc(Result);
    end;
  end;

Das scheint erstmal so zu funktionieren, wie es soll.
Nun ist mein Problem eigenltich nur, ob man es so machen kann wie ich es Umgebaut hab. Nicht das in bestimmten Fällen irgendwas unvorhergesehenes passiert, da ich nicht wirklich weis, was ich da getan hab muss ich zugeben :shock:

Vllt kann himitsu ja dazu was genaueres sagen :)

[p80286]

Wenn in Deinem String Kein CRLF vorhanden ist, dann bekommt i4 keinen Wert, und das könnte unangenehm werden.

Und ich würde die vielen Is mit etwas aussagekräftigeren Namen versehen.

Gruß
K-H

[DeddyH]

Mehrere Befehle in einer Zeile sind ja auch nicht der Hit im Bezug auf Lesbarkeit.

[p80286]

[OT]
Du kennst doch bestimmt noch die Zeitungen, die ein komplettes TP-Programm als 4 Zeiler abgedruckt haben? [/OT]

Gruß
K-H

[DeddyH]

[OT] 1 Kilo Byte? Kenn ich noch :) [/OT]

[Klaus01]

.. sollte das Problem denn nicht auch mit einer TStringList zu erschlagen sein.

Delphi-Quellcode:

function CountStringLines(const S: AnsiString): Integer;
var
  sl: TStringList; // nachträglich eingefügt
begin
  result := 0;
  sl := TStringList.create;
  try
    sl.Text := s;
    result := sl.count;
  finally
    sl.free;
  end;
end;

[Iwo Asnet]

Oder den hier

Delphi-Quellcode:

Function CountCRLF (Const aString : String) : Integer;
Var
  i : Integer;
Begin
  Result := 0;
  For i:=1 to Length(aString)-1 do
    if (aString[i]=#13) and (aString[i+1]=#10) then
      inc(Result);
End;

[himitsu]

Du hast deine Variablendeklaration vergessen, aber notfalls kann man auch die Variable einfach weglassen.

Delphi-Quellcode:

function CountStringLines(const S: String): Integer;
begin
  with TStringList.Create do
    try
      Text := S;
      Result := Count;
    finally
      Free;
    end;
end; 

function CountStringLines(const S: String): Integer;
begin with TStringList.Create do try Text:=S; Result:=Count; finally Free; end; end;

Aber wenn es auf Geschwindigkeit und Speicherverbraucht drauf ankommt, dann geht der Trick mit der Stringliste nicht wirklich,
denn da mußt du mit einigen Speicheroperationen (speicher für die Liste und vorallem die Strings reservieren + Freigeben) und dazu ist mit mindestens nochmals 100% des Stringsspeichers zu rechnen. (bei einem TStream als Quelle anstatt einem String, sogar mit locker zusätzlichen 300%)

Delphi-Quellcode:

function CountLines(const S: string): Integer;
var
  P: PChar;
begin
  if S <> '' then begin
    Result := 1;
    P := PChar(S);
    while P^ <> #0 do begin
      if P^ = #13 then begin
        Inc(Result);
        if (P + 1)^ = #10 then 
          Inc(P);
      end else if P^ = #10 then
        Inc(Result);
      Inc(P);
    end;
  end else
    Result := 0;
end;

[Klaus01]

Zitat:

Zitat von himitsu (Beitrag 1165399)

Du hast deine Variable vergessen.

habe ich eingefügt, danke.

Zitat:

Zitat von himitsu (Beitrag 1165399)

Aber wenn es auf Geschwindigkeit und Speicherverbraucht drauf ankommt, dann geht der Trick mit der Stringliste nicht wirklich,
denn da mußt du mit einigen Speicheroperationen (speicher für die Liste und vorallem die Strings reservieren + Freigeben) und dazu ist mit mindestens nochmals 100% des Stringsspeichers zu rechnen. (bei einem TStream als Quelle anstatt einem String, sogar mit locker zusätzlichen 300%)

stimme ich Dir zu, aber schön lesbar ist es mit der StringList schon.

Grüße
Klaus

[Aphton]

Ich persönlich finde es absolut hässlich, auch wenn es unheimlich gut lesbar ist! Es ist, so wie Himitsu es beschrieben hat, zu ressourcenlästig!

[Iwo Asnet]

Also ich finde eine For-Schleife am einfachsten zu lesen.

[himitsu]

Ich geb's zu, sowas wie mit der Stringliste nutze sich selber ab und zu.
Denn es ist schön kleiner Code, welcher garantiert funktioniert (Bugs sind so gut wie ausgeschlossen)
und wenn es nicht auf die letzte Millisekunde drauf ankommt und wenn der Speicher nicht relevant ist, dann stört es absolut nicht, wenn intern etwas mehr gemacht wird.


z.B. für's Anpassen der Zeilenumbrüche, wo dann unter #10, #13 und #13#10 in das passende format konvertiert werden (unter Windows nach #13#10)

Delphi-Quellcode:

S := 'abc'#10'xyz';

with TStringList.Create do
  try
    Text := S;
    S := Text;
  finally
    Free;
  end;

// S = 'abc' + sLineBreak + 'xyz';

[lbccaleb]

Was ist denn der Unterschied zwischen den beiden Versionen? ausser das die von himitsu ne ganze Ecke unübersichtlicher ist^^

Zitat:

Zitat von himitsu (Beitrag 1165399)

Delphi-Quellcode:

function CountLines(const S: string): Integer;
var
  P: PChar;
begin
  if S <> '' then begin
    Result := 1;
    P := PChar(S);
    while P^ <> #0 do begin
      if P^ = #13 then begin
        Inc(Result);
        if (P + 1)^ = #10 then
          Inc(P);
      end else if P^ = #10 then
        Inc(Result);
      Inc(P);
    end;
  end else
    Result := 0;
end;

Zitat:

Zitat von Iwo Asnet (Beitrag 1165394)

Oder den hier

Delphi-Quellcode:

Function CountCRLF (Const aString : String) : Integer;
Var
  i : Integer;
Begin
  Result := 0;
  For i:=1 to Length(aString)-1 do
    if (aString[i]=#13) and (aString[i+1]=#10) then
      inc(Result);
End;

Ist die schneller?

[himitsu]

Leztere zählt nur CRLF (#13#10).

Erstere beachtet #10 (Linux), #13 (Mac) und #13#10 (Windows).
Und sieh zählt korrekt.
- leerer String = keine Zeile / könnte man aber auch als eine Leerzeile betrachten
- kein Zeilenumbruch = 1 Zeile
- 1 Zeilenumbruch = 2 Zeilen
- 2 Zeilenumbrüche = 3 Zeilen
- 3 Zeilenumbrüche = 4 Zeilen
- ...

Und in Bezug auf die #0, gibt es einen Unterschied.
Bei PChar ist dort Schluß, während der Delphi-String theoretisch noch weitergehn könnte.


Direkt als String (ohne PChar):

Delphi-Quellcode:

function CountLines(const aString: string): Integer;
var
  i: Integer;
begin
  if aString <> '' then begin
    Result := 1;
    i := 1;
    while i <= Length(aString) do
      if aString[i] = #13 then begin
        Inc(Result);
        if (i < Length(aString)) and (aString[i + 1] = #10) then
          Inc(i);
      end else if aString[i] = #10 then
        Inc(Result);
  end else
    Result := 0;
end;

[Popov]

@lbccaleb

Die oben schon erwähnte TStringList ist wohl die Einfachste Methode. Text ist ein StringList laden, Count lesen, fertig. Warum nicht die Möglichkeiten von Delphi nutzen wenn sie da sind.

Erst wenn es wichtig ist ressourcesparend oder ultraschnell zu arbeiten, könnte man sich was anderes nehmen.

[lbccaleb]

Zitat:

Zitat von Popov (Beitrag 1165446)

...
Die oben schon erwähnte TStringList ist wohl die Einfachste Methode. Text ist ein StringList laden, Count lesen, fertig. Warum nicht die Möglichkeiten von Delphi nutzen wenn sie da sind.
...

Naja, das ist einfach. Ich kann die nicht benutzen da es bei mir nonVCL ist. Also gibs da keine StringList oO

Aber nocheinfacher finde ich eigentlich die CountCRLF funktion. Die ist einfach und erfüllt ihren Zweck super :)
Das von himitsu ist bestimmt besser, aber da brauch man ne ganze Weile sich da rein zu finden, wenn man sich das ganze selber beigebracht hat....8-)

[schöni]

Ich sehe hier eine Ungereimtheit:

In CountLines:

Delphi-Quellcode:

while P^ <> #0 do begin
      if P^ = #13 then begin
        Inc(Result);           //wenn true, dann INC(Zeilenzahl)
        if (P + 1)^ = #10 then
          Inc(P);              //wenn true, dann INC(StrPos)
      end else if P^ = #10 then
        Inc(Result);           //wenn true, dann INC(Zeilenzahl)
      Inc(P); //und hier dann ei 2. Mal INC(StrPos), wenn
              //if Zweig durchlaufen 
   end;

Oder hab ich hier einen Denkfehler?

[himitsu]

Eventuell wird es einfacher/übersichtlicher, wenn du das letzte Inc(P), also das der Schleife, mit in die IFs aufnimmst

Delphi-Quellcode:

while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    if (P + 1)^ = #10 then
      Inc(P);
    Inc(P); {<<<}
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P); {<<<}
  end else
    Inc(P); {<<<}

und dann noch etwas an der Reihenfolge veränderst.

Delphi-Quellcode:

while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    Inc(P); {<<<}
    if P^ = #10 then {<<<}
      Inc(P);
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P);
  end else
    Inc(P);

[UliBru]

Zitat:

Zitat von himitsu (Beitrag 1165417)

Delphi-Quellcode:

function CountLines(const aString: string): Integer;
var
  i: Integer;
begin
  if aString <> '' then begin
    Result := 1;
    i := 1;
    while i <= Length(aString) do
      if aString[i] = #13 then begin
        Inc(Result);
        if (i < Length(aString)) and (aString[i + 1] = #10) then
          Inc(i);
      end else if aString[i] = #10 then
        Inc(Result);
  end else
    Result := 0;
end;

Ist das korrekt, dass mit #13 die Zeilenzahl inkrementiert wird? Das Carriage Return springt doch nur wieder an den Anfang derselben Zeile, ist also logisch keine neue Zeile.
Wäre es nicht ausreichend, anhand eines gefundenen Linefeeds hochzuzählen?

Delphi-Quellcode:

function CountLines(const aString: string): Integer;
var
  i: Integer;
begin
  if aString <> '' then begin
    Result := 1;
    i := 1;
    while i <= Length(aString) do
      if aString[i] = #10 then
        Inc(Result);
  end else
    Result := 0;
end;

[DeddyH]

Da hab ich auch noch einen ohne Pointer, sollte mit #10, #13 und #13#10 zurechtkommen.

Delphi-Quellcode:

function CountLines(const s: string): integer;
var
  PrevCR: Boolean; //Previous Carriage Return
  i: integer;
begin
  Result := 0;
  PrevCR := false;
  for i := 1 to Length(s) do
    case s[i] of
      #13:
        begin
          Inc(Result);
          PrevCR := true;
        end;
      #10:
        begin
          if not PrevCR then
            Inc(Result);
          PrevCR := false;
        end;
      else
        PrevCR := false;
    end;
end;

[schöni]

Zitat:

Zitat von himitsu (Beitrag 1165533)

Eventuell wird es einfacher/übersichtlicher, wenn du das letzte Inc(P), also das der Schleife, mit in die IFs aufnimmst

Delphi-Quellcode:

while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    if (P + 1)^ = #10 then
      Inc(P);
    Inc(P); {<<<}  //warum hier dieses zweite Inc(P)?
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P); {<<<}
  end else
    Inc(P); {<<<}

und dann noch etwas an der Reihenfolge veränderst.

Delphi-Quellcode:

while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    Inc(P); {<<<}
    if P^ = #10 then {<<<}
      Inc(P);
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P);
  end else
    Inc(P);

Ich verstehe das 2. Inc(p) nicht.

Delphi-Quellcode:

if (P + 1)^ = #10 then
      Inc(P);
    Inc(P); {<<<} /hier!!!

nach dem ersten Inc(p) steht doch der Stringzeiger bereits auf dem ersten Zeichen der neuen Zeile.

[himitsu]

Das zweite Inc(P) gehört zur #13 und das erste zur #10. (darum nochmal die Drehung im zweiten Code)

Delphi-Quellcode:

while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    if (P + 1)^ = #10 then // nächstes Zeichen
      Inc(P); // #10
    Inc(P); // #13
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P); // #10
  end else
    Inc(P); // Rest


while P^ <> #0 do
  if P^ = #13 then begin
    Inc(Result);
    Inc(P); // #13
    if P^ = #10 then
      Inc(P); // #10
  end else if P^ = #10 then begin
    Inc(Result);
    Inc(P); // #10
  end else
    Inc(P); // Rest

Letzteres ist also die direkte/ursprüngliche Funktionsweise und beim ursprünglichen Code wurde das alles in einen etwas kürzeren Code optimiert.
Dieses Erste entspricht von der Funktion dem Urspungscode, nur daß ursprünglich eben die dreifachen Inc(P) zu Einem zusammengefast und aus den IFs rausgeholt waren.



Früher war #13#10 der Zeilenumbruch (kennt man vorallem von den Druckern ... CR/CarriageReturn/#13 zurück zum Zeilenanfang + LF/LineFeed/#10 zur nächsten Zeile)
Windows macht das standardmäßig immernoch so.

Linux wollte sparen, drum nutzen die standardmäßig nur noch #10, wo implizit das Carriage Return mit enthalten ist.

Macintosh kochte sein eigenes Süppchen und dachte sich #13 wäre auch ein guter Zeilenwechsel, obwohl das syntaktisch nun überhaupt nicht stimmt.

Windows selber unterstützt standardmäßig alles (vorallem #13#10 und #10), aber z.B. im neuen RichEdit-Control v3 hat man totalen Mist gebaut und dort wird das #13 als Zeilenumbruch verwendet (keine Ahnung warum).

#10#13 währe teschnich gesehn auch ein Zeilenumbruch, aber dieses wird als #10 und #13 angesehn, also zwei Zeilenumbrüche.
Vermutlich weil es einfacher zu implementieren war, bzw. bei der implementierung keiner dran gedacht hat (währe aber auch nur ein IF+INC mehr).

[DeddyH]

@schöni:

Zitat:

Delphi-Quellcode:

if P^ = #13 then begin
    Inc(Result);
    if (P + 1)^ = #10 then //wir stehen hier noch auf #13
      Inc(P); //jetzt auf #10
    Inc(P); //und jetzt erst auf der neuen Zeile
  end

[Popov]

Ganz einfach einfach!

Entweder ist es #10 oder #13 oder #13#10, aber nie gemischt, also einfach einfach machen.

Und noch was, auch Str := '' ist eine Zeile!

Delphi-Quellcode:

function CRLFCount(Str: String): Integer;
var
  cl: Char;
begin
  Result := 1;

  cl := #10;
  if Pos(cl, Str) = 0 then cl := #13;

  while Pos(cl, Str) > 0 do
  begin
    Inc(Result);
    Delete(Str, 1, Pos(cl, Str) + 1);
  end;
end;


procedure TForm1.Button1Click(Sender: TObject);
var
  s: String;
begin
  s := 'aaa' + #13#10 + 'aaa' + #13#10 + 'aaa' + #13#10 + 'aaa';

  ShowMessage(IntToStr(CRLFCount(s)))
end;

[UliBru]

Zitat:

Zitat von himitsu (Beitrag 1165539)

Früher war #13#10 der Zeilenumbruch (kennt man vorallem von den Druckern ... CR/CarriageReturn/#13 zurück zum Zeilenanfang + LF/LineFeed/#10 zur nächsten Zeile)
Windows macht das standardmäßig immernoch so.

Ist das nicht auch heute bei einer Konsolenausgabe nach wie vor gültig?

[p80286]

Eine kleine Änderung:

Delphi-Quellcode:

function CountLines(const s: string): integer;
var
  PrevCR: Boolean; //Previous Carriage Return
  i: integer;
begin
  Result := 0;
  PrevCR := false;

  for i := 1 to Length(s) do begin
    case s[i] of
      #13: Inc(Result);
      #10: if not PrevCR then
            Inc(Result);
    end;
    PrevCR := s[i]=#13;
  end;
end;

Gruß
K-H

Das mit dem CarriageReturn und Linefeed sollte man ganz wörtlich nehmen.
mit #13 #10 #10 #10 kann man auf der Konsole, und bei den meisten Druckern 2 Leerzeilen erzeugen.
Wenn das Gerät sich auf die Interpretation der ASCII-Zeichen einläßt!

[DeddyH]

Danke, mich hat die doppelte Zuweisung auch gestört :thumb:

[himitsu]

Zitat:

Ist das nicht auch heute bei einer Konsolenausgabe nach wie vor gültig?

Joar.

Zitat:

Ganz einfach einfach!

Entweder ist es #10 oder #13 oder #13#10, aber nie gemischt, also einfach einfach machen.

Ja, das währe eine Wunschvorstellung, aber wenn man Strings concateniert, dann kann es schonmal passieren, daß eine Vermischung stattfindet, was leider nicht selten vorkommt.

Aber OK, dann müßte die Funktion aber vorher schauen welcher Zeilenumbruch verwendet wurde und dann eine entsprechende Such-/Zählfunktion ausführen,
oder man sagt der Funktion was vermutlich verwendet wurde oder man bastelt sich mehrere Funktion (oder nur die Eine grade nötige) und ruft jeweils die vermutlich Entsprechende auf.
Oder die Funktion kennt gleich alles und ihr ist es egal, was man reingibt. :angle2: