Live Stichwortsuche

[Sir Rufo]

Entweder ist das Zeichen Whitespace oder nicht.

Wenn kein Whitespace dann das Zeichen an den Buffer (string) geben
Wenn Whitespace und der Buffer nicht leer ist, den Buffer an das Array und den Buffer wieder leeren.

Delphi-Quellcode:

function ParseSearchStr( const SearchStr : string ) : TArray<string>;
var
  LCount : integer;
  LBuffer : string;
  LChar : Char;
begin
  SetLength( Result, Length( SearchStr ) div 2 + 1 );
  LCount := 0;
  for LChar in SearchStr do
  begin
    if ( LChar = ' ' ) and ( LBuffer <> '' ) then
    begin
      Result[LCount] := LBuffer;
      Inc( LCount );
      LBuffer := '';
    end
    else
      LBuffer := LBuffer + LChar;
  end;
  if LBuffer <> '' then
  begin
    Result[LCount] := LBuffer;
    Inc( LCount );
  end;
  SetLength( Result, LCount );
end;

Bevor du mich fragst, warum ich das Ausgabe-Array auf

Delphi-Quellcode:

Length( SearchStr ) div 2 + 1

initialisiere, überlege dir wieviele Teile ein String maximal haben kann, wenn diese durch ein Trennzeichen abgegrenzt werden

[DeddyH]

Ähnlich habe ich das auch gerade umgesetzt (nur ohne Generics):

Delphi-Quellcode:

type
  TDynStringArray = array of string;

function StrToArray(const InputStr: string): TDynStringArray;
var
  PLast, PCurrent: PChar;
  s: string;
  ArrayIndex: integer;
begin
  SetLength(Result, Length(InputStr) div 2);
  ArrayIndex := Low(Result);
  PLast := PChar(InputStr);
  PCurrent := PChar(InputStr);
  while PCurrent^ <> #0 do
    begin
      if PCurrent^ = ' ' then
        begin
          SetString(s, PLast, PCurrent - PLast);
          Result[ArrayIndex] := s;
          inc(ArrayIndex);
          PLast := CharNext(PCurrent);
        end;
      PCurrent := CharNext(PCurrent);
    end;
  SetString(s, PLast, PCurrent - PLast);
  Result[ArrayIndex] := s;
  SetLength(Result, ArrayIndex + 1);
end;

[Ajintaro]

:shock:das das zaubert ihr mal eben so raus ?

Das ist natürlich ein schlauer Ansatz: nur wenn der buffer leer ist und im suchstring ein whitespace vorkommt, findet eine Übergabe an das array statt. Dabei muss das Suchwort aus mindestens ein 2 Chars bestehen. D.h. man muss nicht einmal das Wort voll ausschreiben, man kann es auch abgekürzt übergeben! Genial.
Bei erfolgreicher Übergabe wird der Puffer wieder geleert, andernfalls um ein weiteres Zeichen ergänzt.

Das hat mir sehr geholfen und wird vermutlich vielen anderen auch eine große Hilfe sein.

[Sir Rufo]

Zitat:

Zitat von Ajintaro (Beitrag 1249683)

:shock:das das zaubert ihr mal eben so raus ?

Ähm, ja ... ich überlege mir immer wie ich das "zu Fuß" bzw. "per Hand" machen würde.
Also auf einem Blatt Papier steht ein Satz und ich soll alle Worte einzeln untereinander schreiben.

Wenn man jetzt einmal ganz genau darauf achtet, was man wirklich da macht, und sich zusätzlich einmal vorstellt, dass die Worte in einer mir völlig fremden Sprache (aber schon links-nach-rechts) sind, dann muss ich genau so vorgehen wie das der Rechner machen muss.

Das kleide ich jetzt in Befehle und der Drops ist gelutscht ;)

[michaelthuma]

Ja. Das gute alte C und Pascal:) So wie es sich gehört. Programmieren ist noch nicht verboten. :-D

An sich gehört das Ergebnis in eine Liste. Aber nur in der Javawelt :-D Da musst du zum Architekten gehen und Buße tun. Der labert dann wirres Zeug von Matrizen und so. So ist das in der Pascal Welt nicht. Da reichts wenn es läuft und schnell ist, davon haben die Benutzer ein Nutzen und sind nicht die Benutzten.

Delphi intern ist auch eine Liste wie gehabt ein dynamisches Array.

Rein zur Ergänzung ...

Meine Erfahrung je nach DB eher Anzahl der Sätze sollten ein Kriterium ca. 3 Zeichen lang sein, wenn du Objekte erzeugst. Sonst gehen 2. Wenn 3 nicht reichen dann besser mit Tastatur bestätigen lassen die Suche. Hängt an sich von der Arbeitsumgebung ab. Zumeist je mehr Sätze desto der müder der Rechner. Die Hardwareausstattung ist sehr oft umgekehrt proportional zum Nutzen im Arbeitsprozess oder die Hardware einfach älter, da solche Systeme sich ungern jemand traut anzugreifen.

Es gibt Datenbanken die mit %LIKE% nicht so wirklich ein Freude haben. Einer ordentlichen Datenbank ist das heute egal. Das gute alte Access war da etwas pingelig. Selbst bei bescheidenen ca. 100k Sätzen auf einem Celeron oder P IV. Solche Rechner gibt es noch ... da entsteht ein Verzögerung bei der Eingabe selbst ohne Objekterzeugung.

Es sind nicht mehr Zeichen unbedingt weniger Datensätze. 'Love' respektive 'Liebe' in einem Musikrepertoire ist überrepräsentiert.

Dann nimmt man mal einen Kellner im Stress bei der Suche. Der soll ja servieren und nicht auf der Anlage rumspielen. Aber was soll der tun wenn sich die Granny aufrafft und was modernes sich wünscht fürs Enkerl so etwas wie 'Mit BO von U2'. Ist am Ende 'Born in the USA vom Springsteen und das Enkerl kennt das trotzdem nicht...

Früher musste man noch berücksichtigen, dass die Leute das Telefon unterm Kinn hatten... die haben auch nicht viel Freude mit dem Warten. Das Szenario an sich spielt eine Rolle. Suchen und Hektik gehören irgendwie zusammen. Deswegen soll das Suchen wirklich schnell gehen.

An sich aber die beiden vorgeschlagene Variante der bessere Weg im Mittel. Der hält an sich recht gut.

Zitat:

Zitat von Ajintaro (Beitrag 1249683)

:shock:das das zaubert ihr mal eben so raus ?

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1249678)

Ähnlich habe ich das auch gerade umgesetzt (nur ohne Generics):

Delphi-Quellcode:

type
  TDynStringArray = array of string;

function StrToArray(const InputStr: string): TDynStringArray;
var
  PLast, PCurrent: PChar;
  s: string;
  ArrayIndex: integer;
begin
  SetLength(Result, Length(InputStr) div 2);
  ArrayIndex := Low(Result);
  PLast := PChar(InputStr);
  PCurrent := PChar(InputStr);
  while PCurrent^ <> #0 do
    begin
      if PCurrent^ = ' ' then
        begin
          SetString(s, PLast, PCurrent - PLast);
          Result[ArrayIndex] := s;
          inc(ArrayIndex);
          PLast := CharNext(PCurrent);
        end;
      PCurrent := CharNext(PCurrent);
    end;
  SetString(s, PLast, PCurrent - PLast);
  Result[ArrayIndex] := s;
  SetLength(Result, ArrayIndex + 1);
end;

Das Array sollte mit

Delphi-Quellcode:

Length( InputStr ) div 2 + 1

initialisiert werden, denn

Delphi-Quellcode:

'a b'

ergibt 2 Suchworte, aber du initialisierst mit

Delphi-Quellcode:

3 div 2 = 1

und es knallt ;)

Dafür würde bei meiner Version das letzte Wort nicht in das Array geschrieben :shock: und du müsstest bei deiner Version nur 2 Zeilen tauschen, damit es trotzdem funktioniert. :oops:
(Ist gefixed)

Ein weiteres Problemchen ist, dass bei

Delphi-Quellcode:

'a b '

als Ergebnis

Delphi-Quellcode:

['a','b','']

geliefert wird, aber dafür gibt es ja auch die UnitTests ;)

[DeddyH]

Da war noch ein anderer Denkfehler drin: mehrere Trennzeichen hintereinander oder nur Trennzeichen im String sollten IMO ignoriert werden. Das sieht nun so aus:

Delphi-Quellcode:

type
  TDynStringArray = array of string;

function StrToArray(const InputStr: string): TDynStringArray;
var
  PLast, PCurrent: PChar;
  s: string;
  ArrayIndex: integer;
begin
  SetLength(Result, Length(InputStr) div 2 + 1);
  ArrayIndex := Low(Result);
  PLast := PChar(InputStr);
  PCurrent := PChar(InputStr);
  while PCurrent^ <> #0 do
    begin
      if PCurrent^ = ' ' then
        begin
          SetString(s, PLast, PCurrent - PLast);
          if s <> '' then
            begin
              Result[ArrayIndex] := s;
              inc(ArrayIndex);
            end;
          PLast := CharNext(PCurrent);
        end;
      PCurrent := CharNext(PCurrent);
    end;
  SetString(s, PLast, PCurrent - PLast);
  if s <> '' then
    begin
      Result[ArrayIndex] := s;
      inc(ArrayIndex);
    end;
  SetLength(Result, ArrayIndex);
end;

[Jumpy]

Hätte man das nicht einfach mit 'ner TStringlist machen können und das Leerzeichen als Delimiter?
OK, im Falle doppelter Leerzeichen hintereiander hätte man leere Strings in der Liste, die man erst rauslöschen müsste.
Wäre wahrscheinlich langsamner, oder?

[Sir Rufo]

Zitat:

Zitat von Jumpy (Beitrag 1249802)

Hätte man das nicht einfach mit 'ner TStringlist machen können und das Leerzeichen als Delimiter?
OK, im Falle doppelter Leerzeichen hintereiander hätte man leere Strings in der Liste, die man erst rauslöschen müsste.
Wäre wahrscheinlich langsamner, oder?

Hier ist als Whitespace nur das Leerzeichen definiert. Die Erfahrung zeigt aber, dass in der Realität mehrere Zeichen als Whitespace genommen werden (z.B.

Delphi-Quellcode:

' ,.?!;'

) und diese Funktion berücksichtigt das dann einfach und bei einer StringList muss ich erst vorher alles umwandeln.

Beliebt ist es auch zusammenhängende Wörter in "" zu setzen, die dann trotz Whitspace zusammenbleiben.

Input:

Delphi-Quellcode:

'"Hallo du",da!'

Output:

Delphi-Quellcode:

['Hallo du','da']

Auch wäre eine Erweiterung denkbar um bestimmte Begriffe auszuschließen, dann müsste man sich aber ein anderes Ausgabeformat überlegen.

[Furtbichler]

Delphi-Quellcode:

Procedure SentenceToWords (const sentence : String; words : TStringList)
Var
  c : Char;
  word : String;

begin
  for c in sentence do
    if IsWhiteSpace(c) then
      if Length(word)>0 then begin
        words.Add(word);
        word := '';
      end else
    else if IsLetterOrDigit(c) then 
      word := word + c;

  if Length (word)>0 then
    words.Add(word);
end;

Ungetestet. Die Funktionen 'IsWhiteSpace' und 'IsLetterOrDigit' sind natürlich nachzuliefern (falls es sie noch nicht gibt).
Ist zwar vielleicht ein wenig langsamer, aber ob nun 10 Nanosekunden oder 30 ist -denke ich- nicht ganz so tragisch. Dafür ist es imho einfacher zu verstehen und wenigstens kann ich mit Strings arbeiten und muss mich nicht mit PChar rumschlagen, wieso hab ich mich denn für Delphi entschieden? Bei dem PChar-Geraffel hätte ich gleich C nehmen können. :mrgreen: