regex en javascript pour correspondre à la fois RVB ou RVBA

Actuellement, j'ai cette expression qui correspond à une RVB chaîne. J'ai besoin d'elle améliorée de sorte qu'il est suffisamment robuste pour faire correspondre les couleurs RVB ou RVBA.

rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/; //matches RGB

http://jsfiddle.net/YxU2m/

var rgbString =  "rgb(0, 70, 255)";
var RGBAString = "rgba(0, 70, 255, 0.5)";

var rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/;
//need help on this regex
//I figure it needs to be ^rgba?, and then also an optional clause to handle the opacity

var partsRGB = rgbString.match(rgbRegex);
var partsRGBA = RGBAString.match(rgbRegex);

console.log(partsRGB); //["rgb(0, 70, 255)", "0", "70", "255"]
console.log(partsRGBA); //null. I want ["rgb(0, 70, 255, 0.5)", "0", "70", "255", "0.5"]

stackoverflow.com/questions/638948/...
Qui va avoir beaucoup de faux négatifs. Les espaces sont autorisés avant les virgules et les valeurs en pourcentage sont autorisés au lieu de décimales.

OriginalL'auteur fortuneRice | 2011-09-25

7

Cela fera?
```
var rgbRegex = /^rgba?$(\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?$$/
```
Ce sera un retour rgb(0,0,0, 0.5); valable - qui est pas valide rgb couleur.

OriginalL'auteur Rusty Fausak

Il n'est pas si simple - rvb est illégal, avec un quatrième paramètre.
Vous avez également besoin de permettre pour le pourcentage de décimales ainsi que des valeurs entières
pour les valeurs rvb. Et les espaces sont autorisés presque n'importe où.

function getRgbish(c){
    var i= 0, itm,
    M= c.replace(/+/g, '').match(/(rgba?)|(\d+(\.\d+)?%?)|(\.\d+)/g);
    if(M && M.length> 3){
        while(i<3){
            itm= M[++i];
            if(itm.indexOf('%')!= -1){
                itm= Math.round(parseFloat(itm)*2.55);
            }
            else itm= parseInt(itm);
            if(itm<0 || itm> 255) return NaN;
            M[i]= itm;
        }
        if(c.indexOf('rgba')=== 0){
            if(M[4]==undefined ||M[4]<0 || M[4]> 1) return NaN;
        }
        else if(M[4]) return NaN;
        return M[0]+'('+M.slice(1).join(',')+')';
    }
    return NaN;
}

//test de:

var A= ['rgb(100,100,255)',
'rgb(100,100,255,.75)',
'rgba(100,100,255,.75)',
'rgb(100%,100%)',
'rgb(50%,100%,0)',
'rgba(100%,100%,0)',
'rgba(110%,110%,0,1)'];

A.map(getRgbish).join('\n');

returned values:
rgb(100,100,255)
NaN
rgba(100,100,255,.75)
NaN
rgb(127,255,0)
NaN
NaN

rvb est illégal, avec un quatrième paramètre - CSS Couleurs de Niveau 4, rgba() est un alias pour rgb(). Dans les navigateurs qui implémentent le Niveau 4 de la norme, ils acceptent les mêmes paramètres et se comportent de la même manière. Source

OriginalL'auteur kennebec

5

J'ai fait une regex qui vérifie rgb() et rgba() les valeurs. Il vérifie les 3 tuples de 0 à 255 et puis option d'un nombre décimal entre 0 et 1 pour la transparence. TLDR;
```
rgba?$((25[0-5]|2[0-4]\d|1\d{1,2}|\d\d?)\s*,\s*?){2}(25[0-5]|2[0-4]\d|1\d{1,2}|\d\d?)\s*,?\s*([01]\.?\d*?)?$
```
Décomposer en différentes parties, nous avons:
```
rgba?$ //Match rgb( or rgba( as the a is optional
```
0-255 est en correspondance avec l'alternance de:
```
\d\d? //Match 0-99

1\d\d //Match 100 - 199

2[0-4]\d //Match 200-249

25[0-5] //Match 250 - 255
```
La manipulation de la virgule et l'espace autour de la 0-255 tuples prend de la place. J'match 0-255 tuples avec l'obligation de virgule et en option des espaces deux fois
```
(25[0-5]|2[0-4]\d|1([0-9]){1,2}|\d\d?)\s*,\s*){2}
```
Puis un 0-255 tuple avec en option une virgule et un espace pour les rgb() les valeurs sans la virgule
```
(25[0-5]|2[0-4]\d|1([0-9]){1,2}|\d\d?),?\s*
```
Puis vient une option de 0-1 en tant que nombre entier ou un nombre décimal:
```
([01]\.?\d*?)? //0 or 1 needed, dot and decimal numbers optional
```
Et on finit avec un crochet de fermeture
```
$
```
Serait mieux d'expliquer comme: 25[0-5] = faire correspondre les numéros de 250 à 255. 2[0-4]\d = faire Correspondre les numéros de 200 à 249. 1\d\d = correspondent à des nombres de 100 à 199. \d\d? = match de n'importe quel nombre de 0 à 99 (le ? fait le deuxième chiffre facultatif). La façon dont vous l'avez expliqué, il est faux: 25[0-5] // If tripple digit starting with 25 then last number must be 0 est incorrecte est donc 2[0-4]\d // If tripple digit starting with 2, second digit must be 0-5 une description incomplète. 😉
Pour ajouter, ,\s? est insuffisante. rgb/a peut avoir autant de cases que vous le souhaitez avant la virgule et après la virgule, donc \s*,\s* serait la bonne façon.
Mise à jour de répondre à vos améliorations @RokoC.Buljan. Moyen beaucoup plus facile pour expliquer le nombre de correspondance:)

OriginalL'auteur Pistus
2

Si vous avez besoin d'être strict, c'est à dire la règle rvb(0, 70, 255, 0.5), vous avez besoin de fusionner les deux cas avec | :
```
var rgbRegex = /(^rgb$(\d+),\s*(\d+),\s*(\d+)$$)|(^rgba$(\d+),\s*(\d+),\s*(\d+)(,\s*\d+\.\d+)*$$)/; 
```
http://jsfiddle.net/YxU2m/2/

ce /(^rgb((\d+),\s*(\d+),\s*(\d+))$)|(^rgba((\d+),\s*(\d+),\s*(\d+)(,\s*\d+(\.\d+)?)*)$)/j'permettra de couleur rvba avec une décimale dans l'alpha comme "rgba(0, 0, 0, 0)"

OriginalL'auteur mihai
1

- je utiliser cette il ya de l'aide
```
(.*?)(rgb|rgba)$(\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?$/i
```
si vous cochez rgba(102,51,68,0.6)

il sera de retour
```
1.  [0-0]   ``
2.  [0-4]   `rgba`
3.  [5-8]   `102`
4.  [9-11]  `51`
5.  [12-14] `68`
6.  [15-18] `0.6`
```
et si vous vérifiez rgb(102,51,68)

il sera de retour
```
1.  [21-21] ``
2.  [21-24] `rgb`
3.  [25-28] `102`
4.  [29-31] `51`
5.  [32-34] `68`
```
vous pouvez l'utiliser avec (.*?)
Démo
cela permettra rgb(0,0,0,0)
Oui, il permettra rgb(0,0,0) de couleur noire
droit, mais il permet également rgba(0,0,0,0) qui n'est pas valide chaîne de couleur

OriginalL'auteur vipmaa
1

Cette regex est un bon compromis entre la complexité de la regex et le nombre de cas d'utilisation couvert.
```
/(rgb$((([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*){2}([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])$))|(rgba$((([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*){3}(1|1.0*|0?.\d)$))/
```
rvb ou rvba doivent être traités différemment que l'on doit le 4ème argument et qu'on n'a pas.

Cette expression prend ça en compte. Il traite également de:
- 1, 2 ou 3 chiffres valeurs rvb
- valeurs rvb en vertu de 0 et plus de 255
- (certains) des espaces
- un 4ème valeur manquante à partir de rgba
- un 4ème valeur rvb
Cette expression ne prend pas en compte:
- chaque nature juridique de l'espacement
- pourcentage en fonction des valeurs rvb
OriginalL'auteur Votemike

Vous devez vous connecter pour publier un commentaire.