Like unter Delphi

[Muetze1]

Falls ihr OpenSource etc baut, dann weise ich hier mal darauf hin, dass die Unit Masks nicht in den Personal Editionen von Delphi enthalten waren/sind. Ich habe deshalb auch eine eigene Implementation schreiben müssen für meine XMLLib. Im Archiv ist die Funktion enthalten, Link in der Signature...

Ansonsten gibt es ab (D6?) D7 in der StrUtils die Funktion SoundExSimilar() welche hierbei vllt. auch hilfreich ist, wobei die Funktion eher auf ähnliche Aussprache achtet als auf ähnliche Schreibweise...

[sakura]

Zitat von Muetze1:

wobei die Funktion eher auf ähnliche Aussprache achtet

und dazu nur in Englisch und ähnlich auszusprechenden Sprachen

......

[smudo]

Ich habs vorerst mit der von Schubi geposteten Methode gelöst - nur anstelle des * das % verwendet.

Mehr würde mich aber die Möglichkeit über die regulären Ausdrücke interessieren. Das Programm von Chris habe ich dafür schon mal benutzt, bin allerdings auf diesem Gebiet noch völlig unbewandert:

• eine Like-Abfrage z.B. für reg% Ausdr?ck* scheint mit RegEx so auszusehen: reg[ /.äöü\w]* Ausdr[ äöü\w]ck[ äöü\w]*
  damit finde ich reguläre Ausdrücke, reg. Ausdrücke, reg. Ausdruck
  Liege ich damit richtig
• Ich habe keinen Plan, wie ich diesen (oder einen besseren) regulären Ausdruck unter Delphi verwenden kann

[CK_CK]

Hi!
Für reguläre Ausdrücke kann ich den Wikipedia-Artikel dazu empfehlen. Da wird die ganze Syntax perfekt beschrieben.

Für Delphi gibt's z.B. [DIESE] Unit. Die funktioniert schön schnell und versteht auch die Perl-Extensions. Da ist auch eine (deutsche) Dokumentation dabei.

Viele Grüße,
Chris

[Zacherl]

Guckst du hier:

Delphi-Quellcode:

function Like(const AString, APattern: String): Boolean;
var
  StringPtr, PatternPtr: PChar;
  StringRes, PatternRes: PChar;
begin
  Result:=false;
  StringPtr:=PChar(AString);
  PatternPtr:=PChar(APattern);
  StringRes:=nil;
  PatternRes:=nil;
  repeat
    repeat
      case PatternPtr^ of
        #0: begin
          Result:=StringPtr^=#0;
          if Result or (StringRes=nil) or (PatternRes=nil) then
            Exit;
          StringPtr:=StringRes;
          PatternPtr:=PatternRes;
          Break;
        end;
        '*': begin
          inc(PatternPtr);
          PatternRes:=PatternPtr;
          Break;
        end;
        '?': begin
          if StringPtr^=#0 then
            Exit;
          inc(StringPtr);
          inc(PatternPtr);
        end;
        else begin
          if StringPtr^=#0 then
            Exit;
          if StringPtr^<>PatternPtr^ then begin
            if (StringRes=nil) or (PatternRes=nil) then
              Exit;
            StringPtr:=StringRes;
            PatternPtr:=PatternRes;
            Break;
          end
          else begin
            inc(StringPtr);
            inc(PatternPtr);
          end;
        end;
      end;
    until false;
    repeat
      case PatternPtr^ of
        #0: begin
          Result:=true;
          Exit;
        end;
        '*': begin
          inc(PatternPtr);
          PatternRes:=PatternPtr;
        end;
        '?': begin
          if StringPtr^=#0 then
            Exit;
          inc(StringPtr);
          inc(PatternPtr);
        end;
        else begin
          repeat
            if StringPtr^=#0 then
              Exit;
            if StringPtr^=PatternPtr^ then
              Break;
            inc(StringPtr);
          until false;
          inc(StringPtr);
          StringRes:=StringPtr;
          inc(PatternPtr);
          Break;
        end;
      end;
    until false;
  until false;
end;

Das hab ich hier mal irgendwo im Forum gefunden ..

[dominikkv]

Hier -> * klick * hab ich was gefunden mit dem du vergleichen kannst zu wie viel % 2 strings gleich sind... vllt kannst du damit was anfangen.

edit:
und hier kannst du auch mal vorbeischauen

[smudo]

@dominikkv: Dein zweiter Link entspricht dem, was andere schon hier gepostet haben, was auch wirklich gut funktioniert und was meine Frage beantwortet. Für mich blieb nur noch offen, wie man das Ganze mit regulären Ausdrücken machen kann (vielen Dank an CK_CK)

Der erste Link klang auch ganz spannend, ist aber leider nach genauerem Hinsehen ziemlich dürftig...

Vielen Dank an alle

René