String auf Tabulatoren prüfen

[Ajintaro]

Hallo DP !

Ich frage mich wie man die Anzahl der Tabulatoren eines Strings zählen kann. Ich habe eine Datei:

<TAB> Name: Horst
<TAB> Haustiere:
<TAB><TAB> Name: Fiffi
<TAB><TAB> Alter: 10
<TAB><TAB> Vorbesitzer
<TAB><TAB><TAB> Name: Manuel

Ich möchte alle gefundenen Namen in ein Treeview laden und dabei die Tabs als Level der Nodes nutzen. Ergebnis:

Code:

Horst
!-> Fiffi
 !-> Manuel

Mit Pos funktioniert es nicht:

Delphi-Quellcode:

if Open_file.Execute then memo1.Lines.LoadFromFile(Open_file.FileName);
for i := 0 to memo1.lines.count-1 do
begin

       //Root Name (Besitzer)
       iPos := Pos(#9+'"name":',memo1.Lines[i]);
       if (iPos > 0) then
       begin
         s := memo1.Lines[i];
          with tree_import.Items.AddFirst(nil,s) do
           begin
              Selected := true;
           end;
          iPos := 0;
          s := ''
       end;

       //1. Child Name (Haustier)
       iPos := Pos(#9+#9+'"name":',memo1.Lines[i]);
       if (iPos > 0) then
       begin
         s := memo1.Lines[i];
         tree_import.Items.AddChild(tree_import.selected,s);
       end;
   end;

Ich habe schon über eine Stinglist mit #9 als Delimiter eine Alternative nachgegrübelt, bin da aber auch nicht weiter gekommen. Wie kann ich denn die Vorkommen eines Tabulators effektiv zählen ?

Grüße,

JJ

[Faxe]

Probier doch mal:

iPos := Pos(chr(9)+'"name":',memo1.Lines[i]);

iPos ist die Anzahl Tabs.

[pertzschc]

Zitat:

Zitat von Ajintaro (Beitrag 1268846)

Ich frage mich wie man die Anzahl der Tabulatoren eines Strings zählen kann.

Ich würde die einzelne Zeile in eine Stringliste auftrennen und dann schauen, an welcher Stelle im Index ->[i] der String "Name:" auftaucht.

<TAB> Name: Horst ->[1] (da Index bei 0 beginnt: TAB = [0])
<TAB> Haustiere:
<TAB><TAB> Name: Fiffi ->[2]
<TAB><TAB> Alter: 10
<TAB><TAB> Vorbesitzer
<TAB><TAB><TAB> Name: Manuel ->[3]

Damit hast Du Deine Levels.

Hier der Code für das Aufsplitten des Strings (bei Dir eine Memozeile) in eine Stringliste (hat bei mir auch mit TAB funktioniert):

Delphi-Quellcode:

procedure SplitLine(Source: string; Dest: TStringList; Delimeter: char = ';');
// splittet den string am delimeter auf und hängt die einzelnen strings in eine Stringlist
var
  lpos                        : Integer;
begin
  Dest.Clear;
  lpos := Pos(Delimeter, Source); // p = 0, wenn nicht gefunden
  while lpos <> 0 do begin
    Dest.Add(Copy(Source, 1, lpos - 1));
    Delete(Source, 1, lpos);
    lpos := Pos(Delimeter, Source); // suche erneut nach delimiter
  end;
  // wenn string noch nicht leer, dann hänge rest auch an liste
  if Source <> '' then begin
    Dest.Add(Source);
  end;
end;

Grüße, Christoph

[sx2008]

Zitat:

Zitat von Ajintaro (Beitrag 1268846)

... wie man die Anzahl der Tabulatoren eines Strings zählen kann

Hier kommt die Hilfe zur Selbsthilfe...

Warum verwendest du keine Zwischenvariablen?

Delphi-Quellcode:

var
   line : string;
for i := 0 to memo1.lines.count-1 do
begin
   // Grundregel für alle Programmierer die keinen Spaghetticode schreiben wollen
   // wenn man über eine Stringliste iteriert soll man das aktuellen String in eine Zwischenvariable kopieren
   line := memo1.Lines[i];
   ...
end;

Grundregel 2: Teile Methoden/Funktionen so lange auf bis eine weitere Aufteilung keinen Sinn mehr machen würde!

Du brauchst doch eigentlich nur deine Frage von oben anschauen und dann kommst du darauf,
dass du folgende Funktion benötigst:

Delphi-Quellcode:

function CountLeadingTabs(const s:string):Integer;
begin
   // die Implementierung ist trivial; das kriegst du selber hin
   // Schleife über den String und abbrechen sobald das aktuelle Zeichen <> #9 ist
   ...
end;

[Uwe Raabe]

Zitat:

Zitat von sx2008 (Beitrag 1268850)

Warum verwendest du keine Zwischenvariablen?

Delphi-Quellcode:

var
   line : string;
for i := 0 to memo1.lines.count-1 do
begin
   // Grundregel für alle Programmierer die keinen Spaghetticode schreiben wollen
   // wenn man über eine Stringliste iteriert soll man das aktuellen String in eine Zwischenvariable kopieren
   line := memo1.Lines[i];
   ...
end;

Warum dann nicht gleich so?

Delphi-Quellcode:

var
   line : string;
for line in memo1.lines do
begin
   // Grundregel für alle Programmierer die keinen Spaghetticode schreiben wollen
   // wenn man über eine Stringliste iteriert soll man das aktuellen String in eine Zwischenvariable kopieren
   ...
end;

[Dejan Vu]

Ich würde mir eine kleine Methode schreiben, die mir aus einem übergebenen String den Level (Anzahl der Tabs), den Tag (also 'Name', 'Alter','Vorbesitzer') und -falls vorhanden- den Wert, also den Zeil nach dem ':' liefert.

Delphi-Quellcode:

Type
  TTreeNodeDescriptor = record
    level : Integer;
    Caption : String;
    Value : String;
    Procedure FromString (aString : String);
  end;

Procedure TTreeNodeDescriptor.FromString (aString : String);
const
  TAB = #009; // ist das nicht irgendwo in SysUtils o.ä. schon deklariert?

var
  valueDelimiterFound : Boolen;

Begin
  Level := 0;
  Value := '';
  Caption := '';
  valueDelimiterFound := False;

  for c in aString do 
    case c of
      TAB : 
        Inc(Level);
      ':' : 
        valueDelimiterFound := true;
      else 
        if valueDelimiterFound then 
           Value := Value + c 
        else 
           Caption:=Caption + c;
    end
end;

Der Code rennt 1x durch den String und verzichtet Pos und Delete.

Delphi-Quellcode:

for line in memo1.lines do begin
  t := TTreeLevelDescriptior.FromString(line);
  if t.Caption = 'Name' then
     writeln('Anzahl der Tabs (Level)',t.Level,'. Name=',t.Value);
end;

Und falls Du morgen den kompletten Baum aufspannen willst, hast Du mit der 'FromString' Methode schon alles, was Du brauchst.

[OlafSt]

Ich würds noch anders machen:

Delphi-Quellcode:

function LeadingTabs(var AData: string): integer;
var
  i: integer;
begin
  i:=0;
  while Pos(#9,AData) <> 0 do
  begin
    Delete(AData,1,1);
    inc(i);
  end;
  Result:=i;
end;

Liefert die Anzahl Tabs zurück und auch gleich den gefragten String ohne Tabs.

[Dejan Vu]

Wenigstens 1x bis zum ersten nicht-TAB Zeichen rennen und dann mit Substring abschnippeln, das erspart unnötige
'Delete' Operationen.

Delphi-Quellcode:

function LeadingTabs(var AData: string): integer;
var
  i: integer;
begin
  for i:=1 to length(aData) do
    if aData[i] <> #0 then begin
      result := i;
      aData := Substring(aData,i,maxint);
      exit;
    end;

  result := 0;
End;

Aber wo ist da der Mehrwert zu meiner Funktion? Und den Namen musst Du auch noch rausbekommen.

Übrigens sind beide Funktionen falsch, wenn der String z.B. so aussieht '<TAB>Name<Tab>: Meyer'. Meine Funktion liefert nur den falschen Level, aber deine vergisst den Prefix 'Name' und liefert einen noch falscheren (also nicht nur ein bischen falsch, sondern total falsch falsch) Level.

[Ajintaro]

Hallo ihr lieben,

vielen Dank für eure Impulse !

Also

Zitat:

Zitat von sx2008 (Beitrag 1268850)

Hier kommt die Hilfe zur Selbsthilfe...

Warum verwendest du keine Zwischenvariablen?

ist natürlich völlig richtig.

Ich habe mir den code von Dejan Vu einmal angesehen und an einigen Stellen modifiziert. Das Ergebnis funktioniert ganz gut:

Delphi-Quellcode:

Type
  TTreeNodeDescriptor = record
    level : Integer;
    Caption : String;
    Value : String;
    Procedure FromString (aString : String);
  end;
{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// TTreeNodeDescriptor - credits to Dejan Vu
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
Procedure TTreeNodeDescriptor.FromString (aString : String);
const
  TAB = #009;
var
  valueDelimiterFound: Boolean;
  c:char;
Begin
  Level := 0;
  Value := '';
  Caption := '';
  valueDelimiterFound := False;

  for c in aString do
    case c of
      TAB :
        Inc(Level);
      ':' :
        valueDelimiterFound := true;
      else
        if valueDelimiterFound then
           Value := Value + c
        else
           Caption:=Caption + c;
    end
end;
{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Datei importieren button
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
procedure TFmain.button_scen_importClick(Sender: TObject);
var 
 line:string;
 t : TTreeNodeDescriptor;
 anode:TTreeNode;
begin
   treeview.Items.Clear;
   if Opendialog1.Execute then memo1.Lines.LoadFromFile(Opendialog1.FileName);

   for line in memo1.lines do
   begin
    t.FromString(line);
    if (t.Caption = '"name"') then
    begin
     case t.level of
      1:  anode:=treeview.Items.Add(Nil,t.Value);
      3:  begin
           treeview.Items.AddChild(anode,t.Value);
           //Node als knoten für die nächste Ebene vorbereiten?
          end;
      5:  treeview.Items.AddChild(anode,t.Value);
     end;
    end;
   end;
End;

So kann man nicht nur den String auf Tabulatoren untersuchen

Delphi-Quellcode:

for <achar> in <astring>

sondern erhält auch den dazugehörigen Wert. Das Einsortieren in ein Treeview klappt nur noch nicht ganz, da die 3. Ebene

Delphi-Quellcode:

5:  treeview.Items.AddChild(anode,t.Value);

nicht als Child von der 2. Ebene einsortiert wird.

[himitsu]

Gibt es nur vorne Tabulatoren?
Wenn nicht, dann zehlt das falsch, da du dann ja am ersten anderen Zeichen aufhören müsstest, mit dem Zählen.

Gibt es vorne nur Tabulatoren?
Wenn ja, dann TrimLeft und das Abgeschnittene zählen Length(alt)-Length(neu). (oder eben nur vorhne die Tabs zählen)

Und das Zerlegen:
* Pos
* SplitString
* TStringList.DelimitedText (jede Zeile einzeln) oder gleich alles in die StringList, den Delimiter auf ":" einstellen und dann über Name und Value zugreifen. (TrimLeft beim Namen, was auch gleich den Level ergibt), nein Name (also '') ist kein ":" vorhaden, und Trim/TrimLeft entfernt auch das Leerzeichen nach dem ":", also am Anfang vom Value.
* oder sonseine der vielen weiteren Varianten, ohne alles Zeichen für Zeichen einzeln behandeln zu müssen.

[Dejan Vu]

Zitat:

Zitat von himitsu (Beitrag 1268992)

Gibt es nur vorne Tabulatoren?
Wenn nicht, dann zehlt das falsch, da du dann ja am ersten anderen Zeichen aufhören müsstest, mit dem Zählen.

Hab ich schon geschrieben.

Zitat:

Und das Zerlegen:
...
* TStringList.DelimitedText

wieso mit Kanonen auf Spatzen? Geht doch so.

Delphi-Quellcode:

Procedure TTreeNodeDescriptor.FromString (aString : String);
const
   TAB = #009;
var
   captionFound,
   valueDelimiterFound: Boolean;
   c : char;

   Function _AddToText(c : Char);
   begin
     if (c=':') and captionFound then
       valueDelimiterFound := true
     else if valueDelimiterFound then
       Value := Value + c
     else
       Caption:=Caption + c;
   end;

Begin
   Level := 0;
   Value := '';
   Caption := '';
   valueDelimiterFound := False;
   captionFound := False;
   for c in aString do
     if captionFound or (c <> TAB) then
       _AddToText(c)
     else 
       inc(Level)
end;

So müsste es (ungetestet) gehen, damit nur <TAB> Zeichen am Anfang gezählt werden: Sobald das erste nicht-TAB Zeichen gefunden wird, wird das Zählen beendet. Das Zerlegen des Textes in Caption und Value solle aber auch mit Pos und Splitstring gehen. Aber ich dachte mir: Wenn man schon in einer For-Schleife ist, um die TAB-Zeichen vorne zu zählen, kann man auch gleich durchrennen. Na ja. Man kanns auch sein lassen ;-)

Delphi-Quellcode:

Procedure TTreeNodeDescriptor.FromString (aString : String);
const
   TAB = #009;
var
   function GetLevel (Const aString : String) : Integer;
   begin
     for result := 1 to Length(aString) do if aString[Result] <> TAB then exit;
     result := 0;
   end;

Begin
   Level := 0;
   Value := '';
   Caption := '';
   valueDelimiterFound := False;
   captionFound := False;
   Level := GetLevel(aString);
   if Level>0 then Delete(astring,1,Level);
   p := Pos(':', aString);
   if p=0 then Caption := aString
   else begin
     Caption := substring(aString,1,p-1);
     Value := substring(astring,p+1,maxint);
   end
end;

Ungetestet (hab kein Delphi)

[himitsu]

Zitat:

Delphi-Quellcode:

       Value := Value + c
     else
       Caption:=Caption + c;

Wieso mit einem Einrad (Einzelzeichenstringmanipulationsoperationen) einen Käfer (Delphi mit TStringList) versuchen zu verfolgen?
Gut, man kann auch einen Ferrari nehmen (Position suchen und alles zusammen machen).

Selbst eine TStringList erzeugen (jedes Mal und nichtmal über ein globales Singleton) und verwenden, erzeugt weniger Speicheroperationen (Get/Free/Realloc), als das da, mit der For-Schleife.
Gerade in Delphi 7 (ohne FastMM) ist dieses Einzelzeichenstringzusammensetzzeugs die totale Bremse. (zum Glück haben wir seit 2006 standardmäßig ein eigebautes InPlaceRealloc vom Pierre drin, welches solchen Code getwas verbessert, solange die Codeoptimierung aus dem Caption:=Caption+c ein Insert(Caption,C,1) hinbekommt).

Delphi-Quellcode:

(*procedure TTreeNodeDescriptor.FromString(Value: string);
var
  i: Integer;
begin
  i := Pos(':', Value);
  Caption := Trim(Copy(Value, 1, i - 1));
  Value := Trim(Copy(Value, i + 1));
  Level := Length(Value) - Length(TrimLeft(Value));
end;*)

procedure TTreeNodeDescriptor.FromString(Value: string);
var
  i: Integer;
  S: string;
begin
  i := Pos(':', Value);
  S := LeftStr(Value, i - 1);
  Caption := TrimLeft(S);
  Value := TrimLeft(Copy(Value, i + 1));
  Level := Length(S) - Length(Caption);
end;

Gut, man kann das jetzt noch extrem optimieren, indem man die Trims selber berechnet und bei den Copy sofort anwendet, bzw. zum Ausrechnen des Level heranzieht, ohne die String-Zwischenvariable, aber man kann es damit (im Normalfall) auch übertreiben.

[Dejan Vu]

Zitat:

Zitat von himitsu (Beitrag 1269006)

Wieso mit einem Einrad (Einzelzeichenstringmanipulationsoperationen) einen Käfer (Delphi mit TStringList) versuchen zu verfolgen?
Gut, man kann auch einen Ferrari nehmen (Position suchen und alles zusammen machen).

Das ist nicht schneller. Zum suchen musst Du eh bis zum ':' laufen. Und danach kopieren. Bei den kleinen Strings macht das keinen Unterschied. Und deine Argumente bezüglich Speicher ziehen seit FastMem auch nicht mehr. Probiere es mal aus.

Hier mal dein Code kommentiert.

Delphi-Quellcode:

procedure TTreeNodeDescriptor.FromString(Value: string);
var
  i: Integer;
  S: string;
begin
  i := Pos(':', Value);                  --- 1. mal laufen
  S := LeftStr(Value, i - 1);            --- 2. mal laufen und kopieren
  Caption := TrimLeft(S);                --- 3. mal laufen und kopieren
  Value := TrimLeft(Copy(Value, i + 1)); --- 4. mal laufen und kopieren
  Level := Length(S) - Length(Caption);
end;

Du rennst 5 mal durch den String bzw. setzt zu einer Schleife an. Wozu?

Also, ich meine, wir reden hier ziemlich abgehoben über Codeästhetik und ob man eher Makros (Trim,Copy,LeftStr,Pos) nimmt, oder alles per Hand macht.

Rein performancetechnisch würde ich annehmen, das ein einmaliges Durchlaufen am schnellsten ist.
Von der Lesbarkeit würde ich die Makro-Variante wohl vorziehen.