Hallo,

Hat jemand schon mal eine Funktion geschrieben, welche in einem Durchgang
mehere Substrings in einem String sucht?

Falls ein Substring im Suchstring vorkommt, soll die Funktion True zurückgeben.

Anstatt dies schreiben zu müssen,
if (pos(a,y) <> 0) and (pos(b,y) <> 0) and (pos(c,y) <> 0) .... then Bräuchte ich eine Funktion wie

markieren

Delphi-Quellcode:

function StringStringMultiple(const Source: AnsiString;
  const SearchPatterns: array of AnsiString;
  {CaseSensitive: Boolean = True}): Boolean;

Was hindert dich daran, deinen ersten Code in den zweiten zu stecken ? Dann hast du doch deine Funktion.

ähhhm noch nicht, aber so schwer isses ja nicht

zusammenfalten · markieren

Delphi-Quellcode:

function StringStringMultiple(Source: AnsiString;
  Const SearchPatterns: array of AnsiString;
  CaseSensitive: Boolean = True): Boolean;
  var i: Integer;

  begin
    Result := False;
    if CaseSensitive then Source := AnsiLowerCase(Source);
    for i := 0 to High(SearchPatterns) do
      if (CaseSensitive and (Pos(AnsiLowerCase(SearchPatterns[i]), Source) <> 0))
        or (not CaseSensitive and (Pos(SearchPatterns[i], Source) <> 0)) then begin
        Result := True;
        Exit;
      end;
  end;

[edit=Luckie]Tags gefixt. Mfg, Luckie[/edit]
thanks ._.

Wortwörtlich war das natürlich nicht gemeint .

PS: Zwei klitzekleine Fehler sind noch drin.

Wäre es nicht schneller, wenn der ganze String nur einemal Zeichen für Zeichenn durchlaufen wird und
jeweils überprüft, ob die Substrings vorkommen?

Hallo,

wenn man meine Funktion anpasst und nur den ersten Teil verwendet, sollte das auch funktionieren.

Ungefähr so:

zusammenfalten · markieren

Delphi-Quellcode:

function FindMultiple(const Source: AnsiString;
  const Patterns: array of AnsiString;
  CaseSensitive: Boolean = True): Boolean;

type
  TPattern = record
    S: AnsiString;
    L: Integer;
  end;

var
  C: Integer;

  FPatterns: array of TPattern;
  PatternCount: Integer;
  PNum: Integer;

  SourceLength: Integer;
  SearchSource: AnsiString;
begin
  // Is there anything to find at all?
  if (Source = '') or (Length(Patterns) = 0) then
  begin
    Result := False;
    Exit;
  end;

  PatternCount := Length(Patterns);
  SetLength(FPatterns, PatternCount);
  for C := 0 to PatternCount - 1 do
  begin
    if CaseSensitive then
      FPatterns[C].S := Patterns[C]
    else
      FPatterns[C].S := AnsiLowerCase(Patterns[C]);
    FPatterns[C].L := Length(Patterns[C]);
  end;

  if CaseSensitive then
    SearchSource := Source
  else
    SearchSource := AnsiLowerCase(Source);

  Result := True;
  try
    SourceLength := Length(Source);
    C := 1;
    while C <= SourceLength do
    begin
      for PNum := 0 to PatternCount - 1 do
      begin
        // Check first char before we waste a jump to CompareMem
        if (SearchSource[C]) = (FPatterns[PNum].S[1]) then
        begin
          if CompareMem(@SearchSource[C], @FPatterns[PNum].S[1], FPatterns[PNum].L) then
            Exit;
        end;
      end;
      Inc(C);
    end;

  finally
    // Clean up
    Finalize(FPatterns);
  end;
  Result := False;
end;

Gruß
xaromz

Zitat von toms:

Wäre es nicht schneller, wenn der ganze String nur einemal Zeichen für Zeichenn durchlaufen wird und
jeweils überprüft, ob die Substrings vorkommen?

Ob man nun die Suchstrings einmal (im Ganzen) und dafür im Source mehrfach sucht,
oder die Suchstrings mehrfach (Zeichen für Zeichen) und dafür den Source nur einmal sollte eigentlich im Großen und Ganzen egal sein.



@xaromz es kann ja mal jemand Testen, aber da ich abgesehn von AnsiLowerCase keine weißeren speicherverändernten Operationen ausführe (in Bezug auf die Strings), sollte meines wohl etwas schneller sein ^^