Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2020-08-10T18:15:04+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Les expressions régulières, message #2248312020-08-10T18:15:04+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224831<p>Bonjour,</p>
<p>La bêta du contenu « Les expressions régulières » a été désactivée.</p>Les expressions régulières, message #2247892020-08-09T17:56:12+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224789<p>Oui c’est vrai, va pour la traduction la plus courante <img src="/static/smileys/svg/heureux.svg" alt=":D" class="smiley"> </p>Les expressions régulières, message #2247882020-08-09T17:02:29+02:00QuentinC/@QuentinChttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224788<blockquote>
<p> genre cygwin ?</p>
</blockquote>
<p>Non plus.
Cygwin est une super usine à gaz qu’il ne vaut mieux pas installer… c’est limite pire que visual studio.</p>
<blockquote>
<p>Et pour la manière d’appeler les regex ça dépend de la personne mais je pense que regex est suffisamment utilisé en français pour laisser ça </p>
</blockquote>
<p>Personnellement je ne mettrais pas "regex" ou "regexp" comme titre, tout simplement parce que c’est une abréviation, et les abréviations n’ont pas leur place dans un titre.
Donc, je choisirais entre "expressions rationelles", meilleure traduction mais moins courante, ou "expression régulière", moins bonne traduction mais beaucoup plus courante.</p>
<p>Après effectivement, quand on a l’habitude de les utiliser, on les appelle plutôt "regex"; mais ça reste une abréviation.</p>Les expressions régulières, message #2247872020-08-09T15:17:35+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224787<p><a href="/membres/voir/QuentinC/" rel="nofollow" class="ping ping-link">@<span class="ping-username">QuentinC</span></a> genre cygwin ?</p>
<p>Et pour la manière d’appeler les regex ça dépend de la personne mais je pense que regex est suffisamment utilisé en français pour laisser ça</p>Les expressions régulières, message #2247862020-08-09T13:36:30+02:00SpaceFox/@SpaceFoxhttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224786<p><a href="/membres/voir/entwanne/" rel="nofollow" class="ping ping-link">@<span class="ping-username">entwanne</span></a> une meilleure traduction, mais moins utilisée de mon point de vue.</p>Les expressions régulières, message #2247852020-08-09T13:21:30+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224785<figure><blockquote>
<p>Déjà personnellement je mettrais le titre en français. J’ai toujours entendu « regex » ou « expression régulière » de la part de francophones, parfois « regexp » mais rarement « regular expression ».</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14422/regex/?page=1#p224751">SpaceFox</a></figcaption></figure>
<p>Souvent « expressions rationnelles » aussi, qui est une meilleure traduction.</p>Les expressions régulières, message #2247822020-08-09T12:13:10+02:00QuentinC/@QuentinChttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224782<blockquote>
<p>Pour ce qui est de l’utilisation de grep et sed sous windows, c’est totalement possible avec WSL qui est très pratique.</p>
</blockquote>
<p>Oui, on peut avec WSL, mais même pas besoin. A l’époque où je les avais récupérés (il y a plus de 10 ans), il y avait un projet de portage d’utilitaires UNIX sous windows, sauf erreur ça s’appelait GNU Win32.
Ils avaient porté des tas de trucs utiles, dont grep et sed.</p>Les expressions régulières, message #2247692020-08-09T00:46:18+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224769<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3651/regex/">Regex</a> </p></div>
<p>Merci d’avance pour vos commentaires.</p>Les expressions régulières, message #2247672020-08-08T23:19:28+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224767<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3651/regex/">Regex</a> </p></div>
<p>Merci d’avance pour vos commentaires.</p>Les expressions régulières, message #2247632020-08-08T21:33:25+02:00SpaceFox/@SpaceFoxhttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224763<p><a href="/membres/voir/thibsc/" rel="nofollow" class="ping ping-link">@<span class="ping-username">thibsc</span></a> je parle bien des exemples du lien.</p>Les expressions régulières, message #2247542020-08-08T18:22:24+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224754<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3651/regex/">Regex</a> </p></div>
<p>Merci d’avance pour vos commentaires.</p>Les expressions régulières, message #2247532020-08-08T17:32:41+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224753<p>Merci à tous les quatre pour votre retour </p>
<figure><blockquote>
<p>Un bon document sur les bases des Regex, par contre je trouve qu’il manque des références à des outils permettant de les utiliser sur son pc, (sed, grep, …, pour windows je ne sais pas), certaines suites bureautiques (Libre office, Google Calc, … , mais pas MS office a moins de passer par les macros), et le fait que suivant les outils il peut y avoir différentes implémentations des regex.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14422/regular-expression/?page=1#p224747">kayou</a></figcaption></figure>
<p>Je vais ajouter une section pour parler des utilisations potentiels dans un milieu professionnel parce que c’est vrai que les sites comme Rubular sont pratiques mais juste pour tester. Et merci pour la coquille (même s’il en reste sûrement d’autres <img src="/static/smileys/svg/clin.svg" alt=";)" class="smiley"> )</p>
<figure><blockquote>
<p>Attention, les exemples sont particulièrement mauvais puisque <strong>ils ne sont pas comparables entre les langages</strong>. Chaque « implémentation » dans un langage teste une version simplifiée de ce que pourrait être un email, et chaque exemple a ses propres limites. Ceux avec Ruby et Perl sont complexes parce qu’ils sont plus complets, pas parce que le moteur de regex utilisé est plus complexe.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14422/regular-expression/?page=1#p224751">SpaceFox</a></figcaption></figure>
<p>Tu parles des exemples du lien de <a href="/membres/voir/kayou/" rel="nofollow" class="ping ping-link">@<span class="ping-username">kayou</span></a> ou de mon exemple d’entrainement à la fin du tuto ?</p>
<p>Et <a href="/membres/voir/QuentinC/" rel="nofollow" class="ping ping-link">@<span class="ping-username">QuentinC</span></a>, effectivement je vais compléter ça dans la section d’utilisation plus proche du milieu professionnel pour introduire la substitution. Et le <code>^</code> et <code>$</code> je les ai mentionné mais sans détailler, ça manque sûrement <img src="/static/smileys/svg/heureux.svg" alt=":D" class="smiley"> .
Pour ce qui est de l’utilisation de grep et sed sous windows, c’est totalement possible avec WSL qui est très pratique.</p>Les expressions régulières, message #2247522020-08-08T17:13:02+02:00QuentinC/@QuentinChttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224752<p>Bonjour,</p>
<p>Je me joins aux avis précédents. IL y a déjà une bonne base, mais il manque un certain nombre de détails.</p>
<p>JE parlerais quand même des différentes implémentations, car:</p>
<ul>
<li>il y a des variations de syntaxe. Par exemple pour les groupes nommés, il existe <code>(?'nom')</code>, <code>(?<nom>)</code>, <code>(\p<nom>)</code> et d’autres encore</li>
<li>Les assertions arrières et avant ne sont pas toujours supportées</li>
</ul>
<p>Le risque c’est que quelqu’un essaie les regexp en JavaScript ou Java et soit perdu parce que tu as pris l’implémentation de python comme base, ou l’inverse…</p>
<p>Tu ne parles pas de <code>^</code>, <code>$</code>, <code>\b</code> et <code>\B</code> dans les assertions, pourtant ils sont importants.
Idem pour les modificateurs, les plus utiles (i, m et s) sont communs à à peu près toutes les implémentations.</p>
<p>Tu parles de la recherche, mais il faut aussi parler du remplacement. Là aussi avec quelques différences de syntaxe, p.ex. <code>\1</code> vs. <code>$1</code>.</p>
<p>Si ça te dit, tu peux compléter avec des éléments plus avancés: les groupes conditionnels, le sticky/continuation flag, la réutilisation de groupes précédents, la récursion, etc.
Mais en pratique c’est assez peu utilisé donc difficile de trouver de vrais exemples concrets.</p>
<p>Par ailleurs, il serait effectivement intéressant que tu présentes l’utilité des regexp en-dehors des langages de programmation.
ON pense tous à grep bien sûr, mais pourquoi pas awk et/ou sed aussi ?</p>
<p>A noter que grep et sed ont été portés pour windows, et ça doit aussi être le cas pour awk.</p>
<p>Pour finir, change ce titre en anglais ! Ton tutoriel n’a pas à s’appeler "Regular expressions" quand une traduction largement acceptée (et même deux) existe, surtout que tu l’utilises ensuite.</p>Les expressions régulières, message #2247512020-08-08T16:51:28+02:00SpaceFox/@SpaceFoxhttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224751<p>Hello,</p>
<p>Déjà personnellement je mettrais le titre en français. J’ai toujours entendu « regex » ou « expression régulière » de la part de francophones, parfois « regexp » mais rarement « regular expression ».</p>
<p>Pour compléter <a href="/membres/voir/kayou/" rel="nofollow" class="ping ping-link">@<span class="ping-username">kayou</span></a>, le moteur de rechercher/remplacer par regex de Notepad++ (et ceux intégrés aux IDE) m’ont fait gagner des jours de boulot. La principale différence entre les outils au quotidien, c’est que le caractère de remplacement de capture change (<code>$1</code> ou <code>\1</code> généralement).</p>
<figure><blockquote>
<p>Bonjour, je plussoie le commentaire de Kayou. L'<a href="https://emailregex.com">exemple ici</a> nous montre comment détecter un email selon le langage … il existe de nombreuses variantes avec une plus ou moins grande complexité (avec Perl ou Ruby c’est plutôt hardcore).</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14422/regular-expression/?page=1#p224749">Yarflam</a></figcaption></figure>
<p>Attention, les exemples sont particulièrement mauvais puisque <strong>ils ne sont pas comparables entre les langages</strong>. Chaque « implémentation » dans un langage teste une version simplifiée de ce que pourrait être un email, et chaque exemple a ses propres limites. Ceux avec Ruby et Perl sont complexes parce qu’ils sont plus complets, pas parce que le moteur de regex utilisé est plus complexe.</p>Les expressions régulières, message #2247492020-08-08T12:42:40+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224749<p>Bonjour, je plussoie le commentaire de Kayou. L'<a href="https://emailregex.com">exemple ici</a> nous montre comment détecter un email selon le langage … il existe de nombreuses variantes avec une plus ou moins grande complexité (avec Perl ou Ruby c’est plutôt hardcore).</p>Les expressions régulières, message #2247472020-08-08T11:24:46+02:00kayou/@kayouhttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224747<p>Bonjour,</p>
<p>Un bon document sur les bases des Regex, par contre je trouve qu’il manque des références à des outils permettant de les utiliser sur son pc, (sed, grep, …, pour windows je ne sais pas), certaines suites bureautiques (Libre office, Google Calc, … , mais pas MS office a moins de passer par les macros), et le fait que suivant les outils il peut y avoir différentes implémentations des regex.</p>
<p>Nota: Il ya une petite faute dans la note de la partie sur les ensembles</p>
<blockquote>
<p>ce qui <strong>ser<del>(ez)</del>ait</strong> également le cas dans un ensemble SI et seulement SI il n’est pas entouré.</p>
</blockquote>Les expressions régulières, message #2247442020-08-07T19:00:43+02:00thibsc/@thibschttps://zestedesavoir.com/forums/sujet/14422/les-expressions-regulieres/?page=1#p224744<p>Tout le monde se secoue ! <img src="/static/smileys/svg/heureux.svg" alt=":D" class="smiley"></p>
<p>J’ai commencé (il y a 13 heures) la rédaction d’un tutoriel au doux nom
de « Regular Expression » et j’ai pour objectif de proposer en validation
un texte aux petits oignons. Je fais donc appel à votre bonté sans
limites pour dénicher le moindre pépin, que ce soit à propos
du fond ou de la forme. Vous pourrez consulter la bêta à votre guise à
l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3651/regular-expression/">À présent, c’est à vous !</a> </p></div>
<p>Merci !</p>Détecter les balises non fermées, message #1471502017-04-13T17:03:39+02:00tleb/@tlebhttps://zestedesavoir.com/forums/sujet/8371/detecter-les-balises-non-fermees/?page=1#p147150<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>⟩ node
> 1 + 1
2
</pre></div>
</td></tr></table></div>Détecter les balises non fermées, message #1469892017-04-12T12:35:47+02:00picode/@picodehttps://zestedesavoir.com/forums/sujet/8371/detecter-les-balises-non-fermees/?page=1#p146989<p>Merci beaucoup tleb pour ces remarques très pertinentes. J’en prends bonne note et compte bien appliquer cette logique pour la suite.</p>
<p>Pour ta question :</p>
<blockquote>
<p>// je n’ai pas vraiment compris pourquoi tu faisais ça :
var p = parseInt(i) + parseInt(1)</p>
</blockquote>
<p>Et bien si je ne fais pas cela, avec par exemple i = 1, je vais avoir p = 11 (i est concaténé à 1), pareil pour j… (et pourtant je suis bien d’accord avec toi que i est un entier)</p>Détecter les balises non fermées, message #1466602017-04-08T12:19:06+02:00tleb/@tlebhttps://zestedesavoir.com/forums/sujet/8371/detecter-les-balises-non-fermees/?page=1#p146660<p>Quelques commentaires sur ton code :</p>
<div class="spoiler">
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// il faut mieux utiliser la syntaxe</span>
<span class="p">{}</span>
<span class="c1">// plutôt que</span>
<span class="k">new</span> <span class="nb">Object</span><span class="p">()</span>
<span class="c1">// car c'est plus lisible</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// tu peux déclarer deux variables en une ligne</span>
<span class="kd">var</span> <span class="nx">arrTagNotClosed</span> <span class="o">=</span> <span class="p">{},</span> <span class="nx">pile</span> <span class="o">=</span> <span class="p">[]</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7
8</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// dans une boucle, tu peux remplacer</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">c</span> <span class="o">===</span> <span class="s1">'<'</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">foo</span><span class="p">()</span>
<span class="p">}</span>
<span class="c1">// par</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">c</span> <span class="o">!==</span> <span class="s1">'<'</span><span class="p">)</span> <span class="k">continue</span><span class="p">;</span>
<span class="nx">foo</span><span class="p">()</span>
<span class="c1">// ça t'évite d'avoir à indenter la partie `foo()`</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// si deux variables sont égales</span>
<span class="kd">var</span> <span class="nx">isTagStart</span> <span class="o">=</span> <span class="nx">isTagEnd</span> <span class="o">=</span> <span class="kc">false</span>
<span class="c1">// attention, si c'est une référence, quand tu en modifieras un, tu modifieras l'autre</span>
<span class="c1">// par exemple, si tu fais</span>
<span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">bar</span> <span class="o">=</span> <span class="p">[]</span>
<span class="nx">foo</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="c1">// bar vaudra [1]</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// je n'ai pas vraiment compris pourquoi tu faisais ça :</span>
<span class="kd">var</span> <span class="nx">p</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">+</span> <span class="nb">parseInt</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="c1">// tu sais que i est l'indice du caractère, donc c'est un nombre entier de base</span>
<span class="c1">// (note qu'il n'y a pas de type `int` en JS, un entier est juste un `number` avec `n % 1 === 0`)</span>
<span class="c1">// et 1 est un nombre entier lui aussi</span>
<span class="kd">var</span> <span class="nx">p</span> <span class="o">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
<span class="c1">// pareil pour j</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7
8</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="nx">isTagStart</span> <span class="o">||</span> <span class="nx">isTagEnd</span>
<span class="c1">// est toujours vrai car tu as juste au dessus</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">foo</span><span class="p">())</span> <span class="p">{</span>
<span class="nx">isTagStart</span> <span class="o">=</span> <span class="kc">true</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">isTagEnd</span> <span class="o">=</span> <span class="kc">true</span>
<span class="p">}</span>
<span class="c1">// dans tout les cas, l'un des deux est vrai</span>
</pre></div>
</td></tr></table></div>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">// tu n'as pas vraiment besoin d'avoir `isTagStart` et `isTagEnd`, vu que l'un est l'opposé de l'autre</span>
<span class="c1">// donc au lieu de faire</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagStart</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">foo</span><span class="p">()</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagEnd</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">bar</span><span class="p">()</span>
<span class="p">}</span>
<span class="c1">// tu peux faire</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagStart</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">foo</span><span class="p">()</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">bar</span><span class="p">()</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p>Pourquoi est-ce que tu travailles au début de la liste ? Il me semble que c’est du O(n) pour ajouter un élément au début, vu qu’il doit tout déplacer dans la liste alors que c’est du ~ O(1) si tu append. Sinon, il y a des types faits exprès pour ce genre d’opération, mais ça ne sert pas vraiment dans ton cas je pense.</p>
</div>
<p>Pour moi, le principal point d’amélioration que tu peux avoir est d’éviter au maximum d’indenter. Tu arrives à un endroit dans ton algo à 6 indentations. Quand tu sais que la majorité de ton algo va être dans une condition, traite l’inverse avant comme ça tu n’as pas à indenter le corps de l’algo. Et utilise des fonctions pour <em>auto-documenter</em> ton code et isoler les différentes sections de ton algo. Ça ne le rendra que plus clair.</p>Détecter les balises non fermées, message #1466282017-04-07T22:16:55+02:00picode/@picodehttps://zestedesavoir.com/forums/sujet/8371/detecter-les-balises-non-fermees/?page=1#p146628<p>J’ai pondu la fonction ci-dessous sur vos conseils. Je parcours la chaîne (qui n’est jamais bien longue, c’est l’équivalent d’un paragraphe), je détecte si j’ai une balise ouvrante, dans ce cas, je l’empile. Si c’est une balise fermante, je vérifie qu’elle correspond à la dernière balise empilée. Si c’est le cas, je la dépile. Comme j’ai besoin de connaître la position de la balise dans la chaîne, j’ai ajouté une autre variable qui me permet de stocker la position de la balise et son nom.</p>
<p>Après plusieurs tests, j’ai bien le résultat attendu. </p>
<p>Voici ma solution (n’hésitez pas à la critiquer)</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 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</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="kd">function</span> <span class="nx">searchTagNotClosed</span><span class="p">(</span><span class="nx">string</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">arrTagNotClosed</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Object</span><span class="p">();</span>
<span class="kd">var</span> <span class="nx">pile</span> <span class="o">=</span> <span class="p">[];</span>
<span class="k">for</span> <span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">string</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">c</span> <span class="o">=</span> <span class="nx">string</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
<span class="c1">//Détection d'une balise</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">c</span> <span class="o">===</span> <span class="s1">'<'</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">isTagStart</span> <span class="o">=</span> <span class="kc">false</span><span class="p">;</span>
<span class="kd">var</span> <span class="nx">isTagEnd</span> <span class="o">=</span> <span class="kc">false</span><span class="p">;</span>
<span class="kd">var</span> <span class="nx">j</span><span class="p">;</span> <span class="c1">//position à partir de laquelle récupérer le nom de la balise</span>
<span class="c1">//type de la balise (fermante ou ouvrante)</span>
<span class="kd">var</span> <span class="nx">p</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">+</span> <span class="nb">parseInt</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">string</span><span class="p">[</span><span class="nx">p</span><span class="p">]</span> <span class="o">===</span> <span class="s1">'/'</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">//balise fermante</span>
<span class="nx">isTagEnd</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
<span class="nx">j</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">+</span> <span class="nb">parseInt</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="c1">//balise ouvrante</span>
<span class="nx">isTagStart</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
<span class="nx">j</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">+</span> <span class="nb">parseInt</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="c1">//on récupère le nom de la balise et on commence à partir de la</span>
<span class="c1">// position courante (qui est < plus 1)</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagStart</span> <span class="o">||</span> <span class="nx">isTagEnd</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">//on récupère la chaîne à partir de la position courante J</span>
<span class="kd">var</span> <span class="nx">stringWithTagName</span> <span class="o">=</span> <span class="nx">string</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">j</span><span class="p">);</span>
<span class="c1">//le nom s'arrête à > (ce qui inclus alors les éventuels attributs)</span>
<span class="kd">var</span> <span class="nx">pos</span> <span class="o">=</span> <span class="nx">stringWithTagName</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="s1">'>'</span><span class="p">);</span>
<span class="kd">var</span> <span class="nx">stringTagNameWithAttr</span> <span class="o">=</span> <span class="nx">stringWithTagName</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">pos</span><span class="p">);</span>
<span class="nx">pos</span> <span class="o">=</span> <span class="nx">stringTagNameWithAttr</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="s1">' '</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">pos</span> <span class="o">!==</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">//il y avait bien des attributs, donc on récupère seulement</span>
<span class="c1">//le nom du tag</span>
<span class="kd">var</span> <span class="nx">tagName</span> <span class="o">=</span> <span class="nx">stringWithTagName</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">pos</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="c1">//il n'y a pas d'attribut</span>
<span class="nx">tagName</span> <span class="o">=</span> <span class="nx">stringTagNameWithAttr</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">//si c'est une balise ouvrante, il faut l'empiler et mettre à jour</span>
<span class="c1">// le tableau qui contient le tag et sa position (i) dans la chaîne</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagStart</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">//on empile (en début de tableau)</span>
<span class="nx">pile</span><span class="p">.</span><span class="nx">unshift</span><span class="p">(</span><span class="nx">tagName</span><span class="p">);</span>
<span class="nx">arrTagNotClosed</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">tagName</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">//si c'est une balise fermante, il faut regarder si le nom est</span>
<span class="c1">// le même que le premier élément du tableau. Si c'est le cas,</span>
<span class="c1">// cela signifie que la balise est fermée, il faut retirer</span>
<span class="c1">// l'élément de la pile</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">isTagEnd</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nx">tagName</span> <span class="o">===</span> <span class="nx">pile</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="p">{</span>
<span class="c1">//on dépile en début de tableau</span>
<span class="nx">pile</span><span class="p">.</span><span class="nx">shift</span><span class="p">();</span>
<span class="c1">//on supprime également l'élément dépilé du tableau</span>
<span class="c1">// contenant les tags ouverts avec leur position</span>
<span class="nb">Object</span><span class="p">.</span><span class="nx">deleteLast</span><span class="p">(</span><span class="nx">arrTagNotClosed</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">arrTagNotClosed</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">tagName</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nx">arrTagNotClosed</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p>Je marque le sujet comme résolu, mais s’il y a moyen d’optimiser, n’hésitez pas à le dire. De plus, pour l’instant, ma fonction ne gère pas la possibilité de rencontrer des balises orphelines.</p>
<p>Merci à tous les participants de ce sujet.</p>