Zeilen in einem String zählen

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

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

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;