Anzahl eines Zeichens im String ermitteln

[devidespe]

Wie kann man die Anzahl eines Zeichens in einem vorliegenden String ermitteln ? Die Pos-Funktion sucht ja nur das erste Zeichen.

Gibt es dafür eine spezielle Funktion, oder muss ich etwa den String in eine temporäre Variable kopieren und nach jedem gefundenen Pos-Ergebnis das Zeichen in dieser Temp-Variable löschen (in einer Schleife) ?

[dominikkv]

Delphi-Quellcode:

Length(myString)

[1234588]

Delphi-Quellcode:

var
  i: LongInt;
  j: LongInt = 0;
begin
  for i := 1 to length(str) do
    if str[i] = zeichen then Inc(j);

es wird einfach zeichen fuer zeichen verglichen. in j findest du dann die anzahl der zeichen

//edit
die funktion dazu:

Delphi-Quellcode:

function miep(const s: String; c: Char): LongInt;
var
  i: LongInt;
begin
  result := 0;
  for i := 1 to length(s) do
    if s[i] = c then Inc(result);
end;

[mkinzler]

Man könnte es auch mit PosEx() machen

[inherited]

Zitat:

Zitat von mkinzler

Man könnte es auch mit PosEx() machen

Was vermutlich noch ineffektiver wäre

[mkinzler]

Zitat:

Was vermutlich noch ineffektiver wäre

Warum?

[inherited]

Ich hab zwar grad kein Delphi zur verfügung, aber ich denke dass PosEx nichts anderes macht als den String durchzugehen. Dann kann man sich die mehrfachen Aufrufe auch gleich sparen und per Hand zählen.

[mkinzler]

Dann wäre es schlimmstenfalls genauso ineffektiv.

[devidespe]

Also ich habe jetzt eine eigene Funktion geschrieben, die in einer For-To-Do-Schleife (danke @1234588) den String durchsucht.

Ich habe gerade aber auch ein Beispiel mit PosEx hier entdeckt.

[Ydobon]

Geht sogar als Einzeiler:

Delphi-Quellcode:

z:=Length(str)-Length(StringReplace(str, c, '', [rfReplaceAll]))

[inherited]

Zitat:

Zitat von mkinzler

Dann wäre es schlimmstenfalls genauso ineffektiv.

Plus die Zeit die für die Funktionsaufrufe draufgeht plus die Zeit für die Kontrollstruktur drumherum.

[Meflin]

Zitat:

Zitat von inherited

Plus die Zeit die für die Funktionsaufrufe draufgeht plus die Zeit für die Kontrollstruktur drumherum.

Ja und?!

Jungs, es ist immerwieder unglaublich, wie man krampfhaft eine simple Frage unglaublich aufblähen kann :roll:

[marabu]

Moin,

Zitat:

Zitat von inherited

... ich denke dass PosEx nichts anderes macht als den String durchzugehen. ...

das ist zu allgemein: PosEx() benötigt noch eine zweite Schleife für den String-Vergleich. PosEx() ist also nur sinnvoll, wenn wirklich nach einem String gesucht wird. Ein String mit der Länge 1 ist aber ein getarnter Char - und den findet man billiger mit einer eigenen Zählschleife.

Delphi-Quellcode:

function Occurs(const s: string; c: Char): Cardinal;
var
  n: Cardinal;
begin
  Result := 0;
  for n := 1 to Length(s) do
    Inc(Result, Ord(s[n] = c);
end;

Freundliche Grüße

[Missionar]

'ne andere Version in die runde geb

Delphi-Quellcode:

function cCount(str: string; c: char): integer;
var
  x: char;
begin
  result := 0;
  for x in str do
    if x = c then inc(result);
end;

[alzaimar]

Delphi-Quellcode:

...
    Inc(Result, Ord(s[n] = c);
...

Ein IF und das Ganze ist 4x schneller (String mit zufälligen Großbuchstaben füllen, nach 'A' suchen).

Delphi-Quellcode:

Function IFCount (Const s : String; c : Char) : Integer;
Var
  i : Integer;

Begin
  Result := 0;
  For i:=1 to length(s) do
    If s[i]=c then
      inc (Result);
End;

[Alter Mann]

???

An Position Null wird die Länge gespeichert, Abfrage also

Delphi-Quellcode:

var
  s : string;
begin
  s := "Wir gewinnen das Finale";
  case s[0] of
   1 : begin end;
   else : s := s + " am Sonntag!";
  end;
end;

[Apollonius]

Du hast wohl zu lange mit reinem Pascal programmiert. In Delphi ist der Standard-String-Type zur Zeit Ansistring und nicht Shortstring. In Ansistrings wird die Länge nicht mehr im ersten Byte gespeichert, sondern liegt in den vier Byte vor dem eigentlichen String. Das Ansprechen von s[0] führt daher zu einem Compiler-Fehler.
Außerdem hat das nichts mit der Frage zu tun.

[Alter Mann]

Stimmt, mit der Frage hat es nichts zu tun :oops:

[Graf Gustav]

Delphi-Quellcode:

z:=Length(str)-Length(StringReplace(str, c, '', [rfReplaceAll]))

@Ydobon:
das ist genial (auch nach 10 Jahren noch) 8-)

[himitsu]

Vom Code her ja, aber von der Ausführungsgeschwindigkeit und vom Speichermanagement her ist es schon ein bisschen grausam.

> eine "nur lese"-Funktion, die daber sehr oft schreibend im Speicher rumpfuscht

Es geht aber inzwischen noch kürzer

Delphi-Quellcode:

z := Length(str) - Length(StringReplace(str, c, '', [rfReplaceAll]));

z := Length(str) - Length(ReplaceStr(str, c, ''));

Gut, da ist dann noch ein CALL mehr drin, aber der fällt nun auch nicht mehr auf.

* aus dem Char "c" einen String machen (Speicher reservieren)
* im StringReplace einen neuen String erstellen und in dem uneffektiv rumfummeln (StringReplace ist nicht grade effektiv geschrieben, also alles umkopieren nach jedem einzelnen ersetzten Char)
* im Delphi zählen die Length wenigstens nicht die Chars, sondern lesen nur die Längenangabe der String aus, aber wollen wir das nicht mit StrLen auch noch etwas disoptimieren?
* die Strings wieder freigeben

* und in älternen Delphi (vor D2006) macht es noch mehr Spaß ... kein FastMM (im langsamen alten Delphi-MemoryManager) ... ohne FastCode (wobei hier StringReplace eh nicht das Schnellste bekommen hat)


Aber da RegEx sowieso das Coolste hier, hier auch noch eine Lösung damit :stupid:

Delphi-Quellcode:

z := TRegEx.Match(str, c).Groups.Count;

// falls C eines der RegEx-Controlzeichen sein könnte, sollte man es vielleicht besser noch escapen
z := TRegEx.Match(str, Format('\x%.2x', [Ord(c)])).Groups.Count;

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1406941)

Es geht aber inzwischen noch kürzer

Genau:

Delphi-Quellcode:

N := MyString.CountChar(MyChar);

[himitsu]

Du hast zu früh geantwortet und jetzt DIE Megalösung übesehn, welche ich noch nachgetragen hatte. :cry:

[KodeZwerg]

Zitat:

Zitat von himitsu (Beitrag 1406941)

Delphi-Quellcode:

z := TRegEx.Match(str, c).Groups.Count;

// falls C eines der RegEx-Controlzeichen sein könnte, sollte man es vielleicht besser noch escapen
z := TRegEx.Match(str, Format('\x%.2x', [Ord(c)])).Groups.Count;

Welche Unit muss ich dafür einbinden, in meiner Hilfe finde ich nichts über ein TRegEx.

[Uwe Raabe]

Zitat:

Zitat von KodeZwerg (Beitrag 1406963)

Welche Unit muss ich dafür einbinden, in meiner Hilfe finde ich nichts über ein TRegEx.

System.RegularExpressions - gibt's aber noch nicht so lange.

[KodeZwerg]

Danke für instant-Antwort! Schade dann bleibts bei der langsamen Version für D2009 da Strings bei mir auch noch keine Eigenen Funktionen besitzen.

[Uwe Raabe]

Hier der Backport von

Delphi-Quellcode:

string.CountChar

für ältere Delphi-Versionen - sollte bekannt vorkommen (miep)...

Delphi-Quellcode:

function StringCountChar(const S: string; const C: Char): Integer;
var
  I: Integer;
begin
  Result := 0;
  for I:= 1 to Length(S) do
    if S[I] = C then
      Inc(Result);
end;

[KodeZwerg]

Ich nutze etwas ähnliches, hier mein Code um noch eine Variante zu zeigen (oder gabs die hier schon?):

Delphi-Quellcode:

function CountCharInString(const Str: String; const c: Char): Integer;
var
  p: PChar;
begin
  Result := 0;
  p := PChar(Pointer(Str));
  while p <> nil do
    begin
      p := StrScan(p, c);
      if p <> nil then
        begin
          inc(Result);
          inc(p);
        end;
    end;
end;

[p80286]

@KodeZwerg
Ich glaube Du solltest Dich von Deiner Version verabschieden

Zitat:

function StrScan(const Str: PAnsiChar; Chr: AnsiChar): PAnsiChar;
function StrScan(const Str: PWideChar; Chr: WideChar): PWideChar;

Warning: The ANSI version of StrScan is deprecated. Please use the AnsiStrings unit.

Returns a pointer to the first occurrence of a specified character in a string.

StrScan returns a pointer to the first occurrence of Chr in Str. If Chr does not occur in Str, StrScan returns nil (Delphi) or NULL (C++). The null terminator is considered to be part of the string.

Note: If the source string contains international characters, use AnsiStrScan instead.

und

Delphi-Quellcode:

function AnsiStrScan(Str: PAnsiChar; Chr: AnsiChar): PAnsiChar;

Zitat:

Unlike the StrScan function, AnsiStrScan works with multi-byte character systems (MBCS).

Dann aber wohl nicht mit Unicode.


Was auch immer international bedeutet, Uwes Version sollte immer funktionieren.

Gruß
K-H

[KodeZwerg]

Hier aus meiner Delphi-Hilfe, da stand noch nichts vonwegen veraltet aber ich respektiere das und werde das mal updaten, Danke für den Hinweis:thumb:

Delphi-Quellcode:

RAD Studio VCL Referenz

SysUtils.StrScan Funktion
Beschreibung | Siehe auch
Alles schließenGibt einen Zeiger auf das erste Vorkommen eines bestimmten Zeichens in einem String zurück.

Pascal
function StrScan(const Str: PAnsiChar; Chr: AnsiChar): PAnsiChar; overload;
function StrScan(const Str: PWideChar; Chr: WideChar): PWideChar; overload;
C++
PAnsiChar StrScan(const PAnsiChar Str, AnsiChar Chr);
PWideChar StrScan(const PWideChar Str, WideChar Chr);
Datei
SysUtils

Beschreibung
StrScan gibt einen Zeiger auf das erste Vorkommen des Zeichens Chr im String Str zurück. Ist Chr nicht in Str enthalten, gibt die Funktion nil (Delphi) bzw. NULL (C++) zurück. Das Terminierungszeichen wird als Teil des Strings betrachtet. 

Anmerkung: Enthält der Quellstring internationale Zeichen, verwenden Sie stattdessen AnsiStrScan. 
 

C++ Examples: 

 

/*
The following example uses an edit control and a button on a
form. When the button is clicked, the text in the edit
control is searched for a wildcard (asterisk character).
*/
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  if (StrScan(Edit1->Text.c_str(), '*'))
    ShowMessage("Wildcard found.");
  else
    ShowMessage("Wildcard not found.");
}
 

Delphi Examples: 

{
The following example uses a button on a form. When the
button is clicked, the text is searched for a wildcard
(asterisk character).
}
function HasWildcards(FileName: PChar): Boolean;
{ Return true if file name has wildcards in it }
begin
  HasWildcards := (StrScan(FileName, '*') <> nil) or
    (StrScan(FileName, '?') <> nil);
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  P: PChar = 'C:\Test.* ';
begin
  if HasWildcards(P) then
    ShowMessage('The string has wildcards')
  else
    ShowMessage('The string does not have wildcards');
end;
 

Siehe auch
AnsiStrScan 

StrRScan

[KodeZwerg]

Delphi-Quellcode:

function CharInStringA(const Str: AnsiString; const c: AnsiChar): Integer;
var
  p: PAnsiChar;
begin
  Result := 0;
  p := PAnsiChar(Pointer(Str));
  while p <> nil do
    begin
      p := AnsiStrScan(p, c);
      if p <> nil then
        begin
          inc(Result);
          inc(p);
        end;
    end;
end;

Habs gerade mit normalen Strings getestet, funktioniert immer noch (Sau-)schnell.

[himitsu]

Zitat:

Zitat von KodeZwerg (Beitrag 1406963)

Zitat:

Zitat von himitsu (Beitrag 1406941)

Delphi-Quellcode:

z := TRegEx.Match(str, c).Groups.Count;

// falls C eines der RegEx-Controlzeichen sein könnte, sollte man es vielleicht besser noch escapen
z := TRegEx.Match(str, Format('\x%.2x', [Ord(c)])).Groups.Count;

Welche Unit muss ich dafür einbinden, in meiner Hilfe finde ich nichts über ein TRegEx.

Solche Komponenten gibt es auch als Freeware von Fremdanbietern. (Emba hat da auch nur geklaut abgeguckt)

[KodeZwerg]

Danke für diese Information.
BTW Wie findet ihr die Variante mit (Ansi-)StrScan ? Gut oder doof?

[Uwe Raabe]

Zitat:

Zitat von KodeZwerg (Beitrag 1407014)

BTW Wie findet ihr die Variante mit (Ansi-)StrScan ? Gut oder doof?

Zwei durch einen Funktionsaufruf geschachtelte Schleifen, das Hin- und Her-Gecaste mit Ansi und Unicode, die mehrfachen, komplexen Abfragen auf MBCS Zeichen - eher suboptimal und potentiell langsamer als die einfache For-Schleife über den string, die vom Compiler auch noch optimiert werden kann.

Zitat:

Zitat von KodeZwerg (Beitrag 1406975)

Habs gerade mit normalen Strings getestet, funktioniert immer noch (Sau-)schnell.

Hast du mal konkrete Zeiten verglichen oder ist das nur so gefühlt?

[KodeZwerg]

Ich hatte es nur einmal gebencht (die StrScan nicht AnsiStrScan), Jahrzehnte her, da gewann im Benchmark immer die StrScan vs ForToLength. Je Länger der InputString umso deutlicher wurde das Ergebnis. Ich schau mal ob ich einen Benchmark bastel und stell den dann gerne hier vor, ich werde alle Varianten aus diesem Thread darin antreten lassen, implementieren kann ich allerdings nur Methoden die ich mit D2009 auch umsetzen kann, dann Wissen wirs exakter :idea:
Ps: Es ist nur eine Schleife bei mir.

[Uwe Raabe]

Zitat:

Zitat von KodeZwerg (Beitrag 1407024)

Ps: Es ist nur eine Schleife bei mir.

Die andere läuft innerhalb StrScan/AnsiStrScan.

Wenn die For-Schleife denn unbedingt vermieden werden soll, kann man es auch so machen:

Delphi-Quellcode:

function CharCount(const S: string; const C: Char): Integer;
var
  N: Integer;
  P: PChar;
begin
  N := 0;
  P := PChar(S[1]);
  while P^ <> #0 do begin
    if P^ = C then Inc(N);
    Inc(P);
  end;
  Result := N;
end;

[KodeZwerg]

Anbei ein Benchmark Source-Only Projekt.
Eindeutiger Gewinner = StrScan()
Eindeutiger Verlierer = Ydobon mit

Delphi-Quellcode:

x := Length(Data)-Length(StringReplace(Data, 'X', '', [rfReplaceAll]))

.
Am zweitbesten schneidet bei mir alzaimar mit IFCount(Data, 'X'), respekt dafür:thumb::thumb:
Dahinter alles andere, schlusslicht bei den normalen Methoden ist AnsiStrScan().

@Uwe, Dein letzter Code löst bei mir bei Aufruf eine Exception aus, der Code ist bereits enthalten, nur in der Mausklick Procedure rausgeklammert.

[Uwe Raabe]

Zitat:

Zitat von KodeZwerg (Beitrag 1407033)

@Uwe, Dein letzter Code löst bei mir bei Aufruf eine Exception aus

Das muss natürlich auch

Delphi-Quellcode:

P := PChar(S);

heißen.

[KodeZwerg]

Dein letzter Code führt damit die Rangliste an!! Grandioses Ergebnis, schlägt alles um Längen:thumb::thumb:

Tut mir leid, da muss wohl mein Rechner noch an was gewerkelt haben als ich es testete.
StrScan() immer noch #1 aber total dicht dahinter ist Dein Code (@Uwe), im Grunde teilen die sich die Pole-Position.

Im Anhang aktualisiert Fassung, das StringReplace ist rauskommentiert deswegen immer 0 Nanosekunden.
Fenster ist nun sizeable, Memo ist AlignClient.
Ein Kompilat zum sofort Testen ist enthalten.

[gammatester]

Zitat:

Zitat von Uwe Raabe (Beitrag 1407025)

Wenn die For-Schleife denn unbedingt vermieden werden soll, kann man es auch so machen:

Delphi-Quellcode:

function CharCount(const S: string; const C: Char): Integer;
var
  N: Integer;
  P: PChar;
begin
  N := 0;
  P := PChar(S[1]);
  while P^ <> #0 do begin
    if P^ = C then Inc(N);
    Inc(P);
  end;
  Result := N;
end;

Der Code (und auch einige andere) bricht aber die Schleife ab, wenn S ein #0 enthält, zB S = '123'#0#1#2'123'. (Habe nicht den ganzen Thread gelesen, und weiß also nicht ob das verboten ist).

[Uwe Raabe]

Zitat:

Zitat von gammatester (Beitrag 1407043)

Der Code (und auch einige andere) bricht aber die Schleife ab, wenn S ein #0 enthält, zB S = '123'#0#1#2'123'. (Habe nicht den ganzen Thread gelesen, und weiß also nicht ob das verboten ist).

Ja, das machen alle Lösungen, die auf PChar basieren. Wenn das ein Kriterium ist (z.B. wenn man die Anzahl der #0 im String zählen will), dann muss es halt doch über die For-Schleife gehen.