Token Funktionen

[Pseudemys Nelsoni]

Moin,

ich möchte hier meine Token-Funktionen, die ich z.B oft zum Parsen von Text verwende, veröffentlichen - falls sie denn jemand braucht. Wer mIRC kennt, der kennt sie sicher .
Ich gebe hier mal ein Example, anhand von NumTok()/GetTok(), wo soetwas sinnvoll sein kann.
Nehmen wir einmal an, Ihr empfangt Text von einer Socket-Kompomente, der so aussieht:

Zitat:

[e-mail] command Parameter1 parameter2

Wenn ihr nun an den "command" kommen wolltet, müsstet ihr das ca so machen:

Delphi-Quellcode:

procedure TForm1.ClientSocket1Read(Sender: TObject;
  Socket: TCustomWinSocket);
var
  S, Command: string;
begin
  S := Socket.ReceiveText;
  Delete(S, 1, Pos(' ', S));
  Command := Copy(S, 1, Pos(' ', S)-1);
  if Command = 'irgendeincommand' then ...
end;

In einigen Fällen könnte das auch fehlschlagen, da Paramater1 und Parameter2 vielleicht optional sind und daher kein Space mehr nach "command" kommt.
Demnach müsstet Ihr euren Code vielleicht sogar so schreiben:

Delphi-Quellcode:

procedure TForm1.ClientSocket1Read(Sender: TObject;
  Socket: TCustomWinSocket);
var
  S, Command: string;
begin
  S := Socket.ReceiveText;
  Delete(S, 1, Pos(' ', S));
  S := S + ' ';
  Command := Copy(S, 1, Pos(' ', S)-1);
  if Command = 'irgendeincommand' then ...
end;

Nicht sehr schön .

Per GetTok() könnte das ganze nun so aussehen:

Delphi-Quellcode:

procedure TForm1.ClientSocket1Read(Sender: TObject;
  Socket: TCustomWinSocket);
var
  S, Command: string;
begin
  S := Socket.ReceiveText;
  if GetTok(S, 2, ' ') = 'irgendeincommand' then ...
end;

Ein anderes Beispiel: Nehmen wir mal an Ihr wollt alle einzelnen Wörter eines Strings in eine ListBox haben und dummerweise sind mehrere Seperatoren(in unserem Fall spaces) nebeneinander dann könntet Ihr statt:

Delphi-Quellcode:

procedure Parse;
var
  S: string;
begin
  S := '   Wort1  Wort2 Wort3          Wort4   '; // Ja, ein so aufgebauter String ist selten  :-D  - Aber möglich. Ich will hier nur zeigen das immer die richtigen Ergebnisse ausgegeben werden.
  while Pos(#32#32, S) > 0 do //Solange doppelte Spaces vorhanden sind...
    Delete(S, Pos(#32#32), 1); // Lösche eines davon
  while Pos(' ', S) > 0 do // Solange ein Space vorhanden ist...
  begin
    ListBox1.Items.Add(Copy(S, 1, Pos(' ', S)-1)); // Füge String bis zum Space-1 zur Listbox hinzu
    Delete(S, 1, Pos(' ', S)); // Lösche bis zum ersten Space inklusive selbigem.
  end;
  // Kann sein das keine Spaces mehr vorhanden sind, dennoch muss der String noch nicht leer sein...
  if S <> '' then
    ListBox1.Items.Add(S);
end;

einfach per GetTok()/NumTok() folgendes machen:

Delphi-Quellcode:

procedure Parse;
var
  S: string;
  I: Integer;
begin
  S := '   Wort1  Wort2 Wort3          Wort4   ';
  for I := 1 to NumTok(S, ' ') do // Wird "4" zurückgeben.
    ListBox1.Items.Add(GetTok(S, I, ' ')); Holt den Token N anhand des Indexes I
end;

Ich habe zusätzlich noch eine weitere/schnellere Methode für diesen Fall implementiert (Tokenize()). Ihr könnt den String inhalt also auch so in eure Listbox laden:

Delphi-Quellcode:

procedure Parse;
var
  DynArray: array of string;
  I: Integer;
begin
  S := '   Wort1  Wort2 Wort3          Wort4   ';
  DynArray := Tokenize(S);
  for I := 0 to High(DynArray) do
    ListBox1.Items.Add(DynArray[I]);
end;

Ich hoffe die Beispiele reichen so.


Ich werde hier nochmal alle Methoden kurz beschreiben:

Zitat:

function AddTok(const S, T: string; const C: Char; CS: Boolean = False): string;

Fügt ein Token an das Ende eines Strings, sofern er noch nicht existiert.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := AddTok(S, 'blubb', '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.wie.gehts.hallo.blubb"

Zitat:

function DelTok(const S: string; N: Integer; const C: Char): string; overload;

Löscht einen Token anhand seines Indexes (N)

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := DelTok(S, 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.gehts.hallo"

Zitat:

function DelTok(const S: string; const N1, N2: Integer; const C: Char): string; overload;

Löscht einen Token anhand seines Indexes (N) bis zum 2ten Index (N2)

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := DelTok(S, 2, 3, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.hallo"

Zitat:

function FindTok(const S, T: string; N: Integer; const C: Char; CS: Boolean = False): Integer;

Findet den Token T in S anhand des Vorkommens N und gibt dessen Index wieder.
Sollte N 0 sein, werden Die Menge der Übereinstimmungen zurückgeliefert.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: Integer;
begin
  Ergebnis := FindTok(S, 'hallo', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "4"

Zitat:

function GetTok(const S: string; N: Integer; const C: Char): string; overload;

Gibt den Token anhand seines Indexes zurück

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := GetTok(S, 3, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "gehts"

Zitat:

function GetTok(const S: string; const N1, N2: Integer; const C: Char): string; overload;

Gibt den Token anhand seines Indexes bis zum 2ten Index zurück

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := GetTok(S, 2, 3, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "wie.gehts"

Zitat:

function InsTok(const S, T: string; N: Integer; const C: Char): string;

Fügt einen Token in einen String ahand seines Indexes ein.
Sollte N über die Menge der Token in S liegen, wird der eizufügende Token (T) and das Ende von S angefügt.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := InsTok(S, 'jojo', 3, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.wie.jojo.gehts.hallo"

Zitat:

function IsTok(const S, T: string; const C: Char; CS: Boolean = False): Boolean;

Prüft ob ein Token in einem String existiert

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: Boolean;
begin
  Ergebnis := IsTok(S, 'hallo', '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "True"

Zitat:

function MatchTok(const S, T: string; N: Integer; const C: Char): Variant;

Gibt den N Token der mit T übereinstimmt wieder. Sollte N 0 sein, wird die Anzahl der vorkommen von T in S zurückgegeben.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallihallo';
var
  Ergebnis: string;
begin
  Ergebnis := MatchTok(S, 'hal', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallihallo"

Beispiel2:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallihallo';
var
  Ergebnis: Integer;
begin
  Ergebnis := MatchTok(S, 'hal', 0, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "2"

Zitat:

function NumTok(const S: string; const C: Char): Integer;

Zählt die Menge der Token in S

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: Integer;
begin
  Ergebnis := NumTok(S, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "4"

Zitat:

function PutTok(const S, T: string; N: Integer; const C: Char): string;

Ersetzt den Token des Indexes N durch T

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := PutTok(S, 'blah', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.blah.gehts.hallo"

Zitat:

function RemTok(const S, T: string; N: Integer; const C: Char; const CS: Boolean = False): string;

Löscht den N mit T übereinstimmenden Token. Sollte N 0 sein, werden alle Übereinstimmungen aus S entfernt.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := RemTok(S, 'hallo', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.wie.gehts"

Zitat:

function RepTok(const S, T, T2: string; N: Integer; const C: Char; const CS: Boolean = False): string;

Ersetzt den N mit T übereinstimmenden Token durch T2. Sollte N 0 sein, werden alle Übereinstimmungen durch T2 ersetzt.

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := RepTok(S, 'hallo', 'jojo', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo.wie.gehts.jojo"

Zitat:

function Tokenize(const S: string; const C: Char): TStringDynArray;

Gibt ein Array von Token zurück

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: array of string;
begin
  Ergebnis := Tokenize(S, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier:

[0] = "hallo"
[1] = "wie"
[2] = "gehts"
[3] = "hallo"

Zitat:

function WildTok(const S, T: string; N: Integer; const C: Char; const CS: Boolean = False): Variant;

Gibt den N Token der mit der Maske von T übereinstimmt wieder. Sollte N 0 sein, wird die Anzahl der mit der Maske von T in S zurückgegeben

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := WildTok(S, 'h*l', 2, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "hallo"

Beispiel:

Delphi-Quellcode:

procedure Beispiel;
const
  S = 'hallo.wie.gehts.hallo';
var
  Ergebnis: string;
begin
  Ergebnis := WildTok(S, 'h*l', 0, '.');
end;

Das Ergebnis von "Ergebnis" wäre hier: "2"



Es ist egal wieviele Seperatoren nebeneinander stehen, doppelte werden immer ignoriert!
Übrigens: Einige Methoden haben den Parameter "CS", er gibt an, ob Gross/Kleinschreibung beachtet werden soll.

Um die Methoden benutzen zu können, müsst ihr eine Instanz von "TTokenizer" anlegen und könnt dann per: "Instanz." auf dessen Methoden zugreifen.

Die Unit ist im Anhang.

MfG