| Autor |
Beitrag |
Biarchiv
      
Beiträge: 688
|
Verfasst: So 17.04.05 19:05
Hallo,
wie kann man von einem string die letzen stellen bis ; ermitteln.
Wenn die letzte Stelle schon ein ; ist soll sie leer sein.
ZB:
stest;1;sdfdfds;44 > 44
dfsde;asffd;; > [nichts leerer String]
Danke...
|
|
uall@ogc
      
Beiträge: 1826
Erhaltene Danke: 11
Win 2000 & VMware
Delphi 3 Prof, Delphi 7 Prof
|
Verfasst: So 17.04.05 19:08
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8:
| var i, j: integer; s, t: string; begin j := length(s); for i := 1 to length(s) do if s[i] = ';' then j := i; t := copy(s,j, length(s)); end; |
_________________ wer andern eine grube gräbt hat ein grubengrabgerät
- oder einfach zu viel zeit
|
|
alias5000
      
Beiträge: 2145
WinXP Prof SP2, Ubuntu 9.04
C/C++(Code::Blocks, VS.NET),A51(Keil),Object Pascal(D2005PE, Turbo Delphi Explorer) C# (VS 2008 Express)
|
Verfasst: So 17.04.05 19:10
Ich versteh deine Frage zwar net ganz, aber so wie ich das versteh könnte man es so lösen:
-Man geht in eine Schleife und sucht so lange mit der Funktion Pos(...) nach ";" bis sie -1 zurückgibt. Vorher merkt man sich den Index des letzten Semikolons. Und dann hast du's 
_________________ Programmers never die, they just GOSUB without RETURN
|
|
alias5000
      
Beiträge: 2145
WinXP Prof SP2, Ubuntu 9.04
C/C++(Code::Blocks, VS.NET),A51(Keil),Object Pascal(D2005PE, Turbo Delphi Explorer) C# (VS 2008 Express)
|
Verfasst: So 17.04.05 19:13
Tja, da war uall@ogc schneller als ich... 
|
|
uall@ogc
      
Beiträge: 1826
Erhaltene Danke: 11
Win 2000 & VMware
Delphi 3 Prof, Delphi 7 Prof
|
Verfasst: So 17.04.05 19:18
Delphi-Quelltext 1: 2: 3: 4: 5: 6:
| var s: string; begin s := '....'; while pos(';',s) > 0 do delete(s,1,pos(';',s)); end; |
oder so...
_________________ wer andern eine grube gräbt hat ein grubengrabgerät
- oder einfach zu viel zeit
|
|
Lannes
      
Beiträge: 2352
Erhaltene Danke: 4
Win XP, 95, 3.11, IE6
D3 Prof, D4 Standard, D2005 PE, TurboDelphi, Lazarus, D2010
|
Verfasst: So 17.04.05 20:31
Hallo,
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
| var z : integer; s : string; begin s := Edit1.Text; for z := Length(s) downto 1 do if s[z] = ';' then begin Delete(s,1,z); break; end; showmessage(s); end; |
oder so, etwas verschnellert 
_________________ MfG Lannes
(Nichts ist nicht Nichts) and ('' <> nil ) and (Pointer('') = nil ) and (@('') <> nil )
|
|
delfiphan
      
Beiträge: 2684
Erhaltene Danke: 32
|
Verfasst: So 17.04.05 21:05
Man beachte auch die Funktionen StrRScan und LastDelimiter.
Wenn ich aber so die Sources der beiden Funktionen ansehe, würde ich glaub ich meine eigenen Funktionen schreiben, da beide den String von links nach rechts durchsuchen
Hier noch mein Käse. Moto: Effizienz statt Eleganz
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21:
| function FindR(Const S: String; C: Char): String; Var P, PI: PChar; I, J, L: Integer; begin J := Length(S); P := PChar(Pointer(S))+J; PI := P; for I := J-1 downto 0 do begin dec(P); if P^ = C then begin inc(P); break; end; end; L := PI-P; SetLength(Result, L); Move(P^, Pointer(Result)^, L); end; |
|
|
Lannes
      
Beiträge: 2352
Erhaltene Danke: 4
Win XP, 95, 3.11, IE6
D3 Prof, D4 Standard, D2005 PE, TurboDelphi, Lazarus, D2010
|
Verfasst: So 17.04.05 21:58
Hallo,
ja, wobei downto aber schneller ist.
hab es gerade mal getestet.
500.000 Schleifen, String = "stest;1;sdfasfkjsalk;asfdaslk;safhjkahsfkja;dfds;44"
Quelltext 1: 2: 3: 4: 5:
| 1. downto 1,46 Sekunden 2. FindR 1,48 " 3. LastDelimiter 1,60 " 4. StrRScan 1,62 " 5. while 2,28 " |
_________________ MfG Lannes
(Nichts ist nicht Nichts) and ('' <> nil ) and (Pointer('') = nil ) and (@('') <> nil )
|
|
delfiphan
      
Beiträge: 2684
Erhaltene Danke: 32
|
Verfasst: So 17.04.05 22:05
Du musst natürlich die gleichen Bedingungen schaffen. Du kannst nicht dein Code inline nehmen und meine Funktion als Funktion!
Meine Tests ergeben ein anderes Bild:
| Test Output: | DownToFunc (Result = "44"): 173.77 µs
FindR (Result = "44"): Quelltext
FindR (Result = "44"): Quelltext
DownToFunc (Result = "44"): 180.19 µs |
Ich hoffe ich hab das ganze so symmetrisch wie möglich durchgeführt, um keine Funktion irgendwie zu bevorzugen.
Code zum Nachprüfen:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79:
| function FindR(Const S: String; C: Char): String; Var P, PI: PChar; I, L: Integer; begin L := Length(S); P := PChar(Pointer(S))+L; PI := P; for I := L-1 downto 0 do begin dec(P); if P^ = C then begin inc(P); break; end; end; L := PI-P; SetLength(Result, L); Move(P^, Pointer(Result)^, L); end;
function DownToFunc(S: String; C: Char): String; var z : integer; begin for z := Length(s) downto 1 do if s[z] = C then begin Delete(s,1,z); break; end; Result := S; end;
procedure TForm1.Button1Click(Sender: TObject); Var A, B, S: String; Start, Stop, Empty, f: Int64; I: Integer; begin QueryPerformanceCounter(Start); for i := 0 to 99 do S := ''; QueryPerformanceCounter(Stop); QueryPerformanceFrequency(f); Empty := Stop-Start;
S := 'stest;1;sdfasfkjsalk;asfdaslk;safhjkahsfkja;dfds;44'; sleep(1000);
QueryPerformanceCounter(Start); for i := 0 to 99 do A := DownToFunc(S,';'); QueryPerformanceCounter(Stop); Memo1.Lines.Add(Format('DownToFunc (Result = "%s"): %f µs',[A,(Stop - Start - Empty) / f*1000000]));
QueryPerformanceCounter(Start); for i := 0 to 99 do B := FindR(S,';'); QueryPerformanceCounter(Stop); Memo1.Lines.Add(Format('FindR (Result = "%s"): %f µs',[B,(Stop - Start - Empty) / f*1000000]));
A := ''; B := ''; sleep(1000);
QueryPerformanceCounter(Start); for i := 0 to 99 do A := FindR(S,';'); QueryPerformanceCounter(Stop); Memo1.Lines.Add(Format('FindR (Result = "%s"): %f µs',[A,(Stop - Start - Empty) / f*1000000]));
QueryPerformanceCounter(Start); for i := 0 to 99 do B := DownToFunc(S,';'); QueryPerformanceCounter(Stop); Memo1.Lines.Add(Format('DownToFunc (Result = "%s"): %f µs',[B,(Stop - Start - Empty) / f*1000000])); end; |
|
|
Lannes
      
Beiträge: 2352
Erhaltene Danke: 4
Win XP, 95, 3.11, IE6
D3 Prof, D4 Standard, D2005 PE, TurboDelphi, Lazarus, D2010
|
Verfasst: Mo 18.04.05 23:12
Hallo,
delfiphan hat folgendes geschrieben: | | Du musst natürlich die gleichen Bedingungen schaffen. Du kannst nicht dein Code inline nehmen und meine Funktion als Funktion! |
Ob man gleiche Bedingungen herstellen kann?
Bei meinem Test hatte ich Deine und meine Routine inline eingesetzt, jede Routine in einem getrennten gleichmäßig aufgebauten Projekt. Zeitmessung auch mit "QueryPerformance".
Eine Frage:
Können in Deinem Code nicht die vier Zeilen Delphi-Quelltext 1: 2: 3: 4: 5:
| PI := P; .... L := PI-P; SetLength(Result, L); Move(P^, Pointer(Result)^, L); |
entfallen(bei inline-Einbau), da ja z.B
Label1.caption := P;nach dem Ende der Routine auch das richtige Ergebnis liefert?
Bei der Nutzung als Funktion ist Deine schneller. 
_________________ MfG Lannes
(Nichts ist nicht Nichts) and ('' <> nil ) and (Pointer('') = nil ) and (@('') <> nil )
|
|
delfiphan
      
Beiträge: 2684
Erhaltene Danke: 32
|
Verfasst: Di 19.04.05 00:15
Ergibt nur dasselbe, wenn im String keine #0 nach dem letzten ";" vorkommt. Wenn du direkt P verwendest wird der String nicht als AnsiString sondern als PChar interpretiert. Das hat 1. zur Folge, dass das Ganze beim erwähnten Fall (#0 kommt im String vor) fehlschlägt; und 2. muss bei der Zuweisung eine Konvertierung PChar zu AnsiString durchgeführt werden. Bei AnsiStrings ist die Stringlänge bekannt - bei PChars aber nicht. Es muss also nochmals das gesamte PChar ab P bis zur #0 durchsucht werden, was aber völlig unnötig ist (da sich die korrekte Länge durch eine einfache Subtraktion berechnen lässt).
Ich hab in meiner Prozedur mehr oder weniger das String-Handling "selbst" programmiert statt dem Compiler zu überlassen. Wenn man dabei keinen Fehler macht ist man dann meist schneller als die "triviale Pascal-Variante".
Noch schneller wäre statt einer For-Schleife eine While-Schleife gewesen:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22:
| function FindR(Const S: String; C: Char): String; Var P, PI: PChar; L: Integer; begin L := Length(S); P := PChar(Pointer(S))+L; PI := P; while L<>0 do begin dec(P); if P^ = C then begin inc(P); break; end; dec(L); end; L := PI-P; SetLength(Result, L); Move(P^, Pointer(Result)^, L); end; |
| Hier eine kleine Analyse: |
Wenn man den Assemblercode anschaut, sieht man, dass die Variablen L und P als Registers realisiert sind. Es wird also kein Speicher für diese beiden Variablen alloziert.
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
| test esi,esi jz +$0d dec edi cmp bl,[edi] jnz +$03 inc edi jmp +$05 dec esi test esi,esi jnz -$0d |
Als Vergleich, hier die Downto-Variante von Lannes:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
| mov eax, [ebp-$04] cmp bl,[eax+esi-$01] jnz +$11 lea eax,[ebp-$04] mov ecx,esi mov edx,$00000001 call @LStrDelete jmp +$05 dec esi jnz -$1f |
Wie man sieht, muss hier bei jedem Durchgang die Adresse von s[z] erneut berechnet werden (Zeile 2). Ausserdem sieht man, dass für z Speicher auf dem Stack alloziert werden musste. Fazit: Es sind pro Durchlauf 2 Memoryzugriffe nötig (statt 1) und es muss eine komplizierte Adresse berechnet werden.
Wahrscheinlich ist das aber nicht der eigentliche Grund, wieso FindR schneller war. Es wurde ja auch nur ein ganz kleiner String durchsucht.
Verblüffend ist, dass folgende Funktion - welche einfach so die "Lösung" zurückgibt - langsamer als FindR ist. Wieso das genau der Fall ist, da müsste ich noch weitere Analysen durchführen. Merkwürdig erscheint es auf jeden Fall.
Delphi-Quelltext 1: 2: 3: 4:
| function TrivialFunc(const S: String; C: Char): String; begin Result := '44'; end; |
|
Zuletzt bearbeitet von delfiphan am Di 19.04.05 01:22, insgesamt 1-mal bearbeitet
|
|
hansa
      
Beiträge: 3079
Erhaltene Danke: 9
|
Verfasst: Di 19.04.05 01:18
Für Nanosekunden Schinderei bin ich nicht zuständig, aber wie wäre es hiermit :
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
| procedure TForm1.Button1Click(Sender: TObject); var st1, st2 : string; begin st1 := '1;1;33;44'; st2 := ''; while st1 [length (st1)] <> ';' do begin st2 := st2 + st1 [length (st1)]; delete (st1,length (st1),1); end; showmessage ('*'+st2+'*'); end; |
P.S.: ich lege mehr Wert auf Eleganz. 
_________________ Gruß
Hansa
|
|
delfiphan
      
Beiträge: 2684
Erhaltene Danke: 32
|
Verfasst: Di 19.04.05 01:38
hansa hat folgendes geschrieben: | P.S.: ich lege mehr Wert auf Eleganz.  |
Von Eleganz kann hier ja wohl nicht die Rede sein.  Was passiert bei dir, wenn gar kein ';' vorkommt? => Access Violation
PS:
Es geht hier nicht um Nanosekunden. Test an einem 100kb String.
FindR: 442 Mikrosekunden. Deine Funktion: 164000 Mikrosekunden (= 0.16 Sekunden).
|
|
hansa
      
Beiträge: 3079
Erhaltene Danke: 9
|
Verfasst: Di 19.04.05 02:23
delfiphan hat folgendes geschrieben: | ...Was passiert bei dir, wenn gar kein ';' vorkommt? => Access Violation
|
So was simples wie hier teste ich erst gar nicht. Es gibt auch pos (st,1..); Und die Nanosekunden können wir gerne gegen Mikro/Millisekunden austauschen.
P.S.: Die Zeitmessung ist übrigens ziemlich ungenau. Ich würde da nicht zuviel Wert drauf legen. 
_________________ Gruß
Hansa
|
|
BenBE
      
Beiträge: 8721
Erhaltene Danke: 191
Win95, Win98SE, Win2K, WinXP
D1S, D3S, D4S, D5E, D6E, D7E, D9PE, D10E, D12P, DXEP, L0.9\FPC2.0
|
Verfasst: Di 19.04.05 07:07
hansa hat folgendes geschrieben: | delfiphan hat folgendes geschrieben: | | ...Was passiert bei dir, wenn gar kein ';' vorkommt? => Access Violation |
So was simples wie hier teste ich erst gar nicht. |
Solltest Du aber, da Du Dich am Ende wunderst, wenn irgendwo in deinem Programm ein Fehler auftritt und Du die Stelle nicht findest ... Lieber Fehler im Vorhinein abfangen und behandeln als nachher versuchen zu beheben ...
hansa hat folgendes geschrieben: | | Es gibt auch pos (st,1..); |
Leider aber nur für die Vorwärtssuche und damit in diesem Anwendungsfeld recht langsam ...
hansa hat folgendes geschrieben: | Und die Nanosekunden können wir gerne gegen Mikro/Millisekunden austauschen.  |
Nehmt am besten als Maßeinheit Äonen und dürften Glücklich sein, weil die Zahlen dann gar nichts mehr aussagen ...
hansa hat folgendes geschrieben: | P.S.: Die Zeitmessung ist übrigens ziemlich ungenau. Ich würde da nicht zuviel Wert drauf legen.  |
Für meinen Athlon XP komm ich aber mit 1,4GHz Clock-Taktung des RDTSC-Befehls ziemlich weit ... Und selbst für Intels, wo die Taktung nur knapp 30 MHz beträgt (auf vielen), sind es trotzdem noch weniger als eine Mikrosekunde Meßungenauigkeit ...
Ein Unterschied von über dem 100fachen sollte einem eigentlich zu denken geben ...
_________________ Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.
|
|
hansa
      
Beiträge: 3079
Erhaltene Danke: 9
|
Verfasst: Di 19.04.05 11:48
BenBE hat folgendes geschrieben: | | ...Ein Unterschied von über dem 100fachen sollte einem eigentlich zu denken geben ... |
Nicht unbedingt. Wieviel ist 100 * 0  Ich habe hier ein Programm, das zerlegt einen String (Länge ca. 800 Char) in Dutzende Bestandteile und fügt diese als Felder in eine Datenbank ein. Und zwar sind das zigtausend Zeilen. Wenn man liest, was Du schreibst, dann könnte man meinen, eine ASM Routine könne eventuell die Sache 100mal schneller machen.
Die Wirklichkeit sieht aber ganz anders aus. Bei näherer Betrachtung wird man feststellen, daß die Zeit draufgeht beim Lesen der langen Zeilen und beim Einfügen in die DB. Und durch einen simplen Trick habe ich die Laufzeit noch erheblich reduziert (Faktor 1,5) : ich zeige nicht mehr jede gelesene Zeile in einem Memo an, sondern nur noch die mit i mod 100 = 0. Um da noch 1 % durch ASM rauszuholen, dafür handele ich mir nicht den Nachteil ein, daß ich das 100fache an Zeit brauche, um meinen eigenen Quelltext nach einer gewissen Zeit wieder zu verstehen.
Außerdem ging es hier drum :
| Zitat: | wie kann man von einem string die letzen stellen bis ; ermitteln.
Wenn die letzte Stelle schon ein ; ist soll sie leer sein. |
_________________ Gruß
Hansa
|
|
delfiphan
      
Beiträge: 2684
Erhaltene Danke: 32
|
Verfasst: Di 19.04.05 12:07
hansa hat folgendes geschrieben: | Wieviel ist 100 * 0  |
Sorry, aber du hast hier wohl etwas missverstanden: Deine Routine ist rund 300x langsamer verglichen mit meiner, wenn der String genug gross ist (und nein, meine Routine hat nicht 0 Sekunden).
Der Unterschied ist wohl vor allem auf dein "S := S + C"-Konstrukt zurückzuführen. Das ist sowas wie eine Quintenparallele in der Musik (sollte man unbedingt immer vermeiden!!). Wieso? Bei dir wird pro Durchlauf einmal ein ReallocMem ausgeführt. D.h. es wird unter Umständen bei jedem Durchlauf neuer Speicher alloziert, der alte Inhalt kopiert und der alte Speicher gelöscht. Dabei kann es vorkommen, dass dein virtueller Adressbereich bald mal aufgebraucht ist bzw. dass kein genug grosser freier Memoryblock mehr existiert; und dein Programm hängt sich auf, obwohl du noch hunderte von Megabytes freien physikalischen Speicher hast.
hansa hat folgendes geschrieben: | | Die Wirklichkeit sieht aber ganz anders aus. Bei näherer Betrachtung wird man feststellen, daß die Zeit draufgeht beim Lesen der langen Zeilen und beim Einfügen in die DB. |
Ja, es ist stark abhängig von der Anwendung. Du kannst die Prozedur immer mit etwas vergleichen, was zeitlich länger geht... Aber darum ging es ja überhaupt nicht. Einfügen in DB, davon war keine Rede.
hansa hat folgendes geschrieben: | | Und durch einen simplen Trick habe ich die Laufzeit noch erheblich reduziert (Faktor 1,5) : ich zeige nicht mehr jede gelesene Zeile in einem Memo an, sondern nur noch die mit i mod 100 = 0. |
Zusammenhang? -- Klar, wenn der Rest noch schlechter programmiert ist, bringt dir eine schnelle Funktion nicht viel. Was willst du jetzt damit sagen?
hansa hat folgendes geschrieben: | Um da noch 1 % durch ASM rauszuholen, dafür handele ich mir nicht den Nachteil ein, daß ich das 100fache an Zeit brauche, um meinen eigenen Quelltext nach einer gewissen Zeit wieder zu verstehen.  |
Es geht hier nicht nur um die Geschwindigkeit, sondern auch um die Fehlertoleranz und der Umgang mit dem Memory-Manager.
hansa hat folgendes geschrieben: | | Außerdem ging es hier drum : |
Das ist eben der Unterschied zwischen einem guten und schlechten Programmierstil. Man darf nicht einfach so davon ausgehen, dass immer alles klappt. Man muss den Fehlerfall berücksichtigen!!
Zugegeben, meine Funktion ist nicht so gut lesbar. Ich würde aber nicht sagen, dass dein Code viel viel einfacher zu lesen ist. Und: Wenn jemand im Forum nach einer fertigen Funktion fragt, dann biete ich ihm doch eine möglichst schnelle Variante.
|
|
BenBE
      
Beiträge: 8721
Erhaltene Danke: 191
Win95, Win98SE, Win2K, WinXP
D1S, D3S, D4S, D5E, D6E, D7E, D9PE, D10E, D12P, DXEP, L0.9\FPC2.0
|
Verfasst: Di 19.04.05 18:27
hansa hat folgendes geschrieben: | | Wenn man liest, was Du schreibst, dann könnte man meinen, eine ASM Routine könne eventuell die Sache 100mal schneller machen. |
Das würd ich nicht unbedingt sagen, man kann mit ASM nur den Feinschliff machen, niemals ein Highperformance-System aus nem Flaschenhals ... (und wenn, dann gibt's IMMER ne schnellere Lösung*)
hansa hat folgendes geschrieben: | Die Wirklichkeit sieht aber ganz anders aus. Bei näherer Betrachtung wird man feststellen, daß die Zeit draufgeht beim Lesen der langen Zeilen und beim Einfügen in die DB. Und durch einen simplen Trick habe ich die Laufzeit noch erheblich reduziert (Faktor 1,5) : ich zeige nicht mehr jede gelesene Zeile in einem Memo an, sondern nur noch die mit i mod 100 = 0. Um da noch 1 % durch ASM rauszuholen, dafür handele ich mir nicht den Nachteil ein, daß ich das 100fache an Zeit brauche, um meinen eigenen Quelltext nach einer gewissen Zeit wieder zu verstehen.  |
Dass man den Frotschritt nur nach größeren Blöcken anzeigt ist doch aber klar, da ansonsten der Zeitanteil der Fortschrittsroutine sehr schnell größer als der der eigentlichen Berechnung werden kann.
hansa hat folgendes geschrieben: | Außerdem ging es hier drum :
| Zitat: | wie kann man von einem string die letzen stellen bis ; ermitteln.
Wenn die letzte Stelle schon ein ; ist soll sie leer sein. |
|
Man suche von hinten und breche beim ersten Semikolon ab, was man findet und baut sich daraus den String ...
Wird kein Semikolon gefunden ist der Eingabestring das Ergebnis ... That's it.
BTW: Bei PChar sogar noch einfacher:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7:
| MOV AL, ';' MOV ECX, LengthOfInput MOV ESI, EOStr REPNZ SCASB INC ESI MOV EAX, ESI |
That's it ...
*Für den Beweis frag nen Info-Student, bin noch Abiturient 
_________________ Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.
|
|
en!gma
      
Beiträge: 378
win xp
delphi 7.0
|
Verfasst: Mi 03.08.05 10:32
ist zwar schon bissl älter. aber ich schreibs einfach mal hier rein, da es der fragestellung sehr ähnlich kommt.
ich möchte an jeder zeile die überflüssigen tabs und spaces löschen, also die am ende der zeile.
denn trimRight funktioniert irgendwie nicht so recht.
ich hab mir das so gedacht:
Delphi-Quelltext 1: 2: 3: 4:
| for i:=0 to Form1.SynEdit1.Lines.Count do begin TrimRight(Form1.SynEdit1.Lines[i]); end; |
nur bräuchte ich eine andere funktion für trimRight.
warum es nicht funktioniert weiss ich nicht.
aber füge ganz viele spaces ein geh ein paar zeilen runter, führe die prozedur oben aus und die spaces sind immernoch da
Moderiert von raziel: Code- durch Delphi-Tags ersetzt.
|
|
LigH
      
Beiträge: 239
Win98SE, Win2000SP4
D7
|
Verfasst: Mi 03.08.05 11:50
Für mich sieht das Format irgendwie nach "Comma Separated Values" aus (*.csv); dann soll's hinterher sicher wieder in ein Grid, oder so ähnlich?
Dann mal vielleicht eine ungewöhnliche Lösung, aber "seehr elegant"  (wenn auch sicher ziemlich langsam):
Man setze den "Delimiter" einer Stringliste auf ";" und füttert dann die Property "DelimitedText" mit dem ganzen String. 
|
|
|