Volltextsuche

[DeddyH]

Ich habe mal schnell eine kleine Klasse zusammengehackt, die intern eine sortierte Stringliste verwendet (allerdings ganz einfach über Sorted auf true, das dürfte also case-sensitive sein).

Delphi-Quellcode:

type
  TWoerterbuch = class
  strict private
    FWoerter: TStringlist;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(const Wort: string): integer;
    procedure Clear;
    procedure Delete(Index: integer);
    procedure Filter(const Suchwort: string; FilterResult: TStrings);
  end;

...

implementation

...

uses StrUtils;

{ TWoerterbuch }

function TWoerterbuch.Add(const Wort: string): integer;
begin
  Result := FWoerter.Add(Wort);
end;

procedure TWoerterbuch.Clear;
begin
  FWoerter.Clear;
end;

constructor TWoerterbuch.Create;
begin
  inherited;
  FWoerter := TStringlist.Create;
  FWoerter.Sorted := true;
end;

procedure TWoerterbuch.Delete(Index: integer);
begin
  FWoerter.Delete(Index);
end;

destructor TWoerterbuch.Destroy;
begin
  FWoerter.Free;
  inherited;
end;

procedure TWoerterbuch.Filter(const Suchwort: string; FilterResult: TStrings);
var
  i: integer;
begin
  Assert(Assigned(FilterResult));
  FilterResult.BeginUpdate;
  try
    FilterResult.Clear;
    for i := 0 to FWoerter.Count - 1 do
      if (Suchwort = '') or AnsiStartsText(Suchwort, FWoerter[i]) then
        FilterResult.Add(FWoerter[i]);
  finally
    FilterResult.EndUpdate;
  end;
end;

Das ist natürlich die billigste Variante, läuft auf meinem Rechner allerdings erstaunlich performant (Athlon II X4 2,8 GHz, 2 GB RAM).

@jandelph: Ich erwarte natürlich nicht, dass Du den Code verstehst, trotzdem kannst Du ihn ja einmal gedanklich nachvollziehen und zu unklaren Begriffen in der Hilfe nachlesen. Bei weiteren Fragen einfach fragen

[edit] Wobei mir einfällt: das Sorted kann man sich hier eigentlich auch sparen, da in dieser Variante sowieso die ganze Liste durchlaufen wird. Aber durch geschickte Abbruchbedingungen kann man das ja unterbinden, was die ganze Sache wohl enorm beschleunigen kann [/edit]

[himitsu]

Zitat von DeddyH:

das dürfte also case-sensitive sein

Aber nur, wenn TStringList.CaseSensitive auf true gesetzt wurde.

Du könntest über TStringList.Find den Anfang innerhalb der sortierten Liste suchen, also das was als Erstes dem gesuchten Wortanfang "ähnlich" ist.

[patti]

Und warum lässt du die StringList sortieren? Du läufst ja trotzdem die komplette Liste durch, also macht das Sortieren gar keinen Sinn - sondern kostet nur Zeit beim Insert/Delete.

Edit: Sehe gerade dein Edit...

[DeddyH]

StrUtils, steht auch im Source

[himitsu]

Zitat von DeddyH:

StrUtils, steht auch im Source

Und in der (verlinkten) OH.

[DeddyH]

Um mein Edit (und pattis Einwand) jetzt nicht so doof da stehen zu lassen:

Delphi-Quellcode:

procedure TWoerterbuch.Filter(const Suchwort: string; FilterResult: TStrings);
var
  i: integer;
  MatchingFound: Boolean;
begin
  Assert(Assigned(FilterResult));
  FilterResult.BeginUpdate;
  try
    (* Noch keine Treffer gefunden *)
    MatchingFound := false;
    FilterResult.Clear;
    for i := 0 to FWoerter.Count - 1 do
      if (Suchwort = '') or AnsiStartsText(Suchwort, FWoerter[i]) then
        begin
          FilterResult.Add(FWoerter[i]);
          MatchingFound := true;
        end
      else
        (* Wenn bereits Treffer gefunden wurden, der aktuelle String
           aber nicht mehr passt, sind auch keine weiteren Treffer mehr
           zu erwarten -> Schleife verlassen *)
        if MatchingFound then
          break;
  finally
    FilterResult.EndUpdate;
  end;
end;

[himitsu]

Um den Anfang auch noch wegzuoptimieren...

Delphi-Quellcode:

procedure TWoerterbuch.Filter(const Suchwort: string; FilterResult: TStrings);
var
  i: Integer;
begin
  Assert(Assigned(FilterResult));
  FilterResult.BeginUpdate;
  try
    FilterResult.Clear;
    if Suchwort <> '' then begin
      FWoerter.Find(SearchWord, i);
      while (i < FWoerter.Count) and AnsiStartsText(Suchwort, FWoerter[i]) do
        FilterResult.Add(FWoerter[i]);
    end else
      FilterResult.AddStrings(FWoerter);
  finally
    FilterResult.EndUpdate;
  end;
end;

(ich hoffe es funktioniert)

Delphi-Quellcode:

function TDictionary.Filter(const SearchWord: string; FilterResult: TStrings; OnlyAtTheBeginningOfWords: Boolean): Boolean;
var
  i: Integer;
begin
  Assert(Assigned(FilterResult));
  FilterResult.BeginUpdate;
  try
    FilterResult.Clear;
    if SearchWord <> '' then begin
      FListOfWords.Find(SearchWord, i);
      while (i < FListOfWords.Count)
          and ((not OnlyAtTheBeginningOfWords and AnsiContainsText(SearchWord, FListOfWords[i]))
            or (OnlyAtTheBeginningOfWords and AnsiStartsText(SearchWord, FListOfWords[i]))) do 
        FilterResult.Add(FListOfWords[i]);
    end else
      FilterResult.AddStrings(FListOfWords);
  finally
    Result := FilterResult.Count <> 0;
    FilterResult.EndUpdate;
  end;
end;

Und wenn man nun noch Names und Values verwendet, bekommt man auch noch die Übersetzung mit rein.

[haentschman]

ganz ehrlich ?
und wenn es nur 1000 Wörter sind würde ich eine Query auf eine Tabelle in einer DB loslassen. Diese Performance ist glaub ich kaum zu toppen...
...und das alles ohne Kopfschmerzen man kann alles unnötig verkomplizieren...