Le 16/07/2008 23:36, Laurent vilday a écrit :Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
"Ca" ne "passe" plus dès qu'on en vient à mélanger des unités non
entière et autres que le pixel (em,pt,px,pc), même si je ne vois pas
trop pourquoi qqun voudrait faire ça mais bon.
Tu as parfaitement raison. Note que cela ne marche pas non plus avec les
longueurs exprimées en pourcentage, ni avec les longueurs négatives, ni
bien sûr avec les valeurs 'auto' ou 'inherit'.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
ça continuerait à extraire des unités invalides comme ee ou tt. Je ne
sais pas comment rendre ça plus strict pour lui imposer l'extraction
seulement des unitées valides (em, pc, px, pt et pas un mélange
aléatoire de 2 de ces lettres)
Allons-y. Je pars de /[0-9]+/g.
On veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
/-?([0-9]*.)?[0-9]+/g
Il y a des unités relatives (em, ex, px), absolues (in, cm, mm, pt, pc)
et pourcentage (%).
/-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Et maintenant, si on veut accepter aussi auto ou inherit...
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
Argh ! On a perdu la belle simplicité du début...
Le 16/07/2008 23:36, Laurent vilday a écrit :
Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
"Ca" ne "passe" plus dès qu'on en vient à mélanger des unités non
entière et autres que le pixel (em,pt,px,pc), même si je ne vois pas
trop pourquoi qqun voudrait faire ça mais bon.
Tu as parfaitement raison. Note que cela ne marche pas non plus avec les
longueurs exprimées en pourcentage, ni avec les longueurs négatives, ni
bien sûr avec les valeurs 'auto' ou 'inherit'.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].
Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
ça continuerait à extraire des unités invalides comme ee ou tt. Je ne
sais pas comment rendre ça plus strict pour lui imposer l'extraction
seulement des unitées valides (em, pc, px, pt et pas un mélange
aléatoire de 2 de ces lettres)
Allons-y. Je pars de /[0-9]+/g.
On veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
/-?([0-9]*.)?[0-9]+/g
Il y a des unités relatives (em, ex, px), absolues (in, cm, mm, pt, pc)
et pourcentage (%).
/-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Et maintenant, si on veut accepter aussi auto ou inherit...
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
Argh ! On a perdu la belle simplicité du début...
Le 16/07/2008 23:36, Laurent vilday a écrit :Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
"Ca" ne "passe" plus dès qu'on en vient à mélanger des unités non
entière et autres que le pixel (em,pt,px,pc), même si je ne vois pas
trop pourquoi qqun voudrait faire ça mais bon.
Tu as parfaitement raison. Note que cela ne marche pas non plus avec les
longueurs exprimées en pourcentage, ni avec les longueurs négatives, ni
bien sûr avec les valeurs 'auto' ou 'inherit'.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
ça continuerait à extraire des unités invalides comme ee ou tt. Je ne
sais pas comment rendre ça plus strict pour lui imposer l'extraction
seulement des unitées valides (em, pc, px, pt et pas un mélange
aléatoire de 2 de ces lettres)
Allons-y. Je pars de /[0-9]+/g.
On veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
/-?([0-9]*.)?[0-9]+/g
Il y a des unités relatives (em, ex, px), absolues (in, cm, mm, pt, pc)
et pourcentage (%).
/-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Et maintenant, si on veut accepter aussi auto ou inherit...
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
Argh ! On a perdu la belle simplicité du début...
Laurent vilday a écrit :Olivier Miakinen a écrit :Le 16/07/2008 09:23, SAM a écrit :Accessoirement, n'y aurait-il pas une méthode + simple d'extraire
les 4 réglages de clip ?
Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
C'est rien d'le dire :-)
Imaginer qu'en plus on puisse jouer avec les unités !
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9]+/g);
alert(clip.join(', '));
alert(clip);==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
IMO, si qqun voulait extraire les valeurs du clip (même si j'ai bien
compris que c'est un cas d'école),
Oui.il faudrait obligatoirement extraire les unités avec. Quitte à
manipuler les valeurs ensuite pour retomber sur une unité simple comme
le pixel.
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
C'est quoi des pc ? des pouces ? ça existe ?
et les mm ? ou cm ?
Et maintenant ... les conversions en px ?
Laurent vilday a écrit :
Olivier Miakinen a écrit :
Le 16/07/2008 09:23, SAM a écrit :
Accessoirement, n'y aurait-il pas une méthode + simple d'extraire
les 4 réglages de clip ?
Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
C'est rien d'le dire :-)
Imaginer qu'en plus on puisse jouer avec les unités !
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9]+/g);
alert(clip.join(', '));
alert(clip);
==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
IMO, si qqun voulait extraire les valeurs du clip (même si j'ai bien
compris que c'est un cas d'école),
Oui.
il faudrait obligatoirement extraire les unités avec. Quitte à
manipuler les valeurs ensuite pour retomber sur une unité simple comme
le pixel.
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
C'est quoi des pc ? des pouces ? ça existe ?
et les mm ? ou cm ?
Et maintenant ... les conversions en px ?
Laurent vilday a écrit :Olivier Miakinen a écrit :Le 16/07/2008 09:23, SAM a écrit :Accessoirement, n'y aurait-il pas une méthode + simple d'extraire
les 4 réglages de clip ?
Cf. ci-dessus. Chez moi ça marche avec :
------------------------------------------------
clip = 'clip: rect(15px 200px 150px 50px);';
clip = clip.match(/[0-9]+/g);
var haut = clip[0], droite = clip[1];
------------------------------------------------
-> haut vaut 15 et droite vaut 200
Allez, je vais faire mon chieur.
C'est rien d'le dire :-)
Imaginer qu'en plus on puisse jouer avec les unités !
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9]+/g);
alert(clip.join(', '));
alert(clip);==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
IMO, si qqun voulait extraire les valeurs du clip (même si j'ai bien
compris que c'est un cas d'école),
Oui.il faudrait obligatoirement extraire les unités avec. Quitte à
manipuler les valeurs ensuite pour retomber sur une unité simple comme
le pixel.
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
C'est quoi des pc ? des pouces ? ça existe ?
et les mm ? ou cm ?
Et maintenant ... les conversions en px ?
Le 17/07/2008 09:09, Olivier Miakinen a écrit :
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
/(auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
ou
/auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Le 17/07/2008 09:09, Olivier Miakinen a écrit :
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
/(auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
ou
/auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Le 17/07/2008 09:09, Olivier Miakinen a écrit :
/(auto|inherit|-?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
/(auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%))/g
ou
/auto|inherit|[-+]?([0-9]*.)?[0-9]+(em|ex|px|in|cm|mm|pt|pc|%)/g
Tiens, je croyais les longueurs en pourcentages non valides. Mais j'ai
beau lire et relire je ne retrouve pas cette "info".
En passant la règle " p { clip:rect(1%, 2%, 3%, 4%) } " au validateur
CSS, il me dit bien que c'est pas bon, mais il me dit pas que c'est à
cause des %.
Pourtant ça doit bien être les % qui l'embête puisqu'il arrête de raler
si je lui dit " p { clip:rect(1px, 2px, 3px, 4px) } "
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
Tiens, je croyais les longueurs en pourcentages non valides. Mais j'ai
beau lire et relire je ne retrouve pas cette "info".
En passant la règle " p { clip:rect(1%, 2%, 3%, 4%) } " au validateur
CSS, il me dit bien que c'est pas bon, mais il me dit pas que c'est à
cause des %.
Pourtant ça doit bien être les % qui l'embête puisqu'il arrête de raler
si je lui dit " p { clip:rect(1px, 2px, 3px, 4px) } "
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
Tiens, je croyais les longueurs en pourcentages non valides. Mais j'ai
beau lire et relire je ne retrouve pas cette "info".
En passant la règle " p { clip:rect(1%, 2%, 3%, 4%) } " au validateur
CSS, il me dit bien que c'est pas bon, mais il me dit pas que c'est à
cause des %.
Pourtant ça doit bien être les % qui l'embête puisqu'il arrête de raler
si je lui dit " p { clip:rect(1px, 2px, 3px, 4px) } "
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
Laurent vilday a écrit :<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
Laurent vilday a écrit :
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
Laurent vilday a écrit :<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
SAM a écrit :
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
décliper ... dans le sens enlever le clip:rect() ?
alert(clip);==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
Quoi? Moi pas comprendre ?
C'est quoi des pc ? des pouces ? ça existe ?
Euh je sais plus :) C'est pas des picas ?
Et maintenant ... les conversions en px ?
Trop facile :D
function toPixel(longueur)
{
var
valeur,
div = document.createElement('DIV');
div.style.width = longueur;
document.body.appendChild(div);
valeur = div.offsetWidth;
document.body.removeChild(div);
return valeur;
}
alert(toPixel('10em'));
SAM a écrit :
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
décliper ... dans le sens enlever le clip:rect() ?
alert(clip);
==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
Quoi? Moi pas comprendre ?
C'est quoi des pc ? des pouces ? ça existe ?
Euh je sais plus :) C'est pas des picas ?
Et maintenant ... les conversions en px ?
Trop facile :D
function toPixel(longueur)
{
var
valeur,
div = document.createElement('DIV');
div.style.width = longueur;
document.body.appendChild(div);
valeur = div.offsetWidth;
document.body.removeChild(div);
return valeur;
}
alert(toPixel('10em'));
SAM a écrit :
Au fait, comment déclipe t-on ?
au lieu d'enlever l'extérieur on troue (et on voit l'image de fond par
exemple)
décliper ... dans le sens enlever le clip:rect() ?
alert(clip);==> 15, 1, 5, 15
Hein ? le séparateur est out ? (et les dizaines aussi ?!)
Quoi? Moi pas comprendre ?
C'est quoi des pc ? des pouces ? ça existe ?
Euh je sais plus :) C'est pas des picas ?
Et maintenant ... les conversions en px ?
Trop facile :D
function toPixel(longueur)
{
var
valeur,
div = document.createElement('DIV');
div.style.width = longueur;
document.body.appendChild(div);
valeur = div.offsetWidth;
document.body.removeChild(div);
return valeur;
}
alert(toPixel('10em'));
SAM a écrit :Laurent vilday a écrit :<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
Oups, ça m'apprendra à croire qu'une spec est backward compatible. CSS2
vers CSS2.1 je croyais, mais en l'occurence elle ne l'est pas.
SAM a écrit :
Laurent vilday a écrit :
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
Oups, ça m'apprendra à croire qu'une spec est backward compatible. CSS2
vers CSS2.1 je croyais, mais en l'occurence elle ne l'est pas.
SAM a écrit :Laurent vilday a écrit :<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
??? je ne pense pas : d'un côté 'css2' de l'autre 'css21'
<http://www.w3.org/TR/CSS2/visufx.html#clipping>
Oups, ça m'apprendra à croire qu'une spec est backward compatible. CSS2
vers CSS2.1 je croyais, mais en l'occurence elle ne l'est pas.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
Pourquoi ajouter le pipe | ?
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :DOn veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].
Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
Pourquoi ajouter le pipe | ?
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :D
On veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].Mais je suis persuadé que la regexp est foireuse, le [em|px|pc|pt]{2}
surtout, je pense que ça doit pouvoir se remplacer par [empxct]{2} mais
Ah oui, désolé d'avoir enfoncé une porte ouverte. Note quand même
qu'elle n'était qu'entrebaillée car tu as oublié le « | » dans ton
équivalence.
Pourquoi ajouter le pipe | ?
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :DOn veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
La longueur peut être négative : « Les valeurs négatives sont admises. »
http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping
<http://www.w3.org/TR/CSS21/visufx.html#clipping>
The 'clip' property applies only to absolutely positioned elements.
<http://www.yoyodesign.org/doc/w3c/css2/visufx.html#clipping>
La propriété 'clip' s'applique aux éléments dont la valeur de la
propriété 'overflow' est autre que 'visible'
Erreur de traduction de yoyodesign.org.
Le 17/07/2008 10:12, Laurent vilday a écrit :J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
:-Davec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].
Pourquoi ajouter le pipe | ?
C'est toi qui l'as mis, par trois fois, dans [em|px|pc|pt] !
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
En effet : le caractère « | » n'est pas un caractère spécial dans une
classe de caractères. Par conséquent, il ne peut pas *séparer* des
valeurs, mais il *est* une des valeurs possibles.
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :DOn veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
Désolé.
Je fais l'hypothèse que tu as fini par comprendre, mais au besoin je
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
Le 17/07/2008 10:12, Laurent vilday a écrit :
J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
:-D
avec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].
Pourquoi ajouter le pipe | ?
C'est toi qui l'as mis, par trois fois, dans [em|px|pc|pt] !
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
En effet : le caractère « | » n'est pas un caractère spécial dans une
classe de caractères. Par conséquent, il ne peut pas *séparer* des
valeurs, mais il *est* une des valeurs possibles.
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :D
On veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
Désolé.
Je fais l'hypothèse que tu as fini par comprendre, mais au besoin je
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
Le 17/07/2008 10:12, Laurent vilday a écrit :J'essaye mais j'imagine qu'il y a bien plus efficace comme regexp, mes
capacités regexp sont trop limitées :/
var clip = 'clip:rect(15em, 1.5pt, 15px, 1.5pc)';
clip = clip.match(/[0-9.]+[em|px|pc|pt]{2}/g);
Petite confusion entre [] et (), même si tu rattrappes un peu le coup
LOL, petite confusion ? Ahaha, connaissant mes compétences regexp tu
peux largement parler d'énorme confusion et d'incompréhension totale :)
:-Davec le {2} qui suit. Je suppose que tu voulais (em|px|pc|pt) au lieu de
[em|px|pc|pt]. Pour info, [em|px|pc|pt] est équivalent à [cemppptx|||],
c'est-à-dire à [cemptx|].
Pourquoi ajouter le pipe | ?
C'est toi qui l'as mis, par trois fois, dans [em|px|pc|pt] !
Je croyais (à tort j'en suis sur) que le pipe servait à séparer des
valeurs dans l'expression entre crochets. Visiblement, c'est pas ça.
En effet : le caractère « | » n'est pas un caractère spécial dans une
classe de caractères. Par conséquent, il ne peut pas *séparer* des
valeurs, mais il *est* une des valeurs possibles.
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
Allons-y. Je pars de /[0-9]+/g.
Cool, à partir de là je comprend :DOn veut accepter les nombres non entiers : « zéro, ou plusieurs
chiffres, suivi par un point (.) et un, ou plusieurs, chiffres ».
/([0-9]*.)?[0-9]+/g
Et voila ça commence, je comprends dèjà beaucoup moins. Obligé de
décortiquer atome par atome pour esquisser un début de compréhension.
Grr, j'aime pas les regexp.
Désolé.
Je fais l'hypothèse que tu as fini par comprendre, mais au besoin je
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
En revanche, ce caractère « | » sert à séparer des valeurs *en dehors*
des classes de caractères.
Ainsi, les règles suivantes sont toutes équivalentes :
1) [em|px|pc|pt]
2) [cemppptx|||]
3) [cemptx|]
4) [c]|[e]|[m]|[p]|[t]|[x]|[|]
5) c|e|m|p|t|x|[|]
6) c|e|m|p|t|x||
N'hésite pas à demander des précisions si le passage d'une ligne à une
autre n'est pas clair, par exemple 3->4.
veux bien détailler. Voici déjà un début.
Nombre entier :
/[0-9]+/g
Nombre à virgule :
/[0-9]*.[0-9]+/g
Nombre entier ou nombre à virgule :
/[0-9]+|[0-9]*.[0-9]+/g
« ac|bc » est équivalent à « (a|b)c », même avec « a » vide :
/(|[0-9]*.)[0-9]+/g
« (|x) » est équivalent à « (x)? » :
/([0-9]*.)?[0-9]+/g
