3 | 4 |
5 |
6 |
2 |
3 |
4 |
5 |
6 |
32 |
33 | 
34 |
35 |
53 | 
54 |
98 | "the" => The fat cat sat on the mat. 99 |100 | 101 | [Test the regular expression](https://regex101.com/r/dmRygT/1) 102 | 103 | The regular expression `123` matches the string `123`. The regular expression is 104 | matched against an input string by comparing each character in the regular 105 | expression to each character in the input string, one after another. Regular 106 | expressions are normally case-sensitive so the regular expression `The` would 107 | not match the string `the`. 108 | 109 |
110 | "The" => The fat cat sat on the mat. 111 |112 | 113 | [Test the regular expression](https://regex101.com/r/1paXsy/1) 114 | 115 | ## 2. Meta Characters 116 | 117 | Meta characters are the building blocks of regular expressions. Meta 118 | characters do not stand for themselves but instead are interpreted in some 119 | special way. Some meta characters have a special meaning and are written inside 120 | square brackets. The meta characters are as follows: 121 | 122 | |Meta character|Description| 123 | |:----:|----| 124 | |.|Period matches any single character except a line break.| 125 | |[ ]|Character class. Matches any character contained between the square brackets.| 126 | |[^ ]|Negated character class. Matches any character that is not contained between the square brackets| 127 | |*|Matches 0 or more repetitions of the preceding symbol.| 128 | |+|Matches 1 or more repetitions of the preceding symbol.| 129 | |?|Makes the preceding symbol optional.| 130 | |{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.| 131 | |(xyz)|Character group. Matches the characters xyz in that exact order.| 132 | |||Alternation. Matches either the characters before or the characters after the symbol.| 133 | |\|Escapes the next character. This allows you to match reserved characters
[ ] ( ) { } . * + ? ^ $ \ ||
134 | |^|Matches the beginning of the input.|
135 | |$|Matches the end of the input.|
136 |
137 | ## 2.1 The Full Stop
138 |
139 | The full stop `.` is the simplest example of a meta character. The meta character `.`
140 | matches any single character. It will not match return or newline characters.
141 | For example, the regular expression `.ar` means: any character, followed by the
142 | letter `a`, followed by the letter `r`.
143 |
144 | 145 | ".ar" => The car parked in the garage. 146 |147 | 148 | [Test the regular expression](https://regex101.com/r/xc9GkU/1) 149 | 150 | ## 2.2 Character Sets 151 | 152 | Character sets are also called character classes. Square brackets are used to 153 | specify character sets. Use a hyphen inside a character set to specify the 154 | characters' range. The order of the character range inside the square brackets 155 | doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase 156 | `T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`. 157 | 158 |
159 | "[Tt]he" => The car parked in the garage. 160 |161 | 162 | [Test the regular expression](https://regex101.com/r/2ITLQ4/1) 163 | 164 | A period inside a character set, however, means a literal period. The regular 165 | expression `ar[.]` means: a lowercase character `a`, followed by the letter `r`, 166 | followed by a period `.` character. 167 | 168 |
169 | "ar[.]" => A garage is a good place to park a car. 170 |171 | 172 | [Test the regular expression](https://regex101.com/r/wL3xtE/1) 173 | 174 | ### 2.2.1 Negated Character Sets 175 | 176 | In general, the caret symbol represents the start of the string, but when it is 177 | typed after the opening square bracket it negates the character set. For 178 | example, the regular expression `[^c]ar` means: any character except `c`, 179 | followed by the character `a`, followed by the letter `r`. 180 | 181 |
182 | "[^c]ar" => The car parked in the garage. 183 |184 | 185 | [Test the regular expression](https://regex101.com/r/nNNlq3/1) 186 | 187 | ## 2.3 Repetitions 188 | 189 | The meta characters `+`, `*` or `?` are used to specify how many times a 190 | subpattern can occur. These meta characters act differently in different 191 | situations. 192 | 193 | ### 2.3.1 The Star 194 | 195 | The `*` symbol matches zero or more repetitions of the preceding matcher. The 196 | regular expression `a*` means: zero or more repetitions of the preceding lowercase 197 | character `a`. But if it appears after a character set or class then it finds 198 | the repetitions of the whole character set. For example, the regular expression 199 | `[a-z]*` means: any number of lowercase letters in a row. 200 | 201 |
202 | "[a-z]*" => The car parked in the garage #21. 203 |204 | 205 | [Test the regular expression](https://regex101.com/r/7m8me5/1) 206 | 207 | The `*` symbol can be used with the meta character `.` to match any string of 208 | characters `.*`. The `*` symbol can be used with the whitespace character `\s` 209 | to match a string of whitespace characters. For example, the expression 210 | `\s*cat\s*` means: zero or more spaces, followed by a lowercase `c`, 211 | followed by a lowercase `a`, followed by a lowercase `t`, 212 | followed by zero or more spaces. 213 | 214 |
215 | "\s*cat\s*" => The fat cat sat on the concatenation. 216 |217 | 218 | [Test the regular expression](https://regex101.com/r/gGrwuz/1) 219 | 220 | ### 2.3.2 The Plus 221 | 222 | The `+` symbol matches one or more repetitions of the preceding character. For 223 | example, the regular expression `c.+t` means: a lowercase `c`, followed by 224 | at least one character, followed by a lowercase `t`. It needs to be 225 | clarified that`t` is the last `t` in the sentence. 226 | 227 |
228 | "c.+t" => The fat cat sat on the mat. 229 |230 | 231 | [Test the regular expression](https://regex101.com/r/Dzf9Aa/1) 232 | 233 | ### 2.3.3 The Question Mark 234 | 235 | In regular expressions, the meta character `?` makes the preceding character 236 | optional. This symbol matches zero or one instance of the preceding character. 237 | For example, the regular expression `[T]?he` means: Optional uppercase 238 | `T`, followed by a lowercase `h`, followed by a lowercase `e`. 239 | 240 |
241 | "[T]he" => The car is parked in the garage. 242 |243 | 244 | [Test the regular expression](https://regex101.com/r/cIg9zm/1) 245 | 246 |
247 | "[T]?he" => The car is parked in the garage. 248 |249 | 250 | [Test the regular expression](https://regex101.com/r/kPpO2x/1) 251 | 252 | ## 2.4 Braces 253 | 254 | In regular expressions, braces (also called quantifiers) are used to 255 | specify the number of times that a character or a group of characters can be 256 | repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least 257 | 2 digits, but not more than 3, ranging from 0 to 9. 258 | 259 |
260 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
261 |
262 |
263 | [Test the regular expression](https://regex101.com/r/juM86s/1)
264 |
265 | We can leave out the second number. For example, the regular expression
266 | `[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the
267 | regular expression `[0-9]{3}` means: Match exactly 3 digits.
268 |
269 |
270 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
271 |
272 |
273 | [Test the regular expression](https://regex101.com/r/Gdy4w5/1)
274 |
275 |
276 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
277 |
278 |
279 | [Test the regular expression](https://regex101.com/r/Sivu30/1)
280 |
281 | ## 2.5 Capturing Groups
282 |
283 | A capturing group is a group of subpatterns that is written inside parentheses
284 | `(...)`. As discussed before, in regular expressions, if we put a quantifier
285 | after a character then it will repeat the preceding character. But if we put a quantifier
286 | after a capturing group then it repeats the whole capturing group. For example,
287 | the regular expression `(ab)*` matches zero or more repetitions of the character
288 | "ab". We can also use the alternation `|` meta character inside a capturing group.
289 | For example, the regular expression `(c|g|p)ar` means: a lowercase `c`,
290 | `g` or `p`, followed by `a`, followed by `r`.
291 |
292 | 293 | "(c|g|p)ar" => The car is parked in the garage. 294 |295 | 296 | [Test the regular expression](https://regex101.com/r/tUxrBG/1) 297 | 298 | Note that capturing groups do not only match, but also capture, the characters for use in 299 | the parent language. The parent language could be Python or JavaScript or virtually any 300 | language that implements regular expressions in a function definition. 301 | 302 | ### 2.5.1 Non-Capturing Groups 303 | 304 | A non-capturing group is a capturing group that matches the characters but 305 | does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 306 | within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 307 | `(c|g|p)ar` in that it matches the same characters but will not create a capture group. 308 | 309 |
310 | "(?:c|g|p)ar" => The car is parked in the garage. 311 |312 | 313 | [Test the regular expression](https://regex101.com/r/Rm7Me8/1) 314 | 315 | Non-capturing groups can come in handy when used in find-and-replace functionality or 316 | when mixed with capturing groups to keep the overview when producing any other kind of output. 317 | See also [4. Lookaround](#4-lookaround). 318 | 319 | ## 2.6 Alternation 320 | 321 | In a regular expression, the vertical bar `|` is used to define alternation. 322 | Alternation is like an OR statement between multiple expressions. Now, you may be 323 | thinking that character sets and alternation work the same way. But the big 324 | difference between character sets and alternation is that character sets work at the 325 | character level but alternation works at the expression level. For example, the 326 | regular expression `(T|t)he|car` means: either (an uppercase `T` or a lowercase 327 | `t`, followed by a lowercase `h`, followed by a lowercase `e`) OR 328 | (a lowercase `c`, followed by a lowercase `a`, followed by 329 | a lowercase `r`). Note that I included the parentheses for clarity, to show that either expression 330 | in parentheses can be met and it will match. 331 | 332 |
333 | "(T|t)he|car" => The car is parked in the garage. 334 |335 | 336 | [Test the regular expression](https://regex101.com/r/fBXyX0/1) 337 | 338 | ## 2.7 Escaping Special Characters 339 | 340 | A backslash `\` is used in regular expressions to escape the next character. This 341 | allows us to include reserved characters such as `{ } [ ] / \ + * . $ ^ | ?` as matching characters. To use one of these special character as a matching character, prepend it with `\`. 342 | 343 | For example, the regular expression `.` is used to match any character except a 344 | newline. Now, to match `.` in an input string, the regular expression 345 | `(f|c|m)at\.?` means: a lowercase `f`, `c` or `m`, followed by a lowercase 346 | `a`, followed by a lowercase `t`, followed by an optional `.` 347 | character. 348 | 349 |
350 | "(f|c|m)at\.?" => The fat cat sat on the mat. 351 |352 | 353 | [Test the regular expression](https://regex101.com/r/DOc5Nu/1) 354 | 355 | ## 2.8 Anchors 356 | 357 | In regular expressions, we use anchors to check if the matching symbol is the 358 | starting symbol or ending symbol of the input string. Anchors are of two types: 359 | The first type is the caret `^` that checks if the matching character is the first 360 | character of the input and the second type is the dollar sign `$` which checks if a matching 361 | character is the last character of the input string. 362 | 363 | ### 2.8.1 The Caret 364 | 365 | The caret symbol `^` is used to check if a matching character is the first character 366 | of the input string. If we apply the following regular expression `^a` (meaning 'a' must be 367 | the starting character) to the string `abc`, it will match `a`. But if we apply 368 | the regular expression `^b` to the above string, it will not match anything. 369 | Because in the string `abc`, the "b" is not the starting character. Let's take a look 370 | at another regular expression `^(T|t)he` which means: an uppercase `T` or 371 | a lowercase `t` must be the first character in the string, followed by a 372 | lowercase `h`, followed by a lowercase `e`. 373 | 374 |
375 | "(T|t)he" => The car is parked in the garage. 376 |377 | 378 | [Test the regular expression](https://regex101.com/r/5ljjgB/1) 379 | 380 |
381 | "^(T|t)he" => The car is parked in the garage. 382 |383 | 384 | [Test the regular expression](https://regex101.com/r/jXrKne/1) 385 | 386 | ### 2.8.2 The Dollar Sign 387 | 388 | The dollar sign `$` is used to check if a matching character is the last character 389 | in the string. For example, the regular expression `(at\.)$` means: a 390 | lowercase `a`, followed by a lowercase `t`, followed by a `.` 391 | character and the matcher must be at the end of the string. 392 | 393 |
394 | "(at\.)" => The fat cat. sat. on the mat. 395 |396 | 397 | [Test the regular expression](https://regex101.com/r/y4Au4D/1) 398 | 399 |
400 | "(at\.)$" => The fat cat. sat. on the mat. 401 |402 | 403 | [Test the regular expression](https://regex101.com/r/t0AkOd/1) 404 | 405 | ## 3. Shorthand Character Sets 406 | 407 | There are a number of convenient shorthands for commonly used character sets/ 408 | regular expressions: 409 | 410 | |Shorthand|Description| 411 | |:----:|----| 412 | |.|Any character except new line| 413 | |\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`| 414 | |\W|Matches non-alphanumeric characters: `[^\w]`| 415 | |\d|Matches digits: `[0-9]`| 416 | |\D|Matches non-digits: `[^\d]`| 417 | |\s|Matches whitespace characters: `[\t\n\f\r\p{Z}]`| 418 | |\S|Matches non-whitespace characters: `[^\s]`| 419 | 420 | ## 4. Lookarounds 421 | 422 | Lookbehinds and lookaheads (also called lookarounds) are specific types of 423 | ***non-capturing groups*** (used to match a pattern but without including it in the matching 424 | list). Lookarounds are used when a pattern must be 425 | preceded or followed by another pattern. For example, imagine we want to get all 426 | numbers that are preceded by the `$` character from the string 427 | `$4.44 and $10.88`. We will use the following regular expression `(?<=\$)[0-9\.]*` 428 | which means: get all the numbers which contain the `.` character and are preceded 429 | by the `$` character. These are the lookarounds that are used in regular 430 | expressions: 431 | 432 | |Symbol|Description| 433 | |:----:|----| 434 | |?=|Positive Lookahead| 435 | |?!|Negative Lookahead| 436 | |?<=|Positive Lookbehind| 437 | |? 453 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 454 | 455 | 456 | [Test the regular expression](https://regex101.com/r/IDDARt/1) 457 | 458 | ### 4.2 Negative Lookahead 459 | 460 | Negative lookaheads are used when we need to get all matches from an input string 461 | that are not followed by a certain pattern. A negative lookahead is written the same way as a 462 | positive lookahead. The only difference is, instead of an equals sign `=`, we 463 | use an exclamation mark `!` to indicate negation i.e. `(?!...)`. Let's take a look at the following 464 | regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words 465 | from the input string that are not followed by a space character and the word `fat`. 466 | 467 |
468 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 469 |470 | 471 | [Test the regular expression](https://regex101.com/r/V32Npg/1) 472 | 473 | ### 4.3 Positive Lookbehind 474 | 475 | Positive lookbehinds are used to get all the matches that are preceded by a 476 | specific pattern. Positive lookbehinds are written `(?<=...)`. For example, the 477 | regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words 478 | from the input string that come after the word `The` or `the`. 479 | 480 |
481 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 482 |483 | 484 | [Test the regular expression](https://regex101.com/r/avH165/1) 485 | 486 | ### 4.4 Negative Lookbehind 487 | 488 | Negative lookbehinds are used to get all the matches that are not preceded by a 489 | specific pattern. Negative lookbehinds are written `(? 494 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 495 | 496 | 497 | [Test the regular expression](https://regex101.com/r/8Efx5G/1) 498 | 499 | ## 5. Flags 500 | 501 | Flags are also called modifiers because they modify the output of a regular 502 | expression. These flags can be used in any order or combination, and are an 503 | integral part of the RegExp. 504 | 505 | |Flag|Description| 506 | |:----:|----| 507 | |i|Case insensitive: Match will be case-insensitive.| 508 | |g|Global Search: Match all instances, not just the first.| 509 | |m|Multiline: Anchor meta characters work on each line.| 510 | 511 | ### 5.1 Case Insensitive 512 | 513 | The `i` modifier is used to perform case-insensitive matching. For example, the 514 | regular expression `/The/gi` means: an uppercase `T`, followed by a lowercase 515 | `h`, followed by an `e`. And at the end of regular expression 516 | the `i` flag tells the regular expression engine to ignore the case. As you can 517 | see, we also provided `g` flag because we want to search for the pattern in the 518 | whole input string. 519 | 520 |
521 | "The" => The fat cat sat on the mat. 522 |523 | 524 | [Test the regular expression](https://regex101.com/r/dpQyf9/1) 525 | 526 |
527 | "/The/gi" => The fat cat sat on the mat. 528 |529 | 530 | [Test the regular expression](https://regex101.com/r/ahfiuh/1) 531 | 532 | ### 5.2 Global Search 533 | 534 | The `g` modifier is used to perform a global match (finds all matches rather than 535 | stopping after the first match). For example, the regular expression`/.(at)/g` 536 | means: any character except a new line, followed by a lowercase `a`, 537 | followed by a lowercase `t`. Because we provided the `g` flag at the end of 538 | the regular expression, it will now find all matches in the input string, not just the first one (which is the default behavior). 539 | 540 |
541 | "/.(at)/" => The fat cat sat on the mat. 542 |543 | 544 | [Test the regular expression](https://regex101.com/r/jnk6gM/1) 545 | 546 |
547 | "/.(at)/g" => The fat cat sat on the mat. 548 |549 | 550 | [Test the regular expression](https://regex101.com/r/dO1nef/1) 551 | 552 | ### 5.3 Multiline 553 | 554 | The `m` modifier is used to perform a multi-line match. As we discussed earlier, 555 | anchors `(^, $)` are used to check if a pattern is at the beginning of the input or 556 | the end. But if we want the anchors to work on each line, we use 557 | the `m` flag. For example, the regular expression `/at(.)?$/gm` means: a lowercase 558 | `a`, followed by a lowercase `t` and, optionally, anything except 559 | a new line. And because of the `m` flag, the regular expression engine now matches patterns 560 | at the end of each line in a string. 561 | 562 |
563 | "/.at(.)?$/" => The fat 564 | cat sat 565 | on the mat. 566 |567 | 568 | [Test the regular expression](https://regex101.com/r/hoGMkP/1) 569 | 570 |
571 | "/.at(.)?$/gm" => The fat 572 | cat sat 573 | on the mat. 574 |575 | 576 | [Test the regular expression](https://regex101.com/r/E88WE2/1) 577 | 578 | ## 6. Greedy vs Lazy Matching 579 | By default, a regex will perform a greedy match, which means the match will be as long as 580 | possible. We can use `?` to match in a lazy way, which means the match should be as short as possible. 581 | 582 |
583 | "/(.*at)/" => The fat cat sat on the mat.584 | 585 | 586 | [Test the regular expression](https://regex101.com/r/AyAdgJ/1) 587 | 588 |
589 | "/(.*?at)/" => The fat cat sat on the mat.590 | 591 | 592 | [Test the regular expression](https://regex101.com/r/AyAdgJ/2) 593 | 594 | 595 | ## Contribution 596 | 597 | * Open a pull request with improvements 598 | * Discuss ideas in issues 599 | * Spread the word 600 | 601 | ## License 602 | 603 | MIT © Zeeshan Ahmad 604 | -------------------------------------------------------------------------------- /img/img_original.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/img_original.png -------------------------------------------------------------------------------- /img/regexp-cn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-cn.png -------------------------------------------------------------------------------- /img/regexp-de.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-de.png -------------------------------------------------------------------------------- /img/regexp-en.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-en.png -------------------------------------------------------------------------------- /img/regexp-es.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-es.png -------------------------------------------------------------------------------- /img/regexp-fr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-fr.png -------------------------------------------------------------------------------- /img/regexp-he.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-he.png -------------------------------------------------------------------------------- /img/regexp-hu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-hu.png -------------------------------------------------------------------------------- /img/regexp-id.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-id.png -------------------------------------------------------------------------------- /img/regexp-pl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-pl.png -------------------------------------------------------------------------------- /img/regexp-ru.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-ru.png -------------------------------------------------------------------------------- /img/regexp-tr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ziishaned/learn-regex/70e38b70bc434c0b05d97d1aeea0127aea8147c8/img/regexp-tr.png -------------------------------------------------------------------------------- /translations/README-cn.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | 
10 |
11 |
12 | 
13 |
14 |
53 | 
54 |
98 | "the" => The fat cat sat on the mat. 99 |100 | 101 | [在线练习](https://regex101.com/r/dmRygT/1) 102 | 103 | 正则表达式 `123` 匹配字符串 `123`。它逐个字符的与输入的正则表达式做比较。 104 | 105 | 正则表达式是大小写敏感的，所以 `The` 不会匹配 `the`。 106 | 107 |
108 | "The" => The fat cat sat on the mat. 109 |110 | 111 | [在线练习](https://regex101.com/r/1paXsy/1) 112 | 113 | ## 2. 元字符 114 | 115 | 正则表达式主要依赖于元字符。 116 | 元字符不代表他们本身的字面意思，他们都有特殊的含义。一些元字符写在方括号中的时候有一些特殊的意思。以下是一些元字符的介绍： 117 | 118 | |元字符|描述| 119 | |:----:|----| 120 | |.|句号匹配任意单个字符除了换行符。| 121 | |[ ]|字符种类。匹配方括号内的任意字符。| 122 | |[^ ]|否定的字符种类。匹配除了方括号里的任意字符| 123 | |*|匹配 >=0 个重复的在 * 号之前的字符。| 124 | |+|匹配 >=1 个重复的 + 号前的字符。| 125 | |?|标记 ? 之前的字符为可选。| 126 | |{n,m}|匹配 num 个大括号之前的字符或字符集 (n <= num <= m)。| 127 | |(xyz)|字符集，匹配与 xyz 完全相等的字符串。| 128 | |||或运算符，匹配符号前或后的字符。| 129 | |\|转义字符，用于匹配一些保留的字符
[ ] ( ) { } . * + ? ^ $ \ ||
130 | |^|从开始行开始匹配。|
131 | |$|从末端开始匹配。|
132 |
133 | ## 2.1 点运算符 `.`
134 |
135 | `.` 是元字符中最简单的例子。
136 | `.` 匹配任意单个字符，但不匹配换行符。
137 | 例如，表达式 `.ar` 匹配一个任意字符后面跟着是 `a` 和 `r` 的字符串。
138 |
139 | 140 | ".ar" => The car parked in the garage. 141 |142 | 143 | [在线练习](https://regex101.com/r/xc9GkU/1) 144 | 145 | ## 2.2 字符集 146 | 147 | 字符集也叫做字符类。 148 | 方括号用来指定一个字符集。 149 | 在方括号中使用连字符来指定字符集的范围。 150 | 在方括号中的字符集不关心顺序。 151 | 例如，表达式 `[Tt]he` 匹配 `the` 和 `The`。 152 | 153 |
154 | "[Tt]he" => The car parked in the garage. 155 |156 | 157 | [在线练习](https://regex101.com/r/2ITLQ4/1) 158 | 159 | 方括号的句号就表示句号。 160 | 表达式 `ar[.]` 匹配 `ar.` 字符串。 161 | 162 |
163 | "ar[.]" => A garage is a good place to park a car. 164 |165 | 166 | [在线练习](https://regex101.com/r/wL3xtE/1) 167 | 168 | ### 2.2.1 否定字符集 169 | 170 | 一般来说 `^` 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的。 171 | 例如，表达式 `[^c]ar` 匹配一个后面跟着 `ar` 的除了 `c` 的任意字符。 172 | 173 |
174 | "[^c]ar" => The car parked in the garage. 175 |176 | 177 | [在线练习](https://regex101.com/r/nNNlq3/1) 178 | 179 | ## 2.3 重复次数 180 | 181 | 后面跟着元字符 `+`，`*` or `?` 的，用来指定匹配子模式的次数。 182 | 这些元字符在不同的情况下有着不同的意思。 183 | 184 | ### 2.3.1 `*` 号 185 | 186 | `*` 号匹配在 `*` 之前的字符出现 `大于等于0` 次。 187 | 例如，表达式 `a*` 匹配 0 或更多个以 a 开头的字符。表达式 `[a-z]*` 匹配一个行中所有以小写字母开头的字符串。 188 | 189 |
190 | "[a-z]*" => The car parked in the garage #21. 191 |192 | 193 | [在线练习](https://regex101.com/r/7m8me5/1) 194 | 195 | `*` 字符和 `.` 字符搭配可以匹配所有的字符 `.*`。 196 | `*` 和表示匹配空格的符号 `\s` 连起来用，如表达式 `\s*cat\s*` 匹配 0 或更多个空格开头和 0 或更多个空格结尾的 cat 字符串。 197 | 198 |
199 | "\s*cat\s*" => The fat cat sat on the concatenation. 200 |201 | 202 | [在线练习](https://regex101.com/r/gGrwuz/1) 203 | 204 | ### 2.3.2 `+` 号 205 | 206 | `+` 号匹配 `+` 号之前的字符出现 >=1 次。 207 | 例如表达式 `c.+t` 匹配以首字母 `c` 开头以 `t` 结尾，中间跟着至少一个字符的字符串。 208 | 209 |
210 | "c.+t" => The fat cat sat on the mat. 211 |212 | 213 | [在线练习](https://regex101.com/r/Dzf9Aa/1) 214 | 215 | ### 2.3.3 `?` 号 216 | 217 | 在正则表达式中元字符 `?` 标记在符号前面的字符为可选，即出现 0 或 1 次。 218 | 例如，表达式 `[T]?he` 匹配字符串 `he` 和 `The`。 219 | 220 |
221 | "[T]he" => The car is parked in the garage. 222 |223 | 224 | [在线练习](https://regex101.com/r/cIg9zm/1) 225 | 226 |
227 | "[T]?he" => The car is parked in the garage. 228 |229 | 230 | [在线练习](https://regex101.com/r/kPpO2x/1) 231 | 232 | ## 2.4 `{}` 号 233 | 234 | 在正则表达式中 `{}` 是一个量词，常用来限定一个或一组字符可以重复出现的次数。 235 | 例如，表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。 236 | 237 |
238 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
239 |
240 |
241 | [在线练习](https://regex101.com/r/juM86s/1)
242 |
243 | 我们可以省略第二个参数。
244 | 例如，`[0-9]{2,}` 匹配至少两位 0~9 的数字。
245 | 如果逗号也省略掉则表示重复固定的次数。
246 | 例如，`[0-9]{3}` 匹配 3 位数字。
247 |
248 |
249 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
250 |
251 |
252 | [在线练习](https://regex101.com/r/Gdy4w5/1)
253 |
254 |
255 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
256 |
257 |
258 | [在线练习](https://regex101.com/r/Sivu30/1)
259 |
260 | ## 2.5 `(...)` 捕获组
261 |
262 | 特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。
263 | 例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。
264 | 如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b`。
265 | 再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。
266 | 但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。
267 | 我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
268 |
269 | 270 | "(c|g|p)ar" => The car is parked in the garage. 271 |272 | 273 | [在线练习](https://regex101.com/r/tUxrBG/1) 274 | 275 | 请注意，特征标群不仅会匹配，而且会捕获，可以在宿主语言中被引用。 276 | 宿主语言可以是 Python 或 JavaScript 或几乎任何在函数定义中实现正则表达式的语言。 277 | 278 | ### 2.5.1 非捕获组 279 | 280 | 非捕获组匹配字符但不捕获该组。 一个非捕获组由在括号 `（...）` 内的一个 `?` 后跟一个 `:` 表示。 例如，正则表达式 `(?:c|g|p)ar` 和 `(c|g|p)ar` 类似，可以匹配相同的字符，但不会创建捕获组。 281 | 282 |
283 | "(?:c|g|p)ar" => The car is parked in the garage. 284 |285 | 286 | [在线练习](https://regex101.com/r/Rm7Me8/1) 287 | 288 | 非捕获组用于查找和替换功能，或与捕获组混合以在生成任何其他类型的输出的时候，不记录匹配的内容。 289 | 可参考 [4. 零宽度断言(前后预查)](#4-零宽度断言前后预查)。 290 | 291 | ## 2.6 `|` 或运算符 292 | 293 | 或运算符就表示或，用作判断条件。 294 | 295 | 例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`。 296 | 297 |
298 | "(T|t)he|car" => The car is parked in the garage. 299 |300 | 301 | [在线练习](https://regex101.com/r/fBXyX0/1) 302 | 303 | ## 2.7 转义特殊字符 304 | 305 | 反斜线 `\` 在表达式中用于转义紧跟其后的字符。 306 | 用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符。 307 | 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`。 308 | 309 | 例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\.`。 310 | 以下这个例子 `\.?` 是选择性匹配 `.`。 311 | 312 |
313 | "(f|c|m)at\.?" => The fat cat sat on the mat. 314 |315 | 316 | [在线练习](https://regex101.com/r/DOc5Nu/1) 317 | 318 | ## 2.8 锚点 319 | 320 | 在正则表达式中，想要匹配指定开头或结尾的字符串就要使用到锚点。`^` 指定开头，`$` 指定结尾。 321 | 322 | ### 2.8.1 `^` 号 323 | 324 | `^` 用来检查匹配的字符串是否在所匹配字符串的开头。 325 | 326 | 例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。 327 | 但如果使用 `^b` 将匹配不到任何结果。 328 | 因为字符串 `abc` 并不是以 b 开头。 329 | 330 | 例如，`^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串。 331 | 332 |
333 | "(T|t)he" => The car is parked in the garage. 334 |335 | 336 | [在线练习](https://regex101.com/r/5ljjgB/1) 337 | 338 |
339 | "^(T|t)he" => The car is parked in the garage. 340 |341 | 342 | [在线练习](https://regex101.com/r/jXrKne/1) 343 | 344 | ### 2.8.2 `$` 号 345 | 346 | 同理于 `^` 号，`$` 号用来匹配字符是否是最后一个。 347 | 348 | 例如，`(at\.)$` 匹配以 `at.` 结尾的字符串。 349 | 350 |
351 | "(at\.)" => The fat cat. sat. on the mat. 352 |353 | 354 | [在线练习](https://regex101.com/r/y4Au4D/1) 355 | 356 |
357 | "(at\.)$" => The fat cat. sat. on the mat. 358 |359 | 360 | [在线练习](https://regex101.com/r/t0AkOd/1) 361 | 362 | ## 3. 简写字符集 363 | 364 | 正则表达式提供一些常用的字符集简写。如下: 365 | 366 | |简写|描述| 367 | |:----:|----| 368 | |.|除换行符外的所有字符| 369 | |\w|匹配所有字母数字，等同于 `[a-zA-Z0-9_]`| 370 | |\W|匹配所有非字母数字，即符号，等同于： `[^\w]`| 371 | |\d|匹配数字： `[0-9]`| 372 | |\D|匹配非数字： `[^\d]`| 373 | |\s|匹配所有空格字符，等同于： `[\t\n\f\r\p{Z}]`| 374 | |\S|匹配所有非空格字符： `[^\s]`| 375 | |\f|匹配一个换页符| 376 | |\n|匹配一个换行符| 377 | |\r|匹配一个回车符| 378 | |\t|匹配一个制表符| 379 | |\v|匹配一个垂直制表符| 380 | |\p|匹配 CR/LF（等同于 `\r\n`），用来匹配 DOS 行终止符| 381 | 382 | ## 4. 零宽度断言（前后预查） 383 | 384 | 先行断言和后发断言（合称 lookaround）都属于**非捕获组**（用于匹配模式，但不包括在匹配列表中）。当我们需要一个模式的前面或后面有另一个特定的模式时，就可以使用它们。 385 | 386 | 例如，我们希望从下面的输入字符串 `$4.44` 和 `$10.88` 中获得所有以 `$` 字符开头的数字，我们将使用以下的正则表达式 `(?<=\$)[0-9\.]*`。意思是：获取所有包含 `.` 并且前面是 `$` 的数字。 387 | 388 | 零宽度断言如下： 389 | 390 | |符号|描述| 391 | |:----:|----| 392 | |?=|正先行断言-存在| 393 | |?!|负先行断言-排除| 394 | |?<=|正后发断言-存在| 395 | |? 408 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 409 | 410 | 411 | [在线练习](https://regex101.com/r/IDDARt/1) 412 | 413 | ### 4.2 `?!...` 负先行断言 414 | 415 | 负先行断言 `?!` 用于筛选所有匹配结果，筛选条件为其后 不跟随着断言中定义的格式。 416 | `正先行断言` 定义和 `负先行断言` 一样，区别就是 `=` 替换成 `!` 也就是 `(?!...)`。 417 | 418 | 表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`，且其后不跟着 `(空格)fat`。 419 | 420 |
421 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 422 |423 | 424 | [在线练习](https://regex101.com/r/V32Npg/1) 425 | 426 | ### 4.3 `?<= ...` 正后发断言 427 | 428 | 正后发断言记作 `(?<=...)`，用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。 429 | 例如，表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`，且其前跟着 `The` 或 `the`。 430 | 431 |
432 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 433 |434 | 435 | [在线练习](https://regex101.com/r/avH165/1) 436 | 437 | ### 4.4 `? 443 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 444 | 445 | 446 | [在线练习](https://regex101.com/r/8Efx5G/1) 447 | 448 | ## 5. 标志 449 | 450 | 标志也叫模式修正符，因为它可以用来修改表达式的搜索结果。 451 | 这些标志可以任意的组合使用，它也是整个正则表达式的一部分。 452 | 453 | |标志|描述| 454 | |:----:|----| 455 | |i|忽略大小写。| 456 | |g|全局搜索。| 457 | |m|多行修饰符：锚点元字符 `^` `$` 工作范围在每行的起始。| 458 | 459 | ### 5.1 忽略大小写 (Case Insensitive) 460 | 461 | 修饰语 `i` 用于忽略大小写。 462 | 例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`，`g` 表示全局搜索。 463 | 464 |
465 | "The" => The fat cat sat on the mat. 466 |467 | 468 | [在线练习](https://regex101.com/r/dpQyf9/1) 469 | 470 |
471 | "/The/gi" => The fat cat sat on the mat. 472 |473 | 474 | [在线练习](https://regex101.com/r/ahfiuh/1) 475 | 476 | ### 5.2 全局搜索 (Global search) 477 | 478 | 修饰符 `g` 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。 479 | 例如，表达式 `/.(at)/g` 表示搜索 任意字符（除了换行）+ `at`，并返回全部结果。 480 | 481 |
482 | "/.(at)/" => The fat cat sat on the mat. 483 |484 | 485 | [在线练习](https://regex101.com/r/jnk6gM/1) 486 | 487 |
488 | "/.(at)/g" => The fat cat sat on the mat. 489 |490 | 491 | [在线练习](https://regex101.com/r/dO1nef/1) 492 | 493 | ### 5.3 多行修饰符 (Multiline) 494 | 495 | 多行修饰符 `m` 常用于执行一个多行匹配。 496 | 497 | 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾。但我们如果想要它在每行的开头和结尾生效，我们需要用到多行修饰符 `m`。 498 | 499 | 例如，表达式 `/at(.)?$/gm` 表示小写字符 `a` 后跟小写字符 `t` ，末尾可选除换行符外任意字符。根据 `m` 修饰符，现在表达式匹配每行的结尾。 500 | 501 |
502 | "/.at(.)?$/" => The fat 503 | cat sat 504 | on the mat. 505 |506 | 507 | [在线练习](https://regex101.com/r/hoGMkP/1) 508 | 509 |
510 | "/.at(.)?$/gm" => The fat 511 | cat sat 512 | on the mat. 513 |514 | 515 | [在线练习](https://regex101.com/r/E88WE2/1) 516 | 517 | ### 6. 贪婪匹配与惰性匹配 (Greedy vs lazy matching) 518 | 519 | 正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 `?` 将贪婪匹配模式转化为惰性匹配模式。 520 | 521 |
522 | "/(.*at)/" => The fat cat sat on the mat.523 | 524 | [在线练习](https://regex101.com/r/AyAdgJ/1) 525 | 526 |
527 | "/(.*?at)/" => The fat cat sat on the mat.528 | 529 | [在线练习](https://regex101.com/r/AyAdgJ/2) 530 | 531 | ## 贡献 532 | 533 | * 报告问题 534 | * 开放合并请求 535 | * 传播此文档 536 | * 直接和我联系 ziishaned@gmail.com 或 [](https://twitter.com/ziishaned) 537 | 538 | ## 许可证 539 | 540 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 541 | -------------------------------------------------------------------------------- /translations/README-he.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
32 |
33 | 
34 |
35 |
53 | 
54 |
97 | "the" => The fat cat sat on the mat. 98 |99 | 100 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dmRygT/1) 101 | 102 | הביטוי הרגולרי `123` מתאים למחרוזת `123`. הביטוי הרגולרי מותאם למחרוזת קלט על ידי השוואת כל תו 103 | בביטוי הרגולרי לכל תו במחרוזת הקלט, אחד אחרי השני. ביטויים רגולרים לרוב יהיו 104 | תלויי אותיות קטנות או גדולות כך שהביטוי הרגולרי `The` לא יתאים למחרוזת `the`. 105 | 106 |
107 | "The" => The fat cat sat on the mat. 108 |109 | 110 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/1paXsy/1) 111 | 112 | ## 2. תווי-מטא 113 | 114 | תווי-מטא אלו הם אבני הבניין של ביטויים רגולרים. תווי-מטא לא מסמלים את עצמם, אלא מתפרשים באופן מיוחד. 115 | לכמה תווי-מטא יש משמעויות מיוחדות והם נכתבים בתוך סוגריים מרובעים. 116 | תווי-המטא הם כדלקמן: 117 | 118 | |תווי-מטא|תיאור| 119 | |:----:|----| 120 | |.|נקודה תואמת כל תו בודד למעט שבירת שורות.| 121 | |[ ]|מחלקת תווים. תואם כל תו הכלול בין הסוגריים המרובעים.| 122 | |[^ ]|מחלקת תווים שלילית. תואם כל תו שאינו כלול בין הסוגריים המרובעים| 123 | |*|תואם 0 או יותר חזרות של התו הקודם.| 124 | |+|תואם חזרה אחת או יותר של התו הקודם.| 125 | |?|הופך את התו הקודם לאופציונלי.| 126 | |{n,m}|סוגריים מסולסלים. תואם לפחות חזרות "n" אך לא יותר מ- "m" של התו הקודם.| 127 | |(xyz)|קבוצת תווים. תואם את התווים xyz בסדר המדויק הזה.| 128 | |||חלופה (או). התאמה בין התווים שלפני או לתווים שאחרי הסמל.| 129 | |\|מתעלם מהתו הבא. זה מאפשר לך להתאים תווים שמורים
[ ] ( ) { } . * + ? ^ $ \ ||
130 | |^|תואם את תחילת הקלט.|
131 | |$|תואם את סוף הקלט.|
132 |
133 | ## 2.1 עצירה מלאה
134 |
135 | עצירה מלאה `.` היר דוגמא פשוטה לשימוש בתו-מטא. תו-המטא `.` מתאים לכל תו בודד. הוא לא יתאים
136 | לתו return (\r) או לתו newline (\n). למשל, הביטוי הרגולרי `.ar` פירושו: כל תו, שאחריו האות `a`, ואחריה האות `r`.
137 |
138 | 139 | ".ar" => The car parked in the garage. 140 |141 | 142 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/xc9GkU/1) 143 | 144 | ## 2.2 מערכות תוים 145 | 146 | מערכות תוים נקראים גם מחלקות תוים. סוגריים מרובעים משמשים לציון מערכות תוים. 147 | השתמש במקף בתוך ערכת התוים בכדי לציין את טווח התוים. סדר טווח התוים לא משנה. 148 | לדוגמא, הביטוי הרגולרי `[Tt]he` פירושו: אות גדולה 149 | `T` או אות קטנה `t`, שאחריה מופיעה האות `h`, ואחריה מופיעה האות `e`. 150 | 151 |
152 | "[Tt]he" => The car parked in the garage. 153 |154 | 155 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/2ITLQ4/1) 156 | 157 | נקודה בתוך ערכת התוים בשונה מבחוץ תחשב כתו נקודה. הביטוי הרגולרי 158 | `ar[.]` פירושו: תו האות הקטנה `a`, שאחריו האות `r`, 159 | ואחריה התו נקודה `.`. 160 | 161 |
162 | "ar[.]" => A garage is a good place to park a car. 163 |164 | 165 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/wL3xtE/1) 166 | 167 | ### 2.2.1 מערכות תוים שליליות 168 | 169 | באופן כללי, הסימן "קרט"(גג) מייצג את תחילתה של מחרוזת, אך במידה והוא מוקלד לאחר סוגר מרובע פותח, 170 | הוא שולל את מערכת ההתוים שיהיו תחת אותם סוגרים. לדוגמא, הביטוי הרגולרי `[^c]ar` פירושו: כל תו חוץ מ-`c`, 171 | שלאחריו יופיע התו `a`, שאחריו יופיע התו `r`. 172 | 173 |
174 | "[^c]ar" => The car parked in the garage. 175 |176 | 177 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/nNNlq3/1) 178 | 179 | ## 2.3 חזרות 180 | 181 | תווי-המטא `+`, `*` או `?` משמשים לציון כמה פעמים דפוסי משני יכולים להתרחש. 182 | תווי-מטא אלו פועלים אחרת במצבים שונים. 183 | 184 | ### 2.3.1 הכוכבית 185 | 186 | הסימן - `*` תואם אפס או יותר חזרות של המתאם הקודם. הביטוי הרגולרי `a*` פירושו: 187 | אפס או יותר חזרות של התו הקודם- `a`. אבל אם הכוכבית תופיע לאחר מערכת או מערך תוים אז 188 | הוא ימצא את החזרות של מערכת התוים כולה. לדוגמא, הביטוי הרגולרי `[a-z]*` פירושו: 189 | כל מספר של אותיות קטנות בשורה. 190 | 191 |
192 | "[a-z]*" => The car parked in the garage #21. 193 |194 | 195 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/7m8me5/1) 196 | 197 | הסימן - `*` יכול לשמש יחד עם התו-מטא `.` בכדי להתאים כל מחרוזת תוים `.*`. 198 | הסימון - `*` יכול לשמש יחד עם התו רווח - `\s` בכדי להתאים מחרוזת של תוי רווח. 199 | לדוגמא, הביטוי `\s*cat\s*` פירושו: אפס או יותר רווחים, שאחריהם תופיעה האות הקטנה `c`, 200 | שאחריה תופיע האות הקטנה `a`, ואחריה האות הקטנה `t`, ולבסוף אחריה יופיעו אפס או יותר תווי רווח. 201 | 202 |
203 | "\s*cat\s*" => The fat cat sat on the concatenation. 204 |205 | 206 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/gGrwuz/1) 207 | 208 | ### 2.3.2 הפלוס 209 | 210 | הסימן `+` מתאים לאחת או יותר חזרות של התו הקודם לו. לדוגמא, הביטוי הרגולרי 211 | `c.+t` פירושו: האות הקטנה - `c`, לאחריה לפחות תו אחד או יותר, 212 | ואחריה האות הקטנה `t`. חשוב לציין שה - `t` יהיה התו `t` האחרון במשפט. 213 | 214 |
215 | "c.+t" => The fat cat sat on the mat. 216 |217 | 218 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Dzf9Aa/1) 219 | 220 | ### 2.3.3 סימן השאלה 221 | 222 | בביטוי רגולרי, התו-מטא `?` הופך את התו הקודם לאופציונלי, 223 | סמל זה יתאים לאפס או יותר הופעות של אותו תו קודם. לדוגמא, הביטוי הרגולרי 224 | `[T]?he` פירושו: אופציה לאות 225 | `T` גדולה, ולאחריה אות קטנה `h`, ולאחריה תופיע האות - `e`. 226 | 227 |
228 | "[T]he" => The car is parked in the garage. 229 |230 | 231 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/cIg9zm/1) 232 | 233 |
234 | "[T]?he" => The car is parked in the garage. 235 |236 | 237 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/kPpO2x/1) 238 | 239 | ## 2.4 סוגרים מסולסלים 240 | 241 | בביטויים רגולרים, סוגרים מסולסלים (נקראים גם מכמתים) משמשים לציון 242 | מספר הפעמים שניתן לחזור על תו או קבוצת תוים מסויימת. לדוגמא, הביטור הרגולרי 243 | `[0-9]{2,3}` פירושו: התאם לפחות שתי ספרות, אבל לא יותר משלוש, בטווח שבין 0 ל-9 244 | 245 |
246 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
247 |
248 |
249 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/juM86s/1)
250 |
251 | אנחנו יכולים לוותר על המספר השני בסוגרים המסולסלים. לדוגמא, בביטוי הרגולרי
252 | `[0-9]{2,}` פירושו: התאמת שתי ספרות או יותר. בנוסף אם
253 | נוריד את הפסיק, לדוגמא בביטוי הרגולרי `[0-9]{3}` פירושו:
254 | התאם בדיוק שלוש ספרות.
255 |
256 |
257 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
258 |
259 |
260 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Gdy4w5/1)
261 |
262 |
263 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
264 |
265 |
266 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Sivu30/1)
267 |
268 | ## 2.5 קבוצות לכידה
269 |
270 | קבוצה מלכדת היא קבוצה של תת-תבניות שנכתבות בתוך סוגריים רגילים `(...)` .
271 | כפי שצויין קודם לכן, בביטוי רגולרי, אם נניח מכמת אחרי תו הוא יחזור על התו הקודם.
272 | אבל אם נניח מכמת אחרי קבוצה מלכדת אז המכמת יתיחס לכל הקבוצה המלכדת. לדוגמא, הביטוי הרגולרי
273 | `(ab)*` תואם אפס או יותר חזרות של המחרוזת "ab". אנחנו יכולים גם להשתמש
274 | בתו-מטא `|` המשמש לבצע את הפעולה 'OR'(או) בתוך קבוצה מלכדת.
275 | לדוגמא, הביטוי הרגולרי `(c|g|p)ar` פירושו: אות קטנה `c`,
276 | `g` או `p`, שאחריהן תופיע האות `a`, ואחריה האות `r`.
277 |
278 | 279 | "(c|g|p)ar" => The car is parked in the garage. 280 |281 | 282 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/tUxrBG/1) 283 | 284 | יש לשים לב כי קבוצות מלכדות לא רק תואמות, אלא גם תופסות את התוים לשימוש בשפת האם. 285 | שפת האם יכולה להיות Python או JavaScript או כמעט כל שפה שמיישמת ביטויים רגולרים 286 | בבגדרת פונקציה. 287 | 288 | ### 2.5.1 קבוצות שאינן לוכדות 289 | 290 | קבוצה שאינה מלכדת זוהי קבוצת לוכדת התואמת את התוים אבל לא תופסת את הקבוצה. 291 | קבוצה שאינה מלכדת מסומנת על ידי התו `?` ואחריו `:` בתוך הסוגריים הרגילים. `(...)`. 292 | לדוגמא, בביטוי הרגולרי `(?:c|g|p)ar` שדומה ל-`(c|g|p)ar` 293 | בכך שהוא תואם לאותם תווים אך לא ייצר קבוצת לכידה. 294 | 295 |
296 | "(?:c|g|p)ar" => The car is parked in the garage. 297 |298 | 299 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Rm7Me8/1) 300 | 301 | קבוצות שאינן מלכדות יכולות להיות שימושיות כאשר יש צורך בפונקציונליות של חיפוש והחלפה 302 | או כאשר מעורבת גם קבוצת לכידה בכדי לשמור על הסקירה כאשר מפיקים כל סוג אחר של פלט. 303 | ניתן לראות גם ב [4. Lookaround](#4-lookaround). 304 | 305 | ## 2.6 חלופה 306 | 307 | בביטוי רגולרי, הקו ניצב `|` משמש בכדי להגדיר חלופה. חלופה היא כמו הצהרת OR (או) 308 | בין ביטויים שונים. כעט את.ה עלול לחשוב שמערכות התווים והתו המשמש להגדרת חלופה יעבדו באותה הדרך. 309 | אך ההבדל העיקרי בין מערכת תווים לבין חלופה הוא שמערכת תווים פועלת ברמת התו והחלופה 310 | עובדת ברמת הביטוי. לדוגמא, הביטוי הרגולרי `(T|t)he|car` פירושו: או (אות גדולה `T` או אות קטנה 311 | `t`, שלאחריהן אות קטנה `h`, שאחריה אות קטנה `e`) או (אות קטנה `c`, שאחריה תופיע האות `a`, 312 | ולאחריה תופיע האות `r`). יש לשים לב שהכללתי את הסוגריים לשם ההבהרה, 313 | בכדי להראות שאפשר להתמודד עם כל ביטוי בסוגריים והוא יתאים. 314 | 315 |
316 | "(T|t)he|car" => The car is parked in the garage. 317 |318 | 319 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/fBXyX0/1) 320 | 321 | ## 2.7 התעלמות מתווים מיוחדים 322 | 323 | לוכסן שמאלי `\` משמש בביטוי רגולרי בכדי להתעלם מהתו הבא. זה מאפשר לנו לכלול תוים שמורים כמו 324 | `{ } [ ] / \ + * . $ ^ | ?` כתוים להתאמות. הכדי להשתמש בתוים המיוחדים הללו התו התאמה, 325 | יש להוסיף אותו מראש עם `\` לפניו. לדוגמא, הביטוי הרגולרי `.` משמש בכדי להתאים כל תו חוץ משורה חדשה. 326 | כעט בכדי לבצע התאמה עם הסימן `.` במחרוזת קלט, יהיה צורך בהוספת הלוכסן השמאלי. למשל בביטוי הרגולרי 327 | `(f|c|m)at\.?` פירושו: אות קטנה `f`, `c` או `m`, שאחריהן תופיע האות הקטנה 328 | `a`, ואחריה תופיע האות הקטנה `t`, ולבסוף יופיע באופן אופציונלי התו - `.`. 329 | 330 |
331 | "(f|c|m)at\.?" => The fat cat sat on the mat. 332 |333 | 334 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/DOc5Nu/1) 335 | 336 | ## 2.8 עוגנים 337 | 338 | בביטויים רגולרים, אנחנו משתמשים בעוגנים בכדי לבדוק אם סימן ההתאמה הוא סימן התחלה או 339 | סימן סיום של מחרוזת הקלט. ישנם שני סוגי עוגנים: 340 | הסוג הראשון הוא ה"קרט"(גג) `^` שבודק אם תו תואם הוא התו הראשון של הקלט והסוג השני הוא סימן הדולר 341 | `$` אשר בודק אם תו תואם הוא התו האחרון שבקלט 342 | 343 | ### 2.8.1 ה-"קרט" 344 | 345 | הסימן "קרט" `^` משמש לבדיקה אם תו תואם הוא התו הראשון של מחרוזת הקלט. 346 | אם ניישם את הביטור הרגולרי הבא `^a` (כלומר 'a' חייב להיות התו ההתחלתי) 347 | המחרוזת `abc`, תתאים לדרישות `a`. 348 | אך אם ניישם את הביטוי הרגולרי `^b` על במחרוזת למעלה, היא לא תמצא אף התאמה. 349 | בגלל שבמחרוזת `abc`, ה-"b" אינו תו התחלתי. בואו נסתכל על ביטוי רגולרי אחר 350 | `^(T|t)he` שפירושו: אות גדולה `T` או אות קטנה `t` חייבת להיות התו הראשון של המחרוזת, 351 | ואחריה האות הקטנה `h`, ולאחריה האות הקטנה `e`. 352 | 353 |
354 | "(T|t)he" => The car is parked in the garage. 355 |356 | 357 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/5ljjgB/1) 358 | 359 |
360 | "^(T|t)he" => The car is parked in the garage. 361 |362 | 363 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jXrKne/1) 364 | 365 | ### 2.8.2 סימן הדולר 366 | 367 | סימן הדולר `$` משמש בכדי לבדוק אם התו התואם הוא התו האחרון במחרוזת. לדוגמא, 368 | הביטוי הרגולרי `(at\.)$` פירושו: האות הקטנה `a`, שאחריה תיהיה האות הקטנה `t`, ואחריה התו נקודה `.` 369 | וכל ההתאמה חייבת לביות בסופה של המחרוזת. 370 | 371 |
372 | "(at\.)" => The fat cat. sat. on the mat. 373 |374 | 375 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/y4Au4D/1) 376 | 377 |
378 | "(at\.)$" => The fat cat. sat. on the mat. 379 |380 | 381 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/t0AkOd/1) 382 | 383 | ## 3. קיצורי מערכות תווים 384 | 385 | ישנם מספר קיצורים נוחים למערכות תווים נפוצות / ביטויים רגולרים: 386 | 387 | |קיצור|תיאור| 388 | |:----:|----| 389 | |.|תואם כל תו חוץ מתחילת שורה חדשה| 390 | |\w|תואם תוים אלפא-נומריים (אותיות ומספרים): `[a-zA-Z0-9_]`| 391 | |\W|תואם תוים לא אלפא-נומריים: `[^\w]`| 392 | |\d|תואם ספרות: `[0-9]`| 393 | |\D|תואם תוים שאינם ספרות: `[^\d]`| 394 | |\s|תואם תוי רווח: `[\t\n\f\r\p{Z}]`| 395 | |\S|תואם תוים שאינם רווח: `[^\s]`| 396 | 397 | ## 4. הסתכלויות 398 | 399 | מבט לאחור ומבט לפנים (נקראים גם הסתכלויות) אלו הם סוגים ספציפים של קבוצות שאינן לוכדות. 400 | (משמשות בכדי להתאים תבנית אך ללא הכנסתה לרשימת ההתאמות). 401 | הסתכלויות משמשות כאשר יש להקדים תבנית בכך שזו תלויה בתבנית אחרת בכדי שהראשונה תתאים. 402 | לדוגמא, תדמיין.י שאנחנו רוצים לקבל את כל המספרים שלפניהם יש את התו `$` מהמחרוזת 403 | `$4.44 and $10.88`. אנחנו נשתמש בביטוי הרגולרי הבא: 404 | `(?<=\$)[0-9\.]*` שפירושו: התאם את כל הספרות או התו `.` שלפני ההתאמה 405 | קיים התו `$`. בטבלה מטה מוצגים סוגי המבטים המשמשים ביטויים רגולרים: 406 | 407 | |סימן|תיאור| 408 | |:----:|----| 409 | |?=|מבט קדימה חיובי| 410 | |?!|מבט קדימה שלילי| 411 | |?<=|מבט אחורה חיובי| 412 | |?|מבט אחורה שלילי| 413 | 414 | ### 4.1 מבט קדימה חיובי 415 | 416 | מבט קדימה חיובי דורש שבחלקו הראשון של ביטוי חייב להתקיים הביטוי מבט קדימה חיובי. 417 | ההתאמה המוחזרת מכילה רק את הטקסט המתאים לחלק הראשון של הביטוי לפני המבט קדימה. 418 | בכדי להגדיר מבט קדימה חיובי, משתמשים בסוגריים. בתוך הסוגריים, משתמשים בסימן שאלה 419 | ואחריו סימן השוואה כך: `(?=...)`. ביטויי המבט קדימה נכתבים אחרי סימני סוג 420 | המבט בתוך הסוגריים. לדוגמא, הביטוי הרגולרי `(T|t)he(?=\sfat)` פירושו: 421 | התאם או את האות הקטנה `t` או את האות הגדולה `T`, שאחריה תיהיה האות `h`, ואחריה האות `e`. 422 | בסוגריים אנחנו מגדירים מבט קדימה חיובי שאומר למנוע של הביטוי הרגולרי להתאים `The` או `the` 423 | רק אם אחרי ההתאמה מופיעה המחרוזתS ` fat`. 424 | 425 |
426 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 427 |428 | 429 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/IDDARt/1) 430 | 431 | ### 4.2 מבט קדימה שלילי 432 | 433 | משתמשים במבט קדימה שלילי כשאנחנו צריכים לקבל את כל ההתאמות ממחרוזת קלט שלאחריהן אין תבנית מסויימת. 434 | מבט קדימה שלילי יכתב באותה הדרך כמו שנכתב המבט קדימה החיובי. ההבדל היחיד הוא שמבקום 435 | סימן השווה `=`, עלינו להשתמש בסימן קריאה `!` בכדי לציין את השלילה כלומר: `(?!...)`. 436 | בואו נסתכל על הביטוי הרגולרי הבא `(T|t)he(?!\sfat)` שפירושו: התאם את כל המילים `The` או `the` 437 | ממחרוזת קלט שאחריהן אין את התו רווח ולאחר מכן את המילה `fat`. 438 | 439 |
440 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 441 |442 | 443 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/V32Npg/1) 444 | 445 | ### 4.3 מבט אחורה חיובי 446 | 447 | משתמשים במבט אחורה חיובי בכדי לקבל את כל ההתאמות שלפניהן יש תבנית ספציפית מסויימת. 448 | מבטים אחורה חיוביים נכתבים כך: `(?<=...)`. לדוגמא, 449 | הביטוי הרגולרי `(?<=(T|t)he\s)(fat|mat)` פירושו: התאם 450 | את כל המילים `fat` או `mat` ממחרוזת קלט שנמצאות לפני המילים `The` או `the` ויש רווח 451 | שמפריד בינהן. 452 | 453 |
454 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 455 |456 | 457 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/avH165/1) 458 | 459 | ### 4.4 מבט אחורה שלילי 460 | 461 | משתמשים במבט אחורה שלילי בכדי לקבל את כל ההתאמות שלפניהן אין תבנית ספציפית מסויימת. 462 | מבטים אחורה שליליים יכתבו כך: `(?. לדוגמא, הביטוי הרגולרי 463 | `(? פירושו: התאם את כל המילים `cat` 464 | ממחרוזת קלט שלא נמצאות אחרי המילים `The` or `the` כאשר רווח מפריד בינהן. 465 | 466 |
467 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 468 |469 | 470 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/8Efx5G/1) 471 | 472 | ## 5. דגלים 473 | 474 | דגלים נקראים גם משנים בגלל שהם משנים את הפלט של הביטוי הרגולרי. 475 | ניתן להשתמש בדגלים הללו בכל סדר או שילוב והם חלק בלתי נפרד 476 | מהביטוי הרולרי (RegExp). 477 | 478 | |דגל|תיאור| 479 | |:----:|----| 480 | |i|חוסר רגישות לאותיות: ההתאמה לא תהיה רגישה לאותיות קטנות או גדולות.| 481 | |g|חיפוש גלובלי: התאם את כל ההאמות שהופיעו, לא רק את הראשונה.| 482 | |m|רב-שורות: תווי-המטא העוגנים (`$` או `^`) עובדים על כל שורה.| 483 | 484 | ### 5.1 חוסר רגישות לאותיות 485 | 486 | המשנה `i` משמש בכדי לבצע התאמות חסרות רגישות לאותיות קטנות או גדולות. 487 | לדוגמא, בביטוי הרגולרי `/The/gi` פירושו: אות גדולה `T`, ואחריה אות קטנה 488 | `h`, ואחריה אות קטנה `e`. ובסוף הביטוי הרגולרי יש את הדגל `i` שאומר למנוע הביטוי הרגולרי 489 | להתעלם מהבדלי אותיות גדולות או קטנות. וכפי שאת.ה יכול לראות, 490 | סיפקנו גם דגל `g` בגדלל שאנחנו רוצים לחפש את התבנית בכל מחרוזת הקלט. 491 | 492 |
493 | "The" => The fat cat sat on the mat. 494 |495 | 496 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dpQyf9/1) 497 | 498 |
499 | "/The/gi" => The fat cat sat on the mat. 500 |501 | 502 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/ahfiuh/1) 503 | 504 | ### 5.2 חיפוש גלובלי 505 | 506 | המשנה `g` משמש בכדי לבצע התאמות גלובליות (מוצא את כל ההתאמות במקום לעצור בהתאמה הראשונה). 507 | לדוגמא, בביטוי הרגולרי `/.(at)/g` פירושו: כל תו חות משורה חדשה, שאחריו תיהיה האות הקטנה `a`, 508 | ואחריה תיהיה האות הקטנה `t`. בגלל שסיפקנו את הדגל `g` בסופו של הביטוי הרגולרי, 509 | הוא עכשיו ימצא את כל ההתאמות במחרוזת הקלט, לא רק את ההתאמה הראשונה (שזו התנהגות ברירת המחדל). 510 | 511 |
512 | "/.(at)/" => The fat cat sat on the mat. 513 |514 | 515 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jnk6gM/1) 516 | 517 |
518 | "/.(at)/g" => The fat cat sat on the mat. 519 |520 | 521 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dO1nef/1) 522 | 523 | ### 5.3 רב-שורות 524 | 525 | המשנה `m` משמש בכדי לבצע התאמות במספר רב של שורות. כפי שדנו על כך קודם לכן, 526 | העוגנים `(^, $)` משמשים לבדיקה אם תבנית היא בהתחלה או בסופו של קלט. 527 | אבל אם אנחנו רוצים שהעוגנים הללו יעבדו על כל שורה, אנחנו נשתמש בדגל `m`. לדוגמא, 528 | בביטוי הרגולרי `/at(.)?$/gm` פירושו: אות קטנה 529 | `a`, שלאחריה האות הקטנה `t` וכאופציה, כל תו שאינו שורה חדשה. ובגלל הדגל `m`, 530 | המנוע של הביטוי הרגולרי יתאים את התבנית בכל סוף שורה במחרוזת. 531 | 532 |
533 | "/.at(.)?$/" => The fat 534 | cat sat 535 | on the mat. 536 |537 | 538 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/hoGMkP/1) 539 | 540 |
541 | "/.at(.)?$/gm" => The fat 542 | cat sat 543 | on the mat. 544 |545 | 546 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/E88WE2/1) 547 | 548 | ## 6. התאמה חמדנית מול עצלה 549 | 550 | כברירת מחדל, ביטוי רגולרי יבצע התאמה חמדנית, זאת אומרת שביצוע ההתאמה תיהיה ארוכה ככל הניתן. 551 | אנחנו יכולים להשתמש ב-`?` בכדי לבצע התאמה בצורה עצלה, פירוש הדבר שההתאמה תיהיה קצרה ככל שניתן. 552 | 553 |
554 | "/(.*at)/" => The fat cat sat on the mat.555 | 556 | 557 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/1) 558 | 559 |
560 | "/(.*?at)/" => The fat cat sat on the mat.561 | 562 | 563 | [בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/2) 564 | 565 | 566 | ## תרומה 567 | 568 | * Open a pull request with improvements 569 | * Discuss ideas in issues 570 | * Spread the word 571 | * Reach out with any feedback 572 | * [](https://twitter.com/ziishaned) 573 | 574 | ## רישיון 575 | 576 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 577 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
57 | 
58 |
100 | "the" => The fat cat sat on the mat. 101 |102 | 103 | [Teszteld a reguláris kifejezést](https://regex101.com/r/dmRygT/1) 104 | 105 | Az `123` reguláris kifejezés illeszkedik a `123` karakterláncra. A reguláris kifejezés 106 | minden egyes karaktere össze lesz hasonlítva a bevitt karakterlánc minden elemével 107 | egymás után. A reguláris kifejezések alap esetben kis-nagybetű érzékenyek, tehát a 108 | `The` reguláris kifejezés nem fog illeszkedni a `the` karakterláncra. 109 | 110 |
111 | "The" => The fat cat sat on the mat. 112 |113 | 114 | [Teszteld a reguláris kifejezést](https://regex101.com/r/1paXsy/1) 115 | 116 | ## 2. Meta karakterek 117 | 118 | A meta karakterek a reguláris kifejezések építőkockái. A meta karakterek speciális 119 | módon értelmezendőek. Némelyik meta karakternek speciális jelentése van és 120 | szögletes zárójelek közé vannak téve. A meta karakterek a következők: 121 | 122 | |Meta karakter|Leírás| 123 | |:----:|----| 124 | |.|A pont illeszkedik minden egyes karakterre kivéve a sortörést.| 125 | |[ ]|Karakter osztály. Minden karakterre illeszkedik ami a szögletes zárójelek közt van.| 126 | |[^ ]|Negált karakter osztály. Minden karakterre illeszkedik ami nincs a szögletes zárójelek közt.| 127 | |*|Illeszkedik az őt megelőző szimbólum 0 vagy több ismétlődésére.| 128 | |+|Illeszkedik az őt megelőző szimbólum 1 vagy több ismétlődésére.| 129 | |?|Opcionálissá teszi az őt megelőző szimbólumot.| 130 | |{n,m}|Kapcsos zárójelek. Illeszkedik az őt megelőző szimbólum minimum "n" de nem több mint "m" ismétlődésére.| 131 | |(xyz)|Karakter csoport. Illeszkedik az xyz karakterekre pontosan ilyen sorrendben.| 132 | |||Alternáció. Illeszkedik a szimbólum előtt és után álló karakterekre is.| 133 | |\|Escape-li a következő karaktert. A segítségével lefoglalt karakterekre is lehet illeszkedni
[ ] ( ) { } . * + ? ^ $ \ ||
134 | |^|A karakterlánc elejére illeszkedik.|
135 | |$|A karakterlánc végére illeszkedik.|
136 |
137 | ## 2.1 Full stop
138 |
139 | A full stop `.` a legegyszerűbb meta karakter példa. A `.` meta karakter illeszkedik
140 | minden egyes karakterre. Nem fog illeszkedni a kocsi vissza és a sortörés karakterekre.
141 | Például a `.ar` reguláris kifejezés jelentése: minden karakter, amit `a` aztán `r` követ.
142 |
143 | 144 | ".ar" => The car parked in the garage. 145 |146 | 147 | [Teszteld a reguláris kifejezést](https://regex101.com/r/xc9GkU/1) 148 | 149 | ## 2.2 Karakter osztályok 150 | 151 | A szögletes zárójelekkel határozzuk meg a karakter osztályokat. A szögletes 152 | zárójelek közt kötőjel karakterrel határozhatunk meg karakter tartományokat. 153 | A karaktertartomány sorrendje nem számít. Például a `[Tt]he` reguláris kifejezés 154 | jelentése: nagybetűs `T` vagy kisbetűs `t` amit egy `h` majd egy `e` betű követ. 155 | 156 |
157 | "[Tt]he" => The car parked in the garage. 158 |159 | 160 | [Teszteld a reguláris kifejezést](https://regex101.com/r/2ITLQ4/1) 161 | 162 | Egy pont a karakter osztályon belül egyébként szó szerint pont-ot jelent. A 163 | `ar[.]` reguláris kifejezés jelentése: kisbetűs `a` amit egy `r` aztán egy 164 | pont `.` karakter követ. 165 | 166 |
167 | "ar[.]" => A garage is a good place to park a car. 168 |169 | 170 | [Teszteld a reguláris kifejezést](https://regex101.com/r/wL3xtE/1) 171 | 172 | ### 2.2.1 Negált karakter osztályok 173 | 174 | Általában a kalap szimbólum egy karakterlánc elejét jelenti, de ha egy nyitó 175 | szögletes zárójel után áll, akkor negálja a karakter osztályt. Például a 176 | `[^c]ar` reguláris kifejezés jelentése: minden karakter a `c` kivételével 177 | ami után `a` aztán egy `r` betű áll. 178 | 179 |
180 | "[^c]ar" => The car parked in the garage. 181 |182 | 183 | [Teszteld a reguláris kifejezést](https://regex101.com/r/nNNlq3/1) 184 | 185 | ## 2.3 Ismétlések 186 | 187 | A következő meta karaktereket `+`, `*` vagy `?` arra használjuk, hogy meghatározzuk, 188 | hányszor fordulhat elő az al-minta. Ezek a meta karakterek máshogy viselkednek 189 | adott helyzetekben. 190 | 191 | ### 2.3.1 A csillag 192 | 193 | A `*` szimbólum az őt megelőző karakter nulla vagy több ismétlődésére illeszkedik. 194 | A `a*` reguláris kifejezés jelentése: nulla vagy több ismétlődése az őt megelőző `a` 195 | karakternek. De ha egy karakter osztály után áll akkor az egész karakterosztály 196 | ismétlődését keresi. Például, a `[a-z]*` reguláris kifejezés jelentése: bármennyi 197 | kisbetűs betű egy sorban. 198 | 199 |
200 | "[a-z]*" => The car parked in the garage #21. 201 |202 | 203 | [Teszteld a reguláris kifejezést](https://regex101.com/r/7m8me5/1) 204 | 205 | A `*` szimbólum használható a `.` meta karakterrel `.*`, ez illeszkedik 206 | bármilyen karakterláncra. A `*` szimbólum használható a whitespace karakterrel `\s` 207 | együtt, hogy illeszkedjen egy whitespace-ekből álló karakterláncra. Például a 208 | `\s*cat\s*`kifejezés jelentése: nulla vagy több szóköz, amit egy kisbetűs `c`, 209 | aztán egy kisbetűs `a`, aztán egy kisbetűs `t`, amit még nulla vagy több szóköz követ. 210 | 211 |
212 | "\s*cat\s*" => The fat cat sat on the concatenation. 213 |214 | 215 | [Teszteld a reguláris kifejezést](https://regex101.com/r/gGrwuz/1) 216 | 217 | ### 2.3.2 A plusz 218 | 219 | A `+` szimbólum illeszkedik az őt megelőző karakter egy vagy több ismétlődésére. 220 | Például a `c.+t` kifejezés jelentése: kisbetűs `c` betű, amit legalább egy vagy 221 | több `t` követ. Itt tisztázni kell hogy a `t` az utolsó `t` a mondatban. 222 | 223 |
224 | "c.+t" => The fat cat sat on the mat. 225 |226 | 227 | [Teszteld a reguláris kifejezést](https://regex101.com/r/Dzf9Aa/1) 228 | 229 | ### 2.3.3 A kérdőjel 230 | 231 | A reguláris kifejezésben a `?` meta karakter opcionálissá teszi az őt 232 | megelőző karaktert. Ez a szimbólum az őt megelőző karakter nulla vagy egy 233 | példányára illeszkedik. Például a `[T]?he` kifejezés jelentése: opcionális a 234 | nagybetűs `T`, amit egy kisbetűs `h`, majd egy kisbetűs `e` követ. 235 | 236 |
237 | "[T]he" => The car is parked in the garage. 238 |239 | 240 | [Teszteld a reguláris kifejezést](https://regex101.com/r/cIg9zm/1) 241 | 242 |
243 | "[T]?he" => The car is parked in the garage. 244 |245 | 246 | [Teszteld a reguláris kifejezést](https://regex101.com/r/kPpO2x/1) 247 | 248 | ## 2.4 A kapcsos zárójelek 249 | 250 | A reguláris kifejezésben a kapcsos zárójeleket annak meghatározására használjuk, 251 | hogy egy karakter vagy egy karakter csoport hányszor ismétlődhet. Például a 252 | `[0-9]{2,3}` kifejezés jelentése: minimum 2 de nem több mint 3 karakter a `[0-9]` 253 | karaktertartományon belül. 254 | 255 |
256 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
257 |
258 |
259 | [Teszteld a reguláris kifejezést](https://regex101.com/r/juM86s/1)
260 |
261 | Kihagyhatjuk a második számot. Például a `[0-9]{2,}` kifejezés jelentése:
262 | 2 vagy több számra illeszkedik. Ha a vesszőt is kitöröljük `[0-9]{3}`: Pontosan
263 | 3 számra illeszkedik.
264 |
265 |
266 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
267 |
268 |
269 | [Teszteld a reguláris kifejezést](https://regex101.com/r/Gdy4w5/1)
270 |
271 |
272 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
273 |
274 |
275 | [Teszteld a reguláris kifejezést](https://regex101.com/r/Sivu30/1)
276 |
277 | ## 2.5 Karakter csoportok
278 |
279 | A karakter csoport al-minták csoportja amik zárójelek közé `(...)` vannak írva.
280 | Ahogy előbb már megbeszéltük, ha egy karakter után ismétlő karaktert rakunk, az
281 | ismételni fogja az előtte lévő karaktert. De ha egy ismétlő karaktert egy karakter
282 | csoport után rakunk, az ismételni fogja az egész csoportot. Például a `(ab)*`
283 | kifejezés illeszkedik nulla vagy több ismétlődésére az `ab` karaktereknek.
284 | Használhatunk alternáló meta karaktert `|` is a csoporton belül. Például a `(c|g|p)ar`
285 | kifejezés jelentése: kisbetűs `c`, `g` vagy `p` karakter, amit egy `a` aztán
286 | egy `r` karakter követ.
287 |
288 | 289 | "(c|g|p)ar" => The car is parked in the garage. 290 |291 | 292 | [Teszteld a reguláris kifejezést](https://regex101.com/r/tUxrBG/1) 293 | 294 | ## 2.6 Alternálás 295 | 296 | A reguláris kifejezésben a függőleges vonalat `|` alternálásra (választásra) 297 | használjuk. Az alternálás olyan, mint egy feltétel több kifejezés közt. Most 298 | azt gondolhatod, hogy a karakter osztály és az alternáció ugyan úgy működik. 299 | De a fő különbség köztük, hogy a karakter osztály a karakterek szintjén működik, 300 | az alternáció viszont a kifejezés szintjén. Például a `(T|t)he|car` kifejezés 301 | jelentése: nagybetűs `T` karakter vagy kisbetűs `t` karakter, amit egy `h` és 302 | egy `e` követ, VAGY kisbetűs `c` aztán `a` aztán `r` karakter. 303 | 304 |
305 | "(T|t)he|car" => The car is parked in the garage. 306 |307 | 308 | [Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1) 309 | 310 | ## 2.7 Speciális karakter escape-elése 311 | 312 | A visszaper `\` a reguláris kifejezésekben a következő karakter escape-elésére 313 | való. Ez enged nekünk szimbólumokat vagy lefoglalt karaktereket `{ } [ ] / \ + * . $ ^ | ?` 314 | megadni. Egy speciális karakter egyező karakterként való megadásához tedd elé 315 | a `\` karaktert. 316 | 317 | Például a `.` kifejezést az összes karakter, kivéve a sortörés illeszkedéséhez 318 | használjuk. A `(f|c|m)at\.?` kifejezés jelentése: kisbetűs `f`, `c` vagy `m`, amit 319 | egy kisbetűs `a` aztán egy kisbetűs `t`, amit egy opcionális `.` karakter követ. 320 | 321 |
322 | "(f|c|m)at\.?" => The fat cat sat on the mat. 323 |324 | 325 | [Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1) 326 | 327 | ## 2.8 Horgonyok 328 | 329 | A reguláris kifejezésekben horgonyokat használunk, hogy megnézzük, az illeszkedő 330 | szimbólum a kezdő vagy a záró szimbóluma-e a karakterláncnak. A horgonyoknak két 331 | fajtájuk van: Az első a Kalap `^`, ami megnézi, hogy az egyező karakter a karakterlánc 332 | kezdő kerektere-e és a második a Dollár `$`, ami azt vizsgálja, hogy az egyező 333 | karakter a karakterlánc utolsó karaktere-e. 334 | 335 | ### 2.8.1 Kalap 336 | 337 | A kalap `^` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező karakter 338 | a karakterlánc kezdő kerektere-e. Ha megadjuk a következő kifejezést: `^a`, 339 | akkor illeszkedik a `abc` karakterlánc `a` karakterére, mert az za első. De ha 340 | megadjuk, hogy: `^b`, ez nem fog illeszkedni az `abc` egyik részére sem, mert 341 | nem `b` a kezdő karakter. Nézzünk meg egy másik kifejezést. `^(T|t)he` jelentése: 342 | nagybetűs `T` vagy kisbetűs `t` a kezdő karaktere a karakterláncnak, amit kisbetűs 343 | `h`, majd kisbetűs `e` követ. 344 | 345 |
346 | "(T|t)he" => The car is parked in the garage. 347 |348 | 349 | [Teszteld a reguláris kifejezést](https://regex101.com/r/5ljjgB/1) 350 | 351 |
352 | "^(T|t)he" => The car is parked in the garage. 353 |354 | 355 | [Teszteld a reguláris kifejezést](https://regex101.com/r/jXrKne/1) 356 | 357 | ### 2.8.2 Dollár 358 | 359 | A dollár `$` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező 360 | karakter a karakterlánc utolsó karaktere-e. Például a `(at\.)$` kifejezés 361 | jelentése: egy kisbetűs `a`, amit egy kisbetűs `t`, amit egy `.` követ. És 362 | ennek az egésznek a karakterlánc végén kell lennie. 363 | 364 |
365 | "(at\.)" => The fat cat. sat. on the mat. 366 |367 | 368 | [Teszteld a reguláris kifejezést](https://regex101.com/r/y4Au4D/1) 369 | 370 |
371 | "(at\.)$" => The fat cat. sat. on the mat. 372 |373 | 374 | [Teszteld a reguláris kifejezést](https://regex101.com/r/t0AkOd/1) 375 | 376 | ## 3. Shorthand Karakter osztályok 377 | 378 | A gyakran használt karakter osztályokra a reguláris kifejezésnek vannak 379 | rövidítései, amikkel kényelmesebben tudunk használni általános kifejezéseket. 380 | A shorthand karakter osztályok a következők: 381 | 382 | |Rövidítés|Leírás| 383 | |:----:|----| 384 | |.|Minden karakter a sortörésen kívül.| 385 | |\w|Az alfanumerikus karakterekre illeszkedik: `[a-zA-Z0-9_]`| 386 | |\W|A nem alfanumerikus karakterekre illeszkedik: `[^\w]`| 387 | |\d|Számra illeszkedik: `[0-9]`| 388 | |\D|Nem számra illeszkedik: `[^\d]`| 389 | |\s|Whitespace karakterre illeszkedik: `[\t\n\f\r\p{Z}]`| 390 | |\S|Nem whitespace karakterre illeszkedik: `[^\s]`| 391 | 392 | ## 4. Lookaround 393 | 394 | A lookbehind (hátranézés) és a lookahead (előrenézés) speciális típusai a 395 | ***nem tárolt csoport*** oknak, amiket illeszkedésre használnak, de nincsenek 396 | benne az illeszkedési listában. Az előrenézést akkor használjuk, ha feltételezzük, 397 | hogy ezt a mintát egy másik minta előzi meg, vagy követi. Például kell nekünk 398 | az összes szám ami előtt `$` karakter áll a következő karakterláncból: `$4.44 and $10.88`. 399 | Ezt a mintát fogjuk használni: `(?<=\$)[0-9\.]*`, aminek a jelentése: Szedd ki az 400 | összes számot ami `.` karaktert tartalmaz és megelőzi egy `$` karakter. A 401 | következő lookaround-okat használhatjuk: 402 | 403 | |Szimbólum|Leírás| 404 | |:----:|----| 405 | |?=|Positive Lookahead| 406 | |?!|Negative Lookahead| 407 | |?<=|Positive Lookbehind| 408 | |? 423 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 424 | 425 | 426 | [Teszteld a reguláris kifejezést](https://regex101.com/r/IDDARt/1) 427 | 428 | ### 4.2 Negative Lookahead 429 | 430 | A negatív előrenézést akkor használjuk, ha az olyan illeszkedések kellenek, 431 | amelyeket nem követ egy bizonyos minta. A negatív előrenézést ugyanúgy 432 | definiáljuk mint a pozitív előrenézést, az egyetlen különbség, hogy az 433 | egyenlőségjel `=` helyett negálást `!` használunk: `(?!...)`. Nézzük meg 434 | a következő kifejezést: `(T|t)he(?!\sfat)`, jelentése: szedd ki az összes 435 | `The` vagy `the` szót, amelyeket nem követ a `fat` szó (amit még megelőz 436 | egy szóköz). 437 | 438 |
439 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 440 |441 | 442 | [Teszteld a reguláris kifejezést](https://regex101.com/r/V32Npg/1) 443 | 444 | ### 4.3 Positive Lookbehind 445 | 446 | A pozitív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit 447 | egy megadott minta előz meg. A pozitív hátranézés így van jelölve: `(?<=...)`. 448 | A `(?<=(T|t)he\s)(fat|mat)` jelentése: szedd ki az összes `fat` vagy `mat` szót 449 | amelyek a `The` vagy a `the` szavak után vannak. 450 | 451 |
452 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 453 |454 | 455 | [Teszteld a reguláris kifejezést](https://regex101.com/r/avH165/1) 456 | 457 | ### 4.4 Negative Lookbehind 458 | 459 | A negatív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit nem 460 | egy megadott minta előz meg. Jelölése: `(? 465 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 466 | 467 | 468 | [Teszteld a reguláris kifejezést](https://regex101.com/r/8Efx5G/1) 469 | 470 | ## 5. Flag-ek 471 | 472 | A flag-eket módosítónak hívják, mert módosítják a reguláris kifejezés 473 | kimenetét. Ezeket a flag-eket bármilyen sorban vagy kombinációban lehet 474 | használni, a RegExp szerves részét képezik. 475 | 476 | |Flag|Leírás| 477 | |:----:|----| 478 | |i|Kis-nagybetű érzéketlen: Beállítja, hogy az illeszkedés kis-nagybetű érzéketlen legyen.| 479 | |g|Globális keresés: A bemeneti szövegben mindenütt keresi az illeszkedéseket.| 480 | |m|Többsoros: A horgonyok az összes sorra működnek.| 481 | 482 | ### 5.1 Kis-nagybetű érzéketlen 483 | 484 | Az `i` módosító beállítja, hogy az illeszkedés ne legyen kis-nagybetű érzékeny. 485 | Például a `/The/gi` kifejezés jelentése: nagybetűs `T` amit kisbetűs `h`, majd `e` 486 | követ. A kifejezés végén az `i` megmondja a reguláris kifejezés motornak, hogy 487 | hagyja figyelmen kívül a betűk méretét. Ahogy látod, megadtuk a `g` flag-et, mert 488 | az egész bemeneti szövegben akarjuk keresni az illeszkedéseket. 489 | 490 |
491 | "The" => The fat cat sat on the mat. 492 |493 | 494 | [Teszteld a reguláris kifejezést](https://regex101.com/r/dpQyf9/1) 495 | 496 |
497 | "/The/gi" => The fat cat sat on the mat. 498 |499 | 500 | [Teszteld a reguláris kifejezést](https://regex101.com/r/ahfiuh/1) 501 | 502 | ### 5.2 Globális keresés 503 | 504 | A `g` módosítót arra használjuk, hogy globálisan keressünk illeszkedéseket. 505 | (Megkeresi az összes előfordulást, nem áll meg az első egyezés után). Például 506 | a `/.(at)/g` kifejezés jelentése: minden karakter, kivéve a sortörést, amelyet 507 | `a` és `t` követ. Mivel megadtuk a `g` flag-et, az összes ilyenre fog illeszkedni, 508 | nem csak az elsőre (ami az alapértelmezett viselkedés). 509 | 510 |
511 | "/.(at)/" => The fat cat sat on the mat. 512 |513 | 514 | [Teszteld a reguláris kifejezést](https://regex101.com/r/jnk6gM/1) 515 | 516 |
517 | "/.(at)/g" => The fat cat sat on the mat. 518 |519 | 520 | [Teszteld a reguláris kifejezést](https://regex101.com/r/dO1nef/1) 521 | 522 | ### 5.3 Többsoros 523 | 524 | Az `m` módosítót a többsoros illeszkedésekhez használjuk. Ahogy előzőleg beszéltük, 525 | a horgonyokat `(^, $)` arra használjuk, hogy megnézzük, a minta az eleje, vagy a vége-e 526 | a vizsgált karakterláncnak. De ha azt szeretnénk, hogy a horgonyok az összes soron 527 | működjenek, használjuk az `m` módosítót. Például a `/at(.)?$/gm` kifejezés jelentése: 528 | kisbetűs `a` karakter, amit egy kisbetűs `t` követ, amit opcionálisan bármi követhet, 529 | kivéve sortörés. És az `m` flag miatt a reguláris kifejezés motor az összes sor 530 | végéig keres illeszkedést. 531 | 532 |
533 | "/.at(.)?$/" => The fat 534 | cat sat 535 | on the mat. 536 |537 | 538 | [Teszteld a reguláris kifejezést](https://regex101.com/r/hoGMkP/1) 539 | 540 |
541 | "/.at(.)?$/gm" => The fat 542 | cat sat 543 | on the mat. 544 |545 | 546 | [Teszteld a reguláris kifejezést](https://regex101.com/r/E88WE2/1) 547 | 548 | ## Hozzájárulás 549 | 550 | * Jelents hibákat 551 | * Nyiss pull request-eket fejlesztésekkel 552 | * Hírdesd az igét 553 | * Érj el közvetlenül itt: ziishaned@gmail.com vagy [](https://twitter.com/ziishaned) 554 | 555 | ## Licenc 556 | 557 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 558 | -------------------------------------------------------------------------------- /translations/README-ja.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
55 | 
56 |
98 | "the" => The fat cat sat on the mat. 99 |100 | 101 | [正規表現の動作確認をする](https://regex101.com/r/dmRygT/1) 102 | 103 | `123` という正規表現は `123` という文字列にマッチします。 104 | 正規表現は正規表現の文字列と入力文字列を1文字ずつ比較しながらマッチングを行います。 105 | また大文字と小文字は区別されるため、 `The` は `the` にはマッチしません。 106 | 107 |
108 | "The" => The fat cat sat on the mat. 109 |110 | 111 | [正規表現の動作確認をする](https://regex101.com/r/1paXsy/1) 112 | 113 | ## 2. メタ文字 114 | 115 | メタ文字は正規表現の構成要素として使用される文字のことです。 116 | メタ文字はそれ自身が示す文字を表すものではなく、特別な解釈がなされます。 117 | 一部のメタ文字は角括弧内に記述されることで特別な意味を持つものもあります。 118 | メタ文字には次のようなものがあります。 119 | 120 | |メタ文字|説明 | 121 | |:------:|---------------------------------------------------------------------------------------------| 122 | |. |ピリオド。改行を除く任意の1文字にマッチ。 | 123 | |[ ] |文字集合。角括弧内の任意の文字にマッチ。 | 124 | |[^ ] |否定文字集合。角括弧内に含まれない任意の文字にマッチ。 | 125 | |* |直前の文字の 0 個以上の並びにマッチ。 | 126 | |+ |直前の文字の 1 個以上の並びにマッチ。 | 127 | |? |直前の文字がオプションであるとみなす。 | 128 | |{n,m} |括弧でくくる。直前の文字が n 個以上 m 個以下続く場合にマッチ。 | 129 | |(xyz) |文字グループ。 xyz という文字列がその順に現れる場合にマッチ。 | 130 | || |選言。記号の前後の文字列どちらかにマッチ。 | 131 | |\ |次に来る文字をエスケープする。予約語
[ ] ( ) { } . * + ? ^ $ \ | にマッチ。|
132 | |^ |入力値の開始にマッチする。 |
133 | |$ |入力値の終了にマッチする。 |
134 |
135 | ## 2.1 ピリオド
136 |
137 | ピリオド `.` は最もシンプルなメタ文字の例です。
138 | メタ文字 `.` は任意の 1 文字にマッチします。
139 | キャリッジリターンと改行にはマッチしません。
140 | 例えば `.ar` は任意の文字の後に `a` と `r` が続く文字列にマッチします。
141 |
142 | 143 | ".ar" => The car parked in the garage. 144 |145 | 146 | [正規表現の動作確認をする](https://regex101.com/r/xc9GkU/1) 147 | 148 | ## 2.2 文字集合 149 | 150 | 文字集合は文字クラスとも呼ばれます。 151 | 文字集合を指定するには角括弧でくくります。 152 | 文字の範囲を指定するにはハイフンを使用します。 153 | 角括弧内の文字の記述順はマッチングには関係ありません。 154 | 例えば `[Tt]he` という正規表現は大文字 `T` または小文字 `t` の後に `h`, `e` が続く文字列を表します。 155 | 156 |
157 | "[Tt]he" => The car parked in the garage. 158 |159 | 160 | [正規表現の動作確認をする](https://regex101.com/r/2ITLQ4/1) 161 | 162 | 文字集合内でのピリオドは文字としてのピリオドを表します。 163 | `ar[.]` という正規表現は `a` という文字のあとに `r` が続き、さらに `.` という文字が続く文字列を表します。 164 | 165 |
166 | "ar[.]" => A garage is a good place to park a car. 167 |168 | 169 | [正規表現の動作確認をする](https://regex101.com/r/wL3xtE/1) 170 | 171 | ### 2.2.1 否定文字集合 172 | 173 | 通常キャレットは文字列の開始を意味するメタ文字ですが、角括弧内で最初に使用されると 174 | 文字集合を否定する意味を持つようになります。 175 | 例えば `[^c]ar` という正規表現は `c` 以外の任意の文字列の後に 176 | `a`, `r` が続く文字列を表します。 177 | 178 |
179 | "[^c]ar" => The car parked in the garage. 180 |181 | 182 | [正規表現の動作確認をする](https://regex101.com/r/nNNlq3/1) 183 | 184 | ## 2.3 繰り返し 185 | 186 | `+`, `*`, `?` はパターンが何回続くのかを指定するためのメタ文字になります。 187 | これらのメタ文字は異なるシチュエーションで異なる振る舞いをします。 188 | 189 | ### 2.3.1 アスタリスク 190 | 191 | シンボル `*` は直前の文字が 0 個以上続くパターンにマッチします。 192 | `a*` という正規表現は小文字の `a` が 0 個以上続くことを意味します。 193 | しかし文字集合またはクラスの後に現れた場合はその文字集合すべてが続くことを意味します。 194 | 例えば `[a-z]*` という正規表現は行内の任意の小文字の列を表します。 195 | 196 |
197 | "[a-z]*" => The car parked in the garage #21. 198 |199 | 200 | [正規表現の動作確認をする](https://regex101.com/r/7m8me5/1) 201 | 202 | シンボル `*` はメタ文字 `.` と合わせて `.*` のように使用することで 203 | 任意の文字列を表現できます。 204 | またスペースを表す `\s` と併用することで空白文字を表現できます。 205 | 例えば `\s*cat\s*` という正規表現は 0 個以上のスペースの後に 206 | 小文字の `c`, `a`, `t` が続き、その後に 0 個以上のスペースが続きます。 207 | 208 |
209 | "\s*cat\s*" => The fat cat sat on the concatenation. 210 |211 | 212 | [正規表現の動作確認をする](https://regex101.com/r/gGrwuz/1) 213 | 214 | ### 2.3.2 プラス記号 215 | 216 | シンボル `+` は直前の文字が 1 個以上続くパターンにマッチします。 217 | 例えば `c.+t` という正規表現は小文字の `c` の後に 218 | 任意の 1 文字以上が続き、さらに `t` が続くことを意味します。 219 | この `t` は、その文における最後の `t` がマッチします。 220 | 221 |
222 | "c.+t" => The fat cat sat on the mat. 223 |224 | 225 | [正規表現の動作確認をする](https://regex101.com/r/Dzf9Aa/1) 226 | 227 | ### 2.3.3 疑問符 228 | 229 | 正規表現におけるメタ文字 `?` は直前の文字がオプションであることを意味します。 230 | すなわち直前の文字が 0 個または 1 個現れることを意味します。 231 | 例えば `[T]?he` という正規表現は大文字の `T` が 0 個または 1 個出現し、 232 | その後に小文字の `h`, `e` が続くことを意味します。 233 | 234 |
235 | "[T]he" => The car is parked in the garage. 236 |237 | 238 | [正規表現の動作確認をする](https://regex101.com/r/cIg9zm/1) 239 | 240 |
241 | "[T]?he" => The car is parked in the garage. 242 |243 | 244 | [正規表現の動作確認をする](https://regex101.com/r/kPpO2x/1) 245 | 246 | ## 2.4 括弧 247 | この`t`は、その文における最後の`t`であることが明確である必要があります。 248 | 249 | 正規表現における括弧は数量子とも呼ばれますが、文字列がいくつ現れるかを示すために使用されます。 250 | 例えば、`[0-9]{2,3}` という正規表現は 2 桁以上 3 桁以下の数字 251 | （0 から 9 の数字で表された文字列）にマッチします。 252 | 253 |
254 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
255 |
256 |
257 | [正規表現の動作確認をする](https://regex101.com/r/juM86s/1)
258 |
259 | 2つ目の数値は省略できます。
260 | 例えば `[0-9]{2,}` という正規表現は 2 桁以上の数字を意味します。
261 | カンマも省略することができ、その場合 `[0-9]{3}` という正規表現はちょうど 3 桁の数字を意味します。
262 |
263 |
264 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
265 |
266 |
267 | [正規表現の動作確認をする](https://regex101.com/r/Gdy4w5/1)
268 |
269 |
270 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
271 |
272 |
273 | [正規表現の動作確認をする](https://regex101.com/r/Sivu30/1)
274 |
275 | ## 2.5 文字グループ
276 |
277 | 文字グループは括弧 `(...)` 内にパターンを記述してグループ分けをするために使用します。
278 | 前述の通り、正規表現においては数量子を文字の後に置いた場合は
279 | その直前の文字の繰り返しを意味します。しかし、文字グループの後に数量子を置いた場合は
280 | 文字グループ全体が繰り返すことを意味します。
281 | 例えば、 `(ab)*` という正規表現は "ab" という文字列の 0 個以上の繰り返しにマッチします。
282 | 文字グループ内では選言 `|` も使用することができます。
283 | 例えば、`(c|g|p)ar` という正規表現は小文字の `c`, `g`, `p` のいずれかの後に
284 | `a` が続き、さらに `r` が続くことを意味します。
285 |
286 | 287 | "(c|g|p)ar" => The car is parked in the garage. 288 |289 | 290 | [正規表現の動作確認をする](https://regex101.com/r/tUxrBG/1) 291 | 292 | ## 2.6 選言 293 | 294 | 正規表現における縦棒 `|` は選言として使用されます。 295 | 選言は複数の正規表現からなる条件式のようなものです。 296 | もしかすると文字集合と選言が同じものと感じるかもしれません。 297 | この 2 つの大きな違いは文字集合は文字単位で評価されるのに対して選言は正規表現単位で評価されます。 298 | 例えば `(T|t)he|car` という正規表現は大文字の `T` または小文字の `t` の後に 299 | 小文字の `h`, `e` が続くか、または小文字の `c` の後に `a`, `r` が続くことを意味します。 300 | 301 |
302 | "(T|t)he|car" => The car is parked in the garage. 303 |304 | 305 | [正規表現の動作確認をする](https://regex101.com/r/fBXyX0/1) 306 | 307 | ## 2.7 特殊文字をエスケープする 308 | 309 | バックスラッシュ `\` は正規表現内で次に来る文字をエスケープするために使用されます。 310 | これを使うと予約語 `{ } [ ] / \ + * . $ ^ | ?` を 311 | 記号として指定できるようになります。 312 | 例えば `.` という正規表現は改行を除く任意の文字として使用されますが、 313 | `(f|c|m)at\.?` という正規表現では `.` 自体にマッチします。 314 | この正規表現は小文字の `f`, `c` または `m` の後に小文字の `a`, `t` が続き、 315 | さらに `.` が 0 個または 1 個続きます。 316 | 317 |
318 | "(f|c|m)at\.?" => The fat cat sat on the mat. 319 |320 | 321 | [正規表現の動作確認をする](https://regex101.com/r/DOc5Nu/1) 322 | 323 | ## 2.8 アンカー 324 | 325 | 正規表現内でマッチング文字列の開始または終了であることをチェックするために 326 | アンカーを使うことができます。 327 | アンカーには 2 種類あり、1 つ目が開始を表すキャレット `^`、 328 | 2 つ目が終了を表すドル記号 `$` です。 329 | 330 | ### 2.8.1 キャレット 331 | 332 | キャレット `^` は文字列の開始かどうかを調べるために使用します。 333 | 次の正規表現 `^a` は入力文字列 `abc` に対して（a が開始文字列なら）`a` にマッチします。 334 | しかし `^b` という正規表現は前の文字列に対してはどれにもマッチしません。 335 | "b" は `abc` という入力文字列の開始ではないからです。 336 | 他の例を見てみます。`^(T|t)he` は大文字の `T` または小文字の `t` から始まる文字列で 337 | その後に小文字の `h`, `e` が続くことを意味します。 338 | 339 |
340 | "(T|t)he" => The car is parked in the garage. 341 |342 | 343 | [正規表現の動作確認をする](https://regex101.com/r/5ljjgB/1) 344 | 345 |
346 | "^(T|t)he" => The car is parked in the garage. 347 |348 | 349 | [正規表現の動作確認をする](https://regex101.com/r/jXrKne/1) 350 | 351 | ### 2.8.2 ドル記号 352 | 353 | ドル記号 `$` は文字列の終了かどうかを調べるために使用します。 354 | 例えば `(at\.)$` という正規表現は小文字の `a` の後に 355 | 小文字の `t` が続き、最後は `.` で終わることを意味しています。 356 | 357 |
358 | "(at\.)" => The fat cat. sat. on the mat. 359 |360 | 361 | [正規表現の動作確認をする](https://regex101.com/r/y4Au4D/1) 362 | 363 |
364 | "(at\.)$" => The fat cat. sat. on the mat. 365 |366 | 367 | [正規表現の動作確認をする](https://regex101.com/r/t0AkOd/1) 368 | 369 | ## 3. 文字集合の短縮表記 370 | 371 | 正規表現ではよく使われる文字集合に対して短縮表記が提供されており、 372 | 便利なショートカットとして使用できます。 373 | 短縮表記には次のようなものがあります。 374 | 375 | |短縮表記|説明 | 376 | |:------:|-----------------------------------| 377 | |. |改行を除く任意の文字 | 378 | |\w |英数字にマッチ: `[a-zA-Z0-9_]` | 379 | |\W |英数字以外にマッチ: `[^\w]` | 380 | |\d |数字にマッチ: `[0-9]` | 381 | |\D |数字以外にマッチ: `[^\d]` | 382 | |\s |スペースにマッチ: `[\t\n\f\r\p{Z}]`| 383 | |\S |スペース以外にマッチ: `[^\s]` | 384 | 385 | ## 4. 前後参照 386 | 387 | 先読みと後読み（前後参照とも呼ばれます）は **非キャプチャグループ** 388 | （パターンのマッチングはするがマッチングリストには含まれない）という 389 | 特殊な扱いがなされる機能です。 390 | 前後参照はあるパターンが別のあるパターンよりも先行または後続して現れることを示すために使用されます。 391 | 例えば入力文字列 `$4.44 and $10.88` に対して `$` に続く全ての数字を取得することを考えます。 392 | そのためには `(?<=\$)[0-9\.]*` という正規表現を使用します。 393 | これは `$` に続き `.` を含む全ての数字を指すことになります。 394 | 次のような前後参照が正規表現で使用されます。 395 | 396 | |記号 |説明 | 397 | |:----:|--------------| 398 | |?= |肯定的な先読み| 399 | |?! |否定的な先読み| 400 | |?<= |肯定的な後読み| 401 | |? 415 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 416 | 417 | 418 | [正規表現の動作確認をする](https://regex101.com/r/IDDARt/1) 419 | 420 | ### 4.2 否定的な先読み 421 | 422 | 否定的な先読みはあるパターンが後続しない全てのマッチング文字列を取得するために使用します。 423 | 否定的な先読みは肯定的な先読みと同じように定義しますが、 `=` の代わりに 424 | `!` を使うところが唯一の違いで、`(?!...)` と記述します。 425 | 次の正規表現 `(T|t)he(?!\sfat)` について考えてみます。 426 | これはスペースを挟んで `fat` が後続することがない全ての `The` または `the` を得ることができます。 427 | 428 |
429 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 430 |431 | 432 | [正規表現の動作確認をする](https://regex101.com/r/V32Npg/1) 433 | 434 | ### 4.3 肯定的な後読み 435 | 436 | 肯定的な後読みは特定のパターンが先行するような文字列を得るために使用します。 437 | 定義の仕方は `(?<=...)` とします。 438 | 例えば `(?<=(T|t)he\s)(fat|mat)` という正規表現は 439 | `The` または `the` の後に続く全ての `fat` または `mat` が取得できます。 440 | 441 |
442 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 443 |444 | 445 | [正規表現の動作確認をする](https://regex101.com/r/avH165/1) 446 | 447 | ### 4.4 否定的な後読み 448 | 449 | 否定的な後読みは特定のパターンが先行しない全ての文字列を得るために使用します。 450 | 定義の仕方は `(?)` とします。 451 | 例えば `(? 454 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 455 | 456 | 457 | [正規表現の動作確認をする](https://regex101.com/r/8Efx5G/1) 458 | 459 | ## 5. フラグ 460 | 461 | フラグは修飾子とも呼ばれ、正規表現の結果を修正するために使用されます。 462 | フラグは任意の順序・組み合わせで使用でき、正規表現では必要不可欠な機能です。 463 | 464 | |フラグ|説明 | 465 | |:----:|------------------------------------------------------------------------| 466 | |i |大文字・小文字を区別しない: マッチングで大文字・小文字が区別されなくなる| 467 | |g |グローバル検索: 入力文字列の全マッチ列を検索する | 468 | |m |複数行: 複数行をマッチさせるためのアンカー | 469 | 470 | ### 5.1 大文字・小文字を区別しない 471 | 472 | 修飾子 `i` は大文字・小文字を区別したくないときに使用します。 473 | 例えば `/The/gi` という正規表現は大文字の `T` の後に小文字の `h`, `e` が続くという意味ですが、 474 | 最後の `i` で大文字・小文字を区別しない設定にしています。 475 | 文字列内の全マッチ列を検索したいのでフラグ `g` も渡しています。 476 | 477 |
478 | "The" => The fat cat sat on the mat. 479 |480 | 481 | [正規表現の動作確認をする](https://regex101.com/r/dpQyf9/1) 482 | 483 |
484 | "/The/gi" => The fat cat sat on the mat. 485 |486 | 487 | [正規表現の動作確認をする](https://regex101.com/r/ahfiuh/1) 488 | 489 | ### 5.2 グローバル検索 490 | 491 | 修飾子 `g` はグローバル検索（最初のマッチ列を検索する代わりに全マッチ列を検索する）を 492 | 行うために使用します。 493 | 例えば `/.(at)/g` という正規表現は、改行を除く任意の文字列の後に 494 | 小文字の `a`, `t` が続きます。正規表現の最後にフラグ `g` を渡すことで、 495 | 最初のマッチだけではなく（これがデフォルトの動作です）、入力文字列内の全マッチ列を検索するようにしています。 496 | 497 |
498 | "/.(at)/" => The fat cat sat on the mat. 499 |500 | 501 | [正規表現の動作確認をする](https://regex101.com/r/jnk6gM/1) 502 | 503 |
504 | "/.(at)/g" => The fat cat sat on the mat. 505 |506 | 507 | [正規表現の動作確認をする](https://regex101.com/r/dO1nef/1) 508 | 509 | ### 5.3 複数行 510 | 511 | 修飾子 `m` は複数行でマッチさせたいときに使用します。 512 | 前述で `(^, $)` という入力文字列の開始と終了を示すためのアンカーについて説明しましたが、 513 | フラグ `m` は複数行でマッチさせるためのアンカーとして使用できます。 514 | 例えば `/at(.)?$/gm` という正規表現は小文字の `a`, `t` に続き、改行を除く 515 | 任意の文字が 0 個または 1 個続くという意味ですが、 516 | フラグ `m` を渡すことで入力文字列の各行でパターンを検索させることができます。 517 | 518 |
519 | "/.at(.)?$/" => The fat 520 | cat sat 521 | on the mat. 522 |523 | 524 | [正規表現の動作確認をする](https://regex101.com/r/hoGMkP/1) 525 | 526 |
527 | "/.at(.)?$/gm" => The fat 528 | cat sat 529 | on the mat. 530 |531 | 532 | [正規表現の動作確認をする](https://regex101.com/r/E88WE2/1) 533 | 534 | ## 貢献する 535 | 536 | * イシューを発行する 537 | * 修正をプルリクエストする 538 | * ドキュメントを普及させる 539 | * 作者に直接連絡を取る: ziishaned@gmail.com または [](https://twitter.com/ziishaned) 540 | 541 | ## ライセンス 542 | 543 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 544 | -------------------------------------------------------------------------------- /translations/README-ko.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
49 |
50 |
91 | "the" => The fat cat sat on the mat. 92 |93 | 94 | [Test the regular expression](https://regex101.com/r/dmRygT/1) 95 | 96 | 정규 표현식 `123`은 문자열 `123`에 매칭된다. 정규 표현식은 정규 표현식의 각 문자(Character)와 입력된 문자열의 각 문자(Character)를 비교함으로써 해당 문자열과 매칭된다. 정규 표현식들은 일반적으로 대소문자를 구분하기 때문에, 정규 표현식 `The`는 문자열 `the`와 매칭되지 않는다. 97 | 98 |
99 | "The" => The fat cat sat on the mat. 100 |101 | 102 | [Test the regular expression](https://regex101.com/r/1paXsy/1) 103 | 104 | ## 2. 메타 문자 105 | 106 | 메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 아래는 이러한 메타 문자열들이다: 107 | 108 | |메타 문자|설명| 109 | |:----:| ----| 110 | |.|온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.| 111 | |[ ]|문자 클래스. 대괄호 사이에 있는 문자들로 매치.| 112 | |[^ ]|부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.| 113 | |\*|이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.| 114 | |+|이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.| 115 | |?|이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.| 116 | |{n,m}|중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.| 117 | |(xyz)|문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.| 118 | |||대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.| 119 | |\|다음 문자 이스케이프(Escape). 예약된 문자열들
[ ] ( ) { } . \* + ? ^ \$ \ |을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
120 | |^|입력의 시작과 매치.|
121 | |\$|입력의 끝과 매치.|
122 |
123 | ## 2.1 마침표
124 |
125 | 마침표(`.`)는 메타 문자의 가장 간단한 예다. 메타 문자 `.`는 어떠한 단일 문자와도 매치되지만 리턴 혹은 개행 문자와는 매치되지 않는다. 예를 들어, 정규 표현식 `.ar`은 어떠한 단일 문자 다음에 문자 `a`가 오고, 그 다음에 문자 `r`이 오는 패턴을 의미한다.
126 |
127 | 128 | ".ar" => The car parked in the garage. 129 |130 | 131 | [Test the regular expression](https://regex101.com/r/xc9GkU/1) 132 | 133 | ## 2.2 문자 집합 134 | 135 | 문자 집합은 문자 클래스라고도 불린다. 대괄호는 이 문자 집합을 명시하기 위해 사용된다. 문자열 집합내에 사용된 하이픈은 문자들의 범위를 지정하는데 사용된다. 대괄호 내부에 명시된 문자들의 순서는 중요하지 않다. 예를 들어, 정규 표현식 `[Tt]he`는 대문자 `T` 혹은 소문자 `t`가 나온 다음에, 문자 `h`가 나오고 그 뒤에 문자 `e`가 나오는 패턴을 의미한다. 136 | 137 |
138 | "[Tt]he" => The car parked in the garage. 139 |140 | 141 | [Test the regular expression](https://regex101.com/r/2ITLQ4/1) 142 | 143 | 하지만, 문자 집합 내부에서 사용되는 온점(Period)은 온점 그 자체를 의미한다. 정규 표현식 `ar[.]`은 소문자 `a` 다음에 문자 `r`이 오고 그 뒤에 문자 `.`이 오는 패턴을 의미한다. 144 | 145 |
146 | "ar[.]" => A garage is a good place to park a car. 147 |148 | 149 | [Test the regular expression](https://regex101.com/r/wL3xtE/1) 150 | 151 | ### 2.2.1 부정 문자 집합 152 | 153 | 일반적으로, 캐럿 기호(^)는 문자열의 시작지점을 나타내지만, 왼쪽 대괄호 바로 뒤에 위치했을때는 해당 문자 집합의 부정(negation)을 나타낸다. 예를 들어, 정규 표현식 `[^c]ar`은 문자 `c`를 제외한 어떠한 문자뒤에 문자 `a`가 오고, 그 뒤에 문자 `r`이 오는 패턴을 의미한다. 154 | 155 |
156 | "[^c]ar" => The car parked in the garage. 157 |158 | 159 | [Test the regular expression](https://regex101.com/r/nNNlq3/1) 160 | 161 | ## 2.3 반복 162 | 163 | 메타 문자 `+`, `*` 또는 `?`은 하위패턴(subpattern)이 몇 번 발생하는지 지정하는데 사용된다. 이러한 메타 문자들은 상황에 따라 다르게 동작한다. 164 | 165 | ### 2.3.1 별 부호 166 | 167 | `*` 부호는 부호 앞에 위치한 매처(matcher)가 0번 이상 반복된 문자열과 매치된다. 정규 표현식 `a*`은 소문자 `a`가 0번 이상 반복되는 패턴을 의미한다. 하지만, 만약 이 별 부호가 문자 집합(character set) 직후에 나오는 경우에는 문자 집합 전체의 반복을 찾게된다. 예를 들어, 정규 표현식 `[a-z]*`은 소문자들이 갯수와 상관없이 연속으로 반복되는 패턴을 의미한다. 168 | 169 |
170 | "[a-z]*" => The car parked in the garage #21. 171 |172 | 173 | [Test the regular expression](https://regex101.com/r/7m8me5/1) 174 | 175 | `*` 부호는 메타 문자 `.`와 함께 모든 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 또한, `*` 부호는 공백 문자 `\s`와 함께 공백 문자들로 이루어진 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 예를 들어, 정규 표현식 `\s*cat\s*`는 0번 이상 공백문자가 나온 이후에 소문자 `c`, 소문자 `a`, 소문자 `t`가 자체로 나오고 그 뒤에 다시 0번 이상의 공백문자가 나오는 패턴을 의미한다. 176 | 177 |
178 | "\s*cat\s*" => The fat cat sat on the concatenation. 179 |180 | 181 | [Test the regular expression](https://regex101.com/r/gGrwuz/1) 182 | 183 | ### 2.3.2 덧셈 부호 184 | 185 | `+` 부호는 부호 앞에 위치한 문자가 한번 이상 반복되는 패턴을 만드는데 사용된다. 예를 들어, 정규 표현식 `c.+t`는 소문자 `c`가 나오고, 그 뒤에 한개 이상의 문자가 나온 후, 소문자 `t`가 나오는 패턴을 의미한다. 여기서 문자 `t`는 해당 문장의 제일 마지막 글자 `t`라는것을 명확히할 필요가 있다. 186 | 187 |
188 | "c.+t" => The fat cat sat on the mat. 189 |190 | 191 | [Test the regular expression](https://regex101.com/r/Dzf9Aa/1) 192 | 193 | ### 2.3.3 물음표 194 | 195 | 정규 표현식에서 메타 문자 `?`는 선행 문자를 선택적으로 만드는 역할을 한다. 물음표는 부호 앞에 쓰여진 문자가 선택적으로 나오는 패턴을 나타내는데 사용된다. 예를 들어, 정규 표현식 `[T]?he`는 대문자 `T`가 선택적으로 나온 이후에, 그 뒤에 소문자 `h`, 그 뒤에 소문자 `e`가 나오는 패턴을 의미한다. 196 | 197 |
198 | "[T]he" => The car is parked in the garage. 199 |200 | 201 | [Test the regular expression](https://regex101.com/r/cIg9zm/1) 202 | 203 |
204 | "[T]?he" => The car is parked in the garage. 205 |206 | 207 | [Test the regular expression](https://regex101.com/r/kPpO2x/1) 208 | 209 | ## 2.4 중괄호 210 | 211 | 정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다. 212 | 213 |
214 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
215 |
216 |
217 | [Test the regular expression](https://regex101.com/r/juM86s/1)
218 |
219 | 두번째 숫자를 생략하는 것이 가능하다. 예를 들어, 정규 표현식 `[0-9]{2,}`는 2번 이상의 숫자가 연속으로 나오는 패턴을 의미한다. 만약 여기서 쉼표를 삭제하는 경우, 정규 표현식 `[0-9]{3}`은 숫자가 정확히 3번 연속해서 나오는 패턴을 의미한다.
220 |
221 |
222 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
223 |
224 |
225 | [Test the regular expression](https://regex101.com/r/Gdy4w5/1)
226 |
227 |
228 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
229 |
230 |
231 | [Test the regular expression](https://regex101.com/r/Sivu30/1)
232 |
233 | ## 2.5 캡쳐링 그룹
234 |
235 | 캡쳐링 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자 뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 캡쳐링 그룹 뒤에 정량자를 넣는 경우에는 캡쳐링 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
236 |
237 | 238 | "(c|g|p)ar" => The car is parked in the garage. 239 |240 | 241 | [Test the regular expression](https://regex101.com/r/tUxrBG/1) 242 | 243 | 캡처링 그룹은 부모 언어에서 사용하기 위해 문자를 일치시킬뿐만 아니라 문자를 캡처한다는 점에 유의해야 한다. 부모 언어는 파이썬이나 자바 스크립트 또는 함수 정의에서 정규 표현식을 구현하는 거의 모든 언어가 될 수 있다. 244 | 245 | ### 2.5.1 논-캡쳐링 그룹 246 | 247 | 논-캡쳐링 그룹은 오직 문자열에 매칭되지만, 그룹을 캡쳐하지 않는 캡쳐링 그룹이다. 논-캡쳐링 그룹은 `(...)` 괄호안에 `?:` 로 표시된다. 예를 들어 정규식 `(?:c|g|p)ar` 는 `(c|g|p)ar`와 같은 문자열을 매칭하는 것에서 유사하지만, 캡쳐링 그룹을 만들지 않는다. 248 | 249 |
250 | "(?:c|g|p)ar" => The car is parked in the garage. 251 |252 | 253 | [Test the regular expression](https://regex101.com/r/Rm7Me8/1) 254 | 255 | 논-캡처링 그룹은 찾기 및 변경 기능에서 사용하거나 캡처 그룹 함께 사용하여 다른 종류의 출력 생성시 overview를 유지할 때 유용하다. 또한 [4. 전후방탐색](#4-전후방탐색)를 보아라. 256 | 257 | ## 2.6 대안 부호 258 | 259 | 정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합(Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다. 260 | 261 |
262 | "(T|t)he|car" => The car is parked in the garage. 263 |264 | 265 | [Test the regular expression](https://regex101.com/r/fBXyX0/1) 266 | 267 | ## 2.7 특수 문자 이스케이핑 268 | 269 | 백 슬래시 `\`는 정규 표현식에서 다음에 나오는 부호를 이스케이핑하는데 사용된다. 백 슬래시는 예약 문자들인 `{ } [ ] / \ + * . $ ^ | ?`를 메타 부호가 아닌 문자 그 자체로 매칭되도록 명시한다. 특수 문자를 매칭 캐릭터로 사용하기 위해서는 백 슬래시 `\`를 해당 특수 문자 앞에 붙이면 된다. 예를 들어, 정규 표현식 `.`은 개행을 제외한 어떤 문자와 매칭된다. 입력 문자열에 포함된 `.` 문자를 매치시키는 정규 표현식 `(f|c|m)at\.?`은 소문자 `f`, `c` 또는 `m` 이후에 소문자 `a`와 `t`가 차례로 등장하고 이후에 문자 `.`가 선택적으로 나타나는 패턴을 의미한다. 270 | 271 |
272 | "(f|c|m)at\.?" => The fat cat sat on the mat. 273 |274 | 275 | [Test the regular expression](https://regex101.com/r/DOc5Nu/1) 276 | 277 | ## 2.8 앵커 부호 278 | 279 | 정규 표현식에서 앵커는 매칭 문자가 표현식의 시작 문자인지 혹은 끝 문자인지 명시하는데 사용된다. 앵커는 두가지 종류가 있다: 첫번째 종류인 캐럿 부호 `^`는 매칭 문자가 입력 문자열의 첫 시작 문자인지 나타내는데 사용되며 두번째 종류인 달러 부호 `$`는 해당 매칭 문자가 입력 문자의 마지막 문자라는 것을 명시하는데 사용된다. 280 | 281 | ### 2.8.1 캐럿 부호 282 | 283 | 캐럿 부호 `^`는 매칭 문자가 표현식의 시작이라는 것을 명시하는데 사용된다. 만약 (a가 시작 문자인지 확인하는) 정규 표현식 `^a`를 입력 문자열 `abc`에 적용하면, 이 정규 표현식은 `a`를 매칭 결과값으로 내보낸다. 반면, 정규 표현식 `^b`를 위의 입력 문자열에 적용하면, 아무런 매칭도 일어나지 않는다. 왜냐하면 입력 문자열 `abc`에서 "b"는 처음 시작 문자가 아니기 때문이다. 또 다른 정규 표현식인 `^(T|t)he`를 살펴보자. 이 정규 표현식은 대문자 `T` 또는 소문자 `t`가 입력 문자열의 시작으로 나오고, 그 뒤에 문자 `h`와 문자 `e`가 차례로 나오는 패턴을 의미한다. 284 | 285 |
286 | "(T|t)he" => The car is parked in the garage. 287 |288 | 289 | [Test the regular expression](https://regex101.com/r/5ljjgB/1) 290 | 291 |
292 | "^(T|t)he" => The car is parked in the garage. 293 |294 | 295 | [Test the regular expression](https://regex101.com/r/jXrKne/1) 296 | 297 | ### 2.8.2 달러 부호 298 | 299 | 달러 부호 `$`는 입력 문자열의 마지막 문자가 매칭 문자로 끝나는지 확인하는데 사용된다. 예를 들어, 정규 표현식 `(at\.)$`는 소문자 `a`와 `t` 그리고 문자 `.`가 순서대로 입력 문자열의 맨 마지막에 나오는지 확인하는 패턴을 의미한다. 300 | 301 |
302 | "(at\.)" => The fat cat. sat. on the mat. 303 |304 | 305 | [Test the regular expression](https://regex101.com/r/y4Au4D/1) 306 | 307 |
308 | "(at\.)$" => The fat cat. sat. on the mat. 309 |310 | 311 | [Test the regular expression](https://regex101.com/r/t0AkOd/1) 312 | 313 | ## 3. 단축형 문자열 집합 314 | 315 | 정규 표현식은 일반적으로 사용되는 문자열 집합들을 간편하게 사용할 수 있도록 여러 단축형들을 제공한다. 단축형 문자열 집합은 아래와 같다. 316 | 317 | |단축형|설명| 318 | |:----:|----| 319 | |.|개행을 제외한 모든 문자| 320 | |\w|영숫자 문자와 매치: `[a-zA-Z0-9_]`| 321 | |\W|영숫자 문자가 아닌 문자와 매치: `[^\w]`| 322 | |\d|숫자와 매치: `[0-9]`| 323 | |\D|숫자가 아닌 문자와 매치: `[^\d]`| 324 | |\s|공백 문자와 매치: `[\t\n\f\r\p{Z}]`| 325 | |\S|공백 문자가 아닌 문자와 매치: `[^\s]`| 326 | 327 | ## 4. 전후방탐색 328 | 329 | 때때로 전후방탐색Lookaround이라고 알려진 후방탐색Lookbehind과 전방탐색Lookahead은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) **_넌-캡쳐링 그룹_** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$)[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다. 330 | 331 | |부호|설명| 332 | |:----:|----| 333 | |?=|긍정형 전방탐색| 334 | |?!|부정형 전방탐색| 335 | |?<=|긍정형 후방탐색| 336 | |? 343 | "[T|t]he(?=\sfat)" => The fat cat sat on the mat. 344 | 345 | 346 | [Test the regular expression](https://regex101.com/r/IDDARt/1) 347 | 348 | ### 4.2 부정형 전방탐색 349 | 350 | 부정형 전방탐색는 입력 문자열로부터 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 전방탐색는 우리가 긍정형 전방탐색를 정의하는 방식과 동일하게 정의된다. 하지만, 유일한 차이점은 등호 부호 `=` 대신 부정 부호 `!` 문자를 사용한다는 것이다, 즉 `(?!...)`. 정규 표현식 `[T|t]he(?!\sfat)`를 살펴보도록 하자. 이 정규 표현식은 공백 문자와 `fat` 문자열이 연속으로 나오지 않는 모든 `The` 혹은 `the` 문자열과 매치된다. 351 | 352 |
353 | "[T|t]he(?!\sfat)" => The fat cat sat on the mat. 354 |355 | 356 | [Test the regular expression](https://regex101.com/r/V32Npg/1) 357 | 358 | ### 4.3 긍정형 후방탐색 359 | 360 | 긍정형 후방탐색는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 후방탐색는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다. 361 | 362 |
363 | "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat. 364 |365 | 366 | [Test the regular expression](https://regex101.com/r/avH165/1) 367 | 368 | ### 4.4 부정형 후방탐색 369 | 370 | 부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(? 373 | "(?<![T|t]he\s)(cat)" => The cat sat on cat. 374 | 375 | 376 | [Test the regular expression](https://regex101.com/r/8Efx5G/1) 377 | 378 | ## 5. 플래그 379 | 380 | 플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용 가능하며 정규 표현식의 일부분이다. 381 | 382 | |플래그|설명| 383 | |:----:|----| 384 | |i|대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정.| 385 | |g|전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.| 386 | |m|멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.| 387 | 388 | ### 5.1 대소문자 구분없음 389 | 390 | 수정자 `i`는 대소문자 구분없는 매칭을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/The/gi`는 대문자 `T`, 소문자 `h`, 소문자 `e`가 차례로 나오는 패턴을 의미한다. 여기서 정규 표현식 마지막에 있는 `i` 플래그가 정규 표현식 엔진에게 대소문자를 구분하지 않도록 알려준다. `g` 플래그는 전체 입력 문자열 내부에서 패턴을 검색하기 위해 설정되었다. 391 | 392 |
393 | "The" => The fat cat sat on the mat. 394 |395 | 396 | [Test the regular expression](https://regex101.com/r/dpQyf9/1) 397 | 398 |
399 | "/The/gi" => The fat cat sat on the mat. 400 |401 | 402 | [Test the regular expression](https://regex101.com/r/ahfiuh/1) 403 | 404 | ### 5.2 전체 검색 405 | 406 | 수정자 `g`는 첫번째 매칭후에 멈추지 않고 계속해서 모든 매칭을 검색하는 전체 검색을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/.(at)/g`는 개행을 제외한 문자가 나오고, 그 뒤에 소문자 `a`, 소문자 `t`가 나오는 패턴을 의미한다. 여기에서 `g` 플래그를 정규 표현식의 마지막에 설정했기 때문에, 이 패턴은 입력 문자열 전체에서 나타나는 모든 패턴을 찾아낸다. 407 | 408 |
409 | "/.(at)/" => The fat cat sat on the mat. 410 |411 | 412 | [Test the regular expression](https://regex101.com/r/jnk6gM/1) 413 | 414 |
415 | "/.(at)/g" => The fat cat sat on the mat. 416 |417 | 418 | [Test the regular expression](https://regex101.com/r/dO1nef/1) 419 | 420 | ### 5.3 멀티 라인 421 | 422 | 수정자 `m`은 멀티 라인 매치를 수행하는데 사용된다. 이전에 이야기 했던 것처럼, 앵커 `(^, $)`는 패턴의 시작과 끝을 확인하는데 사용된다. 하지만 만약 우리가 각 라인마다 이 앵커가 동작하게하고 싶으면 `m` 플래그를 설정하면된다. 예를 들어, 정규 표현식 `/at(.)?$/gm`은 소문자 `a`와 소문자 `t`가 차례로 나오고, 선택적으로 개행을 제외한 문자가 나오는 패턴을 의미한다. 여기서 플래그 `m`으로 인해서 정규 표현식 엔진은 입력 문자열의 각 라인에 대해서 해당 패턴을 매칭하게 된다. 423 | 424 |
425 | "/.at(.)?$/" => The fat 426 | cat sat 427 | on the mat. 428 |429 | 430 | [Test the regular expression](https://regex101.com/r/hoGMkP/1) 431 | 432 |
433 | "/.at(.)?$/gm" => The fat 434 | cat sat 435 | on the mat. 436 |437 | 438 | [Test the regular expression](https://regex101.com/r/E88WE2/1) 439 | 440 | ## 6. 탐욕적 vs 게으른 매칭 441 | 기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다. 442 | 443 |
444 | "/(.*at)/" => The fat cat sat on the mat. 445 |446 | 447 | [Test the regular expression](https://regex101.com/r/AyAdgJ/1) 448 | 449 |
450 | "/(.*?at)/" => The fat cat sat on the mat. 451 |452 | 453 | [Test the regular expression](https://regex101.com/r/AyAdgJ/2) 454 | 455 | ## 기여 방법 456 | 457 | * 이슈 리포팅 458 | * 코드 개선해서 풀 리퀘스트 열기 459 | * 소문내기 460 | * ziishaned@gmail.com 메일로 직접 연락하기 또는 [](https://twitter.com/ziishaned) 461 | 462 | ## 라이센스 463 | 464 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 465 | -------------------------------------------------------------------------------- /translations/README-pl.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
57 | 
58 |
100 | "the" => The fat cat sat on the mat. 101 |102 | 103 | [Przetestuj wyrażenie](https://regex101.com/r/dmRygT/1) 104 | 105 | Wyrażenie regularne `123` pasuje do łańcucha `123`. Wyrażenie regularne 106 | jest dopasowywane do danego łańcucha poprzez porównanie każdego znaku, 107 | jeden po drugim, w wyrażeniu i łańcuchu. Wyrażenia są zwykle wrażliwe 108 | na wielkość znaków, więc wyrażenie `The` nie pasuje do łańcucha `the`. 109 | 110 |
111 | "The" => The fat cat sat on the mat. 112 |113 | 114 | [Przetestuj wyrażenie](https://regex101.com/r/1paXsy/1) 115 | 116 | ## 2. Metaznaki 117 | 118 | Metaznaki to składowe elementy wyrażeń regularnych. Znaki te, nie oznaczają 119 | siebie samych, są natomiast interpretowane w specjalny sposób. 120 | Niektóre znaki mają specjalne znaczenie i są zapisywane w kwadratowych nawiasach. 121 | Metaznaki to: 122 | 123 | |Metaznaki|Opis| 124 | |:----:|----| 125 | |.|Dowolny znak z wyjątkiem nowej linii.| 126 | |[ ]|Zakres. Każdy znak zapisany w kwadratowym nawiasie.| 127 | |[^ ]|Odwrócony zakres. Każdy znak, który nie znajduje się w kwadratowym nawiasie.| 128 | |*|0 lub więcej poprzedzających znaków.| 129 | |+|1 lub więcej poprzedzających znaków.| 130 | |?|0 lub 1 poprzedzających znaków.| 131 | |{n,m}|Minimum "n" ale nie więcej niż "m" poprzedzających znaków.| 132 | |(xyz)|Grupowanie znaków. Znaki xyz dokładnie w tej kolejności.| 133 | |||Alternatywa. Znaki przed symbolem lub za symbolem.| 134 | |\|Znak ucieczki. Umożliwia używanie zarezerwowanych znaków
[ ] ( ) { } . * + ? ^ $ \ |.|
135 | |^|Oznacza początek wzorca.|
136 | |$|Oznacza koniec wzorca.|
137 |
138 | ## 2.1 Kropka
139 |
140 | Kropka `.` jest najprostszym przykładem metaznaku. Oznacza dowolny znak z wyłączeniem entera
141 | i znaków nowej linii. Na przykład, wyrażenie regularne `.ar` oznacza: dowolny znak, następującą
142 | po niej literę `a`, następującą po niej literę `r`.
143 |
144 | 145 | ".ar" => The car parked in the garage. 146 |147 | 148 | [Przetestuj wyrażenie](https://regex101.com/r/xc9GkU/1) 149 | 150 | ## 2.2 Zestaw znaków 151 | 152 | Zestawy znaków nazywane też klasami znaków. Nawiasy kwadratowe służą do określenia zestawów znaków. 153 | Użycie myślnika wewnątrz zestawu, określa jego zakres. Kolejność znaków w nawiasach kwadratowych 154 | nie ma znaczenia. Na przykład wyrażenie `[Tt]he` oznacza: dużą literę `T` lub małą `t`, 155 | następującą po niej literę `h`, następującą po niej literę `e`. 156 | 157 |
158 | "[Tt]he" => The car parked in the garage. 159 |160 | 161 | [Przetestuj wyrażenie](https://regex101.com/r/2ITLQ4/1) 162 | 163 | Jednak kropka w zestawie znaków, oznacza dosłownie kropkę. Wyrażenie regularne 164 | `ar[.]` oznacza: małą literę `a`, następującą po niej literę `r`, 165 | następującą po niej `.` kropkę. 166 | 167 |
168 | "ar[.]" => A garage is a good place to park a car. 169 |170 | 171 | [Przetestuj wyrażenie](https://regex101.com/r/wL3xtE/1) 172 | 173 | ### 2.2.1 Odwrócony zestaw znaków 174 | 175 | Generalnie znak karety oznacza początek wyrażenia, ale gdy zostanie użyty zaraz 176 | za otwierającym nawiasem kwadratowym, odwraca zestaw znaków. Na przykład 177 | wyrażenie `[^c]ar` oznacza: każdy znak z wyjątkiem `c`, 178 | następującą po niej literę `a`, następującą po niej literę `r`. 179 | 180 |
181 | "[^c]ar" => The car parked in the garage. 182 |183 | 184 | [Przetestuj wyrażenie](https://regex101.com/r/nNNlq3/1) 185 | 186 | ## 2.3 Powtórzenia 187 | 188 | Następujące metaznaki `+`, `*` czy `?` określają ile razy wzorzec może się powtórzyć. 189 | Te metaznaki zachowują się różnie, w zależności od sytuacji. 190 | 191 | ### 2.3.1 Gwiazdka 192 | 193 | Symbol `*` oznacza zero lub więcej powtórzeń poprzedzających znaków. Wyrażenie 194 | regularne `a*` oznacza: zero lub więcej powtórzeń poprzedzającej małej 195 | litery `a`. Ale jeśli występuje po zestawie znaków lub klasie, to oznacza 196 | powtórzenia całego zestawu lub klasy. Na przykład, wyrażenie regularne 197 | `[a-z]*` oznacza: każdy ciąg znaków pisany małymi literami. 198 | 199 |
200 | "[a-z]*" => The car parked in the garage #21. 201 |202 | 203 | [Przetestuj wyrażenie](https://regex101.com/r/7m8me5/1) 204 | 205 | Symbol `*` może być użyty z metaznakiem `.` by oznaczyć każdy łańcuch 206 | znaków `.*`. Symbol `*` może być użyty ze znakiem `\s` 207 | by znaleźć łańcuch zawierający spacje. Na przykład, wyrażenie 208 | `\s*cat\s*` oznacza: zero lub więcej spacji, następującą po niej małą literę `c`, 209 | następującą po niej małą literę `a`, następującą po niej małą literę `t`, 210 | następujące po niej zero lub więcej spacji. 211 | 212 |
213 | "\s*cat\s*" => The fat cat sat on the concatenation. 214 |215 | 216 | [Przetestuj wyrażenie](https://regex101.com/r/gGrwuz/1) 217 | 218 | ### 2.3.2 Plus 219 | 220 | Symbol `+` oznacza jeden lub więcej powtórzeń poprzedzających znaków. Na przykład, 221 | wyrażenie `c.+t` oznacza: małą literę `c`, następujący po niej przynajmniej jeden 222 | dowolny znak, następującą po nim małą literę `t`. W tym wypadku `t` jest ostatnim 223 | `t` w zdaniu. 224 | 225 |
226 | "c.+t" => The fat cat sat on the mat. 227 |228 | 229 | [Przetestuj wyrażenie](https://regex101.com/r/Dzf9Aa/1) 230 | 231 | ### 2.3.3 Znak zapytania 232 | 233 | W wyrażeniach regularnych znak `?` sprawia, że poprzedzający znak jest opcjonalny. 234 | Ten symbol oznacza zero lub jedno wystąpienie poprzedzającego znaku. Na przykład, 235 | wyrażenie regularne `[T]?he` oznacza: opcjonalną dużą literę `T`, następującą 236 | po niej małą literę `h`, następującą po niej małą literę `e`. 237 | 238 |
239 | "[T]he" => The car is parked in the garage. 240 |241 | 242 | [Przetestuj wyrażenie](https://regex101.com/r/cIg9zm/1) 243 | 244 |
245 | "[T]?he" => The car is parked in the garage. 246 |247 | 248 | [Przetestuj wyrażenie](https://regex101.com/r/kPpO2x/1) 249 | 250 | ## 2.4 Klamry 251 | 252 | W wyrażeniach regularnych, klamry zwane również kwantyfikatorami, używane są 253 | do określenia, ile razy znak lub grupa znaków może się powtórzyć. 254 | Na przykład wyrażenie regularne `[0-9]{2,3}` oznacza: przynajmniej 255 | 2 znaki, ale nie więcej niż 3 (znaki z zakresu od 0 do 9). 256 | 257 |
258 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
259 |
260 |
261 | [Przetestuj wyrażenie](https://regex101.com/r/juM86s/1)
262 |
263 | Możemy opuścić drugą liczbę. Na przykład regularne wyrażenie `[0-9]{2,}`
264 | oznacza: 2 lub więcej znaków. Jeżeli dodatkowo usuniemy przecinek,
265 | to wyrażenie `[0-9]{3}` oznacza: dokładnie 3 znaki z zakresu 0 do 9.
266 |
267 |
268 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
269 |
270 |
271 | [Przetestuj wyrażenie](https://regex101.com/r/Gdy4w5/1)
272 |
273 |
274 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
275 |
276 |
277 | [Przetestuj wyrażenie](https://regex101.com/r/Sivu30/1)
278 |
279 | ## 2.5 Grupa znaków
280 |
281 | Grupa znaków to grupa podwzorców, które zapisywane są w nawiasach `(...)`.
282 | Jak wspominaliśmy wyżej, jeśli w wyrażeniu regularnym wstawimy kwantyfikator po
283 | znaku, wtedy powtórzy on ten znak. Ale gdy wstawimy kwantyfikator po grupie znaków,
284 | wtedy cała grupa zostanie powtórzona. Na przykład wyrażenie regularne `(ab)*`
285 | oznacza zero lub więcej powtórzeń grupy "ab". Możemy także użyć metaznaku
286 | alternatywy `|` wewnątrz grupy. Na przykład wyrażenie `(c|g|p)ar` oznacza: małą literę `c`,
287 | `g` lub `p`, następującą po niej literę `a`, następującą po niej literę `r`.
288 |
289 | 290 | "(c|g|p)ar" => The car is parked in the garage. 291 |292 | 293 | [Przetestuj wyrażenie](https://regex101.com/r/tUxrBG/1) 294 | 295 | ## 2.6 Alternatywa 296 | 297 | W wyrażeniach regularnych pionowa kreska `|` oznacza alternatywę. 298 | Działa jak warunek pomiędzy różnymi wyrażeniami. Teraz możesz pomyśleć, że 299 | to działa tak samo jak zestaw znaków. Różnica polega na tym, że zestaw znaków 300 | działa na poziomie znaków, natomiast alternatywa na poziomie wyrażenia. Na przykład 301 | wyrażenie regularne `(T|t)he|car` oznacza: dużą literę `T` lub małą `t`, 302 | następującą po niej literę `h`, następującą po niej literę `e` lub `c`, następującą 303 | po niej literę `a`, następującą po niej literę `r`. 304 | 305 |
306 | "(T|t)he|car" => The car is parked in the garage. 307 |308 | 309 | [Przetestuj wyrażenie](https://regex101.com/r/fBXyX0/1) 310 | 311 | ## 2.7 Znak ucieczki 312 | 313 | Ukośnik `\` w wyrażeniach regularnych jest znakiem ucieczki. Pozwala on 314 | używać w wyrażeniu zarezerwowanych znaków takich jak `{ } [ ] / \ + * . $ ^ | ?`. 315 | Aby użyć znaku specjalnego w wyrażeniu, postaw `\` przed nim. 316 | 317 | Na przykład wyrażenie `.` dopasowuje każdy znak z wyjątkiem nowej linii. 318 | Żeby dopasować kropkę `.` w wyrażeniu regularnym, trzeba wstawić przed nią ukośnik. 319 | Wyrażenie `(f|c|m)at\.?` oznacza: małe litery `f` lub `c` lub `m`, następującą po niej 320 | literę `a`, następującą po niej literę `t`, następującą kropkę `.`, która jest opcjonalna. 321 | 322 |
323 | "(f|c|m)at\.?" => The fat cat sat on the mat. 324 |325 | 326 | [Przetestuj wyrażenie](https://regex101.com/r/DOc5Nu/1) 327 | 328 | ## 2.8 Kotwice 329 | 330 | W wyrażeniach regularnych używamy kotwic aby sprawdzić czy dopasowywany symbol 331 | jest pierwszym lub ostatnim symbolem w łańcuchu. Są dwa typy: pierwszy to 332 | kareta `^`, która sprawdza czy znak jest początkiem łańcucha, drugi to dolar `$`, 333 | który sprawdza czy znak jest ostatnim elementem łańcucha. 334 | 335 | ### 2.8.1 Kareta 336 | 337 | Kareta `^` sprawdza czy znak jest początkiem łańcucha. Jeżeli użyjemy takiego 338 | wyrażenia `^a` (jeśli a jest pierwszym znakiem) na łańcuchu `abc` to dopasuje 339 | nam `a`. Ale jeśli użyjemy takiego wyrażenia `^b` na tym samym łańcuchu, to nie 340 | zwróci nam nic. Ponieważ w łańcuchu `abc` "b" nie jest pierwszym symbolem. 341 | Spójrzmy teraz na wyrażenie `^(T|t)he` które oznacza: dużą literę `T` lub małą 342 | `t`, która jest początkiem łańcucha, następującą po niej literę `h`, następującą 343 | po niej literę `e`. 344 | 345 |
346 | "(T|t)he" => The car is parked in the garage. 347 |348 | 349 | [Przetestuj wyrażenie](https://regex101.com/r/5ljjgB/1) 350 | 351 |
352 | "^(T|t)he" => The car is parked in the garage. 353 |354 | 355 | [Przetestuj wyrażenie](https://regex101.com/r/jXrKne/1) 356 | 357 | ### 2.8.2 Dolar 358 | 359 | Symbol dolara `$` używany jest do sprawdzenia czy dopasowywany znak jest ostatni 360 | w łańcuchu. Na przykład, wyrażenie regularne `(at\.)$` oznacza: małą literę `a`, 361 | następującą po niej literę `t`, następującą po niej kropkę `.` i na dodatek 362 | dopasowanie musi być końcem łańcucha. 363 | 364 |
365 | "(at\.)" => The fat cat. sat. on the mat. 366 |367 | 368 | [Przetestuj wyrażenie](https://regex101.com/r/y4Au4D/1) 369 | 370 |
371 | "(at\.)$" => The fat cat. sat. on the mat. 372 |373 | 374 | [Przetestuj wyrażenie](https://regex101.com/r/t0AkOd/1) 375 | 376 | ## 3. Skróty 377 | 378 | W wyrażeniach regularnych znajdziemy także skróty dla popularnych zestawów znaków, 379 | które ułatwiają pracę z wyrażeniami regularnymi. Skróty wyglądają następująco: 380 | 381 | |Skrót|Opis| 382 | |:----:|----| 383 | |.|Każdy znak z wyjątkiem nowej linii| 384 | |\w|Znaki alfanumeryczne: `[a-zA-Z0-9_]`| 385 | |\W|Znaki nie alfanumeryczne: `[^\w]`| 386 | |\d|Cyfry: `[0-9]`| 387 | |\D|Nie cyfry: `[^\d]`| 388 | |\s|Dowolny biały znak: `[\t\n\f\r\p{Z}]`| 389 | |\S|Każdy znak oprócz białych: `[^\s]`| 390 | 391 | ## 4. Lookaround 392 | 393 | Lookbehind i lookahead (nazywane również lookaround) to specyficzne typy 394 | ***niezwracających grup*** (dopasowują wzorzec, ale nie zwracają wartości). 395 | Lookaround używane są w sytuacji, gdy mamy wzorzec i jest on poprzedzony innym wzorcem, 396 | lub następuje po nim kolejny wzorzec. Na przykład, chcemy mieć wszystkie 397 | numery, które są poprzedzone znakiem `$` w takim łańcuchu `$4.44 and $10.88`. 398 | Użyjemy takiego wyrażenia regularnego `(?<=\$)[0-9\.]*` które oznacza: znajdź 399 | wszystkie liczby ze znakiem `.` poprzedzone znakiem `$`. W wyrażeniach regularnych 400 | wyróżniamy: 401 | 402 | |Symbol|Opis| 403 | |:----:|----| 404 | |?=|Lookahead| 405 | |?!|Odwrócony lookahead| 406 | |?<=|Lookbehind| 407 | |? 422 | "(T|t)he(?=\sfat)" => The fat cat sat on the mat. 423 | 424 | 425 | [Przetestuj wyrażenie](https://regex101.com/r/IDDARt/1) 426 | 427 | ### 4.2 Odwrócony lookahead 428 | 429 | Używany jest, gdy potrzebujemy dopasowania z łańcucha, po których nie następują 430 | żadne wzorce. Odwrócony lookahead definiujemy w nawiasach, stosując znak negacji 431 | `!` po znaku zapytania, na przykład: `(?!...)`. Popatrzmy na następujące wyrażenie 432 | `(T|t)he(?!\sfat)` które oznacza: znajdź wszystkie słowa `The` lub `the` w łańcuchu, 433 | po których nie następuje słowo `fat`, poprzedzone spacją. 434 | 435 |
436 | "(T|t)he(?!\sfat)" => The fat cat sat on the mat. 437 |438 | 439 | [Przetestuj wyrażenie](https://regex101.com/r/V32Npg/1) 440 | 441 | ### 4.3 Lookbehind 442 | 443 | Lookbehind używany jest do odnalezienia wszystkich dopasowań poprzedzonych konkretnym 444 | wzorcem. Wyrażenie lookbehind zapisujemy tak: `(?<=...)`. Na przykład, wyrażenie 445 | `(?<=(T|t)he\s)(fat|mat)` oznacza: znajdź wszystkie słowa `fat` lub `mat` w łańcuchu, 446 | które znajdują się po słowach `The` lub `the`. 447 | 448 |
449 | "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. 450 |451 | 452 | [Przetestuj wyrażenie](https://regex101.com/r/avH165/1) 453 | 454 | ### 4.4 Odwrócony lookbehind 455 | 456 | Odwrócony używany jest do odnalezienia wszystkich dopasowań niepoprzedzonych konkretnym 457 | wzorcem. Odwrócony lookbehind zapisujemy tak: `(? 462 | "(?<!(T|t)he\s)(cat)" => The cat sat on cat. 463 | 464 | 465 | [Przetestuj wyrażenie](https://regex101.com/r/8Efx5G/1) 466 | 467 | ## 5. Flagi 468 | 469 | Flagi nazywane są także modyfikatorami, ponieważ zmieniają wynik wyrażenia regularnego. 470 | Flagi mogą być używane w każdej kombinacji i są integralną częścią wyrażeń regularnych. 471 | 472 | |Flaga|Opis| 473 | |:----:|----| 474 | |i|Wielkość znaków: Sprawia, że dopasowanie nie jest wrażliwe na wielkość znaków.| 475 | |g|Przeszukanie globalne: Wyszukiwanie wzorca w całym łańcuchu.| 476 | |m|Multilinia: Sprawia, że kotwice działają na każdej linii.| 477 | 478 | ### 5.1 Wielkość znaków 479 | 480 | Modyfikator `i` używany jest, gdy wielkość liter nie ma znaczenia. Na przykład 481 | wyrażenie `/The/gi` oznacza: dużą literę `T`, następującą po niej literę `h`, 482 | następującą po niej literę `e`. A na końcu wyrażenia, flaga `i` żeby ignorować 483 | wielkość znaków. Jak widać, została też użyta flaga `g` ponieważ chcemy przeszukać 484 | cały łańcuch. 485 | 486 |
487 | "The" => The fat cat sat on the mat. 488 |489 | 490 | [Przetestuj wyrażenie](https://regex101.com/r/dpQyf9/1) 491 | 492 |
493 | "/The/gi" => The fat cat sat on the mat. 494 |495 | 496 | [Przetestuj wyrażenie](https://regex101.com/r/ahfiuh/1) 497 | 498 | ### 5.2 Przeszukiwanie globalne 499 | 500 | Modyfikator `g` używany jest do przeszukiwania całego łańcucha (znajdź wszystko, 501 | a nie tylko zatrzymuj się na pierwszym). Na przykład wyrażenie `/.(at)/g` 502 | oznacza: każdy znak z wyjątkiem nowej linii, następującą po nim literę `a`, 503 | następującą po niej literę `t`. Ponieważ użyliśmy na końcu wyrażenia flagi `g`, 504 | wyszukane zostaną wszystkie dopasowania w łańcuchu, a nie tylko pierwszy (domyślne zachowanie). 505 | 506 |
507 | "/.(at)/" => The fat cat sat on the mat. 508 |509 | 510 | [Przetestuj wyrażenie](https://regex101.com/r/jnk6gM/1) 511 | 512 |
513 | "/.(at)/g" => The fat cat sat on the mat. 514 |515 | 516 | [Przetestuj wyrażenie](https://regex101.com/r/dO1nef/1) 517 | 518 | ### 5.3 Multilinia 519 | 520 | Modyfikator `m` używany jest do dopasowywania w wielu liniach. Jak wspominaliśmy 521 | wcześniej, kotwice `(^, $)` używane są do sprawdzania czy wzorzec jest początkiem 522 | lub końcem łańcucha. Jeśli chcemy, żeby kotwice zadziałały w każdej linii, używamy 523 | wtedy flagi `m`. Na przykład wyrażenie `/at(.)?$/gm` oznacza: małą literę `a`, 524 | następującą po niej małą literę `t`, opcjonalnie dowolny znak z wyjątkiem nowej linii. 525 | I ponieważ użyliśmy flagi `m` dopasowywane będą wzorce na końcu każdej linii w łańcuchu. 526 | 527 |
528 | "/.at(.)?$/" => The fat 529 | cat sat 530 | on the mat. 531 |532 | 533 | [Przetestuj wyrażenie](https://regex101.com/r/hoGMkP/1) 534 | 535 |
536 | "/.at(.)?$/gm" => The fat 537 | cat sat 538 | on the mat. 539 |540 | 541 | [Przetestuj wyrażenie](https://regex101.com/r/E88WE2/1) 542 | 543 | ## Kontrybucja 544 | 545 | * Zgłaszanie błędów 546 | * Otwieranie pull request z poprawkami 547 | * Dzielenie się poradnikiem 548 | * Skontaktuj się ze mną ziishaned@gmail.com lub [](https://twitter.com/ziishaned) 549 | 550 | ## Licencja 551 | 552 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 553 | -------------------------------------------------------------------------------- /translations/README-pt_BR.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
50 | 
51 |
90 | "the" => The fat cat sat on the mat. 91 |92 | 93 | [Teste a RegExp](https://regex101.com/r/dmRygT/1) 94 | 95 | A expressão regular `123` corresponde à string `123`. A expressão regular é comparada com uma string de entrada, comparando cada caractere da expressão regular para cada caractere da string de entrada, um após o outro. Expressões regulares são normalmente case-sensitive (sensíveis a maiúsculas), então a expressão regular `The` não vai bater com a string `the`. 96 | 97 |
98 | "The" => The fat cat sat on the mat. 99 |100 | 101 | [Teste a RegExp](https://regex101.com/r/1paXsy/1) 102 | 103 | ## 2. Metacaracteres 104 | 105 | Metacaracteres são elementos fundamentais das expressões regulares. Metacaracteres não representam a si mesmos mas, ao invés disso, são interpretados de uma forma especial. Alguns metacaracteres tem um significado especial e são escritos dentro de colchetes. 106 | Os metacaracteres são os seguintes: 107 | 108 | |Metacaracter|Descrição| 109 | |:----:|----| 110 | |.|Corresponde a qualquer caractere, exceto uma quebra de linha| 111 | |[ ]|Classe de caracteres. Corresponde a qualquer caractere contido dentro dos colchetes.| 112 | |[^ ]|Classe de caracteres negada. Corresponde a qualquer caractere que não está contido dentro dos colchetes.| 113 | |*|Corresponde a 0 ou mais repetições do símbolo anterior.| 114 | |+|Corresponde a 1 ou mais repetições do símbolo anterior.| 115 | |?|Faz com que o símbolo anterior seja opcional.| 116 | |{n,m}|Chaves. Corresponde a no mínimo "n" mas não mais que "m" repetições do símbolo anterior.| 117 | |(xyz)|Grupo de caracteres. Corresponde aos caracteres xyz nesta exata ordem.| 118 | |||Alternância. Corresponde aos caracteres antes ou os caracteres depois do símbolo| 119 | |\|Escapa o próximo caractere. Isso permite você utilizar os caracteres reservados
[ ] ( ) { } . * + ? ^ $ \ ||
120 | |^|Corresponde ao início da entrada.|
121 | |$|Corresponde ao final da entrada.|
122 |
123 | ## 2.1 Ponto final
124 |
125 | O ponto final `.` é um simples exemplo de metacaracteres. O metacaractere `.` corresponde a qualquer caractere sozinho. Ele não se iguala ao Enter e à quebra de linha. Por exemplo, a expressão regular `.ar` significa: qualquer caractere, seguido da letra `a`, seguida da letra `r`.
126 |
127 | 128 | ".ar" => The car parked in the garage. 129 |130 | 131 | [Teste a RegExp](https://regex101.com/r/xc9GkU/1) 132 | 133 | ## 2.2 Conjunto de caracteres 134 | 135 | Conjuntos de caracteres também são chamados de classes de caracteres. Utilizamos colchetes para especificar conjuntos de caracteres. Use um hífen dentro de um conjunto de caracteres para especificar o intervalo de caracteres. A ordem dos caracteres dentro dos colchetes não faz diferença. Por exemplo, a expressão regular `[Tt]he` significa: um caractere maiúsculo `T` ou minúsculo `t`, seguido da letra `h`, seguida da letra `e`. 136 | 137 |
138 | "[Tt]he" => The car parked in the garage. 139 |140 | 141 | [Teste a RegExp](https://regex101.com/r/2ITLQ4/1) 142 | 143 | No entanto, um ponto final dentro de um conjunto de caracteres, significa apenas um ponto final. A expressão regular `ar[.]` significa: o caractere minúsculo `a`, seguido da letra `r`, seguida pelo caractere de ponto final `.`. 144 | 145 |
146 | "ar[.]" => A garage is a good place to park a car. 147 |148 | 149 | [Teste a RegExp](https://regex101.com/r/wL3xtE/1) 150 | 151 | ### 2.2.1 Conjunto de caracteres negados 152 | 153 | No geral, o símbolo do circunflexo representa o início da string, mas quando está logo após o colchete de abertura, ele faz a negação do conjunto de caracteres. Por exemplo, a expressão regular `[^c]ar` significa: qualquer caractere com exceção do `c`, seguido pelo caractere `a`, seguido da letra `r`. 154 | 155 |
156 | "[^c]ar" => The car parked in the garage. 157 |158 | 159 | [Teste a RegExp](https://regex101.com/r/nNNlq3/1) 160 | 161 | ## 2.3 Repetições 162 | 163 | Seguindo os metacaracteres `+`, `*` ou `?` são utilizados para especificar quantas vezes um sub-padrão pode ocorrer. Esses metacaracteres atuam de formas diferentes em diferentes situações. 164 | 165 | ### 2.3.1 O Asterisco 166 | 167 | O símbolo `*` corresponde a zero ou mais repetições do padrão antecedente. A expressão regular `a*` significa: zero ou mais repetições do caractere minúsculo precedente `a`. Mas se o asterisco aparecer depois de um conjunto de caracteres, ou classe de caracteres, ele irá procurar as repetições de todo o conjunto. Por exemplo, a expressão regular `[a-z]*` significa: qualquer quantidade de letras minúsculas numa linha. 168 | 169 |
170 | "[a-z]*" => The car parked in the garage #21. 171 |172 | 173 | [Teste a RegExp](https://regex101.com/r/7m8me5/1) 174 | 175 | O símbolo `*` pode ser usado junto do metacaractere `.` para encontrar qualquer string de caracteres `.*`. O símbolo `*` pode ser usado com o caractere de espaço em branco `\s` para encontrar uma string de caracteres em branco. Por exemplo, a expressão `\s*cat\s*` significa: zero ou mais espaços, seguidos do caractere minúsculo `c`, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `t`, seguido de zero ou mais espaços. 176 | 177 |
178 | "\s*cat\s*" => The fat cat sat on the concatenation. 179 |180 | 181 | [Teste a RegExp](https://regex101.com/r/gGrwuz/1) 182 | 183 | ### 2.3.2 O Sinal de Adição 184 | 185 | O símbolo `+` corresponde a uma ou mais repetições do caractere anterior. Por exemplo, a expressão regular `c.+t` significa: a letra minúscula `c`, seguida por pelo menos um caractere, seguido do caractere minúsculo `t`. 186 | 187 |
188 | "c.+t" => The fat cat sat on the mat. 189 |190 | 191 | [Teste a RegExp](https://regex101.com/r/Dzf9Aa/1) 192 | 193 | ### 2.3.3 O Ponto de Interrogação 194 | 195 | Em expressões regulares, o metacaractere `?` faz o caractere anterior ser opcional. Esse símbolo corresponde a zero ou uma ocorrência do caractere anterior. Por exemplo, a expressão regular `[T]?he` significa: A letra maiúsculo `T` opcional, seguida do caractere minúsculo `h`, seguido do caractere minúsculo `e`. 196 | 197 |
198 | "[T]he" => The car is parked in the garage. 199 |200 | 201 | [Teste a RegExp](https://regex101.com/r/cIg9zm/1) 202 | 203 |
204 | "[T]?he" => The car is parked in the garage. 205 |206 | 207 | [Teste a RegExp](https://regex101.com/r/kPpO2x/1) 208 | 209 | ## 2.4 Chaves 210 | 211 | Em expressões regulares, chaves, que também são chamadas de quantificadores, são utilizadas para especificar o número de vezes que o caractere, ou um grupo de caracteres, pode se repetir. Por exemplo, a expressão regular `[0-9]{2,3}` significa: Encontre no mínimo 2 dígitos, mas não mais que 3 (caracteres no intervalo de 0 a 9). 212 | 213 |
214 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
215 |
216 |
217 | [Teste a RegExp](https://regex101.com/r/juM86s/1)
218 |
219 | Nós podemos retirar o segundo número. Por exemplo, a expressão regular `[0-9]{2,}` significa: Encontre 2 ou mais dígitos. Se removermos a vírgula a expressão regular `[0-9]{3}` significa: Encontre exatamente 3 dígitos.
220 |
221 |
222 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
223 |
224 |
225 | [Teste a RegExp](https://regex101.com/r/Gdy4w5/1)
226 |
227 |
228 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
229 |
230 |
231 | [Teste a RegExp](https://regex101.com/r/Sivu30/1)
232 |
233 | ## 2.5 Grupo de Caracteres
234 |
235 | Grupo de caracteres é um grupo de sub-padrão que é escrito dentro de parênteses `(...)`. Como falamos antes, se colocaramos um quantificador depois de um caractere, ele irá repetir o caractere anterior. Mas se colocarmos um quantificador depois de um grupo de caracteres, ele irá repetir todo o conjunto. Por exemplo, a expressão regular `(ab)*` corresponde a zero ou mais repetições dos caracteres "ab". Nós também podemos usar o metacaractere de alternância `|` dentro de um grupo de caracteres. Por exemplo, a expressão regular `(c|g|p)ar` significa: caractere minúsculo `c`, `g` ou `p`, seguido do caractere `a`, seguido do caractere `r`.
236 |
237 | 238 | "(c|g|p)ar" => The car is parked in the garage. 239 |240 | 241 | [Teste a RegExp](https://regex101.com/r/tUxrBG/1) 242 | 243 | ## 2.6 Alternância 244 | 245 | Em expressões regulares, a barra vertical `|` é usada para definir alternância. Alternância é como uma condição entre múltiplas expressões. Agora, você pode estar pensando que um conjunto de caracteres e a alternância funcionam da mesma forma. Mas a grande diferença entre eles é que o conjunto de caracteres trabalha no nível de caracteres, enquanto a alternância trabalha no nível das expressões. Por exemplo, a expressão regular `(T|t)he|car` significa: o caractere maiúsculo `T` ou minúsculo `t`, seguido do caractere minúsculo `h`, seguido do caractere minúsculo `e` ou o caractere minúsculo `c`, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `r`. 246 | 247 |
248 | "(T|t)he|car" => The car is parked in the garage. 249 |250 | 251 | [Teste a RegExp](https://regex101.com/r/fBXyX0/1) 252 | 253 | ## 2.7 Escapando Caracteres Especiais 254 | 255 | Em expressões regulares, a contrabarra `\` é usada para escapar o próximo caractere. Isso possibilita especificar um símbolo como um caractere correspondente, incluindo os caracteres reservados `{ } [ ] / \ + * . $ ^ | ?`. Para usar um caractere especial como um caractere correspondente, utilize `\` antes dele. Por exemplo, a expressão regular `.` é usada para encontrar qualquer caractere, exceto nova linha. Agora, para encontrar `.` em uma string de entrada, a expressão regular `(f|c|m)at\.?` significa: letra minúscula `f`, `c` ou `m`, seguida do caractere minúsculo `a`, seguido da letra minúscula `t`, seguida do caractere `.` opcional. 256 | 257 |
258 | "(f|c|m)at\.?" => The fat cat sat on the mat. 259 |260 | 261 | [Teste a RegExp](https://regex101.com/r/DOc5Nu/1) 262 | 263 | ## 2.8 Âncoras 264 | 265 | Em empressões regulares, usamos âncoras para verificar se o caractere encontrado está no início ou no final da string de entrada. As âncoras podem ser de dois tipos: O primeiro tipo é o Acento Circunflexo `^`, que verifica se o caractere encontrado está no início da string de entrada, e o segundo tipo é o Sinal de Dólar `$`, que verifica se o caractere encontrado é o último caractere da string. 266 | 267 | ### 2.8.1 Acento Circunflexo 268 | 269 | O símbolo do Acento Circunflexo `^` é usado para verificar se o caractere encontrado é o primeiro caractere da string de entrada. Se aplicarmos a seguinte expressão regular `^a` (se a é o primeiro caractere) à string de entrada `abc`, ela encontra o `a`. Mas se nós aplicarmos a expressão regular `^b` na mesma string, ela não encontrará nada. Isso acontece porque, na string `abc`, "b" não é o caractere inicial. Vamos dar uma olhada em outra expressão regular, `^(T|t)he` que significa: o caractere maiúsculo `T` ou o caractere minúsculo `t` que é o primeiro símbolo da string de entrada, seguido do caractere minúsculo `h`, seguido do caractere minúsculo `e`. 270 | 271 |
272 | "(T|t)he" => The car is parked in the garage. 273 |274 | 275 | [Teste a RegExp](https://regex101.com/r/5ljjgB/1) 276 | 277 |
278 | "^(T|t)he" => The car is parked in the garage. 279 |280 | 281 | [Teste a RegExp](https://regex101.com/r/jXrKne/1) 282 | 283 | ### 2.8.2 Sinal de Dólar 284 | 285 | O símbolo do Sinal de Dólar `$` é usado para verificar se o caractere encontrado é o último caractere da string de entrada. Por exemplo, a expressão regular `(at\.)$` significa: um caractere minúsculo `a`, seguido do caractere minúsculo `t`, seguido de um ponto final `.` e o grupo deve estar no final da string. 286 | 287 |
288 | "(at\.)" => The fat cat. sat. on the mat. 289 |290 | 291 | [Teste a RegExp](https://regex101.com/r/y4Au4D/1) 292 | 293 |
294 | "(at\.)$" => The fat cat. sat. on the mat. 295 |296 | 297 | [Teste a RegExp](https://regex101.com/r/t0AkOd/1) 298 | 299 | ## 3. Forma Abreviada de Conjunto de Caracteres 300 | 301 | As expressões regulares fornecem abreviações para conjuntos de caracteres comumente usados, que oferecem atalhos convenientes para expressões regulares comumente usadas. As abreviações são as seguintes: 302 | 303 | |Abreviação|Descrição| 304 | |:----:|----| 305 | |.|Qualquer caractere, exceto nova linha| 306 | |\w|Corresponde a caracteres alfanuméricos: `[a-zA-Z0-9_]`| 307 | |\W|Corresponde a caracteres não alfanuméricos: `[^\w]`| 308 | |\d|Corresponde a dígitos: `[0-9]`| 309 | |\D|Corresponde a não dígitos: `[^\d]`| 310 | |\s|Corresponde a caracteres de espaços em branco: `[\t\n\f\r\p{Z}]`| 311 | |\S|Corresponde a caracteres de espaços não em branco: `[^\s]`| 312 | 313 | ## 4. Olhar ao Redor 314 | 315 | Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrências). Lookarounds são usados quando temos a condição de que determinado padrão seja precedido ou seguido de outro padrão. Por exemplo, queremos capturar todos os números precedidos do caractere `$` da seguinte string de entrada: `$4.44 and $10.88`. Vamos usar a seguinte expressão regular `(?<=\$)[0-9\.]*` que significa: procure todos os números que contêm o caractere `.` e são precedidos pelo caractere `$`. A seguir estão os lookarounds que são utilizados em expressões regulares: 316 | 317 | |Símbolo|Descrição| 318 | |:----:|----| 319 | |?=|Lookahead Positivo| 320 | |?!|Lookahead Negativo| 321 | |?<=|Lookbehind Positivo| 322 | |? 329 | "[T|t]he(?=\sfat)" => The fat cat sat on the mat. 330 | 331 | 332 | [Teste a RegExp](https://regex101.com/r/IDDARt/1) 333 | 334 | ### 4.2 Lookahead Negativo 335 | 336 | O lookahead negativo é usado quando nós precisamos encontrar todas as ocorrências da string de entrada que não são seguidas por um determinado padrão. O lookahead negativo é definido da mesma forma que definimos o lookahead positivo, mas a única diferença é que, no lugar do sinal de igual `=`, usamos o caractere de negação `!`, ex.: `(?!...)`. Vamos dar uma olhada na seguinte expressão regular `[T|t]he(?!\sfat)`, que significa: obtenha as palavras `The` ou `the` da string de entrada que não são seguidas pela palavra `fat`, precedida de um caractere de espaço. 337 | 338 |
339 | "[T|t]he(?!\sfat)" => The fat cat sat on the mat. 340 |341 | 342 | [Teste a RegExp](https://regex101.com/r/V32Npg/1) 343 | 344 | ### 4.3 Lookbehind Positivo 345 | 346 | Lookbehind positivo é usado para encontrar todas as ocorrências que são precedidas por um padrão específico. O lookbehind positivo é indicado por `(?<=...)`. Por exemplo, a expressão regular `(?<=[T|t]he\s)(fat|mat)` significa: obtenha todas as palavras `fat` ou `mat` da string de entrada, que estão depois das palavras `The` ou `the`. 347 | 348 |
349 | "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat. 350 |351 | 352 | [Teste a RegExp](https://regex101.com/r/avH165/1) 353 | 354 | ### 4.4 Lookbehind Negativo 355 | 356 | Lookbehind negativo é usado para encontrar todas as ocorrências que não são precedidas por um padrão específico. O lookbehind negativo é indicado por `(? 359 | "(?<![T|t]he\s)(cat)" => The cat sat on cat. 360 | 361 | 362 | [Teste a RegExp](https://regex101.com/r/8Efx5G/1) 363 | 364 | ## 5. Flags 365 | 366 | Flags (sinalizadores) também são chamados de modificadores, porque eles modificam o resultado da expressão regular. Essas flags podem ser usadas em qualquer ordem ou combinação, e são uma parte integrante da RegExp. 367 | 368 | |Flag|Descrição| 369 | |:----:|----| 370 | |i|Case insensitive: Define que o padrão será case-insensitive.| 371 | |g|Busca global: Procura o padrão em toda a string de entrada.| 372 | |m|Multilinhas: Os metacaracteres de âncora funcionam em cada linha.| 373 | 374 | ### 5.1 Indiferente a Maiúsculas 375 | 376 | O modificador `i` é usado para tornar o padrão case-insensitive. Por exemplo, a expressão regular `/The/gi` significa: a letra maiúscula `T`, seguida do caractere minúsculo `h`, seguido do caractere `e`. E ao final da expressão regular, a flag `i` diz ao motor de expressões regulares para ignorar maiúsculas e minúsculas. Como você pode ver, nós também determinamos a flag `g` porque queremos procurar o padrão em toda a string de entrada. 377 | 378 |
379 | "The" => The fat cat sat on the mat. 380 |381 | 382 | [Teste a RegExp](https://regex101.com/r/dpQyf9/1) 383 | 384 |
385 | "/The/gi" => The fat cat sat on the mat. 386 |387 | 388 | [Teste a RegExp](https://regex101.com/r/ahfiuh/1) 389 | 390 | ### 5.2 Busca Global 391 | 392 | O modificador `g` é usado para realizar uma busca global (encontrar todas as ocorrências sem parar na primeira encontrada). Por exemplo, a expressão regular `/.(at)/g` significa: qualquer caractere, exceto nova linha, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `t`. Por causa da flag `g` no final da expressão regular, agora ela vai encontrar todas as ocorrências em toda a string de entrada. 393 | 394 |
395 | "/.(at)/" => The fat cat sat on the mat. 396 |397 | 398 | [Teste a RegExp](https://regex101.com/r/jnk6gM/1) 399 | 400 |
401 | "/.(at)/g" => The fat cat sat on the mat. 402 |403 | 404 | [Teste a RegExp](https://regex101.com/r/dO1nef/1) 405 | 406 | ### 5.3 Multilinhas 407 | 408 | O modificador `m` é usado para realizar uma busca em várias linhas. Como falamos antes, as âncoras `(^, $)` são usadas para verificar se o padrão está no início ou no final da string de entrada respectivamente. Mas se queremos que as âncoras funcionem em cada uma das linhas, usamos a flag `m`. Por exemplo, a expressão regular `/.at(.)?$/gm` significa: o caractere minúsculo `a`, seguido do caractere minúsculo `t`, opcionalmente seguido por qualquer caractere, exceto nova linha. E por causa da flag `m`, agora o motor de expressões regulares encontra o padrão no final de cada uma das linhas da string. 409 | 410 |
411 | "/.at(.)?$/" => The fat 412 | cat sat 413 | on the mat. 414 |415 | 416 | [Teste a RegExp](https://regex101.com/r/hoGMkP/1) 417 | 418 |
419 | "/.at(.)?$/gm" => The fat 420 | cat sat 421 | on the mat. 422 |423 | 424 | [Teste a RegExp](https://regex101.com/r/E88WE2/1) 425 | 426 | ### 6. Guloso vs Não-Guloso 427 | 428 | Por padrão, uma regex irá realizar uma consulta gulosa, isto significa que a busca irá capturar ao padrão mais longo possível. Nós podemos usar `?` para buscar de uma forma não-gulosa, isto significa que a busca irá capturar ao padrão mais curto possível. 429 | 430 |
431 | "/(.*at)/" => The fat cat sat on the mat.432 | 433 | 434 | [Teste a RegExp](https://regex101.com/r/AyAdgJ/1) 435 | 436 |
437 | "/(.*?at)/" => The fat cat sat on the mat.438 | 439 | 440 | [Teste a RegExp](https://regex101.com/r/AyAdgJ/2) 441 | 442 | 443 | ## Contribution 444 | 445 | * Reporte bugs 446 | * Abra pull request com melhorias 447 | * Espalhe a palavra 448 | * Me encontre diretamente em ziishaned@gmail.com ou [](https://twitter.com/ziishaned) 449 | 450 | ## Licença 451 | 452 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 453 | -------------------------------------------------------------------------------- /translations/README-zh-simple.md: -------------------------------------------------------------------------------- 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
51 |
52 |
96 | "the" => The fat cat sat on the mat. 97 |98 | 99 | [在线练习](https://regex101.com/r/dmRygT/1) 100 | 101 | 正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较. 102 | 103 | 正则表达式是大小写敏感的, 所以`The`不会匹配`the`. 104 | 105 |
106 | "The" => The fat cat sat on the mat. 107 |108 | 109 | [在线练习](https://regex101.com/r/1paXsy/1) 110 | 111 | ## 2. 元字符 112 | 113 | 正则表达式主要依赖于元字符. 114 | 元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍: 115 | 116 | |元字符|描述| 117 | |:----:|----| 118 | |.|句号匹配任意单个字符除了换行符.| 119 | |[ ]|字符种类. 匹配方括号内的任意字符.| 120 | |[^ ]|否定的字符种类. 匹配除了方括号里的任意字符| 121 | |*|匹配>=0个重复的在*号之前的字符.| 122 | |+|匹配>1个重复的+号前的字符. 123 | |?|标记?之前的字符为可选.| 124 | |{n,m}|匹配num个中括号之前的字符 (n <= num <= m).| 125 | |(xyz)|字符集, 匹配与 xyz 完全相等的字符串.| 126 | |||或运算符,匹配符号前或后的字符.| 127 | |\|转义字符,用于匹配一些保留的字符
[ ] ( ) { } . * + ? ^ $ \ ||
128 | |^|从开始行开始匹配.|
129 | |$|从末端开始匹配.|
130 |
131 | ## 2.1 点运算符 `.`
132 |
133 | `.`是元字符中最简单的例子.
134 | `.`匹配任意单个字符, 但不匹配换行符.
135 | 例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串.
136 |
137 | 138 | ".ar" => The car parked in the garage. 139 |140 | 141 | [在线练习](https://regex101.com/r/xc9GkU/1) 142 | 143 | ## 2.2 字符集 144 | 145 | 字符集也叫做字符类. 146 | 方括号用来指定一个字符集. 147 | 在方括号中使用连字符来指定字符集的范围. 148 | 在方括号中的字符集不关心顺序. 149 | 例如, 表达式`[Tt]he` 匹配 `the` 和 `The`. 150 | 151 |
152 | "[Tt]he" => The car parked in the garage. 153 |154 | 155 | [在线练习](https://regex101.com/r/2ITLQ4/1) 156 | 157 | 方括号的句号就表示句号. 158 | 表达式 `ar[.]` 匹配 `ar.`字符串 159 | 160 |
161 | "ar[.]" => A garage is a good place to park a car. 162 |163 | 164 | [在线练习](https://regex101.com/r/wL3xtE/1) 165 | 166 | ### 2.2.1 否定字符集 167 | 168 | 一般来说 `^` 表示一个字符串的开头, 但它用在一个方括号的开头的时候, 它表示这个字符集是否定的. 169 | 例如, 表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符. 170 | 171 |
172 | "[^c]ar" => The car parked in the garage. 173 |174 | 175 | [在线练习](https://regex101.com/r/nNNlq3/1) 176 | 177 | ## 2.3 重复次数 178 | 179 | 后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数. 180 | 这些元字符在不同的情况下有着不同的意思. 181 | 182 | ### 2.3.1 `*` 号 183 | 184 | `*`号匹配 在`*`之前的字符出现`大于等于0`次. 185 | 例如, 表达式 `a*` 匹配以0或更多个a开头的字符, 因为有0个这个条件, 其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串. 186 | 187 |
188 | "[a-z]*" => The car parked in the garage #21. 189 |190 | 191 | [在线练习](https://regex101.com/r/7m8me5/1) 192 | 193 | `*`字符和`.`字符搭配可以匹配所有的字符`.*`. 194 | `*`和表示匹配空格的符号`\s`连起来用, 如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串. 195 | 196 |
197 | "\s*cat\s*" => The fat cat sat on the concatenation. 198 |199 | 200 | [在线练习](https://regex101.com/r/gGrwuz/1) 201 | 202 | ### 2.3.2 `+` 号 203 | 204 | `+`号匹配`+`号之前的字符出现 >=1 次个字符. 205 | 例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串. 206 | 207 |
208 | "c.+t" => The fat cat sat on the mat. 209 |210 | 211 | [在线练习](https://regex101.com/r/Dzf9Aa/1) 212 | 213 | ### 2.3.3 `?` 号 214 | 215 | 在正则表达式中元字符 `?` 标记在符号前面的字符为可选, 即出现 0 或 1 次. 216 | 例如, 表达式 `[T]?he` 匹配字符串 `he` 和 `The`. 217 | 218 |
219 | "[T]he" => The car is parked in the garage. 220 |221 | 222 | [在线练习](https://regex101.com/r/cIg9zm/1) 223 | 224 |
225 | "[T]?he" => The car is parked in the garage. 226 |227 | 228 | [在线练习](https://regex101.com/r/kPpO2x/1) 229 | 230 | ## 2.4 `{}` 号 231 | 232 | 在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数. 233 | 例如, 表达式 `[0-9]{2,3}` 匹配 2~3 位 0~9 的数字. 234 | 235 | 236 |
237 | "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
238 |
239 |
240 | [在线练习](https://regex101.com/r/juM86s/1)
241 |
242 | 我们可以省略第二个参数.
243 | 例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字.
244 |
245 | 如果逗号也省略掉则表示重复固定的次数.
246 | 例如, `[0-9]{3}` 匹配3位数字
247 |
248 |
249 | "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
250 |
251 |
252 | [在线练习](https://regex101.com/r/Gdy4w5/1)
253 |
254 |
255 | "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
256 |
257 |
258 | [在线练习](https://regex101.com/r/Sivu30/1)
259 |
260 | ## 2.5 `(...)` 特征标群
261 |
262 | 特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.
263 |
264 | 我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
265 |
266 | 267 | "(c|g|p)ar" => The car is parked in the garage. 268 |269 | 270 | [在线练习](https://regex101.com/r/tUxrBG/1) 271 | 272 | ## 2.6 `|` 或运算符 273 | 274 | 或运算符就表示或, 用作判断条件. 275 | 276 | 例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`. 277 | 278 |
279 | "(T|t)he|car" => The car is parked in the garage. 280 |281 | 282 | [在线练习](https://regex101.com/r/fBXyX0/1) 283 | 284 | ## 2.7 转码特殊字符 285 | 286 | 反斜线 `\` 在表达式中用于转码紧跟其后的字符. 用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`. 287 | 288 | 例如 `.` 是用来匹配除换行符外的所有字符的. 如果想要匹配句子中的 `.` 则要写成 `\.`. 289 | 290 |
291 | "(f|c|m)at\.?" => The fat cat sat on the mat. 292 |293 | 294 | [在线练习](https://regex101.com/r/DOc5Nu/1) 295 | 296 | ## 2.8 锚点 297 | 298 | 在正则表达式中, 想要匹配指定开头或结尾的字符串就要使用到锚点. `^` 指定开头, `$` 指定结尾. 299 | 300 | ### 2.8.1 `^` 号 301 | 302 | `^` 用来检查匹配的字符串是否在所匹配字符串的开头. 303 | 304 | 例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头. 305 | 306 | 例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串. 307 | 308 |
309 | "(T|t)he" => The car is parked in the garage. 310 |311 | 312 | [在线练习](https://regex101.com/r/5ljjgB/1) 313 | 314 |
315 | "^(T|t)he" => The car is parked in the garage. 316 |317 | 318 | [在线练习](https://regex101.com/r/jXrKne/1) 319 | 320 | ### 2.8.2 `$` 号 321 | 322 | 同理于 `^` 号, `$` 号用来匹配字符是否是最后一个. 323 | 324 | 例如, `(at\.)$` 匹配以 `at.` 结尾的字符串. 325 | 326 |
327 | "(at\.)" => The fat cat. sat. on the mat. 328 |329 | 330 | [在线练习](https://regex101.com/r/y4Au4D/1) 331 | 332 |
333 | "(at\.)$" => The fat cat. sat. on the mat. 334 |335 | 336 | [在线练习](https://regex101.com/r/t0AkOd/1) 337 | 338 | ## 3. 简写字符集 339 | 340 | 正则表达式提供一些常用的字符集简写. 如下: 341 | 342 | |简写|描述| 343 | |:----:|----| 344 | |.|除换行符外的所有字符| 345 | |\w|匹配所有字母数字, 等同于 `[a-zA-Z0-9_]`| 346 | |\W|匹配所有非字母数字, 即符号, 等同于: `[^\w]`| 347 | |\d|匹配数字: `[0-9]`| 348 | |\D|匹配非数字: `[^\d]`| 349 | |\s|匹配所有空格字符, 等同于: `[\t\n\f\r\p{Z}]`| 350 | |\S|匹配所有非空格字符: `[^\s]`| 351 | 352 | ## 4. 前后关联约束(前后预查) 353 | 354 | 前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式). 355 | 前置约束用于判断所匹配的格式是否在另一个确定的格式之后. 356 | 357 | 例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`. 358 | 这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次. 359 | 360 | 前后关联约束如下: 361 | 362 | |符号|描述| 363 | |:----:|----| 364 | |?=|前置约束-存在| 365 | |?!|前置约束-排除| 366 | |?<=|后置约束-存在| 367 | |? 380 | "[T|t]he(?=\sfat)" => The fat cat sat on the mat. 381 | 382 | 383 | [在线练习](https://regex101.com/r/IDDARt/1) 384 | 385 | ### 4.2 `?!...` 前置约束-排除 386 | 387 | 前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式 388 | `前置约束-排除` 定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`. 389 | 390 | 表达式 `[T|t]he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`. 391 | 392 |
393 | "[T|t]he(?!\sfat)" => The fat cat sat on the mat. 394 |395 | 396 | [在线练习](https://regex101.com/r/V32Npg/1) 397 | 398 | ### 4.3 `?<= ...` 后置约束-存在 399 | 400 | 后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式. 401 | 例如, 表达式 `(?<=[T|t]he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`. 402 | 403 |
404 | "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat. 405 |406 | 407 | [在线练习](https://regex101.com/r/avH165/1) 408 | 409 | ### 4.4 `? 415 | "(?<![T|t]he\s)(cat)" => The cat sat on cat. 416 | 417 | 418 | [在线练习](https://regex101.com/r/8Efx5G/1) 419 | 420 | ## 5. 标志 421 | 422 | 标志也叫修饰语, 因为它可以用来修改表达式的搜索结果. 423 | 这些标志可以任意的组合使用, 它也是整个正则表达式的一部分. 424 | 425 | |标志|描述| 426 | |:----:|----| 427 | |i|忽略大小写.| 428 | |g|全局搜索.| 429 | |m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始.| 430 | 431 | ### 5.1 忽略大小写 (Case Insensitive) 432 | 433 | 修饰语 `i` 用于忽略大小写. 434 | 例如, 表达式 `/The/gi` 表示在全局搜索 `The`, 在后面的 `i` 将其条件修改为忽略大小写, 则变成搜索 `the` 和 `The`, `g` 表示全局搜索. 435 | 436 |
437 | "The" => The fat cat sat on the mat. 438 |439 | 440 | [在线练习](https://regex101.com/r/dpQyf9/1) 441 | 442 |
443 | "/The/gi" => The fat cat sat on the mat. 444 |445 | 446 | [在线练习](https://regex101.com/r/ahfiuh/1) 447 | 448 | ### 5.2 全局搜索 (Global search) 449 | 450 | 修饰符 `g` 常用于执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). 451 | 例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果. 452 | 453 |
454 | "/.(at)/" => The fat cat sat on the mat. 455 |456 | 457 | [在线练习](https://regex101.com/r/jnk6gM/1) 458 | 459 |
460 | "/.(at)/g" => The fat cat sat on the mat. 461 |462 | 463 | [在线练习](https://regex101.com/r/dO1nef/1) 464 | 465 | ### 5.3 多行修饰符 (Multiline) 466 | 467 | 多行修饰符 `m` 常用于执行一个多行匹配. 468 | 469 | 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`. 470 | 471 | 例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟0个或1个 `.` 的字符串, 并返回全部结果. 472 | 473 |
474 | "/.at(.)?$/" => The fat 475 | cat sat 476 | on the mat. 477 |478 | 479 | [在线练习](https://regex101.com/r/hoGMkP/1) 480 | 481 |
482 | "/.at(.)?$/gm" => The fat 483 | cat sat 484 | on the mat. 485 |486 | 487 | [在线练习](https://regex101.com/r/E88WE2/1) 488 | 489 | ## 额外补充 490 | 491 | * *正整数*: `^\d+$` 492 | * *负整数*: `^-\d+$` 493 | * *手机国家号*: `^+?[\d\s]{3,}$` 494 | * *手机号*: `^+?[\d\s]+(?[\d\s]{10,}$` 495 | * *整数*: `^-?\d+$` 496 | * *用户名*: `^[\w\d_.]{4,16}$` 497 | * *数字和英文字母*: `^[a-zA-Z0-9]*$` 498 | * *数字和应为字母和空格*: `^[a-zA-Z0-9 ]*$` 499 | * *密码*: `^(?=^.{6,}$)((?=.*[A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z]))^.*$` 500 | * *邮箱*: `^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})*$` 501 | * *IP4 地址*: `^((?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$` 502 | * *纯小写字母*: `^([a-z])*$` 503 | * *纯大写字母*: `^([A-Z])*$` 504 | * *URL*: `^(((http|https|ftp):\/\/)?([[a-zA-Z0-9]\-\.])+(\.)([[a-zA-Z0-9]]){2,4}([[a-zA-Z0-9]\/+=%&_\.~?\-]*))*$` 505 | * *VISA 信用卡号*: `^(4[0-9]{12}(?:[0-9]{3})?)*$` 506 | * *日期 (MM/DD/YYYY)*: `^(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?[0-9]{2}$` 507 | * *日期 (YYYY/MM/DD)*: `^(19|20)?[0-9]{2}[- /.](0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])$` 508 | * *MasterCard 信用卡号*: `^(5[1-5][0-9]{14})*$` 509 | 510 | ## 贡献 511 | 512 | * 报告问题 513 | * 开放合并请求 514 | * 传播此文档 515 | * 直接和我联系 ziishaned@gmail.com 或 [](https://twitter.com/ziishaned) 516 | 517 | ## 许可证 518 | 519 | MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) 520 | -------------------------------------------------------------------------------- /translations/how-to.md: -------------------------------------------------------------------------------- 1 | Please put new translation README files here. 2 | 3 | To start a new translation, please: 4 | 5 | 1. Make an issue (for collaboration with other translators) 6 | 2. Make a pull request to collaborate and commit to. 7 | 3. Let me know when it's ready to pull. 8 | 9 | Thank you! --------------------------------------------------------------------------------