You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
That was a character class for digits. There are other character classes as well.
36
+
Esa fue una clase de caracteres para los dígitos. También hay otras.
37
37
38
-
Most used are:
38
+
Las más usadas son:
39
39
40
-
`pattern:\d` ("d" is from "digit")
41
-
: A digit: a character from `0`to`9`.
40
+
`pattern:\d` ("d" es de dígito")
41
+
: Un dígito: es un caracter de `0`a`9`.
42
42
43
-
`pattern:\s` ("s" is from "space")
44
-
: A space symbol: includes spaces, tabs`\t`, newlines `\n`and few other rare characters, such as `\v`, `\f`and`\r`.
43
+
`pattern:\s` ("s" es un espacio)
44
+
: Un símbolo de espacio: incluye espacios, tabulaciones`\t`, líneas nuevas `\n`y algunos otros caracteres raros, como `\v`, `\f`y`\r`.
45
45
46
-
`pattern:\w` ("w" is from "word")
47
-
: A "wordly" character: either a letter of Latin alphabet or a digit or an underscore`_`. Non-Latin letters (like cyrillic or hindi) do not belong to`pattern:\w`.
46
+
`pattern:\w` ("w" es carácter de palabra)
47
+
: Un carácter de palabra es: una letra del alfabeto latino o un dígito o un guión bajo`_`. Las letras no latinas (como el cirílico o el hindi) no pertenecen al`pattern:\w`.
48
48
49
-
For instance, `pattern:\d\s\w`means a "digit" followed by a "space character" followed by a "wordly character", such as`match:1 a`.
49
+
Por ejemplo, `pattern:\d\s\w`significa un "dígito" seguido de un "carácter de espacio" seguido de un "carácter de palabra", como`match:1 a`.
50
50
51
-
**A regexp may contain both regular symbols and character classes.**
51
+
**Una expresión regular puede contener símbolos regulares y clases de caracteres.**
52
52
53
-
For instance, `pattern:CSS\d`matches a string `match:CSS`with a digit after it:
53
+
Por ejemplo, `pattern:CSS\d`coincide con una cadena `match:CSS`con un dígito después:
54
54
55
55
```js run
56
-
let str ="Is there CSS4?";
56
+
let str ="¿Hay CSS4?";
57
57
let regexp =/CSS\d/
58
58
59
59
alert( str.match(regexp) ); // CSS4
60
60
```
61
61
62
-
Also we can use many character classes:
62
+
También podemos usar varias clases de caracteres:
63
63
64
64
```js run
65
-
alert( "I love HTML5!".match(/\s\w\w\w\w\d/) ); // ' HTML5'
The match (each regexp character class has the corresponding result character):
68
+
La coincidencia (cada clase de carácter de la expresión regular tiene el carácter resultante correspondiente):
69
69
70
70
71
71
72
-
## Inverse classes
72
+
## Clases inversas
73
73
74
-
For every character class there exists an "inverse class", denoted with the same letter, but uppercased.
74
+
Para cada clase de caracteres existe una "clase inversa", denotada con la misma letra, pero en mayúscula.
75
75
76
-
The "inverse" means that it matches all other characters, for instance:
76
+
El "inverso" significa que coincide con todos los demás caracteres, por ejemplo:
77
77
78
78
`pattern:\D`
79
-
: Non-digit: any character except`pattern:\d`, for instance a letter.
79
+
: Sin dígitos: cualquier carácter excepto`pattern:\d`, por ejemplo, una letra.
80
80
81
81
`pattern:\S`
82
-
: Non-space: any character except`pattern:\s`, for instance a letter.
82
+
: Sin espacio: cualquier carácter excepto`pattern:\s`, por ejemplo, una letra.
83
83
84
84
`pattern:\W`
85
-
: Non-wordly character: anything but `pattern:\w`, e.g a non-latin letter or a space.
85
+
: Sin carácter de palabra: cualquier cosa menos `pattern:\w`, por ejemplo, una letra no latina o un espacio.
86
86
87
-
In the beginning of the chapter we saw how to make a number-only phone number from a string like `subject:+7(903)-123-45-67`: find all digits and join them.
87
+
Al comienzo del capítulo vimos cómo hacer un número de teléfono solo de números a partir de una cadena como `subject:+7(903)-123-45-67`: encontrar todos los dígitos y unirlos.
An alternative, shorter way is to find non-digits `pattern:\D`and remove them from the string:
95
+
Una forma alternativa y más corta es usar el patrón sin dígito `pattern:\D`para encontrarlos y eliminarlos de la cadena:
96
96
97
97
```js run
98
98
let str ="+7(903)-123-45-67";
99
99
100
100
alert( str.replace(/\D/g, "") ); // 79031234567
101
101
```
102
102
103
-
## A dot is "any character"
103
+
## Un punto es "cualquier carácter"
104
104
105
-
A dot `pattern:.` is a special character class that matches "any character except a newline".
105
+
El patrón punto (`pattern:.`) es una clase de caracteres especial que coincide con "cualquier carácter excepto una nueva línea".
106
106
107
-
For instance:
107
+
Por ejemplo:
108
108
109
109
```js run
110
110
alert( "Z".match(/./) ); // Z
111
111
```
112
112
113
-
Or in the middle of a regexp:
113
+
O en medio de una expresión regular:
114
114
115
115
```js run
116
116
let regexp =/CS.4/;
117
117
118
118
alert( "CSS4".match(regexp) ); // CSS4
119
119
alert( "CS-4".match(regexp) ); // CS-4
120
-
alert( "CS 4".match(regexp) ); // CS 4 (space is also a character)
120
+
alert( "CS 4".match(regexp) ); // CS 4 (el espacio también es un carácter)
121
121
```
122
122
123
-
Please note that a dot means "any character", but not the "absense of a character". There must be a character to match it:
123
+
Tenga en cuenta que un punto significa "cualquier carácter", pero no la "ausencia de un carácter". Debe haber un carácter para que coincida:
124
124
125
125
```js run
126
-
alert( "CS4".match(/CS.4/) ); // null, no match because there's no character for the dot
126
+
alert( "CS4".match(/CS.4/) ); // null, no coincide porque no hay caracteres entre S y 4
127
127
```
128
128
129
-
### Dot as literally any character with "s" flag
129
+
### Punto es igual a la bandera "s" que literalmente retorna cualquier carácter
130
130
131
-
By default, a dot doesn't match the newline character`\n`.
131
+
Por defecto, *punto* no coincide con el carácter de línea nueva`\n`.
132
132
133
-
For instance, the regexp `pattern:A.B`matches `match:A`, and then`match:B`with any character between them, except a newline`\n`:
133
+
Por ejemplo, la expresión regular `pattern:A.B`coincide con `match:A`, y luego`match:B`con cualquier carácter entre ellos, excepto una línea nueva`\n`:
````warn header="Not supported in Firefox, IE, Edge"
148
-
Check <https://caniuse.com/#search=dotall> for the most recent state of support. At the time of writing it doesn't include Firefox, IE, Edge.
147
+
````warn header="El patrón (`pattern:.`) no es compatible con Firefox (< 78), IE, Edge (< 79)"
148
+
Consulte<https://caniuse.com/#search=dotall>para conocer el soporte actualizado. Al momento de escribirse este manual, no estaban soportados.
149
149
150
-
Luckily, there's an alternative, that works everywhere. We can use a regexp like `pattern:[\s\S]` to match "any character".
150
+
Afortunadamente, hay una alternativa, que funciona en todas partes. Podemos usar una expresión regular como`pattern:[\s\S]`para que coincida con "cualquier carácter".
The pattern `pattern:[\s\S]` literally says: "a space character OR not a space character". In other words, "anything". We could use another pair of complementary classes, such as `pattern:[\d\D]`, that doesn't matter. Or even the `pattern:[^]` -- as it means match any character except nothing.
156
+
El patrón`pattern:[\s\S]`literalmente dice: "con carácter de espacio O sin carácter de espacio". En otras palabras, "cualquier cosa". Podríamos usar otro par de clases complementarias, como `pattern:[\d\D]`, eso no importa. O incluso `pattern:[^]`, que significa que coincide con cualquier carácter excepto nada.
157
157
158
-
Also we can use this trick if we want both kind of "dots" in the same pattern: the actual dot `pattern:.` behaving the regular way ("not including a newline"), and also a way to match "any character" with `pattern:[\s\S]` or alike.
158
+
También podemos usar este truco si queremos ambos tipos de "puntos" en el mismo patrón: el patrón actual `pattern:.`comportándose de la manera regular ("sin incluir una línea nueva"), y la forma de hacer coincidir "cualquier carácter" con el patrón `pattern:[\s\S]`o similar.
159
159
````
160
160
161
-
````warn header="Pay attention to spaces"
162
-
Usually we pay little attention to spaces. For us strings `subject:1-5` and `subject:1 - 5` are nearly identical.
161
+
````warn header="Presta atención a los espacios"
162
+
Por lo general, prestamos poca atención a los espacios. Para nosotros, las cadenas `subject:1-5` y `subject:1 - 5` son casi idénticas.
163
163
164
-
But if a regexp doesn't take spaces into account, it may fail to work.
164
+
Pero si una expresión regular no tiene en cuenta los espacios, puede que no funcione.
165
165
166
-
Let's try to find digits separated by a hyphen:
166
+
Intentemos encontrar dígitos separados por un guión:
167
167
168
168
```js run
169
-
alert( "1 - 5".match(/\d-\d/) ); // null, no match!
169
+
alert( "1 - 5".match(/\d-\d/) ); // null, sin coincidencia!
170
170
```
171
171
172
-
Let's fix it adding spaces into the regexp `pattern:\d - \d`:
172
+
Vamos a arreglarlo agregando espacios en la expresión regular `pattern:\d - \d`:
173
173
174
174
```js run
175
-
alert( "1 - 5".match(/\d - \d/) ); // 1 - 5, now it works
176
-
// or we can use \s class:
177
-
alert( "1 - 5".match(/\d\s-\s\d/) ); // 1 - 5, also works
-`pattern:.` -- cualquier caracter, si la expresión regular usa la bandera `'s'`, de otra forma cualquiera excepto **línea nueva**`\n`.
198
198
199
-
...But that's not all!
199
+
...¡Pero eso no es todo!
200
200
201
-
Unicode encoding, used by JavaScript for strings, provides many properties for characters, like: which language the letter belongs to (if it's a letter) it is it a punctuation sign, etc.
201
+
La codificación Unicode, utilizada por JavaScript para las cadenas, proporciona muchas propiedades para los caracteres, como: a qué idioma pertenece la letra (si es una letra), es un signo de puntuación, etc.
202
202
203
-
We can search by these properties as well. That requires flag `pattern:u`, covered in the next article.
203
+
Se pueden hacer búsquedas usando esas propiedades. Y se requiere la bandera `pattern:u`, analizada en el siguiente artículo.
0 commit comments