Zeilen in einem String zählen

[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 von himitsu:

Du hast deine Variable vergessen.

habe ich eingefügt, danke.

Zitat von himitsu:

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 von himitsu:

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 von 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;

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 von Popov:

...
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....

[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?