regExp et match

**the-destroyer** · 19/05/2011, 21h59

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 :

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

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** · 19/05/2011, 22h20

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

Code regexp :

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

/:([^.)]+)(?:\.|\))/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** · 19/05/2011, 22h33

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** · 19/05/2011, 22h35

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

**Watilin** · 20/05/2011, 00h56

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 :

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

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** · 20/05/2011, 11h37

en conservant le match:

Code :

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

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** · 20/05/2011, 12h01

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

**the-destroyer** · 20/05/2011, 22h43

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

Merci space Frog cela convient parfaitement

**the-destroyer** · 22/05/2011, 14h52

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

Code js :

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

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** · 22/05/2011, 17h11

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** · 22/05/2011, 21h30

Okay merci pour votre aide !

**Watilin** · 23/05/2011, 18h01

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 :

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

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** · 23/05/2011, 18h15

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 :

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

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 :

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

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 :

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

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 :

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

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

Quatrième appelle de la fonction sur retour3:

Code :

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

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

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

**the-destroyer** · 23/05/2011, 20h56

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 :

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
 
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** · 25/05/2011, 00h23

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** · 25/05/2011, 08h47

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** · 25/05/2011, 13h06

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** · 25/05/2011, 13h10

t'as oublié les noix

signé Furax

**andry.aime** · 25/05/2011, 13h17

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

**Watilin** · 27/05/2011, 13h07

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

regExp et match [RegExp]

JavaScript

Discussions similaires

Partager

Partager