Discussion :

[ShaiLeTroll]

Pour ExplodeLazy, oui, elle fonctionne bien, c'est le premier algo que j'ai écrit
ensuite si il y a des courageux, pour utiliser Explode, qui contient plus de paramètre, jusqu'à présent au bureau, elle a donné satisfaction, mais plus j'ai de testeurs, mieux je pourrais y corriger les Erreurs ou bloquer par exceptions des paramètres incompatibles ...

Sinon pour les amateurs de TStringList, j'ai fait aussi le wrapper pour le bureau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
{* -----------------------------------------------------------------------------
la fonction ExplodeToStrings encapsule Explode pour renvoyer une liste.
@param Voir_Explode
@param L Liste de Chaine initialisée qui recevra les chaines découpées
@return Voir_Explode
------------------------------------------------------------------------------ }
function ExplodeToStrings(const S: string; L: TStrings; const Separators: string; ExcludeEmpty: Boolean = False; const Quotes: string = ''): Integer;
var
  A: Types.TStringDynArray;
  iL: Integer;
begin
  if Assigned(L) then
  begin
    Result := Explode(S, A, Separators, ExcludeEmpty, Quotes);
    L.Clear();
    L.Capacity := Result;
    for iL := Low(A) to High(A) do
      L.Add(A[iL]);
  end else
    Result := -1;
end;
 
{* -----------------------------------------------------------------------------
la fonction Explode retourne un tableau de chaînes. Ce sont les sous-chaînes, extraites de S, en utilisant le séparateur Separator. cela peut servir pour lire du CSV
@param S Chaine à découper
@param A Tableau de Chaine qui recevra la découpe
@param Separators Caractères qui délimitent une chaine pour la découpe
@param ExcludeEmpty Si True, les Chaines vides ne sont pas insérés dans le Tableau
@param Quotes Caractères qui délimitent une chaine pour la découpe contenant des Separators, n'importe quel séparateur peut commencer et terminé une chaine, une quote doublée est considéré comme valeur un quote dans la chaine
@param KeepSeparators Si True, A contient les chaines et les séparateurs mais pas les Quotes, sinon (par défaut) A ne contient que les Chaines.
@return Nombre de Séparateur Trouvé (peut-être différent du nombre de chaine dans A !)
------------------------------------------------------------------------------ }
function Explode(const S: string; out A: Types.TStringDynArray; const Separators: string; ExcludeEmpty: Boolean = False; const Quotes: string = ''; KeepSeparators: Boolean = False): Integer;
var
  iLesSep: Integer;
  iLesQuote: Integer;
 
  function IsSeparator(C: Char): Integer;
  begin
    for Result := 1 to iLesSep do
      if C = Separators[Result] then
        Exit;
 
    Result := -1;
  end;
 
  function IsQuote(C: Char): Integer;
  begin
    for Result := 1 to iLesQuote do
      if C = Quotes[Result] then
        Exit;
 
    Result := -1;
  end;
 
var
  iStr: Integer;
  iQuote: Integer;
  iLenS: Integer;
  iLenSS: Integer;
  iLenA: Integer;
  iAdded: Integer;
  iBegin: Integer;
  Quoted: Boolean;
  DoubleQuoted: Boolean;
  AlreadyDQ: Boolean;
  QuoteConcat: string;
  iOffQuote: Integer;
  LastIsSep: Boolean;
begin
  iLenS := Length(S);
  iLesSep := Length(Separators);
 
  if (iLenS = 0) or (iLesSep = 0) then
  begin
    SetLength(A, 1);
    Result := 0;
    A[Result] := '';
    Exit;
  end;
 
  iLesQuote := Length(Quotes);
  for iQuote := 1 to iLesQuote do
    if IsSeparator(Quotes[iQuote]) > 0 then
      raise EParserError.CreateFmt('le Délimiteur "%s" ne peut pas être un Séparateur !', [Quotes[iQuote]]);
 
  Result := 0;
  iQuote := 0;
  for iStr := 1 to Length(S) do
  begin
    if IsSeparator(S[iStr]) > 0 then
      Inc(Result)
    else
      if IsQuote(S[iStr]) > 0 then
        Inc(iQuote);
  end;
 
  if Odd(iQuote) then
    raise EParserError.CreateFmt('Nombre de Délimiteur Incorrect : "%d" !', [iQuote]);
 
  LastIsSep := IsSeparator(S[iLenS]) > 0;
 
  if KeepSeparators then
    iLenA := Result * 2 + 1
  else
    iLenA := Result + 1;
  SetLength(A, iLenA);
  iLenSS := 0;
  iAdded := 0;
  Quoted := False;
  iOffQuote := 0;
  QuoteConcat := '';
  AlreadyDQ := False;
  iBegin := 1;
  if IsSeparator(S[1]) > 0 then
  begin
    if KeepSeparators then
    begin
      iBegin := 2;
      A[iAdded] := S[1];
      Inc(iAdded);
    end;
  end;
 
  for iStr := iBegin to iLenS do
  begin
    if not Quoted and (IsSeparator(S[iStr]) > 0) then
    begin
      if ExcludeEmpty and (iLenSS = 0) then
      begin
        if KeepSeparators then
        begin
          A[iAdded] := S[iStr];
          Inc(iAdded);
        end;
        iBegin := iStr + 1;
      end else
      begin
        if AlreadyDQ then
          A[iAdded] := QuoteConcat
        else
          A[iAdded] := Copy(S, iBegin, iLenSS);
 
        AlreadyDQ := False;
        Inc(iAdded);
 
        if KeepSeparators and (iBegin > 0) then
        begin
          A[iAdded] := S[iStr];
          Inc(iAdded);
        end else
          begin
          if LastIsSep and KeepSeparators and (iStr = iLenS) then
          begin
            A[iAdded] := S[iStr];
            Inc(iAdded);
          end;
        end;
        iBegin := iStr + 1;
        iLenSS := 0;
      end;
    end else
    begin
      if IsQuote(S[iStr]) > 0 then
      begin
        if Quoted then
        begin
          Quoted := False;
          if iStr < iLenS then
          begin
            DoubleQuoted := IsQuote(S[iStr+1]) > 0;
            if AlreadyDQ then
              QuoteConcat := QuoteConcat + Copy(S, iBegin, iLenSS) + IfThen(DoubleQuoted, S[iStr+1], '')
            else
              QuoteConcat := Copy(S, iBegin, iLenSS) + IfThen(DoubleQuoted, S[iStr+1], '');
            AlreadyDQ := AlreadyDQ or DoubleQuoted;
          end;
        end else
        begin
          Quoted := True;
          iBegin := iStr + 1;
          iLenSS := 0;
        end;
      end else
      begin
        if Quoted and (IsSeparator(S[iStr]) > 0) then
          Inc(iOffQuote);
        Inc(iLenSS);
      end;
    end;
  end;
 
  if iBegin <= iLenS then
  begin
    A[iAdded] := Copy(S, iBegin, MaxInt);
    Inc(iAdded);
 
    if LastIsSep and KeepSeparators then
    begin
      A[iAdded] := S[iLenS];
      Inc(iAdded);
    end;
  end;
 
  if LastIsSep and not ExcludeEmpty then
    Inc(iAdded);
 
  if iAdded < iLenA then
    A := Copy(A, 0, iAdded);
 
  Result := Result - iOffQuote;
end;
 
{* -----------------------------------------------------------------------------
la fonction ExplodeLazy retourne un tableau de chaînes. Ce sont les sous-chaînes, extraites de S, en utilisant le séparateur Separator.
@param S Chaine à découper
@param A Tableau de Chaine qui recevra la découpe
@param Separator Caractère qui délimitent une chaine pour la découpe
@return Nombre de Séparateur Trouvé (peut-être différent du nombre de chaine dans A !)
------------------------------------------------------------------------------ }
function ExplodeLazy(const S: string; out A: Types.TStringDynArray; Separator: Char): Integer;
var
  I, J, K: integer;
begin
  Result := 0;
  for I := 1 to Length(S) do
    if S[I] = Separator then
      Inc(Result);
 
  if S[Length(S)] = Separator then
    SetLength(A, Result)
  else
    SetLength(A, Result + 1);
 
  K := 1;
  J := 0;
  for I := 1 to Length(S) do
    if S[I] = Separator then
    begin
      if K <> I then
        A[J] := Copy(S, K, I - K);
 
      Inc(J);
      K := I + 1;
    end;
  if K <= Length(S) then
    A[J] := Copy(S, K, MaxInt);
end;

Attention, ces temps sont valables pour le Temps d'Execution sur [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois ... si le nombre de chaine à découpé est très faible (1 à 5), ExplodeLazy reste le plus performant (on pourrait encore gagner en passant le code en PChar, voire ASM) mais c'est nettement moins sensible qu'avec 10, 20 morceaux ... et uniquement du à la pré-allocation du tableau ...

[Bruno13]

Salut,

Quand j'utilise Explode, à la compilation j'ai cette erreur :
sur A: Types.TStringDynArray;

[Erreur] DCSStrings.pas(261): Identificateur non déclaré : 'Types'

Je suis sous D7, et j'ai voulu insérer cette fonction dans mon unité sur les Strings

Merci pour l'aide
Bruno

[ShaiLeTroll]

Ajoute "Types" à tes USES ! Cela existe en D6 et D7, je les ai au bureaux et je code uniquement sur ces versions, cela contient TStringDynArray

[Bruno13]

Encore un petit soucis désolé :
[Erreur] DCSStrings.pas(426): Identificateur non déclaré : 'IfThen'

Merci

[ShaiLeTroll]

Idem, standard Delphi, StrUtils

[Bruno13]

Re-oups désolé

Bruno

[ShaiLeTroll]

Mise A Jour des Version d'Explode, tous ces algos se ressemblent mais cela montre que pour une fonction de base, les variantes, les idées sont illimitées et cela peut donner des idées à nombreux, de voir un code qui leur ressemble et un autre plus performant dont ils peuvent s'inspirer pour d'autres fonctionnalités ...

Temps d'Execution sur [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois


ExtractStrings (Delphi 7 StrUtils) : 25 ms
ExplodeLazy : 7 ms
Explode : 12 à 13 ms
SplitStrClorish : 123 à 127 ms
SplitDroopyEyes : 66 à 73 ms
ExplodeFabriceRouxel : : 14 à 18 ms
SplitBruno13 : 21 à 27 ms
ExplodeDragonHeart : 18 à 21 ms
Explodeturf_trader : 21 à 25 ms

[Gilbert Geyer]

Bonjour ShaiLeTroll,

Vu les nouveautés! Et c'est toujours ExplodeLazy qui tient le haut du pavé avec les 7 ms.
... faudrait un jour la rebaptiser ExplodeSpeedy ... plutôt que Lazy la paresseuse.

[ShaiLeTroll]

Lazy parce qu'elle en fait le moins que possible (un seul séparateur), contrairement à Explode, qui a bcp de paramètres (plusieurs séparateurs, gestion de délimiteurs, peut découper en conservant les délimiteurs, ...)
le nom vient de là ...
on l'appelera Speedy quand un As, nous la fera en ASM ^_^, moi, j'aimerais bien, mais mon niveau est bien trop faible, ... d'ailleurs, sur un autre forum, Phidels.com (de moins en moins actif), Kr85 disait qu'adapter mes algos biscornu delphi en Assembleur n'était pas évident, ...

[Gilbert Geyer]

...en ASM ^_^, moi, j'aimerais bien, mais mon niveau est bien trop faible

... c'est'y sûr ? Ne serait-ce pas plutôt un excès de modestie, car à voir la rapidité et la pertinence de tes réponses aux diverses questions posées sur le forum je suis certain que tu t'en sortirais en tout cas bien mieux qu'un bidouilleur comme moi. Pourquoi ne pas faire un bout de code en Asm pour amorcer le sujet et le soumettre aux fortiches qui fréquentent le Forum Assembleur ?

[Gilbert Geyer]

A ShaiLeTroll :

J'ai voulu percer le secret de la rapidité de ExplodeLazy, et comme sous Delphi-5 je n'ai pas les unités "Types" et "StrUtils" j'y ai simplement remplacé le TStringDynArray par un TStringList comme suit, et qui marche chez moi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
function ExplodeLazy(const S: string; out A: TStringList; Separator: Char): Integer;
var
  I, J, K: integer;
begin
  Result := 0;
  for I := 1 to Length(S) do
    if S[i] = Separator then
      Inc(Result);
 
  K := 1;
  J := 0;
  for I := 1 to Length(S) do
    if S[i] = Separator then
    begin
      if K <> I then A.Add(Copy(S, K, I - K));
 
      Inc(J);
      K := I + 1;
    end;
  if K <= Length(S) then A.Add(Copy(S, K, MaxInt));
end;

... mais comme en modifiant cette fonction pour l'adapter au cas de la StringList j'ai vu qu'elle parcourait deux fois la longueur de la string "S" (voir les deux for I := 1 to Length(S) do) et qu'elle était également ralentie notamment par le Copy(S, K, I - K)); du coup cela m'a donné une idée vachement simplificatrice et qui du coup est plus rapide :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
function  ExplodeGG(const S: string; out A: TStringList; Sep: Char) : Integer;
var       i : integer; St : string;
begin     St:=S; i:=0; Result:=0;
          while i<length(St) do
          begin inc(i);
                if St[i] = Sep then
                begin Inc(Result); St[i]:=#10; Insert(#13,St,i); end;
          end;
          A.Add(St);
end;

Les Temps d'Execution obtenus avec S égale à [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois ... et avec Pentium III à seulement 1,13 GHz sont :
- ExplodeLazy : 17,57 ms
- ExplodeGG : 9,26 ms
(Hors temps mis pour afficher le résultat de la TStringList dans un RichEdit afin de vérifier si le Split a été correct)
... donc avec un processeur cadencé à 3 GHz le temps mis par ExplodeGG devrait avoisiner les 9,26*(7/17,57) = 3,7 ms (Juste pour se faire une idée car les règles de trois dans ce domaine c'est un peu piffométrique).

P.S : Je ne sais pas si on pourrait encore gagner un chouïa en passant le code en PChar.

[Gilbert Geyer]

A ShaiLeTroll :

En voulant faire un essai avec des PChar dans ExplodeGG, je me suis heurté à la conversion du Insert(#13,St,i); lorsque St est un PChar et en plus il est apparu en neutralisant Insert que la simple conversion de S vers St ralentissait à elle seule énormément.
J'ai donc fait marche arrière en revenant à string et en oubliant de dé-neutraliser le Insert(#13,St,i); ... et à ma grande surprise non seulement le résultat restait correct (#13 superflu) et bien sûr c'est encore plus rapide (3,4 fois) car un Insert ça prend du temps donc voiçi le code de remplacement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
function  ExplodeGG(const S: string; out A: TStringList; Sep: Char) : Integer;
var       i : integer; St : string;
begin     St:=S; i:=0; Result:=0;
          while i<length(St) do
          begin inc(i);
                if St[i] = Sep then
                begin Inc(Result); St[i]:=#10; //Insert(#13,St,i); #13 est superflu pour découper la chaîne
                                               //l''affichage du résultat dans un RichEdit confirme que le #10 suffit
                end;
          end;
          A.Add(St);
end;

Les Temps d'Execution obtenus avec S égale à [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois ... et avec Pentium III à seulement 1,13 GHz sont :
- ExplodeLazy : mis 17,57 ms
- ExplodeGG : mis 2,71 ms soit 3,4 fois moins qu'avec Insert(#13,St,i);
(Hors temps mis pour afficher le résultat des 15000 lignes résultantes de la TStringList dans un RichEdit afin de vérifier si le Split a été correct)
... ce qui devrait ramener le temps d'exécution avec processeur cadencé à 3 GHz aux environs de 1,1 ms.

[CapJack]

J'avais déjà pensé à cette solution, mais on peut faire encore mieux : en effet, il est inutile d'insérer le caractère #10, le simple remplacement par #13 devrait suffire...

Edit : arg. Tu as édité en même temps que moi !

[Gilbert Geyer]

A CapJack

Effectivement on a édité en même temps.

il est inutile d'insérer le caractère #10, le simple remplacement par #13 devrait suffire...

... en fait j'ai constaté que c'est l'inverse car en remplaçant simplement le séparateur par #13 l'affichage dans un RichEdit donne un paté de texte non découpé en lignes distinctes alors qu'avec simplement #10 le résultat est correct.
Par contre autre constat, quand j'ai affiché le Count de la StringList qui engrange temporairement le résultat du découpage celui-ci renvoie un nombre égal au nombre de fois que la fonction a été appelée dans la boucle de test alors que le RichEDit1.Lines.Count renvoie le nombre exact correspondant au Inc(Result) de la fonction ... car je pensais même gratter encore davantage en supprimant ce Inc(Result) mais heureusement que ce Inc(Result) ne mange quasiment pas de temps.

[Bruno13]

Salut Gilbert,

Si je comprends bien ta fonction ExplodeGG fait juste un StringReplace du caractère séparateur, mais comme ensuite tu le mets dans un RichEdit le #10 fait aller à la ligne ??!! ou alors j'y ai rien pigé?!

Quand je regarde le contenu de ma TStringList j'ai des chaines de caractéres avec dans mon cas l'espace remplacés par des #10 mais en aucun cas pour chaque indice de la TStringList un mot ??!!

peux tu m'expliquer ?

millé gracias
Bruno

[Gilbert Geyer]

A Bruno13
Salut Bruno,

Si je comprends bien ta fonction ExplodeGG fait juste un StringReplace du caractère séparateur, mais comme ensuite tu le mets dans un RichEdit le #10 fait aller à la ligne ??!! ou alors j'y ai rien pigé?!

... effectivement, sauf que je remplace le caractère séparateur par un #10 directement sans faire appel à une autre fonction, et arrivé dans le RichEdit cela suffit chez moi (Delphi-5) pour aller à la ligne aprè chaque mot splitté.

Quand je regarde le contenu de ma TStringList j'ai des chaines de caractéres avec dans mon cas l'espace remplacés par des #10 mais en aucun cas pour chaque indice de la TStringList un mot ??!! peux tu m'expliquer ?

... le comportement de la StringList semble effectivement être un peu différent de celui du RichEdit, car, comme je le disais à CapJack, quand j'ai affiché le Count de la StringList qui engrange temporairement le résultat du découpage celui-ci renvoie un nombre égal au nombre de fois que la fonction a été appelée dans la boucle de test alors que le RichEDit1.Lines.Count renvoie le nombre exact correspondant au Inc(Result) de la fonction, raison pour laquelle je n'ai pas supprimé ce Inc(Result).
... par contre s'il est nécessaire d'utiliser le Insert(#13,St,i) pour le problème de la StringList rien n'empêche de l'utiliser vu que même avec ce Insert la fonction reste quand même deux fois plus rapide que ExplodeLazy.
A+

[ShaiLeTroll]

Pour les infos sur Types :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

TStringDynArray = array of string;

StrUtils ? ce n'est pas nécessaire pour ExplodeLazy, ce n'est que du System.pas

sinon, je l'ai déjà cette variante ^_^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
procedure StringToList(Str: String; Sep: Char; List: TStrings);
var
   i: Integer;
   LastIsDelim: Boolean;
begin
     if Assigned(List) then 
     begin
        Str := Trim(Str);
        LastIsDelim := Str[Length(Str)] = Sep;
        for i := 1 to Length(Str) do
        begin
            if Str[i] = Sep then
            begin
               Str[i] := #10;
            end;
        end;
        List.Text := Str;
        if LastIsDelim then List.Add('');
     end;
end;

ou encore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
function StrToList(const Value: string; Sep: Char): TStringList;
begin
   Result := TStringList.Create();
   Result.Delimiter := Sep;
   Result.DelimitedText := Value;
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
function  ExplodeGG(const S: string; out A: TStringList; Sep: Char) : Integer;
var       i : integer; St : string;
begin     St:=S; i:=0; Result:=0;
          while i<length(St) do
          begin inc(i);
                if St[i] = Sep then
                begin Inc(Result); St[i]:=#10; //Insert(#13,St,i); #13 est superflu pour découper la chaîne
                                               //l''affichage du résultat dans un RichEdit confirme que le #10 suffit
                end;
          end;
          A.Add(St);
end;

... par contre s'il est nécessaire d'utiliser le Insert(#13,St,i) pour le problème de la StringList rien n'empêche de l'utiliser vu que même avec ce Insert la fonction reste quand même deux fois plus rapide que ExplodeLazy.
A+

Rapide mais ne fait rien ...
"out A: TStringList" SANS instanciation ne fonctionne pas !!! ... donc A ne contient jamais rien ...
"A.Add(St)" ne sert à rien non car on as toujours qu'une seule chaine, il faut recopier la chaine dans Text ... et là c'est utile mais plus lent !
"Insert(#13,St,i)" cela ne change rien, la TStringList est toujours avec une ligne par appel ...
"RichEdit", bien sur, c'est lui qui gère le #10 comme une ligne mais un TlistBox mettra un petit carré ...

Bon, bonne tentative, mais ExplodeLazy reste plus rapide et fonctionnel

J'ai corrigé ces temps, pour Explode la séparation était sur ; et ! au lieu de ; uniquement ...

ExtractStrings (Delphi 7 StrUtils) : 25 à 35 ms
ExplodeLazy : 7 à 8 ms
Explode : 10 à 11 ms
StringToList: 13 à 14 ms
SplitStrClorish : 120 à 132 ms
SplitDroopyEyes : 65 à 71 ms
ExplodeFabriceRouxel : : 15 à 18 ms
SplitBruno13 : 22 à 25 ms
ExplodeDragonHeart : 17 à 20 ms
Explodeturf_trader : 20 à 23 ms


EDIT : j'ai essayé en PChar, bon surement des erreurs pour certains cas ... et puis je ne suis pas habitué au PChar ... cela reste 7 à 8 ms, pour 1000, j'ai testé à 10 000 mais cela ne change pas grand chose, les temps sont entre 65 et 85 ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
function ExplodeLazyPChar(const S: string; out A: Types.TStringDynArray; Separator: Char): Integer;
var
  J, K, L: integer;
  P, P2, PEnd: PChar;
begin
  Result := 0;
  L := Length(S);
  P := Pointer(S);
  P2 := P;
  PEnd := P;
  Inc(PEnd, L);
 
  while P < PEnd do
  begin
    if P^ = Separator then
    begin
      Inc(Result);
    end;
    Inc(P);
  end;
 
  if S[L] = Separator then
    SetLength(A, Result)
  else
    SetLength(A, Result + 1);
 
  K := 0;
  J := 0;
  P := P2;
  while P < PEnd do
  begin
    if P^ = Separator then
    begin
      if K > 0 then
      begin
        SetLength(A[J], K);
        Move(P2^, PChar(A[J])^, K);
        K := 0;
      end;
      P2 := P;
      Inc(P2);
      Inc(J);
    end else
    begin
      Inc(K);
    end;
 
    Inc(P);
  end;
 
  if (P2 < PEnd) and (K > 0) then
  begin
    SetLength(A[J], K);
    Move(P2^, PChar(A[J])^, K);
  end;
end;

[Gilbert Geyer]

A ShaiLeTroll :

Merci pour les infos sur les types.

"out A: TStringList" SANS instanciation ne fonctionne pas !!! ... donc A ne contient jamais rien ...

... que je mette "out A" ou "var A" j'ai constaté que A contient toujours les 1000 lignes morcellées par les #10.

Rapide mais ne fait rien ...

... si si, ExplodeGG fait le remplacement de ";" par "#10" ou selon le cas par "#13#10" ce qui me suffit dans la plupart des cas où je n'ai pas besoin d'afficher le résultat des 15000 lignes l'affichage ne me servant en général qu'en phase de vérification lors de la mise au point d'un bout de code.
Par contre il est exact que "A.Add(St)" n'ajoute qu'une seule ligne c'est à dire qu'un seul pointeur à la StringList puisque le découpage avec les "#10" n'ajoute pas de pointeurs intermédiaires.

Ceci étant, l'exercice est intéressant, je vais voir pour essayer de faire mieux.

[ShaiLeTroll]

Par contre il est exact que "A.Add(St)" n'ajoute qu'une seule ligne c'est à dire qu'un seul pointeur à la StringList puisque le découpage avec les "#10" n'ajoute pas de pointeurs intermédiaires.

Et malheureusement, c'est le seul intéret de Explode, qui est de mettre Str splitté dans A ... que ce soit un Tableau ou Liste mais en remplaçant "Add" par "Text := ", c'est tout à fait fonctionnel, ... mais déjà proposé plusieurs fois ...

pour en revenir à une autre remarque

... mais comme en modifiant cette fonction pour l'adapter au cas de la StringList j'ai vu qu'elle parcourait deux fois la longueur de la string "S" (voir les deux for I := 1 to Length(S) do) et qu'elle était également ralentie notamment par le Copy(S, K, I - K)); du coup cela m'a donné une idée vachement simplificatrice et qui du coup est plus rapide :

Alors, faut savoir que 'Text := ' fait un SetString, ce qui équivaut à un LStrFromPCharLen, et c'est proche d'un Copy (LStrCopy), le Copy est tout simplement indispensable faut bien remplir quelques choses ...

Sinon pour la double itération, cela est très utile pour allouer d'un coup le tableau, à moins de 5 cela n'est pas notable, mais plus cela augmente mieux c'est, tu as l'équivalent dans la TStringList avec Capacity qui augemte aussi par lot (4, puis 16, puis 25% de Capacity voire méthode Grow)

[Gilbert Geyer]

A ShaiLeTroll :

Vu ces infos complémentaires et l'intérêt de remplacer "Add" par "Text := ".

...tu as l'équivalent dans la TStringList avec Capacity qui augemte aussi par lot (4, puis 16, puis 25% de Capacity voire méthode Grow

... je n'ai pas trouvé la méthode Grow dans mon Aide (Delphi-5).

Au fait je viens de tester ExplodeLazyPChar avec le bout de code suivant où ligTests est égale à [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
procedure TForm1.bExplodeLazyPCharClick(Sender: TObject);
var       A : TStringDynArray; i : integer; Chrono : oChrono;
begin     RichEdit1.clear;
          Chrono.Top;
          for i:=1 to 1000 do ExplodeLazyPChar(ligTests,A,';');
          labChrono.caption:='Mis : '+FloatToStrf(Chrono.Mis,ffFixed,10,2);
          labChrono.upDate;
          for i:=Low(A) to High(A) do RichEdit1.lines.Add(A[i]); //< renvoie seulement les 15 derniers splittés et non les 15000
          labCount.caption:=IntToStr(High(A));
end;

... mais comme le tableau A est redimensionné à chaque appel de ExplodeLazyPChar je ne retrouve en sortie dans le RichEdit que les 15 derniers mots splittés sur l'ensemble des 15000 attendus
... et comme je ne pratique pas bien les PChar je n'ai pas réussi à convertir les Move(P2^, PChar(A[J])^, K) d'ExplodeLazyPChar en un move dans une ligne vide d'une StringList qui remplacerait le tableau A.