[HS] Expression reguliere

Olivier Miakinen a écrit :

Tiens, il semblerait que ce soit possible en JavaScript aussi depuis la
version 1.3 :
http://developer.mozilla.org/fr/docs/R%C3%A9f%C3%A9rence_de_JavaScript_1.5_Core:Objets_globaux:String:replace#Exemple_:_utilisation_d.27une_fonction_inline_modifiant_les_caract.C3.A8res_trouv.C3.A9s

Donc :

sujet.replace('/(?<=[[,])(null,)*null[],]/',
function(match) {
count = strlen(match)/5;
last = match.substring(strlen(match)-1);
return '#' + count + last;
});

(non testé)

Je n'ai pas le temps de rappeler le contexte pour faire suivre dans
fr.comp.lang.javascript, mais ne pas hésiter à le faire s'il y a besoin
de poursuivre les recherches dans ce langage.

Comme ça ne fonctionne pas et en particulier la RegExp, je tente la
chose ...
(en essayant au mieux de mes possibilités bien réduites).
<487a23f8$0$915$ba4acef3@news.orange.fr>

--
sm

Le 13/07/2008 17:49, SAM a écrit :

>
> sujet.replace('/(?<=[[,])(null,)*null[],]/',
> function(match) {
> count = strlen(match)/5;
> last = match.substring(strlen(match)-1);
> return '#' + count + last;
> });
>
> (non testé)

à mon idée ce devrait être plus proche de :

function dorepnull(sujet) {
sujet = sujet.replace(/(?<=[[,])(null,)*null[],]/,
function(match) {
return '#' + match.length/5 + match.substring(match.length-1);
});
return sujet;
}
alert(dorepnull($b));

Oui, tu as bien raison, même s'il restait encore au moins un PHP-isme.

Bon ... ça marche pô :-(

Erreur : invalid quantifier ?<=[[,])(null,)*null[],]
Code Source :
sujet = sujet.replace(/(?<=[[,])(null,)*null[],]/,

Rhazut, je pensais pourtant que les assertions arrières faisaient partie
du tronc commun Perl/PCRE. Autre problème, il ne comprend pas non plus
[],] alors que [],] marche bien.

Bref, j'ai testé ceci, et ça marche :

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null[],]/g,
function(match) {
return match.substring(0,1) + '#' + (match.length-1)/5
+ match.substring(match.length-1);
});
}
------------------------------------------------------------------------
sujet = '[null,null,null,null,null]';
alert(sujet + "n" + dorepnull(sujet));
sujet = '[a,null,b,null,null,c,null,d]';
alert(sujet + "n" + dorepnull(sujet));
sujet = '[nullard,annulle,null,tronull,"null",null,nul]';
alert(sujet + "n" + dorepnull(sujet));
------------------------------------------------------------------------

SAM a écrit :

Résumé depuis f.c.l.php :

======== Etienne SOBOLE a écrit :
>
> Ça donne :
>
> var expr = /(null,)+/
> var tRes = expr.exec(sDossier);
> while (tRes)
> {
> var sDossier = sDossier.replace(expr,
"@N" + (tRes[0].length / tRes[1].length) + "@");
> var tRes = expr.exec(sDossier);
> }
>
> et ca remplace une liste de null, par @Nx@
> où x est le nombre de "null," consécutifs trouvés !

Avec les exemples d'Olivier ce n'est pas au top :

<script type="text/javascript">
$a = '[null,null,null,null,null]';
$b = '[a,null,b,null,null,c,null,d]';
$c = '[nullard,annulle,null,tronull,"null",null,nul]';

function dorepnull(sDossier) {
var expr = /(null,)+/;
var tRes = expr.exec(sDossier);
while (tRes)
{
var sDossier = sDossier.replace(expr,
"@N" + (tRes[0].length / tRes[1].length) + "@"
);
var tRes = expr.exec(sDossier);
}
return sDossier;
}

document.write('$a = '+ dorepnull($a) + '<br>');
document.write('$b = '+ dorepnull($b) + '<br>');
document.write('$c = '+ dorepnull($c) + '<br>');
</script>

Donne :

$a = [@N4@null]
$b = [a,@N1@b,@N2@c,@N1@d]
$c = [nullard,annulle,@N1@tro@N1@"null",@N1@nul]

et le dernier 'null' n'est pas autopsié.

Mais sans doute json n'allonge jamais inutilement les sérialisations ?

--
sm

Olivier Miakinen a écrit :

Le 13/07/2008 17:49, SAM a écrit :

function dorepnull(sujet) {
sujet = sujet.replace(/(?<=[[,])(null,)*null[],]/,
function(match) {
return '#' + match.length/5 + match.substring(match.length-1);
});
return sujet;
}
alert(dorepnull($b));

Erreur : invalid quantifier ?<=[[,])(null,)*null[],]
Code Source :
sujet = sujet.replace(/(?<=[[,])(null,)*null[],]/,

Rhazut, je pensais pourtant que les assertions arrières faisaient partie
du tronc commun Perl/PCRE.

Si ça peut aider :
<http://developer.mozilla.org/fr/docs/R%C3%A9f%C3%A9rence_de_JavaScript_1.5_Core:Objets_globaux:RegExp>
(sic)
les assertions avant,
décrites aux lignes (?=), (?!) et (?:) dans ce tableau
(/sic)

Où il semblerait que le "positive lookbehind assertion"
(je regarde devant par l'arrière)
doive (peut-être ?) s'écrire :
(?:[[,]) ou : (?:[[,])

Pour les esssplications de l'expression originelle
/(?<=[[,])(null,)*null[],]/
voir : <4879c903$1@neottia.net>

Autre problème, il ne comprend pas non plus [],] alors que [],] marche bien.

Ha!? mon interrogation à ce sujet n'était donc pas si futile.

Bref, j'ai testé ceci, et ça marche :

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null[],]/g,
function(match) {
return match.substring(0,1) + '#' + (match.length-1)/5
+ match.substring(match.length-1);
});
}
------------------------------------------------------------------------

Il apparait que : /(?:[[,])(null,)*null[],]/g
donne la même chose

sujet = '[null,null,null,null,null]';
alert(sujet + "n" + dorepnull(sujet));
sujet = '[a,null,b,null,null,c,null,d]';
alert(sujet + "n" + dorepnull(sujet));
sujet = '[nullard,annulle,null,tronull,"null",null,nul]';
alert(sujet + "n" + dorepnull(sujet));
------------------------------------------------------------------------

--
sm

Le 14/07/2008 01:07, SAM a écrit :

Rhazut, je pensais pourtant que les assertions arrières faisaient partie
du tronc commun Perl/PCRE.

Si ça peut aider :
<http://developer.mozilla.org/fr/docs/R%C3%A9f%C3%A9rence_de_JavaScript_1.5_Core:Objets_globaux:RegExp>

Merci, c'est dans mes signets (du moins chez moi, je dois faire pareil
au boulot).

(sic)
les assertions avant,
décrites aux lignes (?=), (?!) et (?:) dans ce tableau
(/sic)

Les deux premières sont des assertions (en avant), la troisième est
juste une façon d'empêcher les parenthèses d'être capturantes.

Où il semblerait que le "positive lookbehind assertion"
(je regarde devant par l'arrière)
doive (peut-être ?) s'écrire :
(?:[[,]) ou : (?:[[,])

Non, visiblement il n'y a que les assertions en avant : positive (?=...)
et négative (?!...). Il n'y a pas les assertions en arrière, ni positive
(?<=...) ni négative (?<!...).

Autre problème, il ne comprend pas non plus [],] alors que [],] marche bien.

Ha!? mon interrogation à ce sujet n'était donc pas si futile.

Je dois le reconnaître.

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null[],]/g,
function(match) {
return match.substring(0,1) + '#' + (match.length-1)/5
+ match.substring(match.length-1);
});
}
------------------------------------------------------------------------

Puisque les assertions en avant sont reconnues, on peut alors simplifier
la fonction :
------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null(?=[],])/g,
function(match) {
return match.substring(0,1) + '#' + match.length/5;
});
}
------------------------------------------------------------------------

J'ai testé (Seamonkey et IE), ça marche.

Olivier Miakinen a écrit :

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null[],]/g,
function(match) {
return match.substring(0,1) + '#' + (match.length-1)/5
+ match.substring(match.length-1);
});
}
------------------------------------------------------------------------

Puisque les assertions en avant sont reconnues, on peut alors simplifier

J'aime bien ta notion "simplifier" en allongeant la RegExp :-)
(bon ... encore kek z'années et je commencerai à peut-être y comprendre
kek chose en expression régulière)

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null(?=[],])/g,
function(match) {
return match.substring(0,1) + '#' + match.length/5;
});
}
------------------------------------------------------------------------

--
sm

Le 14/07/2008 15:33, SAM a écrit :

------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null[],]/g,
function(match) {
return match.substring(0,1) + '#' + (match.length-1)/5
+ match.substring(match.length-1);
});
}
------------------------------------------------------------------------

Puisque les assertions en avant sont reconnues, on peut alors simplifier
------------------------------------------------------------------------
function dorepnull(sujet) {
return sujet.replace(/[[,](null,)*null(?=[],])/g,
function(match) {
return match.substring(0,1) + '#' + match.length/5;
});
}
------------------------------------------------------------------------

J'aime bien ta notion "simplifier" en allongeant la RegExp :-)

J'ai rajouté 4 caractères à la RegExp, mais j'en ai retiré une bonne
quarantaine dans la fonction, en supprimant un appel à length, un autre
à substring(), deux soustractions et une concaténation, le tout tenant
sur une ligne de moins !!! Oui, moi j'appelle ça simplifier.

(bon ... encore kek z'années et je commencerai à peut-être y comprendre
kek chose en expression régulière)

;-)

Peut-être qu'il faut être tombé dedans quand on était petit (j'utilisais
déjà l'éditeur 'vi' il y a plus de vingt ans).