[RegExp] regExp et match [Résolu]

[the-destroyer]

Bonsoir,

je cherche a isoler certaine partie d'une chaine de caractère avec match,
les éléments serait pris à partir du caractère ":" et finirai soit par un "." soit par ")".
Voila mon code actuel mais il ne marche pas, je ne trouve pas pourquoi

Code :

1
2
3
4
5
 
var carac = "textext:textext().textextext:textextext()",
find = carac.match(/:((.)*)\.|\)/g);
 
// find retourne: [":textext().", ")"]

merci d'avance pour votre aide !

[Watilin]

Essaye ça, si j'ai pas compris de travers ce que tu veux obtenir.

Code regexp :

/:([^.)]+)(?:\.|\))/g

Selon moi il y a 3 difficultés avec les regexp :
1- maîtriser la syntaxe
2- savoir exactement ce qui doit correspondre
3- savoir exactement ce qui ne doit pas correspondre

Tu as mis un (.)* à la place d'un (.*), ce qui me laisse penser que tu te heurtes à ma diffculté n°1 , mais mettons-ça sur le compte de la fatigue
Je t'ai mis un + au lieu d'une *, car je pense que trouver une chaîne vide ne t'intéresse pas. De plus, j'ai remplacé le point par une classe [^.)] qui signifie « tout sauf point et parenthèse droite ».
Après ça on a un groupe non capturant : (?: … ). C'est comme un groupe parenthésé normal sauf que le résultat n'est pas conservé. Ça améliore les performances. Et pourquoi un groupe à cet endroit ? C'est pour le pipe « | » : si on n'en met pas, il coupe toute la regexp en deux (pour voir, compare /ab|c/ et /a(?:b|c)/).



Au fait, juste par curiosité : pourquoi tu as besoin de ça ?

[the-destroyer]

Merci de répondre, mon opinion sur tes compétence sont maintenant confirmé ^^

bref, je construis un framework, travaillant sur le moteur de sélection des éléments de la page pour le moment, je souhaite que l'utilisateur puisse le modelé un maximum, c'est a dire, ajouté s'il le désire un moyen de sélection similaire a ce qu'il existe actuellement telle les pseudos classe par exemple, appelons les les sélecteurs, mais pour ce que je t'ai demandé c'est une fonction a part dont je te parlerais plus tard si tu le désires bref par une boucle, je parcourt chaque caractère entré (ex:$("div[id]")), et dès qu'un caractère correspond au caractère identifiant a un des sélecteurs, () la fonction désigné est apellé, par exemple, ici, la fonction nommé "[" serait appellé lorsque le caractere "[" serait verifier.

jusque la tout vas bien ? Que pensse tu de ce moyen de parcourt ? j'ai deja essayé avec des regExp mais c'etait une vrai usine a gaz

[the-destroyer]

awi et le code que tu m'a donné ne marche pas :/

[Watilin]

Envoyé par the-destroyer

Merci de répondre, mon opinion sur tes compétence sont maintenant confirmé ^^

C'est du bluff

Envoyé par the-destroyer

awi et le code que tu m'a donné ne marche pas :/

En fait je faisais mes tests avec la méthode exec des regexp, en oubliant que String.match et RegExp.exec ne se comportent pas tout à fait pareil…

Code console :

1
2
3
4
5
6
7
8
>>> var carac = "textext:textext().textextext:textextext()"
>>> var rx = /:([^.)]+)(?:\.|\))/g
>>> rx.exec(carac)
[":textext()", "textext("]
>>> rx.exec(carac)
[":textextext()", "textextext("]
>>> rx.exec(carac)
null

exec renvoie un tableau. En 0, on a la correspondance totale, et en 1, 2, etc., les différents groupes capturés. Les regexp avec l'option g ont une propriété lastIndex qui évolue à chaque nouvelle recherche, un peu comme les mysql_fetch en PHP.

En gros faut faire une boucle while (tab = rx.exec(carac)) et travailler avec tab dans cette boucle. Récupère tab[1], c'est le groupe capturé qui nous intéresse. Et tu as vu, il reste une parenthèse gauche qui traîne, j'ai suivi à la lettre les « spécifications » de ton premier post

Envoyé par the-destroyer

Que pensse tu de ce moyen de parcourt ?

J'en pense que ça ressemble furieusement à un automate d'analyse lexicale L'analyse lexicale est une technique utilisée en compilation. Si tu trouves des cours en ligne pas trop compliqués là-dessus, ça devrait t'intéresser

[SpaceFrog]

en conservant le match:

Code :

1
2
3
4
 
var carac = "textext:textext().textextext:textextext()",
find = carac.match(/:[^:]*(\.|\))/g);
alert(find)

retourne :textext().,:textextext()

c'est pas le resultat recherché ?

[javatwister]

d'accord SF, j'aurais dit pareil (sauf info en plus)

[the-destroyer]

D'accord merci, mais qu'appelle tu vraiment "compilation" ? En javascript ?

Merci space Frog cela convient parfaitement

[the-destroyer]

Bonjour, me voila avec un nouveau problème que j'aurai du prévoir

Code js :

var string = "text.text:text(text:text(text.text).text:text(text:text().text:text(text.text.text:text(n fois possible)))).text:text()"

Imaginons que ma chaine de caractère soit celle ci-dessus, comment récupérer par une RegExp (pour gagner du temps) juste ce qu'il y a dans les premières parenthèse, c'est a dire qu'il faudrait obtenir le tableaux suivant:

["text.text:text(text:text(text.text).text:text(text:text().text:text(text.text.text:text(n fois possible))))",
":text()"]

"text" pouvant être n'importe quelle caractère sauf ceux nécessaire au bon fonctionnement de la regexp.
L'utilisateur pouvant mettre un nombre de fois indéterminé de "text" dans les parenthèse d'autre "text".
J'ai déjà essayé par diverses regexp mais cela ne me semble pas réalisable... Un triage caractère par caractère semble a envisager :/

Merci d'avance

[SpaceFrog]

Pour matcher avec une regexp, il faut un pattern ...
en l'occurrence je vois mal comment définir un pattern dans ton cas de figure
...

[the-destroyer]

Okay merci pour votre aide !

[Watilin]

Il n'y a pas de compilation en JavaScript (sauf les JIT mais ils sont d'une complexité inhumaine ^^). Je parlais du domaine de la compilation en général, ça peut aller du langage dédié tout simple, comme un langage d'opérations arithmétiques avec juste des nombres à un chiffre, des + et des -, jusqu'aux méta-langages, c'est-à-dire des langages permettant de définir des langages

Sinon pour ton exemple, il te faudrait un pattern récursif. Ça n'existe qu'en Perl, et heureusement ! Ils sont cauchemardesques Mieux vaut passer par un peu de script traditionnel. Il y a deux ans j'ai fait un léger parseur de BBCode en PHP, l'idée était assez simple :
1- je repère les parenthèses dans lesquelles il n'y a pas d'autres parenthèses (plutôt facile, /\([^()]*\)/)
2- s'il n'y en a pas, alors il n'y a rien à traiter
3- sinon, je traite le résultat
4- je retire ces parenthèses de la chaîne totale, j'ai donc « retiré un niveau » de parenthèses
5- je recommence avec cette nouvelle chaîne.

Tout ça repose sur une fonction qui s'auto-appelle :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
function traiter( s ) {
    if (…) {
        // plus rien à faire, on s'arrête
        return s;
    } else {
        s2 = …
 
        …traiter(s2)…
 
        return …
    }
}

C'est ce qu'on appelle une fonction récursive.

Bon j'ai dit que l'idée était assez simple, en fait il faut être méthodique car on s'emmêle très facilement les pinceaux
Je vais te laisser chercher un peu

[the-destroyer]

Helo ! Merci de ton investissement

Bonne idée mais ton parseur ne résoudrais rien :/

Ce qu'il faudrait c'est une fonction qui récupère ce qu'il y a entre parenthèse mais juste une fois, c'est a dire par exemple pour ma string d'avant:

Code :

var string = "text.text:text(text:text(text.text).text:text(text:text().text:text(text.text.text:text(n fois possible)))).text:text()"

Première appelle de la fonction:

Code :

retour1= [":text(text:text(text.text).text:text(text:text().text:text(text.text.text:text(n fois possible))))", ":text()"]

Second appelle de la fonction sur retour1[0]:

Code :

retour2 = [":text(text.text)", ":text(text:text().text:text(text.text.text:text(n fois possible)))"];

Troisième appelle de la fonction sur retour2:

Code :

retour3 = [":text()", ":text(text.text.text:text(n fois possible))"];

Quatrième appelle de la fonction sur retour3:

Code :

retour4 = [":text(n fois possible)"];

Tu vois ? mais comme tu l'a dis les regExp sont inutilisable dans ce cas

[the-destroyer]

voila une fonction que j'ai créer, rien de sorcier mais qui repond a ce que je disais, il me semble qu'il est optimisé:

Code :

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
 
function (objt, where) {
	var i = 0,
	     objtLength = objt.length,
	     str = "",
		inObjt = [],
		inCond = [];
 
for(; i < objtLength; i++) {
if(objt[i] == '(') {
	inObjt.push(str);
	str = "";
 
	var pOpen = 0,
	cond = "";
 
	do {
		if(objt[i] == '(')
			pOpen++;
		else if(objt[i] == ')')
			pOpen--;
                        cond += objt[i++];
	   }												 while(pOpen > 0)
 
inCond.push(cond.replace(/^(\()|(\))$/g, ''));// les parentheses autour ne nous interesse pas
}
else if(objt[i] == '.') {
	inObjt.push(str);
	str = "";
	}
else {
	str += objt[i];
	}
}
}

Ps: j'ai déjà pensée au switch, je change

[Watilin]

Je croyais avoir capté ce que tu voulais faire, mais là… Je suis complètement à côté de la plaque
J'aimerais bien avoir un exemple plus clair avec des pommes et des bananes

[SpaceFrog]

Pour matcher avec une regexp, il faut un pattern ...
en l'occurrence je vois mal comment définir un pattern dans ton cas de figure

[the-destroyer]

Avec des poemmes et des bananes ok

var string = "pomme.pomme:banane(pomme.pomme.pomme:banane(x fois)).pomme.pomme:banane()";

c bon la ?

[SpaceFrog]

t'as oublié les noix

signé Furax

[andry.aime]

Ne peut-on pas générer un String à l'aide d'un boucle et faire un eval pour le pattern?

[Watilin]

Tu suggères un eval ? Qui es-tu ? Qu'as-tu fait du vrai Andry ?
… Plus sérieusement, je veux bien voir ce que tu proposes.

@The-destroyer : en fait je sèche, j'ai pas de meilleure solution à proposer que ton algo avec pOpen. C'est un truc que j'avais vu en cours d'ailleurs, ça me revient maintenant : on devait faire un pretty-printer, ctà-dire un programme qui indente automatiquement un code source (en gros).

@Spaffy : bien vu, mais c'est pas des pommes, c'est des figues xD