\n \t\n
![\"Learn](\"https://i.imgur.com/bYwl7Vf.png\")
\n \n\n
\n \t\n \n \n
\n \n ![\"Download](\"https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a\"){kind=icon}
\n \n
\n ![\"Regular](\"./img/regexp-en.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dmRygT/1)\n\nThe regular expression `123` matches the string `123`. The regular expression is\nmatched against an input string by comparing each character in the regular\nexpression to each character in the input string, one after another. Regular\nexpressions are normally case-sensitive so the regular expression `The` would\nnot match the string `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta Characters\n\nMeta characters are the building blocks of regular expressions. Meta\ncharacters do not stand for themselves but instead are interpreted in some\nspecial way. Some meta characters have a special meaning and are written inside\nsquare brackets. The meta characters are as follows:\n\n|Meta character|Description|\n|:----:|----|\n|.|Period matches any single character except a line break.|\n|[ ]|Character class. Matches any character contained between the square brackets.|\n|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|\n|*|Matches 0 or more repetitions of the preceding symbol.|\n|+|Matches 1 or more repetitions of the preceding symbol.|\n|?|Makes the preceding symbol optional.|\n|{n,m}|Braces. Matches at least \"n\" but not more than \"m\" repetitions of the preceding symbol.|\n|(xyz)|Character group. Matches the characters xyz in that exact order.|\n|||Alternation. Matches either the characters before or the characters after the symbol.|\n|\|Escapes the next character. This allows you to match reserved characters
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Matches the beginning of the input.|\n|$|Matches the end of the input.|\n\n## 2.1 The Full Stop\n\nThe full stop `.` is the simplest example of a meta character. The meta character `.`\nmatches any single character. It will not match return or newline characters.\nFor example, the regular expression `.ar` means: any character, followed by the\nletter `a`, followed by the letter `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Character Sets\n\nCharacter sets are also called character classes. Square brackets are used to\nspecify character sets. Use a hyphen inside a character set to specify the\ncharacters' range. The order of the character range inside the square brackets\ndoesn't matter. For example, the regular expression `[Tt]he` means: an uppercase\n`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/2ITLQ4/1)\n\nA period inside a character set, however, means a literal period. The regular\nexpression `ar[.]` means: a lowercase character `a`, followed by the letter `r`,\nfollowed by a period `.` character.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Test the regular expression](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negated Character Sets\n\nIn general, the caret symbol represents the start of the string, but when it is\ntyped after the opening square bracket it negates the character set. For\nexample, the regular expression `[^c]ar` means: any character except `c`,\nfollowed by the character `a`, followed by the letter `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Repetitions\n\nThe meta characters `+`, `*` or `?` are used to specify how many times a\nsubpattern can occur. These meta characters act differently in different\nsituations.\n\n### 2.3.1 The Star\n\nThe `*` symbol matches zero or more repetitions of the preceding matcher. The\nregular expression `a*` means: zero or more repetitions of the preceding lowercase\ncharacter `a`. But if it appears after a character set or class then it finds\nthe repetitions of the whole character set. For example, the regular expression\n`[a-z]*` means: any number of lowercase letters in a row.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Test the regular expression](https://regex101.com/r/7m8me5/1)\n\nThe `*` symbol can be used with the meta character `.` to match any string of\ncharacters `.*`. The `*` symbol can be used with the whitespace character `\\s`\nto match a string of whitespace characters. For example, the expression\n`\\s*cat\\s*` means: zero or more spaces, followed by a lowercase `c`,\nfollowed by a lowercase `a`, followed by a lowercase `t`,\nfollowed by zero or more spaces.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Test the regular expression](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 The Plus\n\nThe `+` symbol matches one or more repetitions of the preceding character. For\nexample, the regular expression `c.+t` means: a lowercase `c`, followed by\nat least one character, followed by a lowercase `t`. It needs to be\nclarified that`t` is the last `t` in the sentence.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 The Question Mark\n\nIn regular expressions, the meta character `?` makes the preceding character\noptional. This symbol matches zero or one instance of the preceding character.\nFor example, the regular expression `[T]?he` means: Optional uppercase\n`T`, followed by a lowercase `h`, followed by a lowercase `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Braces\n\nIn regular expressions, braces (also called quantifiers) are used to\nspecify the number of times that a character or a group of characters can be\nrepeated. For example, the regular expression `[0-9]{2,3}` means: Match at least\n2 digits, but not more than 3, ranging from 0 to 9.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/juM86s/1)\n\nWe can leave out the second number. For example, the regular expression\n`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the\nregular expression `[0-9]{3}` means: Match exactly 3 digits.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Capturing Groups\n\nA capturing group is a group of subpatterns that is written inside parentheses \n`(...)`. As discussed before, in regular expressions, if we put a quantifier \nafter a character then it will repeat the preceding character. But if we put a quantifier\nafter a capturing group then it repeats the whole capturing group. For example,\nthe regular expression `(ab)*` matches zero or more repetitions of the character\n\"ab\". We can also use the alternation `|` meta character inside a capturing group.\nFor example, the regular expression `(c|g|p)ar` means: a lowercase `c`,\n`g` or `p`, followed by `a`, followed by `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/tUxrBG/1)\n\nNote that capturing groups do not only match, but also capture, the characters for use in \nthe parent language. The parent language could be Python or JavaScript or virtually any\nlanguage that implements regular expressions in a function definition.\n\n### 2.5.1 Non-Capturing Groups\n\nA non-capturing group is a capturing group that matches the characters but \ndoes not capture the group. A non-capturing group is denoted by a `?` followed by a `:` \nwithin parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to \n`(c|g|p)ar` in that it matches the same characters but will not create a capture group.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/Rm7Me8/1)\n\nNon-capturing groups can come in handy when used in find-and-replace functionality or \nwhen mixed with capturing groups to keep the overview when producing any other kind of output. \nSee also [4. Lookaround](#4-lookaround).\n\n## 2.6 Alternation\n\nIn a regular expression, the vertical bar `|` is used to define alternation.\nAlternation is like an OR statement between multiple expressions. Now, you may be\nthinking that character sets and alternation work the same way. But the big\ndifference between character sets and alternation is that character sets work at the\ncharacter level but alternation works at the expression level. For example, the\nregular expression `(T|t)he|car` means: either (an uppercase `T` or a lowercase\n`t`, followed by a lowercase `h`, followed by a lowercase `e`) OR\n(a lowercase `c`, followed by a lowercase `a`, followed by\na lowercase `r`). Note that I included the parentheses for clarity, to show that either expression\nin parentheses can be met and it will match.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Escaping Special Characters\n\nA backslash `\\` is used in regular expressions to escape the next character. This\nallows us to include reserved characters such as `{ } [ ] / \\ + * . $ ^ | ?` as matching characters. To use one of these special character as a matching character, prepend it with `\\`.\n\nFor example, the regular expression `.` is used to match any character except a\nnewline. Now, to match `.` in an input string, the regular expression\n`(f|c|m)at\\.?` means: a lowercase `f`, `c` or `m`, followed by a lowercase\n`a`, followed by a lowercase `t`, followed by an optional `.`\ncharacter.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Anchors\n\nIn regular expressions, we use anchors to check if the matching symbol is the\nstarting symbol or ending symbol of the input string. Anchors are of two types:\nThe first type is the caret `^` that checks if the matching character is the first\ncharacter of the input and the second type is the dollar sign `$` which checks if a matching\ncharacter is the last character of the input string.\n\n### 2.8.1 The Caret\n\nThe caret symbol `^` is used to check if a matching character is the first character\nof the input string. If we apply the following regular expression `^a` (meaning 'a' must be\nthe starting character) to the string `abc`, it will match `a`. But if we apply\nthe regular expression `^b` to the above string, it will not match anything.\nBecause in the string `abc`, the \"b\" is not the starting character. Let's take a look\nat another regular expression `^(T|t)he` which means: an uppercase `T` or\na lowercase `t` must be the first character in the string, followed by a\nlowercase `h`, followed by a lowercase `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 The Dollar Sign\n\nThe dollar sign `$` is used to check if a matching character is the last character\nin the string. For example, the regular expression `(at\\.)$` means: a\nlowercase `a`, followed by a lowercase `t`, followed by a `.`\ncharacter and the matcher must be at the end of the string.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/t0AkOd/1)\n\n## 3. Shorthand Character Sets\n\nThere are a number of convenient shorthands for commonly used character sets/\nregular expressions:\n\n|Shorthand|Description|\n|:----:|----|\n|.|Any character except new line|\n|\\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|\n|\\W|Matches non-alphanumeric characters: `[^\\w]`|\n|\\d|Matches digits: `[0-9]`|\n|\\D|Matches non-digits: `[^\\d]`|\n|\\s|Matches whitespace characters: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Matches non-whitespace characters: `[^\\s]`|\n\n## 4. Lookarounds\n\nLookbehinds and lookaheads (also called lookarounds) are specific types of\n***non-capturing groups*** (used to match a pattern but without including it in the matching\nlist). Lookarounds are used when a pattern must be\npreceded or followed by another pattern. For example, imagine we want to get all\nnumbers that are preceded by the `$` character from the string\n`$4.44 and $10.88`. We will use the following regular expression `(?<=\\$)[0-9\\.]*`\nwhich means: get all the numbers which contain the `.` character and are preceded\nby the `$` character. These are the lookarounds that are used in regular\nexpressions:\n\n|Symbol|Description|\n|:----:|----|\n|?=|Positive Lookahead|\n|?!|Negative Lookahead|\n|?<=|Positive Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negative Lookahead\n\nNegative lookaheads are used when we need to get all matches from an input string\nthat are not followed by a certain pattern. A negative lookahead is written the same way as a\npositive lookahead. The only difference is, instead of an equals sign `=`, we\nuse an exclamation mark `!` to indicate negation i.e. `(?!...)`. Let's take a look at the following\nregular expression `(T|t)he(?!\\sfat)` which means: get all `The` or `the` words\nfrom the input string that are not followed by a space character and the word `fat`.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Positive Lookbehind\n\nPositive lookbehinds are used to get all the matches that are preceded by a\nspecific pattern. Positive lookbehinds are written `(?<=...)`. For example, the\nregular expression `(?<=(T|t)he\\s)(fat|mat)` means: get all `fat` or `mat` words\nfrom the input string that come after the word `The` or `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/avH165/1)\n\n### 4.4 Negative Lookbehind\n\nNegative lookbehinds are used to get all the matches that are not preceded by a\nspecific pattern. Negative lookbehinds are written `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Test the regular expression](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flags\n\nFlags are also called modifiers because they modify the output of a regular\nexpression. These flags can be used in any order or combination, and are an\nintegral part of the RegExp.\n\n|Flag|Description|\n|:----:|----|\n|i|Case insensitive: Match will be case-insensitive.|\n|g|Global Search: Match all instances, not just the first.|\n|m|Multiline: Anchor meta characters work on each line.|\n\n### 5.1 Case Insensitive\n\nThe `i` modifier is used to perform case-insensitive matching. For example, the\nregular expression `/The/gi` means: an uppercase `T`, followed by a lowercase\n`h`, followed by an `e`. And at the end of regular expression\nthe `i` flag tells the regular expression engine to ignore the case. As you can\nsee, we also provided `g` flag because we want to search for the pattern in the\nwhole input string.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Global Search\n\nThe `g` modifier is used to perform a global match (finds all matches rather than\nstopping after the first match). For example, the regular expression`/.(at)/g`\nmeans: any character except a new line, followed by a lowercase `a`,\nfollowed by a lowercase `t`. Because we provided the `g` flag at the end of\nthe regular expression, it will now find all matches in the input string, not just the first one (which is the default behavior).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multiline\n\nThe `m` modifier is used to perform a multi-line match. As we discussed earlier,\nanchors `(^, $)` are used to check if a pattern is at the beginning of the input or\nthe end. But if we want the anchors to work on each line, we use\nthe `m` flag. For example, the regular expression `/at(.)?$/gm` means: a lowercase\n`a`, followed by a lowercase `t` and, optionally, anything except\na new line. And because of the `m` flag, the regular expression engine now matches patterns\nat the end of each line in a string.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/E88WE2/1)\n\n## 6. Greedy vs Lazy Matching\nBy default, a regex will perform a greedy match, which means the match will be as long as\npossible. We can use `?` to match in a lazy way, which means the match should be as short as possible.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/2)\n\n\n## Contribution\n\n* Open a pull request with improvements\n* Discuss ideas in issues\n* Spread the word\n\n## License\n\nMIT © Zeeshan Ahmad\n" }, { "path": "translations/README-cn.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Regular](\"../img/regexp-cn.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/dmRygT/1)\n\n正则表达式 `123` 匹配字符串 `123`。它逐个字符的与输入的正则表达式做比较。\n\n正则表达式是大小写敏感的，所以 `The` 不会匹配 `the`。\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/1paXsy/1)\n\n## 2. 元字符\n\n正则表达式主要依赖于元字符。\n元字符不代表他们本身的字面意思，他们都有特殊的含义。一些元字符写在方括号中的时候有一些特殊的意思。以下是一些元字符的介绍：\n\n|元字符|描述|\n|:----:|----|\n|.|句号匹配任意单个字符除了换行符。|\n|[ ]|字符种类。匹配方括号内的任意字符。|\n|[^ ]|否定的字符种类。匹配除了方括号里的任意字符|\n|*|匹配 >=0 个重复的在 * 号之前的字符。|\n|+|匹配 >=1 个重复的 + 号前的字符。|\n|?|标记 ? 之前的字符为可选。|\n|{n,m}|匹配 num 个大括号之前的字符或字符集 (n <= num <= m)。|\n|(xyz)|字符集，匹配与 xyz 完全相等的字符串。|\n|||或运算符，匹配符号前或后的字符。|\n|\|转义字符，用于匹配一些保留的字符
![](\"https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square\"/){kind=icon}
\n ![](\"https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square\"){kind=icon}
\n [ ] ( ) { } . * + ? ^ $ \\ ||\n|^|从开始行开始匹配。|\n|$|从末端开始匹配。|\n\n## 2.1 点运算符 `.`\n\n`.` 是元字符中最简单的例子。\n`.` 匹配任意单个字符，但不匹配换行符。\n例如，表达式 `.ar` 匹配一个任意字符后面跟着是 `a` 和 `r` 的字符串。\n\n\n\".ar\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 字符集\n\n字符集也叫做字符类。\n方括号用来指定一个字符集。\n在方括号中使用连字符来指定字符集的范围。\n在方括号中的字符集不关心顺序。\n例如，表达式 `[Tt]he` 匹配 `the` 和 `The`。\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/2ITLQ4/1)\n\n方括号的句号就表示句号。\n表达式 `ar[.]` 匹配 `ar.` 字符串。\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[在线练习](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 否定字符集\n\n一般来说 `^` 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的。\n例如，表达式 `[^c]ar` 匹配一个后面跟着 `ar` 的除了 `c` 的任意字符。\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 重复次数\n\n后面跟着元字符 `+`，`*` or `?` 的，用来指定匹配子模式的次数。\n这些元字符在不同的情况下有着不同的意思。\n\n### 2.3.1 `*` 号\n\n`*` 号匹配在 `*` 之前的字符出现 `大于等于0` 次。\n例如，表达式 `a*` 匹配 0 或更多个以 a 开头的字符。表达式 `[a-z]*` 匹配一个行中所有以小写字母开头的字符串。\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[在线练习](https://regex101.com/r/7m8me5/1)\n\n`*` 字符和 `.` 字符搭配可以匹配所有的字符 `.*`。\n`*` 和表示匹配空格的符号 `\\s` 连起来用，如表达式 `\\s*cat\\s*` 匹配 0 或更多个空格开头和 0 或更多个空格结尾的 cat 字符串。\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[在线练习](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 `+` 号\n\n`+` 号匹配 `+` 号之前的字符出现 >=1 次。\n例如表达式 `c.+t` 匹配以首字母 `c` 开头以 `t` 结尾，中间跟着至少一个字符的字符串。\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 `?` 号\n\n在正则表达式中元字符 `?` 标记在符号前面的字符为可选，即出现 0 或 1 次。\n例如，表达式 `[T]?he` 匹配字符串 `he` 和 `The`。\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 `{}` 号\n\n在正则表达式中 `{}` 是一个量词，常用来限定一个或一组字符可以重复出现的次数。\n例如，表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/juM86s/1)\n\n我们可以省略第二个参数。\n例如，`[0-9]{2,}` 匹配至少两位 0~9 的数字。\n如果逗号也省略掉则表示重复固定的次数。\n例如，`[0-9]{3}` 匹配 3 位数字。\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/Sivu30/1)\n\n## 2.5 `(...)` 捕获组\n\n特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。\n例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。\n如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b`。\n再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。\n但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。\n我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/tUxrBG/1)\n\n请注意，特征标群不仅会匹配，而且会捕获，可以在宿主语言中被引用。\n宿主语言可以是 Python 或 JavaScript 或几乎任何在函数定义中实现正则表达式的语言。\n\n### 2.5.1 非捕获组\n\n非捕获组匹配字符但不捕获该组。 一个非捕获组由在括号 `（...）` 内的一个 `?` 后跟一个 `:` 表示。 例如，正则表达式 `(?:c|g|p)ar` 和 `(c|g|p)ar` 类似，可以匹配相同的字符，但不会创建捕获组。\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/Rm7Me8/1)\n\n非捕获组用于查找和替换功能，或与捕获组混合以在生成任何其他类型的输出的时候，不记录匹配的内容。\n可参考 [4. 零宽度断言(前后预查)](#4-零宽度断言前后预查)。\n\n## 2.6 `|` 或运算符\n\n或运算符就表示或，用作判断条件。\n\n例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`。\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 转义特殊字符\n\n反斜线 `\\` 在表达式中用于转义紧跟其后的字符。\n用于指定 `{ } [ ] / \\ + * . $ ^ | ?` 这些特殊字符。\n如果想要匹配这些特殊字符则要在其前面加上反斜线 `\\`。\n\n例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\\.`。\n以下这个例子 `\\.?` 是选择性匹配 `.`。\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 锚点\n\n在正则表达式中，想要匹配指定开头或结尾的字符串就要使用到锚点。`^` 指定开头，`$` 指定结尾。\n\n### 2.8.1 `^` 号\n\n`^` 用来检查匹配的字符串是否在所匹配字符串的开头。\n\n例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。\n但如果使用 `^b` 将匹配不到任何结果。\n因为字符串 `abc` 并不是以 b 开头。\n\n例如，`^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串。\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 `$` 号\n\n同理于 `^` 号，`$` 号用来匹配字符是否是最后一个。\n\n例如，`(at\\.)$` 匹配以 `at.` 结尾的字符串。\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[在线练习](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[在线练习](https://regex101.com/r/t0AkOd/1)\n\n## 3. 简写字符集\n\n正则表达式提供一些常用的字符集简写。如下:\n\n|简写|描述|\n|:----:|----|\n|.|除换行符外的所有字符|\n|\\w|匹配所有字母数字，等同于 `[a-zA-Z0-9_]`|\n|\\W|匹配所有非字母数字，即符号，等同于： `[^\\w]`|\n|\\d|匹配数字： `[0-9]`|\n|\\D|匹配非数字： `[^\\d]`|\n|\\s|匹配所有空格字符，等同于： `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|匹配所有非空格字符： `[^\\s]`|\n|\\f|匹配一个换页符|\n|\\n|匹配一个换行符|\n|\\r|匹配一个回车符|\n|\\t|匹配一个制表符|\n|\\v|匹配一个垂直制表符|\n|\\p|匹配 CR/LF（等同于 `\\r\\n`），用来匹配 DOS 行终止符|\n\n## 4. 零宽度断言（前后预查）\n\n先行断言和后发断言（合称 lookaround）都属于**非捕获组**（用于匹配模式，但不包括在匹配列表中）。当我们需要一个模式的前面或后面有另一个特定的模式时，就可以使用它们。\n\n例如，我们希望从下面的输入字符串 `$4.44` 和 `$10.88` 中获得所有以 `$` 字符开头的数字，我们将使用以下的正则表达式 `(?<=\\$)[0-9\\.]*`。意思是：获取所有包含 `.` 并且前面是 `$` 的数字。\n\n零宽度断言如下：\n\n|符号|描述|\n|:----:|----|\n|?=|正先行断言-存在|\n|?!|负先行断言-排除|\n|?<=|正后发断言-存在|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/IDDARt/1)\n\n### 4.2 `?!...` 负先行断言\n\n负先行断言 `?!` 用于筛选所有匹配结果，筛选条件为其后 不跟随着断言中定义的格式。\n`正先行断言` 定义和 `负先行断言` 一样，区别就是 `=` 替换成 `!` 也就是 `(?!...)`。\n\n表达式 `(T|t)he(?!\\sfat)` 匹配 `The` 和 `the`，且其后不跟着 `(空格)fat`。\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/V32Npg/1)\n\n### 4.3 `?<= ...` 正后发断言\n\n正后发断言记作 `(?<=...)`，用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。\n例如，表达式 `(?<=(T|t)he\\s)(fat|mat)` 匹配 `fat` 和 `mat`，且其前跟着 `The` 或 `the`。\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/avH165/1)\n\n### 4.4 `?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[在线练习](https://regex101.com/r/8Efx5G/1)\n\n## 5. 标志\n\n标志也叫模式修正符，因为它可以用来修改表达式的搜索结果。\n这些标志可以任意的组合使用，它也是整个正则表达式的一部分。\n\n|标志|描述|\n|:----:|----|\n|i|忽略大小写。|\n|g|全局搜索。|\n|m|多行修饰符：锚点元字符 `^` `$` 工作范围在每行的起始。|\n\n### 5.1 忽略大小写 (Case Insensitive)\n\n修饰语 `i` 用于忽略大小写。\n例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`，`g` 表示全局搜索。\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 全局搜索 (Global search)\n\n修饰符 `g` 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。\n例如，表达式 `/.(at)/g` 表示搜索 任意字符（除了换行）+ `at`，并返回全部结果。\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/dO1nef/1)\n\n### 5.3 多行修饰符 (Multiline)\n\n多行修饰符 `m` 常用于执行一个多行匹配。\n\n像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾。但我们如果想要它在每行的开头和结尾生效，我们需要用到多行修饰符 `m`。\n\n例如，表达式 `/at(.)?$/gm` 表示小写字符 `a` 后跟小写字符 `t` ，末尾可选除换行符外任意字符。根据 `m` 修饰符，现在表达式匹配每行的结尾。\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[在线练习](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[在线练习](https://regex101.com/r/E88WE2/1)\n\n### 6. 贪婪匹配与惰性匹配 (Greedy vs lazy matching)\n\n正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 `?` 将贪婪匹配模式转化为惰性匹配模式。\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n[在线练习](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n[在线练习](https://regex101.com/r/AyAdgJ/2)\n\n## 贡献\n\n* 报告问题\n* 开放合并请求\n* 传播此文档\n* 直接和我联系 ziishaned@gmail.com 或 [](https://twitter.com/ziishaned)\n\n## 许可证\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-de.md", "content": "
\n
\n \n \n \n
\n ![\"Regular](\"../img/regexp-de.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1)\n\nDer reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Auf Übereinstimmung mit einer Zeichenkette wird er überprüft, indem jedes Zeichen in dem regulären Ausdruck nacheinander mit jedem Zeichen der Zeichenkette verglichen wird. \nReguläre Ausdrücke berücksichtigen normalerweise Groß- und Kleinschreibung, sodass etwa der Ausdruck `The` nicht mit der Zeichenkette `the` übereinstimmen würde. \n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/1paXsy/1)\n\n## 2. Metazeichen\n\nMetazeichen sind Bausteine von regulären Ausdrücken. Sie stehen nicht für sich selbst, sondern haben eine besondere Bedeutung und werden in spezieller Weise interpretiert.\nEinige Metazeichen erhalten eine andere Bedeutung oder überhaupt erst eine besondere Bedeutung innerhalb eckiger Klammern `[]`. Folgende Metazeichen gibt es:\n\n|Metazeichen|Beschreibung|\n|:----:|----|\n|.|Der Punkt entspricht jedem einzelnen Zeichen, außer Zeilenumbrüchen.|\n|[ ]|Zeichenklasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|\n|[^ ]|Negierte Zeichenklasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|\n|*|Entspricht 0 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|\n|+|Entspricht 1 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|\n|?|Macht den vorhergehenden Teilausdruck optional.|\n|{n,m}|Entspricht mindestens \"n\", aber nicht mehr als \"m\" Wiederholungen des vorhergehenden Teilausdrucks.|\n|(xyz)|Gruppierung, entspricht den Zeichen xyz in der exakten Reihenfolge.|\n|||Alternation, entspricht entweder dem Teilausdruck vor oder nach dem \\|.|\n|\|Escaped das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Entspricht dem Anfang der Eingabe.|\n|$|Entspricht dem Ende der Eingabe.|\n\n## 2.1 Punkt\n\nDer Punkt `.` ist das einfachste Beispiel für ein Metazeichen. Er steht für jedes beliebiges Zeichen mit der Ausnahme von Zeilenumbrüchen/Enter-Zeichen. \nAls Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n[Teste den regulären Ausdruck](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Zeichenklasse\n\nZeichenklassen werden auch als Zeichenmengen oder -sätze bezeichnet (eng. *character set/class*). Sie werden in eckige Klammern definiert. Um eine Zeichenfolge wie `A-Z` oder `0-9` zu definieren, kann ein Bindestrich `-` verwendet werden. Die Reihenfolge sonstiger Zeichen innerhalb der eckigen Klammern spielt keine Rolle. Zum Beispiel bedeutet der reguläre Ausdruck `[Tt]he`: ein groß geschriebenes `T` oder ein kleingeschriebenes `t`, gefolgt vom Buchstaben `h` und weiter gefolgt vom Buchstaben `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n[Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1)\n\nEin Punkt in einer Zeichenklasse bedeutet, anders als sonst, einen wörtlichen Punkt. Der reguläre Ausdruck `ar[.]` bedeutet: ein kleingeschriebenes Zeichen `a`, gefolgt vom kleingeschriebenen Buchstaben `r`, gefolgt von einem Punkt-Zeichen `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negierte Zeichenklasse\n\nIm Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird die Zeichenklasse negiert (eng. *negated character set*). Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: ein beliebiges Zeichen außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. \n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Wiederholungen\n\nDie Metazeichen `+`, `*` und `?` bieten einen einfachen Weg, anzugeben, wie oft sich ein bestimmter Teilausdruck wiederholen soll. Sie gehören damit zu den sogenannten \"Quantifizierern\" (eng. *quantifier*).\nSie können sich je nach Situation unterschiedlich verhalten.\n\n### 2.3.1 Stern\n\nDas Symbol `*` stimmt mit beliebig vielen Wiederholungen des vorhergehenden Teilausdrucks überein. Der Ausdruck `a*` heißt: \nnull, eins oder mehrere `a`s in Folge. Da sich der Stern auf Teilausdrücke bezieht, kann er auch bspw. hinter einer Zeichenklasse stehen\nund stimmt dann mit beliebig vielen Zeichen aus der Klasse in Folge überein. Zum Beispiel bedeutet der Ausdruck `[a-z]*`: eine \nbeliebige Anzahl von Kleinbuchstaben in Folge.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/7m8me5/1)\n\nDas `*`-Symbol kann zusammen mit dem Metazeichen `.` verwendet werden, um mit einer vollkommen beliebigen Zeichenkette übereinzustimmen `.*`.\nEs kann auch mit der vordefinierten Zeichenklasse `\\s` verwendet werden, um mit beliebig viel Leerraum (Leerzeichen, Tabulatoren, Zeilenumbrüchen)\nübereinzustimmen. Der Ausdruck `\\s*cat\\s*` heißt zum Beispiel: null oder mehrere Leerzeichen, gefolgt von dem Buchstaben `c`, gefolgt vom Buchstaben `a`, \ngefolgt vom Buchstaben `t` und schließlich gefolgt von null oder mehreren Leerzeichen.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Plus\n\nDas `+`-Symbol stimmt mit einer oder mehr Wiederholungen des vorhergehenden Teilausdrucks überein. Der reguläre Ausdruck\n`c.+t` bedeutet: Buchstabe `c`, gefolgt von mindestens einem beliebigen Zeichen, gefolgt vom Buchstaben `t`. Das `t` ist dabei\ndas letzte `t` in der hier zu sehenden Übereinstimmung, wobei es hier auch weitere Übereinstimmungen gäbe (siehe \"Teste den regulären Ausdruck\").\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Fragezeichen\n\nIn regulären Ausdrücken sorgt das Metazeichen `?` dafür, dass der vorhergehende Teilausdruck optional wird.\nSomit stimmt es mit null oder einer Übereinstimmung des Teilausdrucks überein.\nZum Beispiel heißt der reguläre Ausdruck `[T]?he`: ein oder kein `T`, gefolgt von dem Buchstaben `h`, gefolgt von dem Buchstaben `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Geschweifte Klammern\n\nGeschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantifizierern. Sie werden verwendet, \num genau anzugeben wie oft ein Teilausdruck minimal und maximal hintereinander übereinstimmen muss.\nZum Beispiel bedeutet der reguläre Ausdruck `[0-9]{2,3}`: Mindestens zwei, aber maximal drei Ziffern (Zeichenfolge 0-9) hintereinander.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/juM86s/1)\n\nDie zweite Zahl kann ausgelassen werden. Somit heißt der Ausdruck `[0-9]{2,}`: zwei oder mehr Ziffern in Folge.\nWenn wir auch das Komma entfernen, heißt `[0-9]{3}`: genau drei Ziffern in Folge.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Gruppierungen\n\nEine Gruppierung (eng. *capturing group*) fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen. \nEine Gruppierung selbst ist ebenfalls ein Teilausdruck, weshalb Quantoren wie `{}`, `*` oder `?` auf sie angewendet werden können.\nZum Beispiel stimmt der reguläre Ausdruck `(ab)*` mit null oder mehr Vorkommen von `a` und `b` hintereinander überein.\nAuch das \"Oder\"-Metazeichen `|` kann innerhalb einer Gruppierung verwendet werden. Der reguläre Ausdruck `(c|g|p)ar` bedeutet:\nkleines `c`, `g` oder `p`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. Dies ist äquivalent zu `[cgp]ar`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/tUxrBG/1)\n\nGruppierungen stimmen nicht nur mit Zeichenketten überein, sondern \"merken\" sich auch die übereinstimmenden Zeichen in der Gruppe für die Verwendung in der Elternsprache\n(auch Rückwärtsreferenz genannt).\nDie Elternsprache kann Python, JavaScript oder sonst irgendeine Sprache sein, die reguläre Ausdrücke implementiert.\n\n\n### 2.5.1 Gruppierungen ohne Rückwärtsreferenz\n\nGruppierungen ohne Rückwärtsreferenz (eng. *non-capturing groups*) sind Gruppierungen, die nur mit den Zeichen übereinstimmen, diese aber nicht für spätere Verwendung zwischenspeichern.\nSolche Gruppierungen werden mit einem `?`, gefolgt von einem `:` in Klammern `(...)` definiert.\nSomit gleicht der reguläre Ausdruck `(?:c|g|p)ar` dem Ausdruck `(c|g|p)ar` in seiner Übereinstimmung mit den Zeichenketten, aber im Gegensatz erzeugt er keine Rückwärtsreferenz.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/Rm7Me8/1)\n\nGruppierungen ohne Rückwärtsreferenz können für Finden-und-Ersetzen oder in Kombination mit normalen Gruppierungen nützlich sein, um den Überblick zu behalten, \nwenn auf Basis der Übereinstimmungen eine Ausgabe erzeugt wird. Siehe auch [4. Lookaround](#4-lookaround).\n\n## 2.6 Alternation\n\nIn einem regulären Ausdruck wird der Trennstrich `|` verwendet, um Alternativen (eng. *alternation*) zu definieren.\nAlternation ist wie ein \"ODER\" zwischen mehreren Teilausdrücken. Nun könnte man annehmen, dass\nZeichenklassen und Alternation auf die gleiche Art und Weise funktionieren. Aber der große Unterschied \nzwischen diesen beiden ist, dass Zeichenklassen für einzelne Zeichen funktionieren, während für Alternationen\nbeliebige Teilausdrücke verwendet werden können. So heißt der reguläre Ausdruck `(T|t)he|car` beispielsweise:\nEntweder ein großes `T` oder kleines `t`, dann der Buchstabe `h` gefolgt vom Buchstaben `e` ODER \n`c`, gefolgt von `a`, gefolgt von `r`. Man beachte die Klammern, die zur Trennung der einen Alternation von der anderen\ngesetzt wurden.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Escaping\n\nDer Backslash `\\` wird in regulären Ausdrücken verwendet, um die besondere Bedeutung des folgenden Zeichens aufzuheben (eng. *escape*) oder ihm eine besondere Bedeutung zu verleihen \n(s. [Vordefinierte Zeichenklassen](#3-vordefinierte-zeichenklassen)).\nEr erlaubt es, für andere Zwecke reservierte Zeichen wie die Metazeichen `{ } [ ] / \\ + * . $ ^ | ?` als Literale, also wörtliche Übereinstimmungen zu nutzen.\nUm mit einem besonderen Zeichen wortwörtlich übereinzustimmen, muss es auf ein `\\` folgen.\n\nDer reguläre Ausdruck `.` zum Beispiel wird benutzt, um mit einem beliebigen Zeichen übereinzustimmen. \nDer Ausdruck `(f|c|m)at\\.?` hebt diese Bedeutung auf: `f`, `c` oder `m`, gefolgt von `a`, gefolgt von `t`, schließlich gefolgt von einem optionalen `.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Anker\n\nIn regulären Audrücken werden Anker (eng. *anchor*) verwendet, um zu überprüfen, ob der Teilausdruck mit dem \nAnfang oder dem Ende der Teilausgabe übereinstimmt. Es gibt zwei Arten von Ankern: das Zirkumflex `^`\nstimmt mit dem Anfang, das Dollarzeichen `$` mit dem Ende der Eingabe überein. \n\n### 2.8.1 Zirkumflex\n\nDas Zirkumflex `^` (eng. *caret*) wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Anfang der Zeichenkette übereinstimmt.\nWenn wir den regulären Ausdruck `^a` auf die Eingabe `abc` anwenden, stimmt er mit `a` überein. \nAber wenn wir auf die gleiche Eingabe den Ausdruck `^b` anwenden, gibt es keine Übereinstimmungen, weil in der Zeichenkette `abc` kein \"b\"\nam Anfang steht. Schauen wir uns einen anderen Ausdruck an: `^(T|t)he`. Dieser bedeutet: kleines `t` oder großes `T` am Anfang der Eingabe,\ngefolgt von `h`, gefolgt von `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dollar\n\nDas Dollarzeichen `$` wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Ende der Zeichenkette übereinstimmt.\nDer reguläre Ausdruck `(at\\.)$` etwa bedeutet: `a`, gefolgt von `t` und dann `.` am Ende der Eingabe.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/t0AkOd/1)\n\n## 3. Vordefinierte Zeichenklassen\n\nReguläre Ausdrücke haben Kürzel für die am häufigsten benötigten Zeichenklassen, was viele Ausdrücke vereinfacht und kürzer macht.\nDas sind die vordefinierten Zeichenklassen:\n\n|Shorthand|Description|\n|:----:|----|\n|.|Beliebiges Zeichen außer Zeilenumbruch|\n|\\w|Stimmt mit alphanumerischen Zeichen überein: `[a-zA-Z0-9_]`|\n|\\W|Stimmt mit nicht-alphanumerischen Zeichen überein: `[^\\w]`|\n|\\d|Stimmt mit Ziffern überein: `[0-9]`|\n|\\D|Stimmt mit Zeichen, die keine Ziffern sind überein: `[^\\d]`|\n|\\s|Stimmt mit Leerraum überein: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Stimmt mit allem außer Leerraum überein: `[^\\s]`|\n\n## 4. Umsehen (Lookaround)\n\nLookbehind (\"zurückschauen\") und Lookahead (\"vorausschauen\") (auch Lookaround (\"Umsehen\") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**\n(zur Erinnerung: das sind Gruppierungen, die zwar mit dem Muster übereinstimmen, aber sich die Übereinstimmung nicht \"merken\").\nSie werden in Situationen verwendet, wo wir ein Muster einfangen wollen, dem andere Muster folgen oder vorhergehen.\nZum Beispiel wollen wir alle Zahlen aus der Zeichenkette `$4.44 and $10.88`, vor denen ein Dollarzeichen `$` steht. Wir benutzen dafür den folgenden regulären Audruck:\n`(?<=\\$)[0-9.]*`. Das heißt: Stimme mit allen Zeichenketten überein, die Ziffern `0-9` oder Punkte `.` enthalten und die einem Dollarzeichen `$` folgen.\n\nDas sind die Lookarounds, die es gibt:\n\n|Symbol|Name|\n|:----:|----|\n|?=|Positiver Lookahead|\n|?!|Negativer Lookahead|\n|?<=|Positiver Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negatives Vorausschauen (Lookahead)\n\nNegative Lookaheads werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, auf die **nicht** ein bestimmtes Muster folgt.\nEin Negativer Lookahead wird wie ein positiver Lookahead definiert, nur dass statt einem Gleichheitszeichen ein Ausrufezeichen `!` benutzt wird, d.h.\n`(?!...)`. Aus dem regulären Ausdruck `(T|t)he(?!\\sfat)` folgt somit: alle `The` oder `the`, auf die **kein** Leerzeichen und das Wort `fat` folgt, stimmen überein.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Positives Zurückschauen (Lookbehind)\n\nPositive Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen ein bestimmtes Muster vorhergeht.\nPostive Lookbehinds werden mit `(?<=...)` notiert. Der reguläre Ausdruck `(?<=(T|t)he\\s)(fat|mat)` zum Beispiel bedeutet: alle `fat` oder `mat`, \ndie nach `The ` oder `the ` kommen, stimmen überein.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/avH165/1)\n\n### 4.4 Negativer Lookbehind\n\nNegative Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen **nicht** ein bestimmtes Muster vorhergeht.\nNegative Lookbehinds werden mit `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/8Efx5G/1)\n\n## 5. Modifikatoren\n\nModifikatoren (eng. *flags* oder *modifiers*) verändern die Ausgabe eines regulären Ausdrucks. Sie können in beliebiger Kombination oder Reihenfolge \ngenutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.\n\n\n|Modifikator|Beschreibung|\n|:----:|----|\n|i|Schreibungsunabhängig: Unterschiede bei Groß- und Kleinschreibung in den Mustern werden ignoriert.|\n|g|Globale Suche: Die Suche geht durch die gesamte Eingabe.|\n|m|Mehrzeilig: Anker-Metazeichen funktionieren für Anfang/Ende jeder Zeile.|\n\n### 5.1 Groß-/Kleinschreibung unempfindlich\n\nDer `i` Modifikator wird benutzt, um unabhängige Übereinstimmungen bei der Groß-/Kleinschreibung zu finden. Zum Beispiel heißt der reguläre Ausdruck\n`/The/gi`: großes `T`, gefolgt von `h`, dann `e`. Und am Ende des Ausdrucks ist der `i` Modifikator zu finden, welcher der Maschine \nzu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden sollen. Wie zu sehen ist, wird auch der `g` Modifikator benutzt,\nda wir die gesamte Eingabe nach dem Muster absuchen wollen.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Globale Suche\n\nDer `g` Modifikator wird benutzt, um eine globale Suche durchzuführen (alle Übereinstimmungen finden, nicht nach der ersten aufhören).\nZum Beispiel heißt der reguläre Ausdruck `/.(at)/g`: ein beliebiges Zeichen (außer Zeilenumbruch), gefolgt von `a`, gefolgt von `t`.\nWeil wir den `g` Modifikator angegeben haben, findet der reguläre Ausdruck nun alle Übereinstimmungen in der Eingabe, nicht nur die erste\n(was das Standardverhalten ist).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Mehrzeilig\n\nDer `m` Modifikator wird benutzt, um eine mehrzeilige Suche durchzuführen. Wie zuvor erwähnt werden Anker `(^, $)` genutzt, um zu überprüfen,\nob ein Muster dem Anfang oder dem Ende der Eingabe entspricht. Wenn wir stattdessen wollen, dass Anker zeilenweise funktionieren, nutzen wir den `m`\nModifikator. Zum Beispiel bedeutet der reguläre Ausdruck `/at(.)?$/gm`: `a`, gefolgt von `t`, dann optional ein beliebiges Zeichen außer \nZeilenumbruch. Wegen des `m` Modifikators wird das Muster nun auf das Ende jeder Zeile statt nur das Ende der gesamten Eingabe angewandt.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1)\n\n## 6. Gierige vs. faule Übereinstimmung\n\nStandardmäßig finden reguläre Ausdrücke Übereinstimmungen mit Gier (eng. *greed*), d.h. es wird nach den längsten Übereinstimmungen gesucht. \nMit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten Übereinstimmungen gesucht.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n\n[Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2)\n\n## Beitragen\n\n* Öffne Pull Requests mit Verbesserungen\n* Diskutiere Ideen in Issues\n* Erzähl es anderen\n* Gib Rückmeldung [](https://twitter.com/ziishaned)\n\n## Lizenz\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-es.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Expresión](\"../img/regexp-es.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/dmRygT/1)\n\nLa expresión regular `123` coincide con la cadena `123`. La expresión regular se compara con una cadena de entrada al comparar cada carácter de la expresión regular con cada carácter de la cadena de entrada, uno tras otro. Las expresiones regulares son normalmente sensibles a mayúsculas y minúsculas, por lo que la expresión regular `The` no coincide con la cadena `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta-caracteres\n\nLos meta-caracteres son los bloques de construcción de las expresiones regulares. Los meta-caracteres no se trabajan por sí mismos, sino que se interpretan de alguna manera especial. Algunos meta-caracteres tienen un significado especial y se escriben entre corchetes. Los meta-caracteres son los siguientes:\n\n|Meta-carácter|Descripción|\n|:----:|----|\n|.|Punto: Coincide con cualquier carácter excepto un salto de línea.|\n|[ ]|Clase de caracteres: Coincide con cualquier carácter contenido entre corchetes.|\n|[^ ]|Clase de caracteres negados: Coincide con cualquier carácter que no está contenido dentro de los corchetes.|\n|*|Asterisco: Corresponde con 0 o más repeticiones del símbolo precedente.|\n|+|Signo de más: Corresponde con 1 o más repeticiones del símbolo precedente.|\n|?|Signo de interrogación: Hace que el símbolo precedente sea opcional.|\n|{n,m}|Llaves: Corresponde al menos \"n\" pero no más de \"m\" repeticiones del símbolo precedente.|\n|(xyz)|Grupo de caracter: Hace coincidir los caracteres xyz en ese orden exacto.|\n|||Alternancia: Corresponde a los caracteres anteriores o los caracteres después del símbolo.|\n|\|Escapa el siguiente carácter: Esto le permite hacer coincidir los caracteres reservados
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Acento circunflejo: Hace coincidir el principio de la entrada.|\n|$|Símbolo de dólar: Corresponde al final de la entrada.|\n\n## 2.1 Full stop\n\nFull stop `.` es el ejemplo más simple del meta-carácter. El meta-carácter `.` coincide con cualquier carácter. No coincidirá con el retorno o nuevos caracteres de línea. Por ejemplo, la expresión regular `.ar` significa: cualquier carácter, seguido del carácter `a`, seguido del carácter `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Conjunto de caracteres\n\nLos conjuntos de caracteres también se llaman clase de caracteres. Los corchetes se utilizan para especificar conjuntos de caracteres. Utilice un guion dentro de un conjunto de caracteres para especificar el rango de los caracteres. El orden del rango de caracteres dentro de corchetes no importa. Por ejemplo, la expresión regular `[Tt]he` significa: un carácter en mayúscula `T` o minúscula `t`, seguido del carácter `h`, seguido del carácter `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/2ITLQ4/1)\n\nSin embargo, un período dentro de un conjunto de caracteres significa un período literal. La expresión regular `ar[.]` significa: un carácter en minúscula `a`, seguido del carácter `r`, seguido del carácter `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Prueba la expresión regular](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Conjunto de caracteres negados\n\nEn general, el símbolo de intercalación representa el comienzo de la cadena, pero cuando se escribe después del corchete de apertura niega el conjunto de caracteres. Por ejemplo, la expresión regular `[^c]ar` significa: cualquier carácter, excepto `c`, seguido del carácter `a`, seguido del carácter `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Repeticiones\n\nLos siguientes caracteres meta `+`, `*` o `?`, se utilizan para especificar cuántas veces puede producirse un subpatrón. Estos meta-caracteres actúan de manera diferente en diferentes situaciones.\n\n### 2.3.1 Asterisco\n\nEl símbolo `*` coincide con cero o más repeticiones del marcador anterior. La expresión regular `a*` significa: cero o más repeticiones del carácter en minúscula precedente `a`. Pero, si aparece después de un conjunto de caracteres o una clase, entonces encuentra las repeticiones de todo el conjunto de caracteres. Por ejemplo, la expresión regular `[a-z]*` significa: cualquier número de letras minúsculas en una fila.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Prueba la expresión regular](https://regex101.com/r/7m8me5/1)\n\nEl símbolo `*` se puede utilizar con el meta-carácter `.` para que coincida con cualquier cadena de caracteres `.*`. El símbolo `*` se puede utilizar con el carácter de espacio en blanco `\\s` para que coincida con una cadena de caracteres de espacio en blanco. Por ejemplo, la expresión `\\s*cat\\s*` significa: cero o más espacios, seguido por el carácter en minúscula `c`, seguido del carácter en minúscula `a`, seguido del carácter en minúscula `t`, seguido de cero o más espacios.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Prueba la expresión regular](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Signo de más\n\nEl símbolo `+` coincide con una o más repeticiones del carácter anterior. Por ejemplo, la expresión regular `c.+T` significa: carácter en minúscula `c`, seguido por lo menos de un carácter, luego el carácter en minúscula `t`.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Signo de interrogación\n\nEn expresiones regulares el meta-carácter `?` hace que el carácter precedente sea opcional. Este símnbolo coincide con cero o una instancia del carácter precedente. Por ejemplo, la expresión regular `[T]?he` significa: El carácter opcional `T` seguido por el carácter en minúscula `h`, seguido del carácter en minúscula `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Llaves\n\nEn la expresión regular, las llaves, que también se denominan cuantificadores, son utilizados para especificar el número de veces que se puede repetir un carácter o un grupo de caracteres. Por ejemplo, la expresión regular `[0-9]{2,3}` significa: Combina al menos 2 dígitos pero no más de 3 (caracteres en el rango de 0 a 9).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Prueba la expresión regular](https://regex101.com/r/juM86s/1)\n\nPodemos dejar fuera el segundo número. Por ejemplo, la expresión regular `[0-9] {2,}` significa: Combina 2 o más dígitos. Si también eliminamos la coma, la expresión regular `[0-9]{3}` significa: coincidir exactamente con 3 dígitos.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Prueba la expresión regular](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Prueba la expresión regular](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Grupos de caracteres\n\nUn grupo de caracteres es un grupo de sub-patrones que se escribe dentro de paréntesis `(...)`. Como hemos discutido antes en la expresión regular, si ponemos un cuantificador después de un carácter, repetiremos el carácter anterior. Pero si ponemos un cuantificador después de un grupo de caracteres, entonces repetimos todo el grupo de caracteres. Por ejemplo, la expresión regular `(ab)*` coincide con cero o más repeticiones del caracter `ab`. También podemos usar el carácter de alternancia `|` meta dentro del grupo de caracteres. Por ejemplo, la expresión regular `(c|g|p)ar` significa: carácter en minúscula `c`, `g` o `p`, seguido del carácter `a`, seguido del carácter `r`.\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Alternancia\n\nEn la expresión regular, la barra vertical `|` se utiliza para definir la alternancia. La alternancia es como una condición entre múltiples expresiones. Ahora, puedes estar pensando que el conjunto de caracteres y la alternancia funciona de la misma manera. Sin embargo, la gran diferencia entre el conjunto de caracteres y la alternancia es que el conjunto de caracteres funciona a nivel de carácter pero la alternancia funciona a nivel de expresión. Por ejemplo, la expresión regular `(T|t)he|car` significa: el carácter en mayúscula `T` o en minúscula `t`, seguido del carácter en minúscula `h`, seguido del carácter en minúscula `e` o del carácter en minúscula `c`, seguido de un carácter en minúscula `a`, seguido del carácter en minúscula `r`.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Caracteres especiales de escape\n\nLa barra invertida `\\` se utiliza en la expresión regular para escapar el carácter siguiente. Esto permite especificar un símbolo como un carácter coincidente incluyendo caracteres reservados `{}[]/\\+*.^|?`. Para usar un carácter especial como un carácter coincidente, agrega `\\` a su izquierda.\n\nPor ejemplo, la expresión regular `.` se utiliza para coincidir con cualquier carácter, excepto la nueva línea. Ahora, para emparejar `.` en una cadena de entrada, la expresión regular `(f|c|m)at\\.?` significa: el carácter en minúscula `f`, `c` o `m`, seguido del carácter en minúscula `a`, seguido del carácter en minúscula `t`, seguido del carácter opcional `.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Anclas\n\nEn expresiones regulares, usamos anclas para comprobar si el símbolo coincidente es el símbolo inicial o el símbolo final de la cadena de entrada. Los anclajes son de dos tipos: El primer tipo es el símbolo de intercalación `^` que comprueba si el carácter coincidente es el carácter inicial de la entrada y el segundo tipo es el símbolo del dólar `$` que comprueba si el carácter coincidente es el último carácter de la cadena de entrada.\n\n### 2.8.1 Símbolo de intercalación\n\nEl símbolo de intercalación `^` se usa para verificar si el carácter coincidente es el primer carácter de la cadena de entrada. Si aplicamos la siguiente expresión regular `^a` (si `a` es el símbolo inicial) a la cadena de entrada, `abc` coincide con `a`. Pero si aplicamos la expresión regular `^b` en la cadena de entrada anterior, no coincide con nada. Porque en la cadena de entrada `abc`, `b` no es el símbolo inicial. Vamos a echar un vistazo a la expresión regular `^(T|t)he` que significa: carácter en mayúscula `T` o carácter en minúscula `t` es el símbolo inicial de la cadena de entrada, seguido del carácter minúscula `h` y seguido del carácter en minúscula `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Prueba la expresión regular](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Símbolo del dólar\n\nEl símbolo del dólar `$` se utiliza para comprobar si el carácter coincidente es el último carácter de la cadena de entrada. Por ejemplo, la expresión regular `(at\\.)$` significa: un carácter en minúscula `a`, seguido del carácter en minúscula `t`, seguido de un carácter `.` y el marcador debe ser el final de la cadena.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Pueba la expresión regular](https://regex101.com/r/t0AkOd/1)\n\n## 3. Conjunto de caracteres abreviados\n\nLa expresión regular proporciona abreviaturas para los conjuntos de caracteres\ncomúnmente utilizados, que ofrecen abreviaturas convenientes para expresiones\nregulares de uso común. Los conjuntos de caracteres abreviados son los siguientes:\n\n|Abreviatura|Descripción|\n|:----:|----|\n|.|Cualquier carácter excepto nueva línea|\n|\\w|Coincide con los caracteres alfanuméricos: `[a-zA-Z0-9_]`|\n|\\W|Coincide con los caracteres no alfanuméricos: `[^\\w]`|\n|\\d|Coincide con los dígitos: `[0-9]`|\n|\\D|Coincide con los no dígitos: `[^\\d]`|\n|\\s|Coincide con los caracteres espaciales: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Coincide con los caracteres no espaciales: `[^\\s]`|\n\n## 4. Mirar alrededor\n\nMirar hacia delante (lookahead) y mirar hacia atrás (lookbehind), a veces conocidos\ncomo lookaround, son tipo específico de **grupo que no captura** (Utilizados para\ncoincidir con el patrón pero no se incluyen en la lista correspondiente). Los\nlookaheads se usan cuando tenemos la condición de que este patrón es precedido o\nseguido por otro patrón determinado. Por ejemplo, queremos obtener todos los números\nque están precedidos por el carácter `$` de la siguiente cadena de entrada\n`$4.44 y $10.88`. Usaremos la siguiente expresión regular `(?<=\\$)[0-9\\.] *`,\nesto significa: obtener todos los números que contienen el carácter `.` y\nestán precedidos del carácter `$`. A continuación se muestran los lookarounds\nque se utilizan en expresiones regulares:\n\n|Símbolo|Descripción|\n|:----:|----|\n|?=|Lookahead Positivo|\n|?!|Lookahead Negativo|\n|?<=|Lookbehind Positivo|\n|?<\\!|Lookbehind Negativo|\n\n## 4.1 Mirar hacia adelate positivo\n\nEl lookahead positivo afirma que la primera parte de la expresión debe ser\nseguida por la expresión lookahead. La coincidencia devuelta sólo contiene el texto que\ncoincide con la primera parte de la expresión. Para definir un lookahead positivo,\nse utilizan paréntesis. Dentro de esos paréntesis, un signo de interrogación con\nsigno igual se utiliza de esta manera: `(?= ...)`. La expresión de Lookahead se\nescribe después del signo igual dentro de los paréntesis. Por ejemplo, la\nexpresión regular `[T|t]he (?=\\Sfat)` significa: opcionalmente emparejar\nel carácter en minúscula `t` o el carácter en mayúscula `T`, seguida del carácter `h`, seguida\ndel carácter `e`. Entre paréntesis definimos el lookahead positivo que indica al motor\nde expresión regular que coincida con `The` o `the` seguido de la palabra `fat`.\n\n
\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Mirar hacia adelate negativo\n\nEl lookahead negativo se usa cuando necesitamos obtener todas las coincidencias\nde la cadena de entrada que no son seguidas por un patrón. El aspecto negativo se\ndefine de la misma manera que definimos el aspecto positivo, pero la única diferencia\nes que en lugar del carácter igual `=` utilizamos carácter negación `!` , es decir,\n`(?! ...)`. Vamos a echar un vistazo a la siguiente expresión regular `[T|t]he(?!\\Sfat)`\nque significa: obtener todas las `The` o `the` seguidos por la palabra `fat` precedido por un carácter de espacio.\n\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Mirar hacia atras positivo\n\nPositivo lookbehind se utiliza para obtener todos los caracteres que están precedidos\npor un patrón específico. La apariencia positiva se denotar por `(?<=...)`.\nPor ejemplo, la expresión regular `(? <= [T|t]he\\s)(fat|mat)` significa: obtener todas las palabras\n`fat` o `mat` de la cadena de entrada después de la palabra `The` o `the`.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/avH165/1)\n\n### 4.4 Mirar hacia atras negativo\n\nEl lookbehind negativo se utiliza para obtener todas las coincidencias que no\nestán precedidas por un patrón específico. El lookbehind negativo se denota por\n`(? \n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/8Efx5G/1)\n\n## 5. Indicadores\n\nLos indicadores también se llaman modificadores porque modifican la salida\nde una expresión regular. Estos indicadores se pueden utilizar en cualquier orden\no combinación, y son una parte integral de RegExp.\n\n\n|Indicador|Descripción|\n|:----:|----|\n|i|Insensible a mayúsculas y minúsculas: Ajusta la coincidencia para que no distinga mayúsculas y minúsculas.|\n|g|Búsqueda global: Busca un patrón en toda la cadena de entrada.|\n|m|Multilínea: Ancla meta carácter trabaja en cada línea.|\n\n### 5.1 Mayúsculas y minúsculas\n\nEl modificador `i` se utiliza para realizar la coincidencia entre mayúsculas y\nminúsculas. Por ejemplo, la expresión regular `/The/gi` significa: carácter en mayúscula\n`T`, seguido del carácter en minúscula `h`, seguido del carácter `e`. Y al final\nde la expresión regular, el indicador `i` indica al motor de expresiones\nregulares que ignore el caso. Como puede ver, también proveimos el indicador\n`g` porque queremos buscar el patrón en toda la cadena de entrada.\n\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regularn](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Búsqueda global\n\nEl modificador `g` se utiliza para realizar una coincidencia global\n(encontrar todos las coincidencias en lugar de detenerse después de la primera coincidencia).\nPor ejemplo, la expresión regular `/.(At)/g` significa: cualquier carácter,\nexcepto la nueva línea, seguido del carácter en minúscula `a`, seguido del carácter\nen minúscula `t`. Debido a que proveimos el indicador `g` al final de la expresión\nregular, ahora encontrará todas las coincidencias de toda la cadena de entrada, no sólo la\nprimera instancia (el cual es el comportamiento normal).\n\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multilínea\n\nEl modificador `m` se utiliza para realizar una coincidencia de varias líneas.\nComo analizamos anteriormente, las anclas `(^,$)` se utilizan para comprobar si\nel patrón es el comienzo de la entrada o el final de la cadena de entrada. Pero\nsi queremos que las anclas funcionen en cada línea usamos el indicador `m`.\nPor ejemplo, la expresión regular `/at(.)?$/Gm` significa: carácter en minúscula `a`, seguido del carácter en minúscula `t`,\nopcionalmente cualquier cosa menos la nueva línea. Y debido al indicador `m`, ahora\nel motor de expresión regular coincide con el patrón al final de cada línea de una cadena.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Prueba la expresión regular](https://regex101.com/r/E88WE2/1)\n\n## Contribución\n\n* Reporta un problema\n* Abre un pull request con mejoras\n* Pasa la palabra\n* Contáctame directamente a ziishaned@gmail.com o [](https://twitter.com/ziishaned)\n\n## Licencia\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-fa.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Regular](\"../img/regexp-en.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n
![](\"https://img.shields.io/twitter/follow/ziishaned.svg?style=social\")
\n ![](\"https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social\")
\n [ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Matches the beginning of the input.|\n|$|Matches the end of the input.|\n\n## 2.1 Full stop\n\nFull stop `.` is the simplest example of meta character. The meta character `.`\nmatches any single character. It will not match return or newline characters.\nFor example, the regular expression `.ar` means: any character, followed by the\nletter `a`, followed by the letter `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Character set\n\nCharacter sets are also called character class. Square brackets are used to\nspecify character sets. Use a hyphen inside a character set to specify the\ncharacters' range. The order of the character range inside square brackets\ndoesn't matter. For example, the regular expression `[Tt]he` means: an uppercase\n`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/2ITLQ4/1)\n\nA period inside a character set, however, means a literal period. The regular\nexpression `ar[.]` means: a lowercase character `a`, followed by letter `r`,\nfollowed by a period `.` character.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Test the regular expression](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negated character set\n\nIn general, the caret symbol represents the start of the string, but when it is\ntyped after the opening square bracket it negates the character set. For\nexample, the regular expression `[^c]ar` means: any character except `c`,\nfollowed by the character `a`, followed by the letter `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Repetitions\n\nFollowing meta characters `+`, `*` or `?` are used to specify how many times a\nsubpattern can occur. These meta characters act differently in different\nsituations.\n\n### 2.3.1 The Star\n\nThe symbol `*` matches zero or more repetitions of the preceding matcher. The\nregular expression `a*` means: zero or more repetitions of preceding lowercase\ncharacter `a`. But if it appears after a character set or class then it finds\nthe repetitions of the whole character set. For example, the regular expression\n`[a-z]*` means: any number of lowercase letters in a row.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Test the regular expression](https://regex101.com/r/7m8me5/1)\n\nThe `*` symbol can be used with the meta character `.` to match any string of\ncharacters `.*`. The `*` symbol can be used with the whitespace character `\\s`\nto match a string of whitespace characters. For example, the expression\n`\\s*cat\\s*` means: zero or more spaces, followed by lowercase character `c`,\nfollowed by lowercase character `a`, followed by lowercase character `t`,\nfollowed by zero or more spaces.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Test the regular expression](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 The Plus\n\nThe symbol `+` matches one or more repetitions of the preceding character. For\nexample, the regular expression `c.+t` means: lowercase letter `c`, followed by\nat least one character, followed by the lowercase character `t`. It needs to be\nclarified that `t` is the last `t` in the sentence.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 The Question Mark\n\nIn regular expression the meta character `?` makes the preceding character\noptional. This symbol matches zero or one instance of the preceding character.\nFor example, the regular expression `[T]?he` means: Optional the uppercase\nletter `T`, followed by the lowercase character `h`, followed by the lowercase\ncharacter `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Braces\n\nIn regular expression braces that are also called quantifiers are used to\nspecify the number of times that a character or a group of characters can be\nrepeated. For example, the regular expression `[0-9]{2,3}` means: Match at least\n2 digits but not more than 3 ( characters in the range of 0 to 9).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/juM86s/1)\n\nWe can leave out the second number. For example, the regular expression\n`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the\nregular expression `[0-9]{3}` means: Match exactly 3 digits.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Capturing Group\n\nA capturing group is a group of sub-patterns that is written inside Parentheses \n`(...)`. Like as we discussed before that in regular expression if we put a quantifier \nafter a character then it will repeat the preceding character. But if we put quantifier\nafter a capturing group then it repeats the whole capturing group. For example,\nthe regular expression `(ab)*` matches zero or more repetitions of the character\n\"ab\". We can also use the alternation `|` meta character inside capturing group.\nFor example, the regular expression `(c|g|p)ar` means: lowercase character `c`,\n`g` or `p`, followed by character `a`, followed by character `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/tUxrBG/1)\n\nNote that capturing groups do not only match but also capture the characters for use in \nthe parent language. The parent language could be python or javascript or virtually any\nlanguage that implements regular expressions in a function definition.\n\n### 2.5.1 Non-capturing group\n\nA non-capturing group is a capturing group that only matches the characters, but \ndoes not capture the group. A non-capturing group is denoted by a `?` followed by a `:` \nwithin parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to \n`(c|g|p)ar` in that it matches the same characters but will not create a capture group.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/Rm7Me8/1)\n\nNon-capturing groups can come in handy when used in find-and-replace functionality or \nwhen mixed with capturing groups to keep the overview when producing any other kind of output. \nSee also [4. Lookaround](#4-lookaround).\n\n## 2.6 Alternation\n\nIn a regular expression, the vertical bar `|` is used to define alternation.\nAlternation is like an OR statement between multiple expressions. Now, you may be\nthinking that character set and alternation works the same way. But the big\ndifference between character set and alternation is that character set works on\ncharacter level but alternation works on expression level. For example, the\nregular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase\n`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR\n(lowercase character `c`, followed by lowercase character `a`, followed by\nlowercase character `r`). Note that I put the parentheses for clarity, to show that either expression\nin parentheses can be met and it will match.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Escaping special character\n\nBackslash `\\` is used in regular expression to escape the next character. This\nallows us to specify a symbol as a matching character including reserved\ncharacters `{ } [ ] / \\ + * . $ ^ | ?`. To use a special character as a matching\ncharacter prepend `\\` before it.\n\nFor example, the regular expression `.` is used to match any character except\nnewline. Now to match `.` in an input string the regular expression\n`(f|c|m)at\\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase\ncharacter `a`, followed by lowercase letter `t`, followed by optional `.`\ncharacter.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Anchors\n\nIn regular expressions, we use anchors to check if the matching symbol is the\nstarting symbol or ending symbol of the input string. Anchors are of two types:\nFirst type is Caret `^` that check if the matching character is the start\ncharacter of the input and the second type is Dollar `$` that checks if matching\ncharacter is the last character of the input string.\n\n### 2.8.1 Caret\n\nCaret `^` symbol is used to check if matching character is the first character\nof the input string. If we apply the following regular expression `^a` (if a is\nthe starting symbol) to input string `abc` it matches `a`. But if we apply\nregular expression `^b` on above input string it does not match anything.\nBecause in input string `abc` \"b\" is not the starting symbol. Let's take a look\nat another regular expression `^(T|t)he` which means: uppercase character `T` or\nlowercase character `t` is the start symbol of the input string, followed by\nlowercase character `h`, followed by lowercase character `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dollar\n\nDollar `$` symbol is used to check if matching character is the last character\nof the input string. For example, regular expression `(at\\.)$` means: a\nlowercase character `a`, followed by lowercase character `t`, followed by a `.`\ncharacter and the matcher must be end of the string.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/t0AkOd/1)\n\n## 3. Shorthand Character Sets\n\nRegular expression provides shorthands for the commonly used character sets,\nwhich offer convenient shorthands for commonly used regular expressions. The\nshorthand character sets are as follows:\n\n|Shorthand|Description|\n|:----:|----|\n|.|Any character except new line|\n|\\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|\n|\\W|Matches non-alphanumeric characters: `[^\\w]`|\n|\\d|Matches digit: `[0-9]`|\n|\\D|Matches non-digit: `[^\\d]`|\n|\\s|Matches whitespace character: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Matches non-whitespace character: `[^\\s]`|\n\n## 4. Lookaround\n\nLookbehind and lookahead (also called lookaround) are specific types of\n***non-capturing groups*** (Used to match the pattern but not included in matching\nlist). Lookarounds are used when we have the condition that this pattern is\npreceded or followed by another certain pattern. For example, we want to get all\nnumbers that are preceded by `$` character from the following input string\n`$4.44 and $10.88`. We will use following regular expression `(?<=\\$)[0-9\\.]*`\nwhich means: get all the numbers which contain `.` character and are preceded\nby `$` character. Following are the lookarounds that are used in regular\nexpressions:\n\n|Symbol|Description|\n|:----:|----|\n|?=|Positive Lookahead|\n|?!|Negative Lookahead|\n|?<=|Positive Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negative Lookahead\n\nNegative lookahead is used when we need to get all matches from input string\nthat are not followed by a pattern. Negative lookahead is defined same as we define\npositive lookahead but the only difference is instead of equal `=` character we\nuse negation `!` character i.e. `(?!...)`. Let's take a look at the following\nregular expression `(T|t)he(?!\\sfat)` which means: get all `The` or `the` words\nfrom input string that are not followed by the word `fat` precedes by a space\ncharacter.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Positive Lookbehind\n\nPositive lookbehind is used to get all the matches that are preceded by a\nspecific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the\nregular expression `(?<=(T|t)he\\s)(fat|mat)` means: get all `fat` or `mat` words\nfrom input string that are after the word `The` or `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/avH165/1)\n\n### 4.4 Negative Lookbehind\n\nNegative lookbehind is used to get all the matches that are not preceded by a\nspecific pattern. Negative lookbehind is denoted by `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Test the regular expression](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flags\n\nFlags are also called modifiers because they modify the output of a regular\nexpression. These flags can be used in any order or combination, and are an\nintegral part of the RegExp.\n\n|Flag|Description|\n|:----:|----|\n|i|Case insensitive: Sets matching to be case-insensitive.|\n|g|Global Search: Search for a pattern throughout the input string.|\n|m|Multiline: Anchor meta character works on each line.|\n\n### 5.1 Case Insensitive\n\nThe `i` modifier is used to perform case-insensitive matching. For example, the\nregular expression `/The/gi` means: uppercase letter `T`, followed by lowercase\ncharacter `h`, followed by character `e`. And at the end of regular expression\nthe `i` flag tells the regular expression engine to ignore the case. As you can\nsee we also provided `g` flag because we want to search for the pattern in the\nwhole input string.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Global search\n\nThe `g` modifier is used to perform a global match (find all matches rather than\nstopping after the first match). For example, the regular expression`/.(at)/g`\nmeans: any character except new line, followed by lowercase character `a`,\nfollowed by lowercase character `t`. Because we provided `g` flag at the end of\nthe regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multiline\n\nThe `m` modifier is used to perform a multi-line match. As we discussed earlier\nanchors `(^, $)` are used to check if pattern is the beginning of the input or\nend of the input string. But if we want that anchors works on each line we use\n`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase\ncharacter `a`, followed by lowercase character `t`, optionally anything except\nnew line. And because of `m` flag now regular expression engine matches pattern\nat the end of each line in a string.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/E88WE2/1)\n\n## 6. Greedy vs lazy matching\nBy default regex will do greedy matching , means it will match as long as\npossible. we can use `?` to match in lazy way means as short as possible\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/2)\n\n\n## Contribution\n\n* Open pull request with improvements\n* Discuss ideas in issues\n* Spread the word\n* Reach out with any feedback [](https://twitter.com/ziishaned)\n\n## License\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-fr.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Expressions](\"../img/regexp-fr.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/dmRygT/1)\n\nL'expression régulière `123` coïncide à la chaîne `123`. Chaque caractère de l'expression régulière est comparée à la chaîne passée en entrée, caractère par caractère. Les expressions régulières sont normalement sensibles à la casse, donc l'expression régulière `The` ne va pas coïncider à la chaîne de caractère `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta-caractères\n\nLes meta-caractères sont les blocs de construction des expressions régulières. Les meta-caractères sont interprétés de manière particulière. Certains meta-caractères ont des significations spéciales et sont écrits entre crochets.\nSignifications des meta-caractères:\n\n|Meta-caractère|Description|\n|:----:|----|\n|.|Un point coïncide avec n'importe quel caractère unique à part le retour à la ligne.|\n|[ ]|Classe de caractères. Coïncide avec n'importe quel caractère entre crochets.|\n|[^ ]|Négation de classe de caractère. Coïncide avec n'importe quel caractère qui n'est pas entre les crochets.|\n|*|Coïncide avec 0 ou plus répétitions du caractère précédent.|\n|+|Coïncide avec 1 ou plus répétitions du caractère précédent.|\n|?|Rend le caractère précédent optionnel.|\n|{n,m}|Accolades. Coïncide avec au moins \"n\" mais pas plus que \"m\" répétition(s) du caractère précédent.|\n|(xyz)|Groupe de caractères. Coïncide avec les caractères \"xyz\" dans l'ordre exact.|\n|||Alternation (ou). Coïncide soit avec le caractère avant ou après le symbole.|\n|\|Échappe le prochain caractère. Cela permet de faire coïncider des caractères réservés tels que
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Coïncide avec le début de la chaîne de caractères (string).|\n|$|Coïncide avec la fin de la chaîne de caractères (string).|\n\n## 2.1 Full stop\n\nLe full stop `.` est l'exemple le plus simple d'un meta-caratère. Le `.` coïncide avec n'importe quel caractère unique, mais ne coïncide pas avec les caractères de retour ou de nouvelle ligne. Par exemple, l'expression régulière `.ar` signifie : n'importe quel caractère suivi par la lettre `a`, suivie par la lettre `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Inclusions de caractères\n\nLes inclusions de caractères sont également appelées classes de caractères. Les crochets sont utilisés pour spécifier les inclusions de caractères. Un trait d'union utilisé dans une inclusion de caractères permet de définir une gamme de caractères. L'ordre utilisé dans la gamme de caractère n'a pas d'importance. Par exemple, l'expression régulière `[Tt]he` signifie : un `T` majuscule ou `t` minuscule, suivie par la lettre `h`, suivie par la lettre `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/2ITLQ4/1)\n\nL'utilisation du point dans une inclusion de caractère signifie toutefois un `.` littéral. L'expression régulière `ar[.]` signifie : un `a` minuscule, suivi par la lettre `r` minuscule, suivie par un `.` (point).\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Exclusion de caractères\n\nEn règle générale, le caractère circonflexe représente le début d'une chaîne de caractères (string). Néanmoins, lorsqu'il est utilisé après le crochet ouvrant, il permet d'exclure la gamme de caractères. Par exemple, l'expression régulière `[^c]ar` signifie : n'importe quel caractère sauf `c`, suivi par la lettre `a`, suivie par la lettre `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Répétitions\n\nLes meta-caractères suivants `+`, `*` ou `?` sont utilisés pour spécifier combien de fois un sous-schéma peut apparaître. Ces meta-caractères agissent différemment selon la situation dans laquelle ils sont utilisés.\n\n### 2.3.1 Astérisque\n\nLe symbole `*` correspond à zéro ou plus de répétitions du schéma précédent. L'expression régulière `a*` signifie : zéro ou plus de répétitions\ndu précédent `a` minuscule. Mais si il se trouve après une liste de caractères alors il s'agit de la répétition de la liste entière.\nPar exemple, l'expression régulière `[a-z]*` signifie : peu importe la chaine tant qu'il s'agit de lettres minuscules.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/7m8me5/1)\n\nLe symbole `*` peut être utilisé avec le meta-caractère `.` pour correspondre à n'importe quelle chaîne de caractères (string) `.*`. Le symbole `*` peut être utilisé avec le\ncaractère espace vide `\\s` pour correspondre à une chaîne d'espaces vides. Par exemple, l'expression `\\s*cat\\s*` signifie : zéro ou plus\nd'espaces, suivis du caractère `c` minuscule, suivi par le caractère `a` minuscule, suivi par le caractère `t` minuscule, suivi par\nzéro ou plus d'espaces.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Le Plus\n\nLe meta-caractère `+` correspond à une ou plusieurs répétitions du caractère précédent. Par exemple, l'expression régulière `c.+t` signifie : la lettre `c` minuscule, suivie par au moins un caractère, suivie par la lettre `t` minuscule. Le `t` coïncide par conséquent avec le dernier `t` de la phrase.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Le point d'interrogation\n\nLe meta-caractère `?` rend le caractère précédent optionnel. Ce symbole permet de faire coïncider 0 ou une instance du caractère précédent. Par exemple, l'expression régulière `[T]?he` signifie : la lettre `T` majuscule optionnelle, suivie par la lettre `h` minuscule, suivie par la lettre `e` minuscule.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Accolades\n\nDans une expression régulière, les accolades, qui sont aussi appelées quantifieurs, sont utilisées pour spécifier le nombre de fois qu'un\ncaractère ou un groupe de caractères peut être répété. Par exemple, l'expression régulière `[0-9]{2,3}` signifie : trouve au moins 2 chiffres mais pas plus de 3\n(caractères dans la gamme de 0 à 9).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/juM86s/1)\n\nNous pouvons omettre le second nombre. Par exemple, l'expression régulière `[0-9]{2,}` signifie : trouve 2 chiffres ou plus. Si nous supprimons aussi\nla virgule l'expression régulière `[0-9]{3}` signifie : trouve exactement 3 chiffres.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Groupement de caractères\n\nUn groupement de caractères est un groupe de sous-schémas qui sont écrits entre parenthèses `(...)`. Nous avions mentionné plus tôt que, dans une expression régulière,\nsi nous mettons un quantifieur après un caractère alors le caractère précédent sera répété. Mais si nous mettons un quantifieur après un groupement de caractères alors\nil répète le groupement de caractères en entier. Par exemple, l'expression régulière `(ab)*` trouve zéro ou plus de répétitions des caractères \"ab\".\nNous pouvons aussi utiliser le meta-caractère d'alternation `|` à l'intérieur d'un groupement. Par exemple, l'expression régulière `(c|g|p)ar` signifie : caractère `c` minuscule,\n`g` ou `p`, suivi par le caractère `a`, suivi par le caractère `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Alternation\n\nDans une expression régulière, la barre verticale `|` est utilisée pour définir une alternation. L'alternation est comme une condition entre plusieurs expressions. Maintenant,\nnous pourrions penser que la liste de caractères et l'alternation sont la même chose. Mais la grande différence entre une liste de caractères et l'alternation\nest que la liste de caractères fonctionne au niveau des caractères mais l'alternation fonctionne au niveau de l'expression. Par exemple, l'expression régulière\n`(T|t)he|car` signifie : le caractère `T` majuscule ou `t` minuscule, suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule\nou le caractère `c` minuscule, suivi par le caractère `a` minuscule, suivit par le caractère `r` minuscule.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Caractère d'échappement\n\nL'antislash `\\` est utilisé dans les expressions régulières pour échapper (ignorer) le caractère suivant. Cela permet de spécifier un symbole comme caractère à trouver\ny compris les caractères réservés `{ } [ ] / \\ + * . $ ^ | ?`. Pour utiliser un caractère spécial comme caractère à trouver, préfixer `\\` avant celui-ci.\nPar exemple, l'expression régulière `.` est utilisée pour trouver n'importe quel caractère sauf le retour de ligne. Donc pour trouver `.` dans une chaine de caractères (string)\nl'expression régulière `(f|c|m)at\\.?` signifie : la lettre minuscule `f`, `c` ou `m`, suivie par le caractère `a` minuscule, suivi par la lettre\n`t` minuscule, suivie par le caractère optionnel `.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Ancres\n\nDans les expressions régulières, nous utilisons des ancres pour vérifier si le symbole trouvé est le premier ou dernier symbole de la\nchaine de caractères (string). Il y a 2 types d'ancres : Le premier type est le circonflexe `^` qui cherche si le caractère est le premier\ncaractère de la chaine de caractères (string) et le deuxième type est le Dollar `$` qui vérifie si le caractère est le dernier caractère de la chaine de caractères (string).\n\n### 2.8.1 Circonflexe\n\nLe symbole circonflexe `^` est utilisé pour vérifier si un caractère est le premier caractère de la chaine de caractères (string). Si nous appliquons l'expression régulière\nsuivante `^a` (si a est le premier symbole) à la chaine de caractères (string) `abc`, ça coïncide. Mais si nous appliquons l'expression régulière `^b` sur cette même chaine de caractères (string),\nça ne coïncide pas. Parce que dans la chaine de caractères (string) `abc` \"b\" n'est pas le premier symbole. Regardons une autre expression régulière\n`^(T|t)he` qui signifie : le caractère `T` majuscule ou le caractère `t` minuscule est le premier symbole de la chaine de caractères (string),\nsuivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dollar\n\nLe symbole Dollar `$` est utilisé pour vérifier si un caractère est le dernier caractère d'une chaine de caractères (string). Par exemple, l'expression régulière\n`(at\\.)$` signifie : un caractère `a` minuscule, suivi par un caractère `t` minuscule, suivi par un caractère `.` et tout cela doit être\nà la fin de la chaine de caractères (string).\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/t0AkOd/1)\n\n## 3. Liste de caractères abrégés\n\nLes expressions régulières fournissent des abréviations pour les listes de caractères, ce qui offres des raccourcis pratiques pour\nles expressions régulières souvent utilisées. Ces abréviations sont les suivantes :\n\n|Abréviation|Description|\n|:----:|----|\n|.|N'importe quel caractère à part le retour de ligne|\n|\\w|Caractères alphanumériques : `[a-zA-Z0-9_]`|\n|\\W|Caractères non-alphanumériques : `[^\\w]`|\n|\\d|Chiffres : `[0-9]`|\n|\\D|Non-numériques : `[^\\d]`|\n|\\s|Espace vide : `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Tout sauf espace vide : `[^\\s]`|\n\n## 4. Recherche\n\nLa recherche en avant et en arrière sont un type spécifique appelé ***groupe non-capturant*** (utilisés pour trouver un schéma mais pas\npour l'inclure dans la liste de correspondance). Les recherches positives sont utilisées quand nous avons la condition qu'un schéma doit être précédé ou suivi\npar un autre schéma. Par exemple, nous voulons tous les chiffres qui sont précédés par le caractère `$` dans la chaine de caractères suivante `$4.44 and $10.88`.\nNous allons utiliser l'expression régulière suivante `(?<=\\$)[0-9\\.]*` qui signifie : trouver tous les nombres qui contiennent le caractère `.` et sont précédés\npar le caractère `$`. Les recherches que nous trouvons dans les expressions régulières sont les suivantes:\n\n|Symbole|Description|\n|:----:|----|\n|?=|Recherche en avant positive|\n|?!|Recherche en avant négative|\n|?<=|Recherche en arrière positive|\n|?\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Recherche en avant négative\n\nLa recherche en avant négative est utilisée quand nous avons besoin de trouver une chaine de caractères (string) qui n'est pas suivie d'un schéma. La recherche en avant négative\nest définie de la même manière que la recherche en avant positive mais la seule différence est qu'à la place du signe égal `=` nous utilisons le caractère de négation `!`\ni.e. `(?!...)`. Regardons l'expression régulière suivante `[T|t]he(?!\\sfat)` qui signifie : trouve tous les mots `The` ou `the` de la chaine de caractères (string)\nqui ne sont pas suivis du mot `fat` précédé d'un espace.\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Recherche en arrière positive\n\nLa recherche en arrière positive est utilisée pour trouver une chaine de caractères (string) précédée d'un schéma. La recherche en arrière positive se note\n`(?<=...)`. Par exemple, l'expression régulière `(?<=[T|t]he\\s)(fat|mat)` signifie : trouve tous les mots `fat` ou `mat` de la chaine de caractères (string) qui\nse trouve après le mot `The` ou `the`.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/avH165/1)\n\n### 4.4 Recherche en arrière négative\n\nLa recherche en arrière négative est utilisée pour trouver une chaine de caractères (string) qui n'est pas précédée d'un schéma. La recherche en arrière négative se note\n`(?\n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/8Efx5G/1)\n\n## 5. Drapeaux\n\nLes drapeaux sont aussi appelés modifieurs car ils modifient la sortie d'une expression régulière. Ces drapeaux peuvent être utilisés\ndans n'importe quel ordre et combinaison et font partie intégrante de la RegExp.\n\n|Drapeau|Description|\n|:----:|----|\n|i|Insensible à la casse : Définit que la correspondance sera insensible à la casse.|\n|g|Recherche globale : Recherche la correspondance dans la chaine de caractères (string) entière.|\n|m|Multiligne : Meta-caractère ancre qui agit sur toutes les lignes.|\n\n### 5.1 Insensible à la casse\n\nLe modifieur `i` est utilisé pour faire une correspondance insensible à la casse. Par exemple, l'expression régulière `/The/gi` signifie : la lettre\n`T` majuscule, suivie par le caractère `h` minuscule, suivi par le caractère `e` minuscule. Et à la fin de l'expression régulière, le drapeau `i` dit au\nmoteur d'expression régulière d'ignorer la casse. Comme vous pouvez le voir, nous mettons aussi un drapeau `g` parce que nous voulons chercher le schéma dans\nla chaine de caractères (string) entière.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Correspondance globale\n\nLe modifieur `g` est utilisé pour faire une recherche globale (trouver toutes les chaines de caractères (string) plutôt que de s'arrêter à la première correspondance ). Par exemple,\nl'expression régulière `/.(at)/g` signifie : n'importe quel caractère sauf le retour de ligne, suivi par le caractère `a` minuscule, suivi par le caractère\n`t` minuscule. Grâce au drapeau `g` à la fin de l'expression régulière maintenant il trouvera toutes les correspondances de toute la chaine de caractères (string).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multilignes\n\nLe modifieur `m` est utilisé pour trouver une correspondance multiligne. Comme mentionné plus tôt, les ancres `(^, $)` sont utilisés pour vérifier si le schéma\nse trouve au début ou à la fin de la chaine de caractères (string). Mais si nous voulons que l'ancre soit sur chaque ligne nous utilisons le drapeau `m`. Par exemple, l'expression régulière\n`/at(.)?$/gm` signifie : le caractère `a` minuscule, suivi par le caractère `t` minuscule, suivi par optionnellement n'importe quel caractère à part le retour de ligne.\nGrâce au drapeau `m` maintenant le moteur d'expression régulière trouve le schéma à chaque début de ligne dans la chaine de caractères (string).\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Essayer l'expression régulière](https://regex101.com/r/E88WE2/1)\n\n## Contribution\n\n* Signaler les problèmes (issues)\n* Ouvrir des \"pull requests\" pour les améliorations\n* Parlez-en autour de vous !\n* Contactez moi en anglais à ziishaned@gmail.com ou [](https://twitter.com/ziishaned)\n\n## License\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-gr.md", "content": "
\n
\n \n \n \n
\n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dmRygT/1)\n\nΗ κανονική έκφραση `123` \"ταιριάζει\" με το string `123`. Η έκφραση αυτή\nαναζητείται μέσα σ'ένα string εισόδου αντιστοιχίζοντας κάθε χαρακτήρα της με κάθε\nχαρακτήρα του string. Οι κανονικές εκφράσεις συνήθως λαμβάνουν υπόψη το αν τα γράμματα είναι\nκεφαλαία ή πεζά και άρα η έκφραση `The` δεν θα ταίριαζε με το string `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/1paXsy/1)\n\n## 2. Μεταχαρακτήρες\n\nΟι μεταχαρακτήρες είναι τα δομικά στοιχεία των κανονικών εκφράσεων. Δεν αντιπροσωπεύουν\nτον εαυτό τους αλλά ερμηνεύονται με ειδικό τρόπο. Μερικοί από αυτούς, έχουν\nειδικό νόημα και γι'αυτό γράφονται μέσα σε αγκύλες. Οι μεταχαρακτήρες είναι οι παρακάτω:\n\n|Μεταχαρακτήρας|Περιγραφή|\n|:----:|----|\n|.|Η τελεία είναι ισοδύναμη με οποιονδήποτε μεμονωμένο χαρακτήρα εκτός από αυτόν για αλλαγή γραμμής.|\n|[ ]|Κλάση χαρακτήρων. Είναι ισοδύναμη με οποιονδήποτε χαρακτήρα βρίσκεται μέσα σε αγκύλες.|\n|[^ ]|Κλάση χαρακτήρων εξαίρεσης. Είναι ισοδύναμη με οποιονδήποτε χαρακτήρα δεν βρίσκεται μέσα σε αγκύλες|\n|*|Ταιριάζει με 0 ή παραπάνω επαναλήψεις του προηγούμενου συμβόλου.|\n|+|Ταιριάζει με 1 ή παραπάνω επαναλήψεις του προηγούμενου συμβόλου.|\n|?|Κάνει το προηγούμενο σύμβολο προαιρετικό.|\n|{n,m}|Αγκύλες. Ταιριάζει με τουλάχιστον \"n\" αλλά όχι με παραπάνω από \"m\" επαναλήψεις του προηγούμενου συμβόλου.|\n|(xyz)|Ομάδα χαρακτήρων. Είναι ισοδύναμη με τους χαρακτήρες xyz ακριβώς με την σειρά στην οποία βρίσκονται.|\n|||Εναλλαγή. Ταιριάζει είτε με τους χαρακτήρες που βρίσκονται πριν είτε μετά το σύμβολο.|\n|\|Παραλείπει το ειδικό νόημα του χαρακτήρα. Αυτό μας επιτρέπει να ταιριάξουμε χαρακτήρες\nειδικής χρήσης
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Αναζητά το μοτίβο που ακολουθεί στην αρχή μιας εισόδου.|\n|$|Αναζητά το μοτίβο που ακολουθεί στο τέλος μιας εισόδου.|\n\n## 2.1 Τελεία\n\nΗ τελεία `.` είναι το πιο απλό παράδειγμα μεταχαρακτήρα. Είναι ισοδύναμη με οποιονδήποτε\nμεμονωμένο χαρακτήρα με εξαίρεση τον χαρακτήρα για επιστροφή στην αρχή της γραμμής\nκαι αυτόν για νέα σειρά. Για παράδειγμα, η κανονική έκφραση `.ar` αναπαριστά: οποιονδήποτε\nχαρακτήρα που ακολουθείται από το γράμμα `a`, που με την σειρά του ακολουθείται από το γράμμα `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Σύνολα Χαρακτήρων\n\nΤα σύνολα χαρακτήρων καλούνται αλλιώς και κλάσεις χαρακτήρων. Τα σύνολα αυτά γράφονται μέσα\nσε αγκύλες. Για τον ορισμό της εμβέλειας ενός τέτοιου συνόλου χρησιμοποιείται μια παύλα\nγια να διαχωρίζει την αρχή από το τέλος. Η σειρά των χαρακτήρων, που βρίσκονται μέσα στην\nεμβέλεια του συνόλου που ορίζεται από τις αγκύλες, δεν έχει σημασία. Για παράδειγμα,\nη κανονική έκφραση `[Tt]he` αναπαριστά: ένα κεφαλαίο `T` ή ένα πεζό `t`, που ακολουθείται\nαπό το γράμμα `h`, που με τη σειρά του ακολουθείται από το γράμμα `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/2ITLQ4/1)\n\nΌμως, μια τελεία μέσα σε ένα σύνολο χαρακτήρων, είναι μια κλασική τελεία και δεν εκλαμβάνεται\nως μεταχαρακτήρας. Η κανονική έκφραση `ar[.]` αναπαριστά: ένα πεζό γράμμα `a`, που\nακολουθείται από το γράμμα `r`, που με την σειρά του ακολουθείται από τον χαρακτήρα `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Σύνολο Χαρακτήρων προς Εξαίρεση\n\nΓενικά, το σύμβολο ^ αναπαριστά την αρχή ενός string, αλλά όταν βρίσκεται\nμέσα σε αγκύλες ([] όχι {}), αναπαριστά ένα σύνολο χαρακτήρων που θα εξαιρεθούν από την διαδικασία\nτης αναζήτησης. Για παράδειγμα, η κανονική έκφραση `[^c]ar` αναπαριστά: οποιονδήποτε χαρακτήρα\nεκτός από το `c`, που ακολουθείται από τον χαρακτήρα `a`, που ακολουθείται από\nτο `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Επαναλήψεις\n\nΟι μεταχαρακτήρες `+`, `*` και `?`, χρησιμοποιούνται για να προσδιοριστεί\nτο πόσες φορές επαναλαμβάνεται ένα υπό-μοτίβο χαρακτήρων μέσα στο string εισόδου. Αυτοί οι\nμεταχαρακτήρες συμπεριφέρονται διαφορετικά ανάλογα με την περίσταση.\n\n### 2.3.1 Ο Αστερίσκος\n\nΤο σύμβολο `*` ψάχνει για μηδέν ή παραπάνω επαναλήψεις της έκφρασης\nπου βρίσκεται πριν από αυτό. Η κανονική έκφραση `a*` αναπαριστά: αναζήτηση για μηδέν ή παραπάνω\nεπαναλήψεις του πεζού χαρακτήρα `a`. Όταν το σύμβολο * βρίσκεται μετά από ένα σύνολο\nή κλάση χαρακτήρων, τότε εντοπίζει ολόκληρο το σύνολο όσες φορές και αν υπάρχει σε μια\nγραμμή. Για παράδειγμα, η κανονική έκφραση `[a-z]*` αναπαριστά: οποιονδήποτε συνδυασμό\nπεζών γραμμάτων που βρίσκονται στην σειρά.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/7m8me5/1)\n\nΤο σύμβολο `*` μπορεί να χρησιμοποιηθεί σε συνδυασμό με τον χαρακτήρα `.` ώστε\nνα αναζητηθεί μια ακολουθία χαρακτήρων. Μπορεί επίσης να χρησιμοποιηθεί με τον\nχαρακτήρα κενού `\\s` ώστε να αναζητηθεί μια ακολουθία κενών. Για παράδειγμα, η\nέκφραση `\\s*cat\\s*` αναπαριστά: μηδέν ή περισσότερα κενά, που ακολουθούνται από\nτον πεζό χαρακτήρα `c`, που ακολουθείται από τον πεζό χαρακτήρα `a`, που ακολουθείται\n από τον πεζό χαρακτήρα `t`, που ακολουθείται από μηδέν ή περισσότερα κενά.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Το Σύμβολο της Πρόσθεσης\n\nΜε σύμβολο `+` γίνεται αναζήτηση για μία ή περισσότερες επαναλήψεις του προηγούμενου του χαρακτήρα.\nΓια παράδειγμα, η κανονική έκφραση `c.+t` αναπαριστά: το πεζό γράμμα `c`, που ακολουθείται\nαπό τουλάχιστον ένα χαρακτήρα, που ακολουθείται από το πεζό γράμμα `t`. Πρέπει να διευκρινίσουμε\nότι το `t` είναι το τελευταίο `t` της πρότασης.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Το Ερωτηματικό\n\nΣε μια κανονική έκφραση, ο μεταχαρακτήρας `?` κάνει τον χαρακτήρα που βρίσκεται πριν από αυτόν,\nπροαιρετικό ως προς την εύρεσή του. Έτσι γίνεται αναζήτηση για μηδέν ή παραπάνω περιπτώσεις εμφάνισης\nτου προηγούμενου από το ερωτηματικό χαρακτήρα. Για παράδειγμα, η κανονική έκφραση `[T]?he` αναπαριστά:\nτο προαιρετικό κεφαλαίο `T`, που ακολουθείται από πεζό `h`, που ακολουθείται από\nπεζό `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Αγκύλες\n\nΟι αγκύλες στις κανονικές εκφράσεις ονομάζονται αλλιώς και \"ποσοτικοποιητές\" αφού\nχρησιμοποιούνται για την εύρεση όλων επαναλήψεων ενός χαρακτήρα ή μιας\nομάδας χαρακτήρων μέσα σ'ένα κείμενο. Για παράδειγμα, η κανονική έκφραση `[0-9]{2,3}` αναπαριστά: την\nαναζήτηση τουλάχιστον 2 ψηφίων το ένα μετά το άλλο αλλά όχι παραπάνω από 3 (στους χαρακτήρες από το 0 ως το 9).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/juM86s/1)\n\nΜπορούμε να παραλείψουμε τον δεύτερο αριθμό. Για παράδειγμα, η κανονική έκφραση\n`[0-9]{2,}` αναπαριστά: την αναζήτηση 2 ή περισσότερων ψηφίων το ένα μετά το άλλο. Αν αφαιρέσουμε και\nτην κόμμα, τότε η κανονική έκφραση `[0-9]{3}` αναπαριστά: την σύγκριση ακριβώς 3 ψηφίων.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Ομάδα Χαρακτήρων\n\nΜια ομάδα χαρακτήρων είναι μια ομάδα υπό-μοτίβων που γράφονται μέσα σε παρενθέσεις `(...)`.\nΌπως είπαμε και προηγουμένως, σε μια κανονική έκφραση, αν τοποθετήσουμε έναν ποσοτικοποιητή μετά από έναν\nχαρακτήρα, τότε αυτός ο χαρακτήρας θα βρεθεί όσες φορές και αν υπάρχει μέσα στο κείμενο στο οποίο\nεκτελείται η αναζήτηση. Παρομοίως, αν τον βάλουμε μετά από μια ομάδα χαρακτήρων. Για παράδειγμα,\nη κανονική έκφραση `(ab)*` ταιριάζει με μηδέν ή παραπάνω επαναλήψεις του χαρακτήρα\n\"ab\". Ακόμη, μπορούμε να χρησιμοποιήσουμε τον μεταχαρακτήρα εναλλαγής `|` μέσα σε μια ομάδα χαρακτήρων.\nΓια παράδειγμα, η κανονική έκφραση `(c|g|p)ar` αναπαριστά: τους πεζούς χαρακτήρες `c`,\n`g` ή `p`, που ακολουθούνται από τον χαρακτήρα `a`, που ακολουθείται από τον χαρακτήρα `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Εναλλαγή\n\nΣτις κανονικές εκφράσεις, η κάθετη γραμμή `|`, ορίζει μια εναλλαγή.\nΈτσι δηλαδή γίνεται μια επιλογή μεταξύ πολλαπλών εκφράσεων. Ίσως σκέφτεστε ότι\nη εναλλαγή και τα σύνολα , λειτουργούν με τον ίδιο τρόπο. Αλλά η μεγάλη διαφορά τους\nείναι ότι τα σύνολα χαρακτήρων δουλεύουν με χαρακτήρες ενώ η εναλλαγή με εκφράσεις.\nΓια παράδειγμα, η κανονική έκφραση `(T|t)he|car` αναπαριστά: τον κεφαλαίο χαρακτήρα `T`\nή τον πεζό χαρακτήρα `t`, που ακολουθείται από πεζό χαρακτήρα `h`, που ακολουθείται από\nπεζό χαρακτήρα `e` ή πεζό χαρακτήρα `c`, που ακολουθείται από πεζό χαρακτήρα `a`, που\nακολουθείται από πεζό χαρακτήρα `r`.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Ειδικός Χαρακτήρας Διαφυγής\n\nΤο σύμβολο `\\` χρησιμοποιείται στις κανονικές εκφράσεις ώστε να αγνοηθεί η ειδική σημασία\nπου μπορεί να έχει ο χαρακτήρας που βρίσκεται μετά από αυτό. Αυτό μας επιτρέπει να αναζητήσουμε ένα\nσύμβολο, συμπεριλαμβανομένων των ειδικών χαρακτήρων `{ } [ ] / \\ + * . $ ^ | ?`. Άρα για αναζήτηση\nειδικών χαρακτήρων, τοποθετούμε ακριβώς πριν το σύμβολο `\\`.\n\nΓια παράδειγμα, η κανονική έκφραση `.` χρησιμοποιείται για αναζήτηση οποιουδήποτε χαρακτήρα εκτός από\nαυτόν για την νέα γραμμή. Η παρακάτω κανονική έκφραση ψάχνει για το σύμβολο της τελείας `.` σε ένα string εισόδου. Η\n`(f|c|m)at\\.?` αναπαριστά: ένα πεζό γράμμα `f`, `c` ή `m`, που ακολουθείται από τον πεζό τον\nχαρακτήρα `a`, που ακολουθείται από το πεζό γράμμα `t`, που ακολουθείται από τον προαιρετικό χαρακτήρα `.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Σύμβολα \"Άγκυρες\"\n\nΣε μια κανονική έκφραση, χρησιμοποιούμε \"άγκυρες\" για να ελέγξουμε αν το σύμβολο που αναζητάμε είναι\nτο πρώτο ή το τελευταίο σύμβολο ενός string. Οι άγκυρες είναι δύο τύπων:\nΠρώτα είναι το σύμβολο `^` που ελέγχει αν ο χαρακτήρας που ψάχνουμε είναι ο πρώτος\nχαρακτήρας της εισόδου και μετά είναι το σύμβολο του δολαρίου `$` που ελέγχει αν ο χαρακτήρας που\nψάχνουμε είναι ο τελευταίος στο string εισόδου.\n\n### 2.8.1 Το Σύμβολο ^\n\nΤο σύμβολο `^` χρησιμοποιείται για να ελέγξουμε αν ο χαρακτήρας που ψάχνουμε είναι ο πρώτος χαρακτήρας\nτου string εισόδου. Αν δοκιμάσουμε την κανονική έκφραση `^a` (ψάχνουμε δηλαδή αν το a είναι το πρώτο\nσύμβολο) στο string εισόδου `abc`, τότε βλέπουμε ότι όντως το `a` είναι ο πρώτος χαρακτήρας. Αλλά\nαν δοκιμάσουμε την κανονική έκφραση `^b` στην παραπάνω είσοδο, τότε δεν θα πάρουμε κάποιο αποτέλεσμα.\nΑυτό συμβαίνει επειδή στην έκφραση `abc` το \"b\" δεν είναι ο πρώτος χαρακτήρας. Ας ρίξουμε μια ματιά\nστην κανονική έκφραση `^(T|t)he` η οποία ψάχνει για: έναν κεφαλαίο χαρακτήρα `T` ή έναν\nπεζό χαρακτήρα `t` που να είναι ο πρώτος χαρακτήρας της εισόδου και να ακολουθείται από\nέναν πεζό χαρακτήρα `h`, που ακολουθείται από έναν πεζό χαρακτήρα `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Το Δολάριο\n\nΤο σύμβολο του δολαρίου `$` χρησιμοποιείται για να ελέγξουμε αν ο χαρακτήρας που αναζητάμε είναι ο τελευταίος\nχαρακτήρας του string εισόδου. Για παράδειγμα, η κανονική έκφραση `(at\\.)$` αναπαριστά: έναν\nπεζό χαρακτήρα `a`, που ακολουθείται από έναν πεζό χαρακτήρα `t`, που ακολουθείται από μια τελεία `.`\nκαι όλα αυτά πρέπει να είναι οι τελευταίοι χαρακτήρες της εισόδου.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/t0AkOd/1)\n\n## 3. Συντομογραφίες Συνόλων Χαρακτήρων\n\nΟι κανονικές εκφράσεις χρησιμοποιούν κάποιες συντομογραφίες για τα σύνολα χαρακτήρων που\nχρησιμοποιούνται πιο συχνά και έτσι γίνονται πιο εύκολες και βολικές για τον χρήστη.\nΟι συντομογραφίες των συνόλων χαρακτήρων είναι οι παρακάτω:\n\n|Συντομογραφία|Περιγραφή|\n|:----:|----|\n|.|Αναζήτηση όλων των χαρακτήρων εκτός από αυτόν για νέα γραμμή|\n|\\w|Αναζήτηση αλφαριθμητικών χαρακτήρων: `[a-zA-Z0-9_]`|\n|\\W|Αναζήτηση μη αλφαριθμητικών χαρακτήρων: `[^\\w]`|\n|\\d|Αναζήτηση στα ψηφία: `[0-9]`|\n|\\D|Αναζήτηση χαρακτήρων που δεν είναι αριθμοί: `[^\\d]`|\n|\\s|Αναζήτηση του χαρακτήρα του κενού: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Αναζήτηση χαρακτήρων που δεν είναι το κενό: `[^\\s]`|\n\n## 4. Αναζήτηση\n\nΗ προς τα μπροστά και προς τα πίσω αναζήτηση, είναι συγκεκριμένοι τύποι συνόλων που\nονομάζονται ***non-capturing groups*** (Χρησιμοποιούνται για αναζήτηση κάποιου μοτίβου\nαλλά δεν συμπεριλαμβάνονται στην λίστα των χαρακτήρων που ψάχνουμε). Οι αναζητήσεις προς τα μπροστά, χρησιμοποιούνται\nόταν το μοτίβο έχει πριν ή μετά ένα ακόμη μοτίβο. Για παράδειγμα, αν θέλουμε να βρούμε όλους\nτους αριθμούς που βρίσκονται μετά τον χαρακτήρα `$` στο παρακάτω string\n`$4.44 and $10.88`, τότε θα χρησιμοποιήσουμε την κανονική έκφραση `(?<=\\$)[0-9\\.]*`\nη οποία: βρίσκει όλους τους αριθμούς που βρίσκονται μετά από το σύμβολο`$` και περιέχουν τον χαρακτήρα `.` .\nΠαρακάτω μπορείτε να δείτε τους τύπους αναζήτησης στις κανονικές εκφράσεις:\n\n|Σύμβολο|Περιγραφή|\n|:----:|----|\n|?=|Θετική Αναζήτηση προς τα Μπροστά|\n|?!|Αρνητική Αναζήτηση προς τα Μπροστά|\n|?<=|Θετική Αναζήτηση προς τα Πίσω|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Αρνητική Αναζήτηση προς τα Μπροστά\n\nΗ αρνητική αναζήτηση προς τα μπροστά, χρησιμοποιείται όταν θέλουμε όλες τις εκφράσεις που\nταιριάζουν με το μοτίβο που αναζητάμε, που όμως δεν ακολουθούνται από κάποιο άλλο μοτίβο.\nΑυτή η αναζήτηση ορίζεται όπως και η παραπάνω αλλά αντί για το σύμβολο `=` χρησιμοποιούμε το `!`,\nμε αυτό τον τρόπο: `(?!...)`. Ας δούμε την κανονική έκφραση `(T|t)he(?!\\sfat)` η οποία: επιστρέφει\nόλα τα `The` ή `the` που υπάρχουν στο string εισόδου και δεν ακολουθούνται από την λέξη `fat`\nμετά από κενό.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Θετική Αναζήτηση προς τα Πίσω\n\nΗ θετική αναζήτηση προς τα πίσω, χρησιμοποιείται όταν θέλουμε να βρούμε όλες τις εκφράσεις που\nταιριάζουν με ένα μοτίβο (που ορίζουμε εμείς) που βρίσκεται πριν από αυτές. Αυτή η αναζήτηση χρησιμοποιεί τα\nσύμβολα `(?<=...)`. Για παράδειγμα, η κανονική έκφραση `(?<=(T|t)he\\s)(fat|mat)`:\nεπιστρέφει όλες τις λέξεις `fat` ή `mat` που βρίσκονται μετά την λέξη `The` ή `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/avH165/1)\n\n### 4.4 Αρνητική Αναζήτηση προς τα Πίσω\n\nΗ αρνητική αναζήτηση προς τα πίσω χρησιμοποιείται όταν θέλουμε να βρούμε όλες τις εκφράσεις που\nταιριάζουν με το μοτίβο αναζήτησης, χωρίς όμως να υπάρχει άλλο μοτίβο (που ορίζουμε εμείς) πριν από αυτές.\nΑυτή η αναζήτηση χρησιμοποιεί τα σύμβολα `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/8Efx5G/1)\n\n## 5. Σημαίες\n\nΟι σημαίες καλούνται αλλιώς και τροποποιητές αφού επηρεάζουν τον τρόπο αναζήτησης των\nκανονικών εκφράσεων. Μπορούν να χρησιμοποιηθούν με οποιαδήποτε σειρά και σε οποιονδήποτε συνδυασμό\nσυμβόλων και είναι αναπόσπαστο κομμάτι των RegExp.\n\n|Σημαία|Περιγραφή|\n|:----:|----|\n|i|Αλλάζει την αναζήτηση ώστε να μην ενδιαφέρεται για τον αν τα γράμματα είναι πεζά ή κεφαλαία.|\n|g|Καθολική αναζήτηση: Ψάχνει ένα μοτίβο σε ολόκληρο το string εισόδου.|\n|m|Πολλαπλές γραμμές: Οι μεταχαρακτήρες άγκυρας λειτουργούν σε όλες τις γραμμές.|\n\n### 5.1 Χωρίς Διάκριση Πεζών-Κεφαλαίων\n\nΟ τροποποιητής `i` χρησιμοποιείται για αναζήτηση που δεν κάνει διακρίσεις μεταξύ πεζών\nκαι κεφαλαίων γραμμάτων. Για παράδειγμα, η κανονική έκφραση `/The/gi` αναπαριστά: ένα\nκεφαλαίο γράμμα `T`, που ακολουθείται από έναν πεζό χαρακτήρα `h`, που ακολουθείται από τον χαρακτήρα `e`.\nΣτο τέλος της κανονικής έκφρασης υπάρχει η σημαία `i` η οποία λέει στην κανονική\nέκφραση να αγνοήσει το αν ένας χαρακτήρας είναι πεζός ή κεφαλαίος. Όπως βλέπετε υπάρχει και η\nσημαία `g` ώστε η αναζήτηση του μοτίβου να γίνει σε όλο το string εισόδου.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Καθολική Αναζήτηση\n\nΟ τροποποιητής `g`χρησιμοποιείται για καθολική αναζήτηση (για να βρεθούν δηλαδή όλες οι\nπεριπτώσεις που ταιριάζουν με το μοτίβο αναζήτησης και να μην σταματήσει στην πρώτη εύρεση). Για παράδειγμα, η\nκανονική έκφραση `/.(at)/g` αναπαριστά: οποιονδήποτε χαρακτήρα εκτός από αυτόν για\nνέα γραμμή, που ακολουθείται από τον πεζό χαρακτήρα `a`, που ακολουθείται από τον πεζό\nχαρακτήρα `t` και αφού στο τέλος της κανονικής έκφρασης υπάρχει η σημαία `g`,\nθα βρεθούν όλες οι περιπτώσεις που περιγράφονται από την παραπάνω κανονική έκφραση και όχι μόνο\nη πρώτη (που είναι η προκαθορισμένη συμπεριφορά όταν δεν υπάρχει η σημαία `g`).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Πολλές Γραμμές\n\nΟ τροποποιητής `m` χρησιμοποιείται για αναζήτηση σε πολλές γραμμές. Όπως είπαμε\nπροηγουμένως, οι άγκυρες `(^, $)` χρησιμοποιούνται για να ελέγξουμε αν ένα μοτίβο\nβρίσκεται στην αρχή ή στο τέλος του string εισόδου. Αν θέλουμε οι άγκυρες αυτές να\nισχύουν για κάθε γραμμή, τότε χρησιμοποιούμε την σημαία `m`. Για παράδειγμα, η\nκανονική έκφραση `/at(.)?$/gm` αναπαριστά: τον πεζό χαρακτήρα `a`, που ακολουθείται\nαπό τον πεζό χαρακτήρα `t` και προαιρετικά οτιδήποτε άλλο εκτός από τον χαρακτήρα για\nνέα γραμμή. Και αφού υπάρχει και η σημαία `m`, η κανονική έκφραση θα αναζητήσει\nτο μοτίβο στο τέλος κάθε γραμμής του string.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/E88WE2/1)\n\n## Contribution\n\n* Report issues\n* Open pull request with improvements\n* Spread the word\n* Reach out to me directly at ziishaned@gmail.com or [](https://twitter.com/ziishaned)\n\n## License\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-he.md", "content": "
\n
\n \t\n \n \n
\n \n ![\"הורד](\"https://img.shields.io/badge/-%20PDF%20%D7%93%D7%A8%D7%95%D7%94%20-0a0a0a.svg?style=flat&colorA=0a0a0a\"){kind=icon}
\n \n
\n ![\"Regular](\"../img/regexp-he.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dmRygT/1)\n\nהביטוי הרגולרי `123` מתאים למחרוזת `123`. הביטוי הרגולרי מותאם למחרוזת קלט על ידי השוואת כל תו \nבביטוי הרגולרי לכל תו במחרוזת הקלט, אחד אחרי השני. ביטויים רגולרים לרוב יהיו \nתלויי אותיות קטנות או גדולות כך שהביטוי הרגולרי `The` לא יתאים למחרוזת `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/1paXsy/1)\n\n## 2. תווי-מטא\n\nתווי-מטא אלו הם אבני הבניין של ביטויים רגולרים. תווי-מטא לא מסמלים את עצמם, אלא מתפרשים באופן מיוחד.\nלכמה תווי-מטא יש משמעויות מיוחדות והם נכתבים בתוך סוגריים מרובעים.\nתווי-המטא הם כדלקמן: \n\n|תווי-מטא|תיאור|\n|:----:|----|\n|.|נקודה תואמת כל תו בודד למעט שבירת שורות.|\n|[ ]|מחלקת תווים. תואם כל תו הכלול בין הסוגריים המרובעים.|\n|[^ ]|מחלקת תווים שלילית. תואם כל תו שאינו כלול בין הסוגריים המרובעים|\n|*|תואם 0 או יותר חזרות של התו הקודם.|\n|+|תואם חזרה אחת או יותר של התו הקודם.|\n|?|הופך את התו הקודם לאופציונלי.|\n|{n,m}|סוגריים מסולסלים. תואם לפחות חזרות \"n\" אך לא יותר מ- \"m\" של התו הקודם.|\n|(xyz)|קבוצת תווים. תואם את התווים xyz בסדר המדויק הזה.|\n|||חלופה (או). התאמה בין התווים שלפני או לתווים שאחרי הסמל.|\n|\|מתעלם מהתו הבא. זה מאפשר לך להתאים תווים שמורים
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|תואם את תחילת הקלט.|\n|$|תואם את סוף הקלט.|\n\n## 2.1 עצירה מלאה\n\nעצירה מלאה `.` היר דוגמא פשוטה לשימוש בתו-מטא. תו-המטא `.` מתאים לכל תו בודד. הוא לא יתאים\nלתו return (\\r) או לתו newline (\\n). למשל, הביטוי הרגולרי `.ar` פירושו: כל תו, שאחריו האות `a`, ואחריה האות `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 מערכות תוים\n\nמערכות תוים נקראים גם מחלקות תוים. סוגריים מרובעים משמשים לציון מערכות תוים.\nהשתמש במקף בתוך ערכת התוים בכדי לציין את טווח התוים. סדר טווח התוים לא משנה.\nלדוגמא, הביטוי הרגולרי `[Tt]he` פירושו: אות גדולה\n`T` או אות קטנה `t`, שאחריה מופיעה האות `h`, ואחריה מופיעה האות `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/2ITLQ4/1)\n\nנקודה בתוך ערכת התוים בשונה מבחוץ תחשב כתו נקודה. הביטוי הרגולרי \n`ar[.]` פירושו: תו האות הקטנה `a`, שאחריו האות `r`,\nואחריה התו נקודה `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 מערכות תוים שליליות \n\nבאופן כללי, הסימן \"קרט\"(גג) מייצג את תחילתה של מחרוזת, אך במידה והוא מוקלד לאחר סוגר מרובע פותח,\nהוא שולל את מערכת ההתוים שיהיו תחת אותם סוגרים. לדוגמא, הביטוי הרגולרי `[^c]ar` פירושו: כל תו חוץ מ-`c`,\nשלאחריו יופיע התו `a`, שאחריו יופיע התו `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 חזרות\n\nתווי-המטא `+`, `*` או `?` משמשים לציון כמה פעמים דפוסי משני יכולים להתרחש.\nתווי-מטא אלו פועלים אחרת במצבים שונים.\n\n### 2.3.1 הכוכבית\n\nהסימן - `*` תואם אפס או יותר חזרות של המתאם הקודם. הביטוי הרגולרי `a*` פירושו: \nאפס או יותר חזרות של התו הקודם- `a`. אבל אם הכוכבית תופיע לאחר מערכת או מערך תוים אז\nהוא ימצא את החזרות של מערכת התוים כולה. לדוגמא, הביטוי הרגולרי `[a-z]*` פירושו: \nכל מספר של אותיות קטנות בשורה.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/7m8me5/1)\n\nהסימן - `*` יכול לשמש יחד עם התו-מטא `.` בכדי להתאים כל מחרוזת תוים `.*`.\nהסימון - `*` יכול לשמש יחד עם התו רווח - `\\s` בכדי להתאים מחרוזת של תוי רווח.\nלדוגמא, הביטוי `\\s*cat\\s*` פירושו: אפס או יותר רווחים, שאחריהם תופיעה האות הקטנה `c`,\nשאחריה תופיע האות הקטנה `a`, ואחריה האות הקטנה `t`, ולבסוף אחריה יופיעו אפס או יותר תווי רווח.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 הפלוס\n\nהסימן `+` מתאים לאחת או יותר חזרות של התו הקודם לו. לדוגמא, הביטוי הרגולרי\n `c.+t` פירושו: האות הקטנה - `c`, לאחריה לפחות תו אחד או יותר,\n ואחריה האות הקטנה `t`. חשוב לציין שה - `t` יהיה התו `t` האחרון במשפט.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 סימן השאלה\n\nבביטוי רגולרי, התו-מטא `?` הופך את התו הקודם לאופציונלי, \nסמל זה יתאים לאפס או יותר הופעות של אותו תו קודם. לדוגמא, הביטוי הרגולרי \n`[T]?he` פירושו: אופציה לאות\n`T` גדולה, ולאחריה אות קטנה `h`, ולאחריה תופיע האות - `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 סוגרים מסולסלים\n\nבביטויים רגולרים, סוגרים מסולסלים (נקראים גם מכמתים) משמשים לציון\nמספר הפעמים שניתן לחזור על תו או קבוצת תוים מסויימת. לדוגמא, הביטור הרגולרי\n `[0-9]{2,3}` פירושו: התאם לפחות שתי ספרות, אבל לא יותר משלוש, בטווח שבין 0 ל-9\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/juM86s/1)\n\nאנחנו יכולים לוותר על המספר השני בסוגרים המסולסלים. לדוגמא, בביטוי הרגולרי \n`[0-9]{2,}` פירושו: התאמת שתי ספרות או יותר. בנוסף אם \nנוריד את הפסיק, לדוגמא בביטוי הרגולרי `[0-9]{3}` פירושו: \nהתאם בדיוק שלוש ספרות.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Sivu30/1)\n\n## 2.5 קבוצות לכידה\n\nקבוצה מלכדת היא קבוצה של תת-תבניות שנכתבות בתוך סוגריים רגילים `(...)` . \nכפי שצויין קודם לכן, בביטוי רגולרי, אם נניח מכמת אחרי תו הוא יחזור על התו הקודם. \nאבל אם נניח מכמת אחרי קבוצה מלכדת אז המכמת יתיחס לכל הקבוצה המלכדת. לדוגמא, הביטוי הרגולרי \n`(ab)*` תואם אפס או יותר חזרות של המחרוזת \"ab\". אנחנו יכולים גם להשתמש \nבתו-מטא `|` המשמש לבצע את הפעולה 'OR'(או) בתוך קבוצה מלכדת.\nלדוגמא, הביטוי הרגולרי `(c|g|p)ar` פירושו: אות קטנה `c`,\n`g` או `p`, שאחריהן תופיע האות `a`, ואחריה האות `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/tUxrBG/1)\n\nיש לשים לב כי קבוצות מלכדות לא רק תואמות, אלא גם תופסות את התוים לשימוש בשפת האם. \nשפת האם יכולה להיות Python או JavaScript או כמעט כל שפה שמיישמת ביטויים רגולרים \nבבגדרת פונקציה.\n\n### 2.5.1 קבוצות שאינן לוכדות\n\nקבוצה שאינה מלכדת זוהי קבוצת לוכדת התואמת את התוים אבל לא תופסת את הקבוצה.\nקבוצה שאינה מלכדת מסומנת על ידי התו `?` ואחריו `:` בתוך הסוגריים הרגילים. `(...)`. \nלדוגמא, בביטוי הרגולרי `(?:c|g|p)ar` שדומה ל-`(c|g|p)ar` \nבכך שהוא תואם לאותם תווים אך לא ייצר קבוצת לכידה.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Rm7Me8/1)\n\nקבוצות שאינן מלכדות יכולות להיות שימושיות כאשר יש צורך בפונקציונליות של חיפוש והחלפה\nאו כאשר מעורבת גם קבוצת לכידה בכדי לשמור על הסקירה כאשר מפיקים כל סוג אחר של פלט. \nניתן לראות גם ב [4. Lookaround](#4-lookaround).\n\n## 2.6 חלופה\n\nבביטוי רגולרי, הקו ניצב `|` משמש בכדי להגדיר חלופה. חלופה היא כמו הצהרת OR (או) \nבין ביטויים שונים. כעט את.ה עלול לחשוב שמערכות התווים והתו המשמש להגדרת חלופה יעבדו באותה הדרך. \nאך ההבדל העיקרי בין מערכת תווים לבין חלופה הוא שמערכת תווים פועלת ברמת התו והחלופה\nעובדת ברמת הביטוי. לדוגמא, הביטוי הרגולרי `(T|t)he|car` פירושו: או (אות גדולה `T` או אות קטנה\n`t`, שלאחריהן אות קטנה `h`, שאחריה אות קטנה `e`) או (אות קטנה `c`, שאחריה תופיע האות `a`, \nולאחריה תופיע האות `r`). יש לשים לב שהכללתי את הסוגריים לשם ההבהרה, \nבכדי להראות שאפשר להתמודד עם כל ביטוי בסוגריים והוא יתאים. \n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 התעלמות מתווים מיוחדים\n\nלוכסן שמאלי `\\` משמש בביטוי רגולרי בכדי להתעלם מהתו הבא. זה מאפשר לנו לכלול תוים שמורים כמו \n`{ } [ ] / \\ + * . $ ^ | ?` כתוים להתאמות. הכדי להשתמש בתוים המיוחדים הללו התו התאמה, \nיש להוסיף אותו מראש עם `\\` לפניו. לדוגמא, הביטוי הרגולרי `.` משמש בכדי להתאים כל תו חוץ משורה חדשה. \nכעט בכדי לבצע התאמה עם הסימן `.` במחרוזת קלט, יהיה צורך בהוספת הלוכסן השמאלי. למשל בביטוי הרגולרי \n`(f|c|m)at\\.?` פירושו: אות קטנה `f`, `c` או `m`, שאחריהן תופיע האות הקטנה\n`a`, ואחריה תופיע האות הקטנה `t`, ולבסוף יופיע באופן אופציונלי התו - `.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 עוגנים\n\nבביטויים רגולרים, אנחנו משתמשים בעוגנים בכדי לבדוק אם סימן ההתאמה הוא סימן התחלה או \nסימן סיום של מחרוזת הקלט. ישנם שני סוגי עוגנים: \nהסוג הראשון הוא ה\"קרט\"(גג) `^` שבודק אם תו תואם הוא התו הראשון של הקלט והסוג השני הוא סימן הדולר \n`$` אשר בודק אם תו תואם הוא התו האחרון שבקלט\n\n### 2.8.1 ה-\"קרט\"\n\nהסימן \"קרט\" `^` משמש לבדיקה אם תו תואם הוא התו הראשון של מחרוזת הקלט. \nאם ניישם את הביטור הרגולרי הבא `^a` (כלומר 'a' חייב להיות התו ההתחלתי) \nהמחרוזת `abc`, תתאים לדרישות `a`. \nאך אם ניישם את הביטוי הרגולרי `^b` על במחרוזת למעלה, היא לא תמצא אף התאמה. \nבגלל שבמחרוזת `abc`, ה-\"b\" אינו תו התחלתי. בואו נסתכל על ביטוי רגולרי אחר \n`^(T|t)he` שפירושו: אות גדולה `T` או אות קטנה `t` חייבת להיות התו הראשון של המחרוזת, \nואחריה האות הקטנה `h`, ולאחריה האות הקטנה `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 סימן הדולר\n\nסימן הדולר `$` משמש בכדי לבדוק אם התו התואם הוא התו האחרון במחרוזת. לדוגמא, \nהביטוי הרגולרי `(at\\.)$` פירושו: האות הקטנה `a`, שאחריה תיהיה האות הקטנה `t`, ואחריה התו נקודה `.`\nוכל ההתאמה חייבת לביות בסופה של המחרוזת.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/t0AkOd/1)\n\n## 3. קיצורי מערכות תווים\n\nישנם מספר קיצורים נוחים למערכות תווים נפוצות / ביטויים רגולרים: \n\n|קיצור|תיאור|\n|:----:|----|\n|.|תואם כל תו חוץ מתחילת שורה חדשה|\n|\\w|תואם תוים אלפא-נומריים (אותיות ומספרים): `[a-zA-Z0-9_]`|\n|\\W|תואם תוים לא אלפא-נומריים: `[^\\w]`|\n|\\d|תואם ספרות: `[0-9]`|\n|\\D|תואם תוים שאינם ספרות: `[^\\d]`|\n|\\s|תואם תוי רווח: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|תואם תוים שאינם רווח: `[^\\s]`|\n\n## 4. הסתכלויות\n\nמבט לאחור ומבט לפנים (נקראים גם הסתכלויות) אלו הם סוגים ספציפים של קבוצות שאינן לוכדות. \n(משמשות בכדי להתאים תבנית אך ללא הכנסתה לרשימת ההתאמות).\nהסתכלויות משמשות כאשר יש להקדים תבנית בכך שזו תלויה בתבנית אחרת בכדי שהראשונה תתאים. \nלדוגמא, תדמיין.י שאנחנו רוצים לקבל את כל המספרים שלפניהם יש את התו `$` מהמחרוזת \n`$4.44 and $10.88`. אנחנו נשתמש בביטוי הרגולרי הבא: \n`(?<=\\$)[0-9\\.]*` שפירושו: התאם את כל הספרות או התו `.` שלפני ההתאמה \nקיים התו `$`. בטבלה מטה מוצגים סוגי המבטים המשמשים ביטויים רגולרים: \n\n|סימן|תיאור|\n|:----:|----|\n|?=|מבט קדימה חיובי|\n|?!|מבט קדימה שלילי|\n|?<=|מבט אחורה חיובי|\n|?|מבט אחורה שלילי|\n\n### 4.1 מבט קדימה חיובי\n\nמבט קדימה חיובי דורש שבחלקו הראשון של ביטוי חייב להתקיים הביטוי מבט קדימה חיובי. \nההתאמה המוחזרת מכילה רק את הטקסט המתאים לחלק הראשון של הביטוי לפני המבט קדימה. \nבכדי להגדיר מבט קדימה חיובי, משתמשים בסוגריים. בתוך הסוגריים, משתמשים בסימן שאלה \nואחריו סימן השוואה כך: `(?=...)`. ביטויי המבט קדימה נכתבים אחרי סימני סוג \nהמבט בתוך הסוגריים. לדוגמא, הביטוי הרגולרי `(T|t)he(?=\\sfat)` פירושו: \nהתאם או את האות הקטנה `t` או את האות הגדולה `T`, שאחריה תיהיה האות `h`, ואחריה האות `e`. \nבסוגריים אנחנו מגדירים מבט קדימה חיובי שאומר למנוע של הביטוי הרגולרי להתאים `The` או `the` \nרק אם אחרי ההתאמה מופיעה המחרוזתS ` fat`.\n\n
\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/IDDARt/1)\n\n### 4.2 מבט קדימה שלילי\n\nמשתמשים במבט קדימה שלילי כשאנחנו צריכים לקבל את כל ההתאמות ממחרוזת קלט שלאחריהן אין תבנית מסויימת. \nמבט קדימה שלילי יכתב באותה הדרך כמו שנכתב המבט קדימה החיובי. ההבדל היחיד הוא שמבקום \nסימן השווה `=`, עלינו להשתמש בסימן קריאה `!` בכדי לציין את השלילה כלומר: `(?!...)`. \nבואו נסתכל על הביטוי הרגולרי הבא `(T|t)he(?!\\sfat)` שפירושו: התאם את כל המילים `The` או `the` \nממחרוזת קלט שאחריהן אין את התו רווח ולאחר מכן את המילה `fat`.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/V32Npg/1)\n\n### 4.3 מבט אחורה חיובי\n\nמשתמשים במבט אחורה חיובי בכדי לקבל את כל ההתאמות שלפניהן יש תבנית ספציפית מסויימת. \nמבטים אחורה חיוביים נכתבים כך: `(?<=...)`. לדוגמא, \nהביטוי הרגולרי `(?<=(T|t)he\\s)(fat|mat)` פירושו: התאם \nאת כל המילים `fat` או `mat` ממחרוזת קלט שנמצאות לפני המילים `The` או `the` ויש רווח \nשמפריד בינהן.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/avH165/1)\n\n### 4.4 מבט אחורה שלילי\n\nמשתמשים במבט אחורה שלילי בכדי לקבל את כל ההתאמות שלפניהן אין תבנית ספציפית מסויימת.\nמבטים אחורה שליליים יכתבו כך: `(?. לדוגמא, הביטוי הרגולרי \n`(? פירושו: התאם את כל המילים `cat` \nממחרוזת קלט שלא נמצאות אחרי המילים `The` or `the` כאשר רווח מפריד בינהן.\n\n
\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/8Efx5G/1)\n\n## 5. דגלים\n\nדגלים נקראים גם משנים בגלל שהם משנים את הפלט של הביטוי הרגולרי. \nניתן להשתמש בדגלים הללו בכל סדר או שילוב והם חלק בלתי נפרד \nמהביטוי הרולרי (RegExp).\n\n|דגל|תיאור|\n|:----:|----|\n|i|חוסר רגישות לאותיות: ההתאמה לא תהיה רגישה לאותיות קטנות או גדולות.|\n|g|חיפוש גלובלי: התאם את כל ההאמות שהופיעו, לא רק את הראשונה.|\n|m|רב-שורות: תווי-המטא העוגנים (`$` או `^`) עובדים על כל שורה.|\n\n### 5.1 חוסר רגישות לאותיות\n\nהמשנה `i` משמש בכדי לבצע התאמות חסרות רגישות לאותיות קטנות או גדולות.\nלדוגמא, בביטוי הרגולרי `/The/gi` פירושו: אות גדולה `T`, ואחריה אות קטנה\n`h`, ואחריה אות קטנה `e`. ובסוף הביטוי הרגולרי יש את הדגל `i` שאומר למנוע הביטוי הרגולרי \nלהתעלם מהבדלי אותיות גדולות או קטנות. וכפי שאת.ה יכול לראות,\nסיפקנו גם דגל `g` בגדלל שאנחנו רוצים לחפש את התבנית בכל מחרוזת הקלט. \n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 חיפוש גלובלי\n\nהמשנה `g` משמש בכדי לבצע התאמות גלובליות (מוצא את כל ההתאמות במקום לעצור בהתאמה הראשונה). \nלדוגמא, בביטוי הרגולרי `/.(at)/g` פירושו: כל תו חות משורה חדשה, שאחריו תיהיה האות הקטנה `a`,\nואחריה תיהיה האות הקטנה `t`. בגלל שסיפקנו את הדגל `g` בסופו של הביטוי הרגולרי, \nהוא עכשיו ימצא את כל ההתאמות במחרוזת הקלט, לא רק את ההתאמה הראשונה (שזו התנהגות ברירת המחדל).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dO1nef/1)\n\n### 5.3 רב-שורות\n\nהמשנה `m` משמש בכדי לבצע התאמות במספר רב של שורות. כפי שדנו על כך קודם לכן, \nהעוגנים `(^, $)` משמשים לבדיקה אם תבנית היא בהתחלה או בסופו של קלט. \nאבל אם אנחנו רוצים שהעוגנים הללו יעבדו על כל שורה, אנחנו נשתמש בדגל `m`. לדוגמא, \nבביטוי הרגולרי `/at(.)?$/gm` פירושו: אות קטנה\n`a`, שלאחריה האות הקטנה `t` וכאופציה, כל תו שאינו שורה חדשה. ובגלל הדגל `m`, \nהמנוע של הביטוי הרגולרי יתאים את התבנית בכל סוף שורה במחרוזת. \n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/E88WE2/1)\n\n## 6. התאמה חמדנית מול עצלה\n\nכברירת מחדל, ביטוי רגולרי יבצע התאמה חמדנית, זאת אומרת שביצוע ההתאמה תיהיה ארוכה ככל הניתן. \nאנחנו יכולים להשתמש ב-`?` בכדי לבצע התאמה בצורה עצלה, פירוש הדבר שההתאמה תיהיה קצרה ככל שניתן.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/2)\n\n\n## תרומה\n\n* Open a pull request with improvements\n* Discuss ideas in issues\n* Spread the word\n* Reach out with any feedback \n* [](https://twitter.com/ziishaned)\n\n## רישיון\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n
\n
\n \n \n \n
\n
\n ![\"Regular](\"../img/regexp-hu.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/dmRygT/1)\n\nAz `123` reguláris kifejezés illeszkedik a `123` karakterláncra. A reguláris kifejezés\nminden egyes karaktere össze lesz hasonlítva a bevitt karakterlánc minden elemével\negymás után. A reguláris kifejezések alap esetben kis-nagybetű érzékenyek, tehát a\n`The` reguláris kifejezés nem fog illeszkedni a `the` karakterláncra.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta karakterek\n\nA meta karakterek a reguláris kifejezések építőkockái. A meta karakterek speciális\nmódon értelmezendőek. Némelyik meta karakternek speciális jelentése van és\nszögletes zárójelek közé vannak téve. A meta karakterek a következők:\n\n|Meta karakter|Leírás|\n|:----:|----|\n|.|A pont illeszkedik minden egyes karakterre kivéve a sortörést.|\n|[ ]|Karakter osztály. Minden karakterre illeszkedik ami a szögletes zárójelek közt van.|\n|[^ ]|Negált karakter osztály. Minden karakterre illeszkedik ami nincs a szögletes zárójelek közt.|\n|*|Illeszkedik az őt megelőző szimbólum 0 vagy több ismétlődésére.|\n|+|Illeszkedik az őt megelőző szimbólum 1 vagy több ismétlődésére.|\n|?|Opcionálissá teszi az őt megelőző szimbólumot.|\n|{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.|\n|(xyz)|Karakter csoport. Illeszkedik az xyz karakterekre pontosan ilyen sorrendben.|\n|||Alternáció. Illeszkedik a szimbólum előtt és után álló karakterekre is.|\n|\|Escape-li a következő karaktert. A segítségével lefoglalt karakterekre is lehet illeszkedni
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|A karakterlánc elejére illeszkedik.|\n|$|A karakterlánc végére illeszkedik.|\n\n## 2.1 Full stop\n\nA full stop `.` a legegyszerűbb meta karakter példa. A `.` meta karakter illeszkedik\nminden egyes karakterre. Nem fog illeszkedni a kocsi vissza és a sortörés karakterekre.\nPéldául a `.ar` reguláris kifejezés jelentése: minden karakter, amit `a` aztán `r` követ.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Karakter osztályok\n\nA szögletes zárójelekkel határozzuk meg a karakter osztályokat. A szögletes\nzárójelek közt kötőjel karakterrel határozhatunk meg karakter tartományokat.\nA karaktertartomány sorrendje nem számít. Például a `[Tt]he` reguláris kifejezés\njelentése: nagybetűs `T` vagy kisbetűs `t` amit egy `h` majd egy `e` betű követ.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/2ITLQ4/1)\n\nEgy pont a karakter osztályon belül egyébként szó szerint pont-ot jelent. A\n`ar[.]` reguláris kifejezés jelentése: kisbetűs `a` amit egy `r` aztán egy\npont `.` karakter követ.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negált karakter osztályok\n\nÁltalában a kalap szimbólum egy karakterlánc elejét jelenti, de ha egy nyitó\nszögletes zárójel után áll, akkor negálja a karakter osztályt. Például a \n`[^c]ar` reguláris kifejezés jelentése: minden karakter a `c` kivételével\nami után `a` aztán egy `r` betű áll.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Ismétlések\n\nA következő meta karaktereket `+`, `*` vagy `?` arra használjuk, hogy meghatározzuk,\nhányszor fordulhat elő az al-minta. Ezek a meta karakterek máshogy viselkednek\nadott helyzetekben.\n\n### 2.3.1 A csillag\n\nA `*` szimbólum az őt megelőző karakter nulla vagy több ismétlődésére illeszkedik.\nA `a*` reguláris kifejezés jelentése: nulla vagy több ismétlődése az őt megelőző `a`\nkarakternek. De ha egy karakter osztály után áll akkor az egész karakterosztály\nismétlődését keresi. Például, a `[a-z]*` reguláris kifejezés jelentése: bármennyi\nkisbetűs betű egy sorban.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/7m8me5/1)\n\nA `*` szimbólum használható a `.` meta karakterrel `.*`, ez illeszkedik\nbármilyen karakterláncra. A `*` szimbólum használható a whitespace karakterrel `\\s`\negyütt, hogy illeszkedjen egy whitespace-ekből álló karakterláncra. Például a\n`\\s*cat\\s*`kifejezés jelentése: nulla vagy több szóköz, amit egy kisbetűs `c`,\naztán egy kisbetűs `a`, aztán egy kisbetűs `t`, amit még nulla vagy több szóköz követ.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 A plusz\n\nA `+` szimbólum illeszkedik az őt megelőző karakter egy vagy több ismétlődésére.\nPéldául a `c.+t` kifejezés jelentése: kisbetűs `c` betű, amit legalább egy vagy\ntöbb `t` követ. Itt tisztázni kell hogy a `t` az utolsó `t` a mondatban.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 A kérdőjel\n\nA reguláris kifejezésben a `?` meta karakter opcionálissá teszi az őt\nmegelőző karaktert. Ez a szimbólum az őt megelőző karakter nulla vagy egy\npéldányára illeszkedik. Például a `[T]?he` kifejezés jelentése: opcionális a\nnagybetűs `T`, amit egy kisbetűs `h`, majd egy kisbetűs `e` követ.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 A kapcsos zárójelek\n\nA reguláris kifejezésben a kapcsos zárójeleket annak meghatározására használjuk,\nhogy egy karakter vagy egy karakter csoport hányszor ismétlődhet. Például a\n`[0-9]{2,3}` kifejezés jelentése: minimum 2 de nem több mint 3 karakter a `[0-9]`\nkaraktertartományon belül.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/juM86s/1)\n\nKihagyhatjuk a második számot. Például a `[0-9]{2,}` kifejezés jelentése:\n2 vagy több számra illeszkedik. Ha a vesszőt is kitöröljük `[0-9]{3}`: Pontosan\n3 számra illeszkedik.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Karakter csoportok\n\nA karakter csoport al-minták csoportja amik zárójelek közé `(...)` vannak írva.\nAhogy előbb már megbeszéltük, ha egy karakter után ismétlő karaktert rakunk, az\nismételni fogja az előtte lévő karaktert. De ha egy ismétlő karaktert egy karakter\ncsoport után rakunk, az ismételni fogja az egész csoportot. Például a `(ab)*`\nkifejezés illeszkedik nulla vagy több ismétlődésére az `ab` karaktereknek.\nHasználhatunk alternáló meta karaktert `|` is a csoporton belül. Például a `(c|g|p)ar`\nkifejezés jelentése: kisbetűs `c`, `g` vagy `p` karakter, amit egy `a` aztán\negy `r` karakter követ.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Alternálás\n\nA reguláris kifejezésben a függőleges vonalat `|` alternálásra (választásra)\nhasználjuk. Az alternálás olyan, mint egy feltétel több kifejezés közt. Most\nazt gondolhatod, hogy a karakter osztály és az alternáció ugyan úgy működik.\nDe a fő különbség köztük, hogy a karakter osztály a karakterek szintjén működik,\naz alternáció viszont a kifejezés szintjén. Például a `(T|t)he|car` kifejezés\njelentése: nagybetűs `T` karakter vagy kisbetűs `t` karakter, amit egy `h` és\negy `e` követ, VAGY kisbetűs `c` aztán `a` aztán `r` karakter.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Speciális karakter escape-elése\n\nA visszaper `\\` a reguláris kifejezésekben a következő karakter escape-elésére\nvaló. Ez enged nekünk szimbólumokat vagy lefoglalt karaktereket `{ } [ ] / \\ + * . $ ^ | ?`\nmegadni. Egy speciális karakter egyező karakterként való megadásához tedd elé\na `\\` karaktert.\n\nPéldául a `.` kifejezést az összes karakter, kivéve a sortörés illeszkedéséhez\nhasználjuk. A `(f|c|m)at\\.?` kifejezés jelentése: kisbetűs `f`, `c` vagy `m`, amit\negy kisbetűs `a` aztán egy kisbetűs `t`, amit egy opcionális `.` karakter követ.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)\n\n## 2.8 Horgonyok\n\nA reguláris kifejezésekben horgonyokat használunk, hogy megnézzük, az illeszkedő\nszimbólum a kezdő vagy a záró szimbóluma-e a karakterláncnak. A horgonyoknak két\nfajtájuk van: Az első a Kalap `^`, ami megnézi, hogy az egyező karakter a karakterlánc\nkezdő kerektere-e és a második a Dollár `$`, ami azt vizsgálja, hogy az egyező\nkarakter a karakterlánc utolsó karaktere-e.\n\n### 2.8.1 Kalap\n\nA kalap `^` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező karakter\na karakterlánc kezdő kerektere-e. Ha megadjuk a következő kifejezést: `^a`,\nakkor illeszkedik a `abc` karakterlánc `a` karakterére, mert az za első. De ha\nmegadjuk, hogy: `^b`, ez nem fog illeszkedni az `abc` egyik részére sem, mert\nnem `b` a kezdő karakter. Nézzünk meg egy másik kifejezést. `^(T|t)he` jelentése:\nnagybetűs `T` vagy kisbetűs `t` a kezdő karaktere a karakterláncnak, amit kisbetűs\n`h`, majd kisbetűs `e` követ.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dollár\n\nA dollár `$` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező\nkarakter a karakterlánc utolsó karaktere-e. Például a `(at\\.)$` kifejezés\njelentése: egy kisbetűs `a`, amit egy kisbetűs `t`, amit egy `.` követ. És\nennek az egésznek a karakterlánc végén kell lennie.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/t0AkOd/1)\n\n## 3. Shorthand Karakter osztályok\n\nA gyakran használt karakter osztályokra a reguláris kifejezésnek vannak\nrövidítései, amikkel kényelmesebben tudunk használni általános kifejezéseket.\nA shorthand karakter osztályok a következők:\n\n|Rövidítés|Leírás|\n|:----:|----|\n|.|Minden karakter a sortörésen kívül.|\n|\\w|Az alfanumerikus karakterekre illeszkedik: `[a-zA-Z0-9_]`|\n|\\W|A nem alfanumerikus karakterekre illeszkedik: `[^\\w]`|\n|\\d|Számra illeszkedik: `[0-9]`|\n|\\D|Nem számra illeszkedik: `[^\\d]`|\n|\\s|Whitespace karakterre illeszkedik: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Nem whitespace karakterre illeszkedik: `[^\\s]`|\n\n## 4. Lookaround\n\nA lookbehind (hátranézés) és a lookahead (előrenézés) speciális típusai a\n***nem tárolt csoport*** oknak, amiket illeszkedésre használnak, de nincsenek\nbenne az illeszkedési listában. Az előrenézést akkor használjuk, ha feltételezzük,\nhogy ezt a mintát egy másik minta előzi meg, vagy követi. Például kell nekünk\naz összes szám ami előtt `$` karakter áll a következő karakterláncból: `$4.44 and $10.88`.\nEzt a mintát fogjuk használni: `(?<=\\$)[0-9\\.]*`, aminek a jelentése: Szedd ki az\nösszes számot ami `.` karaktert tartalmaz és megelőzi egy `$` karakter. A\nkövetkező lookaround-okat használhatjuk:\n\n|Szimbólum|Leírás|\n|:----:|----|\n|?=|Positive Lookahead|\n|?!|Negative Lookahead|\n|?<=|Positive Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negative Lookahead\n\nA negatív előrenézést akkor használjuk, ha az olyan illeszkedések kellenek,\namelyeket nem követ egy bizonyos minta. A negatív előrenézést ugyanúgy\ndefiniáljuk mint a pozitív előrenézést, az egyetlen különbség, hogy az\negyenlőségjel `=` helyett negálást `!` használunk: `(?!...)`. Nézzük meg\na következő kifejezést: `(T|t)he(?!\\sfat)`, jelentése: szedd ki az összes\n`The` vagy `the` szót, amelyeket nem követ a `fat` szó (amit még megelőz\negy szóköz).\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Positive Lookbehind\n\nA pozitív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit\negy megadott minta előz meg. A pozitív hátranézés így van jelölve: `(?<=...)`.\nA `(?<=(T|t)he\\s)(fat|mat)` jelentése: szedd ki az összes `fat` vagy `mat` szót\namelyek a `The` vagy a `the` szavak után vannak.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/avH165/1)\n\n### 4.4 Negative Lookbehind\n\nA negatív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit nem\negy megadott minta előz meg. Jelölése: `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flag-ek\n\nA flag-eket módosítónak hívják, mert módosítják a reguláris kifejezés\nkimenetét. Ezeket a flag-eket bármilyen sorban vagy kombinációban lehet\nhasználni, a RegExp szerves részét képezik.\n\n|Flag|Leírás|\n|:----:|----|\n|i|Kis-nagybetű érzéketlen: Beállítja, hogy az illeszkedés kis-nagybetű érzéketlen legyen.|\n|g|Globális keresés: A bemeneti szövegben mindenütt keresi az illeszkedéseket.|\n|m|Többsoros: A horgonyok az összes sorra működnek.|\n\n### 5.1 Kis-nagybetű érzéketlen\n\nAz `i` módosító beállítja, hogy az illeszkedés ne legyen kis-nagybetű érzékeny.\nPéldául a `/The/gi` kifejezés jelentése: nagybetűs `T` amit kisbetűs `h`, majd `e`\nkövet. A kifejezés végén az `i` megmondja a reguláris kifejezés motornak, hogy\nhagyja figyelmen kívül a betűk méretét. Ahogy látod, megadtuk a `g` flag-et, mert\naz egész bemeneti szövegben akarjuk keresni az illeszkedéseket.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Globális keresés\n\nA `g` módosítót arra használjuk, hogy globálisan keressünk illeszkedéseket.\n(Megkeresi az összes előfordulást, nem áll meg az első egyezés után). Például\na `/.(at)/g` kifejezés jelentése: minden karakter, kivéve a sortörést, amelyet\n`a` és `t` követ. Mivel megadtuk a `g` flag-et, az összes ilyenre fog illeszkedni,\nnem csak az elsőre (ami az alapértelmezett viselkedés). \n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Többsoros\n\nAz `m` módosítót a többsoros illeszkedésekhez használjuk. Ahogy előzőleg beszéltük,\na horgonyokat `(^, $)` arra használjuk, hogy megnézzük, a minta az eleje, vagy a vége-e\na vizsgált karakterláncnak. De ha azt szeretnénk, hogy a horgonyok az összes soron\nműködjenek, használjuk az `m` módosítót. Például a `/at(.)?$/gm` kifejezés jelentése:\nkisbetűs `a` karakter, amit egy kisbetűs `t` követ, amit opcionálisan bármi követhet,\nkivéve sortörés. És az `m` flag miatt a reguláris kifejezés motor az összes sor\nvégéig keres illeszkedést.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Teszteld a reguláris kifejezést](https://regex101.com/r/E88WE2/1)\n\n## Hozzájárulás\n\n* Jelents hibákat\n* Nyiss pull request-eket fejlesztésekkel\n* Hírdesd az igét\n* Érj el közvetlenül itt: ziishaned@gmail.com vagy [](https://twitter.com/ziishaned)\n\n## Licenc\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-id.md", "content": "
\n
\n \t\n \n \n
\n \n \n \n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/dmRygT/1)\n\nEkspresi reguler `123` cocok dengan string `123`. Ekspresi reguler adalah\ndicocokkan dengan string input dengan membandingkan setiap karakter di reguler\nekspresi ke setiap karakter dalam string input, satu demi satu. Reguler\nekspresi biasanya peka huruf besar/kecil sehingga ekspresi reguler `The` akan\ntidak cocok dengan string `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/1paXsy/1)\n\n## 2. Karakter Meta\n\nKarakter meta adalah blok bangunan ekspresi reguler. Meta\nkarakter tidak berdiri sendiri tetapi sebaliknya ditafsirkan dalam beberapa\ncara spesial. Beberapa karakter meta memiliki arti khusus dan tertulis di dalamnya\ntanda kurung siku. Karakter metanya adalah sebagai berikut:\n\n|Meta karakter|Deskripsi|\n|:----:|----|\n|.|Titik cocok dengan karakter tunggal apa pun kecuali jeda baris.|\n|[ ]|Kelas karakter. Mencocokkan karakter apa pun yang ada di antara tanda kurung siku.|\n|[^ ]|Kelas karakter yang dinegasikan. Cocok dengan karakter apa pun yang tidak ada di antara tanda kurung siku|\n|*|Mencocokkan dengan 0 atau lebih pengulangan dari simbol sebelumnya.|\n|+|Mencocokkan 1 atau lebih pengulangan dari simbol sebelumnya.|\n|?|Jadikan simbol sebelumnya opsional.|\n|{n,m}|Kurung Kurawal. Mencocokkan setidaknya \"n\" tetapi tidak lebih dari \"m\" pengulangan simbol sebelumnya.|\n|(xyz)|Kelompok karakter. Mencocokkan karakter xyz dalam urutan yang tepat.|\n|||Alternasi. Mencocokkan dengan karakter sebelum atau karakter setelah simbol.|\n|\|Meloloskan dari karakter berikutnya. Ini memungkinkan Anda untuk mencocokkan karakter yang dipesan
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Mencocokkan dengan awal input.|\n|$|Mencocokkan dengan akhir input.|\n\n## 2.1 Perhentian Penuh\n\nTanda titik `.` adalah contoh paling sederhana dari karakter meta. Karakter meta `.`\ncocok dengan karakter tunggal apa pun. Itu tidak akan cocok dengan karakter kembali atau baris baru.\nMisalnya, ekspresi reguler `.ar` berarti: karakter apa pun, diikuti oleh\nhuruf `a`, diikuti dengan huruf `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Set Karakter\n\nKumpulan karakter juga disebut kelas karakter. Tanda kurung siku digunakan untuk\nmenentukan set karakter. Gunakan tanda hubung di dalam set karakter untuk menentukan\njangkauan karakter. Urutan rentang karakter di dalam tanda kurung siku\ntidak masalah. Misalnya, ekspresi reguler `[Tt]he` berarti: huruf besar\n`T` atau huruf kecil `t`, diikuti huruf `h`, diikuti huruf `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/2ITLQ4/1)\n\nSebuah periode di dalam set karakter, bagaimanapun, berarti periode literal. yang biasa\nekspresi `ar[.]` berarti: karakter huruf kecil `a`, diikuti dengan huruf `r`,\ndiikuti dengan karakter titik `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Set Karakter yang Dinegasikan\n\nSecara umum, simbol tanda sisipan mewakili awal string, tetapi ketika itu\ndiketik setelah kurung siku pembuka itu meniadakan set karakter. Untuk\ncontoh, ekspresi reguler `[^c]ar` berarti: karakter apa pun kecuali `c`,\ndiikuti dengan karakter `a`, diikuti dengan huruf `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Pengulangan\n\nKarakter meta `+`, `*` atau `?` digunakan untuk menentukan berapa kali a\nsubpola dapat terjadi. Karakter meta ini bertindak secara berbeda di berbagai\nsituasi.\n\n### 2.3.1 Tanda Bintang\n\nSimbol `*` cocok dengan nol atau lebih pengulangan dari pencocokan sebelumnya. Itu\nekspresi reguler `a*` berarti: nol atau lebih pengulangan dari huruf kecil sebelumnya\nkarakter `a`. Tetapi jika itu muncul setelah set karakter atau kelas maka ia menemukan\npengulangan seluruh set karakter. Misalnya, ekspresi reguler\n`[a-z]*` artinya: sejumlah huruf kecil dalam satu baris.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/7m8me5/1)\n\nSimbol `*` dapat digunakan dengan karakter meta `.` untuk mencocokkan string apa pun dari\nkarakter `.*`. Simbol `*` dapat digunakan dengan karakter spasi putih `\\s`\nuntuk mencocokkan string karakter spasi. Misalnya, ungkapan\n`\\s*cat\\s*` artinya: nol spasi atau lebih, diikuti dengan huruf kecil `c`,\ndiikuti dengan huruf kecil `a`, diikuti dengan huruf kecil `t`,\ndiikuti oleh nol atau lebih spasi.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Tanda Tambah\n\nSimbol `+` cocok dengan satu atau lebih pengulangan karakter sebelumnya. Untuk\ncontoh, ekspresi reguler `c.+t` berarti: huruf kecil `c`, diikuti oleh\nsetidaknya satu karakter, diikuti dengan huruf kecil `t`. Itu perlu\nmengklarifikasi bahwa `t` adalah `t` terakhir dalam kalimat.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Tanda Tanya\n\nDalam ekspresi reguler, karakter meta `?` membuat karakter sebelumnya\nopsional. Simbol ini cocok dengan nol atau satu contoh karakter sebelumnya.\nMisalnya, ekspresi reguler `[T]?he` artinya: Huruf besar opsional\n`T`, diikuti dengan huruf kecil `h`, diikuti dengan huruf kecil `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Braces\n\nDalam ekspresi reguler, kurung kurawal (juga disebut quantifier) digunakan untuk\ntentukan berapa kali karakter atau sekelompok karakter dapat\nulang. Misalnya, ekspresi reguler `[0-9]{2,3}` berarti: Setidaknya cocok\n2 digit, tetapi tidak lebih dari 3, mulai dari 0 hingga 9.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/juM86s/1)\n\nKita bisa meninggalkan nomor kedua. Misalnya, ekspresi reguler\n`[0-9]{2,}` berarti: Mencocokkan 2 digit atau lebih. Jika kita juga menghapus koma,\nekspresi reguler `[0-9]{3}` berarti: Sama persis dengan 3 digit.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Menangkap Grup\n\nGrup penangkap adalah grup subpola yang ditulis di dalam tanda kurung\n`(...)`. Seperti yang dibahas sebelumnya, dalam ekspresi reguler, jika kita menempatkan quantifier\nsetelah karakter maka akan mengulangi karakter sebelumnya. Tetapi jika kita menempatkan quantifier\nsetelah grup penangkap kemudian mengulangi seluruh grup penangkap. Sebagai contoh,\nekspresi reguler `(ab)*` cocok dengan nol atau lebih pengulangan karakter\n\"ab\". Kita juga dapat menggunakan karakter meta `|` bergantian di dalam grup penangkap.\nMisalnya, ekspresi reguler `(c|g|p)ar` berarti: huruf kecil `c`,\n`g` atau `p`, diikuti oleh `a`, diikuti oleh `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/tUxrBG/1)\n\nPerhatikan bahwa menangkap grup tidak hanya cocok, tetapi juga menangkap, karakter untuk digunakan dalam\nbahasa induk. Bahasa induk bisa berupa Python atau JavaScript atau hampir semua\nbahasa yang mengimplementasikan ekspresi reguler dalam definisi fungsi.\n\n### 2.5.1 Grup yang Tidak Menangkap\n\nGrup yang tidak menangkap adalah grup yang cocok dengan karakter tetapi\ntidak menangkap kelompok. Grup yang tidak menangkap dilambangkan dengan `?` diikuti oleh `:`\ndalam tanda kurung `(...)`. Misalnya, ekspresi reguler `(?:c|g|p)ar` mirip dengan\n`(c|g|p)ar` karena cocok dengan karakter yang sama tetapi tidak akan membuat grup tangkapan.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/Rm7Me8/1)\n\nGrup yang tidak menangkap dapat berguna saat digunakan dalam fungsi temukan-dan-ganti atau\nketika dicampur dengan grup penangkap untuk menjaga gambaran umum saat memproduksi jenis keluaran lainnya.\nLihat juga [4. Melihat-lihat](#4-lookaround).\n\n## 2.6 Alternasi\n\nDalam ekspresi reguler, bilah vertikal `|` digunakan untuk mendefinisikan pergantian.\nPergantian seperti pernyataan OR antara beberapa ekspresi. Sekarang, Anda mungkin\nberpikir bahwa set karakter dan pergantian bekerja dengan cara yang sama. Tapi yang besar\nperbedaan antara set karakter dan pergantian adalah bahwa set karakter bekerja di\ntingkat karakter tetapi pergantian bekerja pada tingkat ekspresi. Misalnya,\nekspresi reguler `(T|t)he|car` berarti: baik (huruf besar `T` atau huruf kecil\n`t`, diikuti dengan huruf kecil `h`, diikuti dengan huruf kecil `e`) ATAU\n(huruf kecil `c`, diikuti dengan huruf kecil `a`, diikuti oleh\nhuruf kecil `r`). Perhatikan bahwa saya menyertakan tanda kurung untuk kejelasan, untuk menunjukkan bahwa salah satu ekspresi\ndalam tanda kurung dapat dipenuhi dan itu akan cocok.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Karakter Spesial\n\nGaris miring terbalik `\\` digunakan dalam ekspresi reguler untuk keluar dari karakter berikutnya. Ini\nmemungkinkan kita untuk menyertakan karakter yang dicadangkan seperti `{ } [ ] / \\ + * . $ ^ | ?` sebagai karakter yang cocok. Untuk menggunakan salah satu karakter khusus ini sebagai karakter yang cocok, awali dengan `\\`.\n\nMisalnya, ekspresi reguler `.` digunakan untuk mencocokkan karakter apa pun kecuali a\ngaris baru. Sekarang, untuk mencocokkan `.` dalam string input, ekspresi reguler\n`(f|c|m)at\\.?` artinya: huruf kecil `f`, `c` atau `m`, diikuti dengan huruf kecil\n`a`, diikuti dengan huruf kecil `t`, diikuti dengan `.` . opsional\nkarakter.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Anchor Text\n\nDalam ekspresi reguler, kami menggunakan jangkar untuk memeriksa apakah simbol yang cocok adalah\nsimbol awal atau simbol akhir dari string input. Jangkar terdiri dari dua jenis:\nTipe pertama adalah tanda sisipan `^` yang memeriksa apakah karakter yang cocok adalah yang pertama\nkarakter input dan tipe kedua adalah tanda dolar `$` yang memeriksa apakah cocok\nkarakter adalah karakter terakhir dari string input.\n\n### 2.8.1 Tanda Sisipan\n\nSimbol tanda sisipan `^` digunakan untuk memeriksa apakah karakter yang cocok adalah karakter pertama\ndari string masukan. Jika kita menerapkan ekspresi reguler berikut `^a` (artinya 'a' harus\nkarakter awal) ke string `abc`, itu akan cocok dengan `a`. Tapi jika kita melamar\nekspresi reguler `^b` ke string di atas, itu tidak akan cocok dengan apa pun.\nKarena dalam string `abc`, \"b\" bukanlah karakter awal. Mari lihat\ndi ekspresi reguler lain `^(T|t)he` yang artinya: huruf besar `T` atau\nhuruf kecil `t` harus menjadi karakter pertama dalam string, diikuti oleh a\nhuruf kecil `h`, diikuti dengan huruf kecil `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Tanda Dolar\n\nTanda dolar `$` digunakan untuk memeriksa apakah karakter yang cocok adalah karakter terakhir\ndalam tali. Misalnya, ekspresi reguler `(at\\.)$` berarti: a\nhuruf kecil `a`, diikuti dengan huruf kecil `t`, diikuti oleh `.`\nkarakter dan matcher harus berada di akhir string.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/t0AkOd/1)\n\n## 3. Set Karakter Singkatan\n\nAda sejumlah singkatan yang mudah digunakan untuk set karakter yang umum digunakan/\nekspresi reguler:\n\n|Singkatan|Deskripsi|\n|:----:|----|\n|.|Karakter apa pun kecuali baris baru|\n|\\w|Mencocokkan karakter alfanumerik: `[a-zA-Z0-9_]`|\n|\\W|Mencocokkan karakter non-alfanumerik: `[^\\w]`|\n|\\d|Mencocokkan digit: `[0-9]`|\n|\\D|Mencocokkan non-digit: `[^\\d]`|\n|\\s|Mencocokkan karakter spasi putih: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Mencocokkan karakter non-spasi: `[^\\s]`|\n\n## 4. Melihat-lihat\n\nMelihat ke belakang dan melihat ke depan (juga disebut melihat sekeliling) adalah jenis tertentu dari\n***grup non-penangkapan*** (digunakan untuk mencocokkan pola tetapi tanpa menyertakannya dalam pencocokan\ndaftar). Lookarounds digunakan ketika sebuah pola harus\ndidahului atau diikuti oleh pola lain. Misalnya, bayangkan kita ingin mendapatkan semua\nangka yang didahului oleh karakter `$` dari string\n`$4,44 dan $10,88`. Kami akan menggunakan ekspresi reguler berikut `(?<=\\$)[0-9\\.]*`\nyang artinya: dapatkan semua angka yang mengandung karakter `.` dan didahului\noleh karakter `$`. Ini adalah lookaround yang biasa digunakan\nekspresi:\n\n|Simbol|Deskripsi|\n|:----:|----|\n|?=|Pandangan ke Depan Positif|\n|?!|Melihat ke Depan Negatif|\n|?<=|Tampilan Positif di Belakang|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Pandangan ke Depan Negatif\n\nPandangan negatif ke depan digunakan ketika kita perlu mendapatkan semua kecocokan dari string input\nyang tidak mengikuti pola tertentu. Sebuah lookahead negatif ditulis dengan cara yang sama seperti a\npandangan positif ke depan. Satu-satunya perbedaan adalah, alih-alih tanda sama dengan `=`, kami\ngunakan tanda seru `!` untuk menunjukkan negasi yaitu `(?!...)`. Yuk simak berikut ini\nekspresi reguler `(T|t)he(?!\\sfat)` yang artinya: dapatkan semua kata `The` atau `the`\ndari string input yang tidak diikuti oleh karakter spasi dan kata `fat`.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Pandangan Positif ke Belakang\n\nPositif melihat ke belakang digunakan untuk mendapatkan semua kecocokan yang didahului oleh a\npola tertentu. Positif lookbehinds ditulis `(?<=...)`. Misalnya,\nekspresi reguler `(?<=(T|t)he\\s)(fat|mat)` artinya: dapatkan semua kata `fat` atau `mat`\ndari string input yang datang setelah kata `The` atau `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/avH165/1)\n\n### 4.4 Pandangan negatif ke belakang\n\nPandangan belakang negatif digunakan untuk mendapatkan semua kecocokan yang tidak didahului oleh a\npola tertentu. Tampilan negatif di belakang ditulis `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Test the regular expression](https://regex101.com/r/8Efx5G/1)\n\n## 5. Bendera\n\nBendera juga disebut pengubah karena mereka memodifikasi output dari regular\nekspresi. Bendera ini dapat digunakan dalam urutan atau kombinasi apa pun, dan merupakan\nbagian integral dari RegExp.\n\n|Bendera|Deskripsi|\n|:----:|----|\n|i|Tidak peka huruf besar/kecil: Pencocokan tidak peka huruf besar/kecil.|\n|g|Penelusuran Global: Cocokkan semua instance, bukan hanya yang pertama.|\n|m|Multiline: Karakter meta jangkar bekerja di setiap baris.|\n\n### 5.1 Tidak peka huruf besar/kecil\n\nPengubah `i` digunakan untuk melakukan pencocokan case-insensitive. Misalnya,\nekspresi reguler `/The/gi` berarti: huruf besar `T`, diikuti dengan huruf kecil\n`h`, diikuti oleh `e`. Dan di akhir ekspresi reguler\nflag `i` memberitahu mesin ekspresi reguler untuk mengabaikan kasus ini. Sebisa kamu\nlihat, kami juga menyediakan flag `g` karena kami ingin mencari pola di\nseluruh string masukan.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Pencarian Global\n\nPengubah `g` digunakan untuk melakukan kecocokan global (menemukan semua kecocokan daripada\nberhenti setelah pertandingan pertama). Misalnya, ekspresi reguler`/.(at)/g`\nberarti: karakter apa pun kecuali baris baru, diikuti dengan huruf kecil `a`,\ndiikuti dengan huruf kecil `t`. Karena kami menyediakan flag `g` di akhir\nekspresi reguler, sekarang akan menemukan semua kecocokan dalam string input, bukan hanya yang pertama (yang merupakan perilaku default).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multiline\n\nPengubah `m` digunakan untuk melakukan pencocokan multi-baris. Seperti yang telah kita bahas sebelumnya,\njangkar `(^, $)` digunakan untuk memeriksa apakah suatu pola ada di awal input atau\ntamat. Tetapi jika kita ingin jangkar bekerja pada setiap baris, kita menggunakan\nbendera `m`. Misalnya, ekspresi reguler `/at(.)?$/gm` berarti: huruf kecil\n`a`, diikuti dengan huruf kecil `t` dan, opsional, apa pun kecuali\nbaris baru. Dan karena flag `m`, mesin ekspresi reguler sekarang cocok dengan pola\ndi akhir setiap baris dalam sebuah string.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/E88WE2/1)\n\n## 6. Greedy vs Lazy Matching\nSecara default, regex akan melakukan kecocokan greedy, yang berarti kecocokan akan berlangsung selama\nmungkin. Kita dapat menggunakan `?` untuk mencocokkan dengan cara yang lazy, yang berarti pencocokan harus sesingkat mungkin.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Uji ekspresi reguler](https://regex101.com/r/AyAdgJ/2)\n\n\n## Kontribusi\n\n* Buka pull request dengan peningkatan\n* Diskusikan ide dalam issue\n* Sebarkan materinya\n* Jangkau dengan umpan balik apa pun [](https://twitter.com/ziishaned)\n\n## Lisensi\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-it.md", "content": "
\n
\n \t\n \n \n
\n \n \n \n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/dmRygT/1)\n\nL'espressione regolare `123` corrisponde alla stringa `123`. L'espressione regolare viene confrontata con il testo da ricercare carattere per carattere, al fine di trovare la corrispondenza completa.\nLe espressioni regolari sono normalmente sensibili a caratteri maiuscoli e minuscoli, perciò l'espressione regolare `The` non troverà corrispondenza con il testo `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/1paXsy/1)\n\n## 2. Caratteri jolly\n\nI caratteri jolly sono i mattoncini per la costruzione di espressioni regolari. I caratteri jolly non vengono usati letteralmente, vengono invece interpretati come caratteri speciali. Alcuni caratteri jolly hanno un significato speciale se inseriti all'interno di parentesi quadre. I caratteri jolly sono i seguenti:\n\n|Carattere jolly|Descrizione|\n|:----:|----|\n|.|Il punto corrisponde ad ogni carattere eccetto l'invio e l'interruzione di riga.|\n|[ ]|Classe di caratteri. Corrispondenza con ciascun carattere contenuto tra le parentesi.|\n|[^ ]|Negazione di classe di caratteri. Corrispondenza con ciascun carattere non contenuto all'interno delle parentesi|\n|*|Corrispondenza con zero o più ripetizioni del carattere che lo precede.|\n|+|Corrispondenza con una o più ripetizioni del carattere che lo precede|\n|?|Rende opzionale il carattere che lo precede.|\n|{n,m}|Parentesi graffe. Corrisponde con le ripetizione minima di \"n\" ma non più di \"m\", del carattere che le precede.|\n|(xyz)|Gruppo di caratteri. Corrispondenza con i caratteri tra parentesi xyz solo nell'ordine esatto.|\n|||Alternativa. Corrispondenza con il carattere che precede o con quello che segue.|\n|\|Escape sul carattere successivo. Consente la corrispondenza con i caratteri riservati
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Corrispondenza con l'inizio del testo.|\n|$|Corrispondenza con la fine del testo.|\n\n## 2.1 Il punto\n\nIl punto `.` è il più semplice esempio di carattere jolly. Il carattere jolly `.` ha corrispondenza con ogni singolo carattere nel testo da cercare. Non ha corrispondenza con i caratteri di invio e fine riga.\nAd esempio, l'espressione regolare `.ar` significa: ciascun carattere, seguito dalla lettera `a`, seguita dalla lettera `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Classi di carattere\n\nLe parentesi quadre sono utilizzate per definire una classe di caratteri. Si può utilizzare il trattino per definire degli intervalli all'interno della classe. L'ordine dei caratteri utilizzati nella classe non ha influenza sul risultato. Ad esempio, l'espressione regolare `[Tt]he` significa: una lettera maiuscola `T` o una lettera minuscola `t`, seguita dalla lettera `h`, seguita dalla lettera `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/2ITLQ4/1)\n\nUn punto all'interno di una classe di caratteri, in ogni caso, corrisponde al punto letterale. L'espressione regolare `ar[.]` corrisponde a: una lettera minuscola `a`, seguita dalla lettera `r`, seguita dal carattere `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negazione di classe di carattere\n\nIn generale, il carattere di omissione ^ rappresenta l'inizio di un testo, ma se inserito come primo carattere all'interno di parentesi quadre, funziona come negazione della classe di caratteri. Ad esempio, l'espressione regolare `[^c]ar` corrisponde a: qualsiasi carattere tranne la lettera `c`, seguito dalla lettera `a`, seguita dalla lettera `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Ripetizioni\n\nI caratteri jolly `+`, `*` o `?` sono utilizzati per specificare quante volte uno schema si può ripetere. Questi caratteri jolly agiscono in modo differente per differenti situazioni.\n\n### 2.3.1 Simbolo Asterisco\n\nIl simbolo `*` corrisponde a zero o più ripetizioni della sequenza precedente. L'espressione regolare `a*` corrisponde a: zero o più ripetizioni della precedente lettera minuscola `a`.\nSe il simbolo viene utilizzato a seguito di una classe di caratteri allora verranno applicate le ripetizioni all'intera classe. Ad esempio, l'espressione regolare `[a-z]*` corrisponde a: qualsiasi ripetizione di ciascuna lettera minuscola in un testo.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/7m8me5/1)\n\nIl simbolo `*` più essere applicato al carattere jolly `.` per la corrispondenza con qualsiasi numero di caratteri `.*`. Il simbolo `*` può essere usato con lo spazio vuoto `\\s` per la corrispondenza con una stringa di spazi vuoti. Ad esempio l'espressione regolare `\\s*cat\\s*` corrisponde a: nessuno o più spazi, seguiti dalla lettera minuscola `c`, seguita dalla lettera minuscola `a`, seguita dalla lettera minuscola `t`, seguite da nessuno o più spazi vuoti.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Simbolo Più\n\nIl simbolo `+` corrisponde a una o più ripetizioni della sequenza precedente. Ad esempio, l'espressione regolare `c.+t` corrisponde a: una lettera minuscola `c`, seguita da almeno un carattere, seguito dalla lettera minuscola `t`. \nÈ importante chiarire che `t` corrisponde all'ultima lettera `t` nella stringa.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Carattere Punto di Domanda\n\nNelle espressioni regolari, il carattere jolly `?` rende opzionale il carattere che lo precede. Questo simbolo corrisponde alla ripetizione zero o una volta della sequenza che lo precede.\nAd esempio, l'espressione regolare `[T]?he` corrisponde a: Lettera maiuscola opzionale `T`, seguita, se presente, dalla lettera maiuscola `h`, seguita dalla lettera minuscola `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Parentesi graffe\n\nNelle espressioni regolari, le parentesi graffe (chiamate anche quantificatori) sono utilizzate per specificare il numero di volte che un carattere o una classe di caratteri possono essere ripetute per mantenere la corrispondenza. Ad esempio, l'espressione regolare `[0-9]{2,3}` corrisponde a: Almeno 2 cifre, ma non più di 3, nell'intervallo da 0 a 9.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/juM86s/1)\n\nSi può omettere il secondo numero. Ad esempio, l'espressione regolare `[0-9]{2,}` corrisponde a: 2 o più cifre. Inoltre possiamo rimuove la virgola di separazione, l'espressione regolare `[0-9]{3}` corrisponde a: esattamente 3 cifre.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Raggruppamento e cattura di caratteri\n\nUn gruppo di caratteri è un sottoschema scritto all'interno di parentesi `(...)`. Come esposto in precedenza, se inseriamo un quantificatore a seguito di un carattere, viene definita la ripetizione del carattere stesso; allo stesso modo, se inseriamo un quantificatore a seguito di un gruppo di caratteri, definiamo la ripetizione dell'intero gruppo. Ad esempio, l'espressione regolare `(ab)*` corrisponde a zero o più ripetizioni della sequenza esatta di lettere minuscole \"ab\". \nSi può inoltre utilizzare il carattere di alternativa `|` all'interno di un gruppo di caratteri.\nAd esempio, l'espressione regolare `(c|g|p)ar` corrisponde a: una lettera minuscola a scelta tra `c`, `g` o `p`, seguita dalla lettera minuscola `a`, seguite dalla lettera minuscola `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/tUxrBG/1)\n\nNota che il gruppo di carattere non trova solo corrispondenza, ma cattura il contenuto del gruppo, per utilizzarlo in un linguaggio di programmazione. Il linguaggio può essere Python, Javascript o qualsiasi linguaggio che implementi funzioni per l'utilizzo di espressioni regolari.\n\n### 2.5.1 Raggruppamento di caratteri senza cattura\n\nUn gruppo di caratteri senza cattura è un gruppo utilizzato per la corrispondenza ma non per la cattura. È definito dal carattere `?` seguito da `:` all'interno delle parentesi `(...)`. Ad esempio, l'espressione regolare `(?:c|g|p)ar` è simile a `(c|g|p)ar`, corrisponde alla stessa stringa ma non cattura il gruppo.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/Rm7Me8/1)\n\nI gruppi senza cattura sono utili per funzioni di ricerca e sostituzione o quando utilizzati in abbinata con gruppi di cattura per produrre diversi tipi di output.\nVedere anche [4. Guardarsi intorno](#4-lookaround).\n\n## 2.6 Alternativa\n\nIn un'espressione regolare, la barra verticale `|` è utilizzata per definire alternative.\nL'alternativa corrisponde alla dichiarazione OR tra espressioni multiple. Sagrai pensando che gli insiemi di caratteri e le alternative funzionino allo stesso modo, ma la grande differenza è che l'alternativa funziona a livello di espressione. Ad esempio, l'espressione regolare `(T|t)he|car` corrisponde a: sia (una lettera maiuscola `T` o una lettera minuscola `t`, seguita dalla lettera minuscola `h`, seguita da una lettera minuscola `e`), sia\n(Una lettera minuscola `c`, seguita da una lettera minuscola `a`, seguita dalla lettera minuscola `r`).\nNota che sono state incluse le parentesi per chiarezza, per dimostrare come le espressioni possono funzionare anche all'interno delle parentesi stesse.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Carattere speciale Escape\n\nIl carattere di escape `\\` è utilizzato nelle espressioni regolari per annullare la funzione del carattere jolly seguente. Questo consente di includere caratteri riservati, come `{ } [ ] / \\ + * . $ ^ | ?` all'interno di un'espressione regolare per la corrispondenza letterale.\n\nAd esempio, l'espressione regolare `.` è utilizzata per la corrispondenza con qualsiasi carattere eccetto il carattere di invio e di fine riga. Quindi, per la corrispondenza del carattere `.`, l'espressione regolare `(f|c|m)at\\.?` corrisponde a: una lettera minuscola `f`, `c` o `m`, seguita dalla lettera minuscola `a`, seguita dalla lettera minuscola `t`, seguita dal carattere `.` opzionale.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Ancore\n\nNelle espressioni regolari, si usano le ancore per la corrispondenza dell'espressione stessa, all'inizio o al termine di un testo.\nLe ancora sono di due tipi:\nIl primo tipo è il carattere di negazione `^` che verifica la corrispondenza all'inizio del testo, il secondo tipo è il carattere `$` che verifica la corrispondenza al termine del testo.\n\n### 2.8.1 Il carattere di negazione ^\n\nIl simbolo di negazione `^` è usato per verificare la corrispondenza al primo carattere del testo. Utilizzando l'espressione regolare `^a` (significa che 'a' deve essere il primo carattere) con il testo `abc`, ci sarà corrispondenza con `a`. Applicando l'espressione regolare `^b` al testo precedente, non ci sarà alcuna corrispondenza.\nQuesto perché nel testo `abc`, la lettera \"b\" non è il carattere iniziale. Vediamo un'altra espressione regolare, `^(T|t)he` che corrisponde a: una lettera maiuscola `T` o una lettera minuscola `t` deve essere la prima lettera del testo, seguita dalla lettera minuscola `h`, seguita dalla lettera minuscola `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Il simbolo del Dollaro\n\nIl simbolo del collario `$` è utilizzato per verificare la corrispondenza con la parte finale del testo. Ad esempio, l'espressione regolare `(at\\.)$` corrisponde a: una lettera minuscola `a`, seguita da una lettera minuscola `t`, seguita dal carattere punto `.`, il tutto deve trovarsi al termine del testo.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/t0AkOd/1)\n\n## 3. Classe di caratteri rapide\n\nCi sono alcune classe di caratteri rapide per l'utilizzo nelle espressioni regolari:\n\n|Classe di caratteri rapide|Descrizione|\n|:----:|----|\n|.|Qualsiasi carattere tranne invio e fine riga|\n|\\w|Corrispondenza con caratteri alfanumerici: `[a-zA-Z0-9_]`|\n|\\W|Corrispondenza con caratteri non alfanumerici: `[^\\w]`|\n|\\d|Corrispondenza con numeri: `[0-9]`|\n|\\D|Corrispondenza con caratteri che non siano numeri: `[^\\d]`|\n|\\s|Corrispondenza con spazi vuoti: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Corrispondenza con caratteri che non siano spazi vuoti: `[^\\s]`|\n\n## 4. Guardarsi intorno\n\nLookbehinds e lookaheads sono speciali tipi di ***gruppi di caratteri senza cattura***. Guardarsi intorno sono utilizzati quando uno schema deve essere preceduto o seguito da un altro schema. Ad esempio, pensiamo di dover selezionare i numeri preceduti dal carattere `$` nel testo `$4.44 and $10.88`. Useremo l'espressione regolare `(?<=\\$)[0-9\\.]*` che corrisponde a: selezionare tutti i numeri che contengono il carattere `.` e sono preceduti dal carattere `$`. Queste sono le espressioni di guardarsi intorno utilizzate:\n\n|Simbolo|Descrizione|\n|:----:|----|\n|?=|Lookahead positivo|\n|?!|Lookahead negativo|\n|?<=|Lookbehind positivo|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Lookahead negativo\n\nLookahead negativo è utilizzato per ottenere corrispondenza con una stringa che non è seguita da un determinato schema. Il lookahead negativo è scritto nello stesso modo del lookahead positivo. L'unica differenza consiste nell'utilizzo del carattere di punto esclamativo `!`, al posto del segno uguale `=`, per indicare la negazione, ad esempio `(?!...)`. Vediamo la seguente espressioni regolare `(T|t)he(?!\\sfat)` che trova corrispondenza con: tutte le parole `The` o `the` che non sono seguite da uno spazio dalla parola `fat`.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Lookbehind positivo\n\nLookbehind positivo è utilizzato per trovare il testo preceduto da uno specifico schema. Il lookbehind positivo è sxcritto come `(?<=...)`. Ad esempio, l'espressione regolare `(?<=(T|t)he\\s)(fat|mat)` corrisponde a: tutte le parole `fat` o `mat` che seguono la parola `The` o `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/avH165/1)\n\n### 4.4 Lookbehind negativo\n\nLookbehind negativo è utilizzato per trovare il testo non preceduto da uno specifico schema. Il lookbehind negativo è sxcritto come `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/8Efx5G/1)\n\n## 5. Opzioni\n\nLe opzioni (o modificatori) modificano il risultato delle espressioni regolari. Queste opzioni possono essere utilizzate in qualsiasi ordine o combinazione, sono parti integranti di RegExp.\n\n|Opzione|Descrizione|\n|:----:|----|\n|i|Non sensibilità maiuscolo / minuscolo|\n|g|Ricerca globale: trova tutte le corrispondenze, non solo la prima.|\n|m|Multi riga: estende il funzionamento delle ancore su ogni riga.|\n\n### 5.1 Non sensibilità maiuscolo / minuscolo\n\nL'opzione `i` è usato per rendere la corrispondenza non sensibile a maiuscolo / minuscolo. Ad esempio, l'espressione regolare `/The/gi` corrisponde a: una lettera maiuscola `T`, seguita da una lettera minuscola `h`, seguita da una lettera minuscola `e`. L'opzione `i` alla fine dell'espressione regolare indica di ignorare minuscole / maiuscole. Come si può notare, l'utilizzo dell'opzione `g` estende la ricerca all'intero testo.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Ricerca globale\n\nL'opzione `g` è utilizzata per estendere la ricerca a corrispondenze multiple. Ad esempio, l'espressione regolare `/.(at)/g` corrisponde a: qualsiasi carattere eccetto invio e nuova riga, seguito dalla lettera minuscola `a`, seguita dalla lettera minuscola `t`. L'utilizzo dell'opzione `g` estende la ricerca all'intero testo.\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multi riga\n\nL'opzione `m` è utilizzata per estendere la corrispondenza in modalità multi riga. Come già esposto, le ancore `(^, $)` sono utilizzate per verificare se l'espressione si trova all'inizio o alla fine del testo. Volendo utilizzare le ancore su già righe di testo, si può attivare l'opzione `m`. Ad esempio, l'espressione regolare `/at(.)?$/gm` corrisponde a: una lettera minuscola `a`, seguita da una lettera minuscola `t` e, opzionalmente, qualsiasi carattere eccetto invio e nuova riga. Grazie all'opzione `m`, la corrispondenza viene estesa a ciascuna riga del testo.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/E88WE2/1)\n\n## 6. Corrispondenza vorace vs pigra\nRegex ha un funzionamento predefinito vorace, ,significa che la corrispondenza è più estesa possibile. Si può utilizzare `?` per determinare una corrispondenza più pigra, così la corrispondenza è più breve possibile.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Verifica l'espressione regolare](https://regex101.com/r/AyAdgJ/2)\n\n\n## Contribution\n\n* Open a pull request with improvements\n* Discuss ideas in issues\n* Spread the word\n* Reach out with any feedback [](https://twitter.com/ziishaned)\n* Traduzione italiana: Claudio Marconato (cmpro.it)\n\n## License\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)" }, { "path": "translations/README-ja.md", "content": "
\n
\n \n \n \n
\n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/dmRygT/1)\n\n`123` という正規表現は `123` という文字列にマッチします。\n正規表現は正規表現の文字列と入力文字列を1文字ずつ比較しながらマッチングを行います。\nまた大文字と小文字は区別されるため、 `The` は `the` にはマッチしません。\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/1paXsy/1)\n\n## 2. メタ文字\n\nメタ文字は正規表現の構成要素として使用される文字のことです。\nメタ文字はそれ自身が示す文字を表すものではなく、特別な解釈がなされます。\n一部のメタ文字は角括弧内に記述されることで特別な意味を持つものもあります。\nメタ文字には次のようなものがあります。\n\n|メタ文字|説明 |\n|:------:|---------------------------------------------------------------------------------------------|\n|. |ピリオド。改行を除く任意の1文字にマッチ。 |\n|[ ] |文字集合。角括弧内の任意の文字にマッチ。 |\n|[^ ] |否定文字集合。角括弧内に含まれない任意の文字にマッチ。 |\n|* |直前の文字の 0 個以上の並びにマッチ。 |\n|+ |直前の文字の 1 個以上の並びにマッチ。 |\n|? |直前の文字がオプションであるとみなす。 |\n|{n,m} |括弧でくくる。直前の文字が n 個以上 m 個以下続く場合にマッチ。 |\n|(xyz) |文字グループ。 xyz という文字列がその順に現れる場合にマッチ。 |\n|| |選言。記号の前後の文字列どちらかにマッチ。 |\n|\ |次に来る文字をエスケープする。予約語
[ ] ( ) { } . * + ? ^ $ \\ | にマッチ。|\n|^ |入力値の開始にマッチする。 |\n|$ |入力値の終了にマッチする。 |\n\n## 2.1 ピリオド\n\nピリオド `.` は最もシンプルなメタ文字の例です。\nメタ文字 `.` は任意の 1 文字にマッチします。\nキャリッジリターンと改行にはマッチしません。\n例えば `.ar` は任意の文字の後に `a` と `r` が続く文字列にマッチします。\n\n\n\".ar\" => The car parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 文字集合\n\n文字集合は文字クラスとも呼ばれます。\n文字集合を指定するには角括弧でくくります。\n文字の範囲を指定するにはハイフンを使用します。\n角括弧内の文字の記述順はマッチングには関係ありません。\n例えば `[Tt]he` という正規表現は大文字 `T` または小文字 `t` の後に `h`, `e` が続く文字列を表します。\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/2ITLQ4/1)\n\n文字集合内でのピリオドは文字としてのピリオドを表します。\n`ar[.]` という正規表現は `a` という文字のあとに `r` が続き、さらに `.` という文字が続く文字列を表します。\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 否定文字集合\n\n通常キャレットは文字列の開始を意味するメタ文字ですが、角括弧内で最初に使用されると\n文字集合を否定する意味を持つようになります。\n例えば `[^c]ar` という正規表現は `c` 以外の任意の文字列の後に\n`a`, `r` が続く文字列を表します。\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 繰り返し\n\n`+`, `*`, `?` はパターンが何回続くのかを指定するためのメタ文字になります。\nこれらのメタ文字は異なるシチュエーションで異なる振る舞いをします。\n\n### 2.3.1 アスタリスク\n\nシンボル `*` は直前の文字が 0 個以上続くパターンにマッチします。\n`a*` という正規表現は小文字の `a` が 0 個以上続くことを意味します。\nしかし文字集合またはクラスの後に現れた場合はその文字集合すべてが続くことを意味します。\n例えば `[a-z]*` という正規表現は行内の任意の小文字の列を表します。\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/7m8me5/1)\n\nシンボル `*` はメタ文字 `.` と合わせて `.*` のように使用することで\n任意の文字列を表現できます。\nまたスペースを表す `\\s` と併用することで空白文字を表現できます。\n例えば `\\s*cat\\s*` という正規表現は 0 個以上のスペースの後に\n小文字の `c`, `a`, `t` が続き、その後に 0 個以上のスペースが続きます。\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 プラス記号\n\nシンボル `+` は直前の文字が 1 個以上続くパターンにマッチします。\n例えば `c.+t` という正規表現は小文字の `c` の後に\n任意の 1 文字以上が続き、さらに `t` が続くことを意味します。\nこの `t` は、その文における最後の `t` がマッチします。\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 疑問符\n\n正規表現におけるメタ文字 `?` は直前の文字がオプションであることを意味します。\nすなわち直前の文字が 0 個または 1 個現れることを意味します。\n例えば `[T]?he` という正規表現は大文字の `T` が 0 個または 1 個出現し、\nその後に小文字の `h`, `e` が続くことを意味します。\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 括弧\nこの`t`は、その文における最後の`t`であることが明確である必要があります。\n\n正規表現における括弧は数量子とも呼ばれますが、文字列がいくつ現れるかを示すために使用されます。\n例えば、`[0-9]{2,3}` という正規表現は 2 桁以上 3 桁以下の数字\n（0 から 9 の数字で表された文字列）にマッチします。\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/juM86s/1)\n\n2つ目の数値は省略できます。\n例えば `[0-9]{2,}` という正規表現は 2 桁以上の数字を意味します。\nカンマも省略することができ、その場合 `[0-9]{3}` という正規表現はちょうど 3 桁の数字を意味します。\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/Sivu30/1)\n\n## 2.5 文字グループ\n\n文字グループは括弧 `(...)` 内にパターンを記述してグループ分けをするために使用します。\n前述の通り、正規表現においては数量子を文字の後に置いた場合は\nその直前の文字の繰り返しを意味します。しかし、文字グループの後に数量子を置いた場合は\n文字グループ全体が繰り返すことを意味します。\n例えば、 `(ab)*` という正規表現は \"ab\" という文字列の 0 個以上の繰り返しにマッチします。\n文字グループ内では選言 `|` も使用することができます。\n例えば、`(c|g|p)ar` という正規表現は小文字の `c`, `g`, `p` のいずれかの後に\n`a` が続き、さらに `r` が続くことを意味します。\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 選言\n\n正規表現における縦棒 `|` は選言として使用されます。\n選言は複数の正規表現からなる条件式のようなものです。\nもしかすると文字集合と選言が同じものと感じるかもしれません。\nこの 2 つの大きな違いは文字集合は文字単位で評価されるのに対して選言は正規表現単位で評価されます。\n例えば `(T|t)he|car` という正規表現は大文字の `T` または小文字の `t` の後に\n小文字の `h`, `e` が続くか、または小文字の `c` の後に `a`, `r` が続くことを意味します。\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 特殊文字をエスケープする\n\nバックスラッシュ `\\` は正規表現内で次に来る文字をエスケープするために使用されます。\nこれを使うと予約語 `{ } [ ] / \\ + * . $ ^ | ?` を\n記号として指定できるようになります。\n例えば `.` という正規表現は改行を除く任意の文字として使用されますが、\n`(f|c|m)at\\.?` という正規表現では `.` 自体にマッチします。\nこの正規表現は小文字の `f`, `c` または `m` の後に小文字の `a`, `t` が続き、\nさらに `.` が 0 個または 1 個続きます。\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 アンカー\n\n正規表現内でマッチング文字列の開始または終了であることをチェックするために\nアンカーを使うことができます。\nアンカーには 2 種類あり、1 つ目が開始を表すキャレット `^`、\n2 つ目が終了を表すドル記号 `$` です。\n\n### 2.8.1 キャレット\n\nキャレット `^` は文字列の開始かどうかを調べるために使用します。\n次の正規表現 `^a` は入力文字列 `abc` に対して（a が開始文字列なら）`a` にマッチします。\nしかし `^b` という正規表現は前の文字列に対してはどれにもマッチしません。\n\"b\" は `abc` という入力文字列の開始ではないからです。\n他の例を見てみます。`^(T|t)he` は大文字の `T` または小文字の `t` から始まる文字列で\nその後に小文字の `h`, `e` が続くことを意味します。\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 ドル記号\n\nドル記号 `$` は文字列の終了かどうかを調べるために使用します。\n例えば `(at\\.)$` という正規表現は小文字の `a` の後に\n小文字の `t` が続き、最後は `.` で終わることを意味しています。\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/t0AkOd/1)\n\n## 3. 文字集合の短縮表記\n\n正規表現ではよく使われる文字集合に対して短縮表記が提供されており、\n便利なショートカットとして使用できます。\n短縮表記には次のようなものがあります。\n\n|短縮表記|説明 |\n|:------:|-----------------------------------|\n|. |改行を除く任意の文字 |\n|\\w |英数字にマッチ: `[a-zA-Z0-9_]` |\n|\\W |英数字以外にマッチ: `[^\\w]` |\n|\\d |数字にマッチ: `[0-9]` |\n|\\D |数字以外にマッチ: `[^\\d]` |\n|\\s |スペースにマッチ: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S |スペース以外にマッチ: `[^\\s]` |\n\n## 4. 前後参照\n\n先読みと後読み（前後参照とも呼ばれます）は **非キャプチャグループ**\n（パターンのマッチングはするがマッチングリストには含まれない）という\n特殊な扱いがなされる機能です。\n前後参照はあるパターンが別のあるパターンよりも先行または後続して現れることを示すために使用されます。\n例えば入力文字列 `$4.44 and $10.88` に対して `$` に続く全ての数字を取得することを考えます。\nそのためには `(?<=\\$)[0-9\\.]*` という正規表現を使用します。\nこれは `$` に続き `.` を含む全ての数字を指すことになります。\n次のような前後参照が正規表現で使用されます。\n\n|記号 |説明 |\n|:----:|--------------|\n|?= |肯定的な先読み|\n|?! |否定的な先読み|\n|?<= |肯定的な後読み|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/IDDARt/1)\n\n### 4.2 否定的な先読み\n\n否定的な先読みはあるパターンが後続しない全てのマッチング文字列を取得するために使用します。\n否定的な先読みは肯定的な先読みと同じように定義しますが、 `=` の代わりに\n`!` を使うところが唯一の違いで、`(?!...)` と記述します。\n次の正規表現 `(T|t)he(?!\\sfat)` について考えてみます。\nこれはスペースを挟んで `fat` が後続することがない全ての `The` または `the` を得ることができます。\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/V32Npg/1)\n\n### 4.3 肯定的な後読み\n\n肯定的な後読みは特定のパターンが先行するような文字列を得るために使用します。\n定義の仕方は `(?<=...)` とします。\n例えば `(?<=(T|t)he\\s)(fat|mat)` という正規表現は\n`The` または `the` の後に続く全ての `fat` または `mat` が取得できます。\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/avH165/1)\n\n### 4.4 否定的な後読み\n\n否定的な後読みは特定のパターンが先行しない全ての文字列を得るために使用します。\n定義の仕方は `(?)` とします。\n例えば `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/8Efx5G/1)\n\n## 5. フラグ\n\nフラグは修飾子とも呼ばれ、正規表現の結果を修正するために使用されます。\nフラグは任意の順序・組み合わせで使用でき、正規表現では必要不可欠な機能です。\n\n|フラグ|説明 |\n|:----:|------------------------------------------------------------------------|\n|i |大文字・小文字を区別しない: マッチングで大文字・小文字が区別されなくなる|\n|g |グローバル検索: 入力文字列の全マッチ列を検索する |\n|m |複数行: 複数行をマッチさせるためのアンカー |\n\n### 5.1 大文字・小文字を区別しない\n\n修飾子 `i` は大文字・小文字を区別したくないときに使用します。\n例えば `/The/gi` という正規表現は大文字の `T` の後に小文字の `h`, `e` が続くという意味ですが、\n最後の `i` で大文字・小文字を区別しない設定にしています。\n文字列内の全マッチ列を検索したいのでフラグ `g` も渡しています。\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 グローバル検索\n\n修飾子 `g` はグローバル検索（最初のマッチ列を検索する代わりに全マッチ列を検索する）を\n行うために使用します。\n例えば `/.(at)/g` という正規表現は、改行を除く任意の文字列の後に\n小文字の `a`, `t` が続きます。正規表現の最後にフラグ `g` を渡すことで、\n最初のマッチだけではなく（これがデフォルトの動作です）、入力文字列内の全マッチ列を検索するようにしています。\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/dO1nef/1)\n\n### 5.3 複数行\n\n修飾子 `m` は複数行でマッチさせたいときに使用します。\n前述で `(^, $)` という入力文字列の開始と終了を示すためのアンカーについて説明しましたが、\nフラグ `m` は複数行でマッチさせるためのアンカーとして使用できます。\n例えば `/at(.)?$/gm` という正規表現は小文字の `a`, `t` に続き、改行を除く\n任意の文字が 0 個または 1 個続くという意味ですが、\nフラグ `m` を渡すことで入力文字列の各行でパターンを検索させることができます。\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[正規表現の動作確認をする](https://regex101.com/r/E88WE2/1)\n\n## 貢献する\n\n* イシューを発行する\n* 修正をプルリクエストする\n* ドキュメントを普及させる\n* 作者に直接連絡を取る: ziishaned@gmail.com または [](https://twitter.com/ziishaned)\n\n## ライセンス\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-ko.md", "content": "
\n
\n \n \n \n
\n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dmRygT/1)\n\n정규 표현식 `123`은 문자열 `123`에 매칭된다. 정규 표현식은 정규 표현식의 각 문자(Character)와 입력된 문자열의 각 문자(Character)를 비교함으로써 해당 문자열과 매칭된다. 정규 표현식들은 일반적으로 대소문자를 구분하기 때문에, 정규 표현식 `The`는 문자열 `the`와 매칭되지 않는다.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/1paXsy/1)\n\n## 2. 메타 문자\n\n메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 아래는 이러한 메타 문자열들이다:\n\n|메타 문자|설명|\n|:----:| ----|\n|.|온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|\n|[ ]|문자 클래스. 대괄호 사이에 있는 문자들로 매치.|\n|[^ ]|부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|\n|\\*|이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|\n|+|이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|\n|?|이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|\n|{n,m}|중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|\n|(xyz)|문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|\n|||대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|\n|\|다음 문자 이스케이프(Escape). 예약된 문자열들
[ ] ( ) { } . \\* + ? ^ \\$ \\ |을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|\n|^|입력의 시작과 매치.|\n|\\$|입력의 끝과 매치.|\n\n## 2.1 마침표\n\n마침표(`.`)는 메타 문자의 가장 간단한 예다. 메타 문자 `.`는 어떠한 단일 문자와도 매치되지만 리턴 혹은 개행 문자와는 매치되지 않는다. 예를 들어, 정규 표현식 `.ar`은 어떠한 단일 문자 다음에 문자 `a`가 오고, 그 다음에 문자 `r`이 오는 패턴을 의미한다.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 문자 집합\n\n문자 집합은 문자 클래스라고도 불린다. 대괄호는 이 문자 집합을 명시하기 위해 사용된다. 문자열 집합내에 사용된 하이픈은 문자들의 범위를 지정하는데 사용된다. 대괄호 내부에 명시된 문자들의 순서는 중요하지 않다. 예를 들어, 정규 표현식 `[Tt]he`는 대문자 `T` 혹은 소문자 `t`가 나온 다음에, 문자 `h`가 나오고 그 뒤에 문자 `e`가 나오는 패턴을 의미한다.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/2ITLQ4/1)\n\n하지만, 문자 집합 내부에서 사용되는 온점(Period)은 온점 그 자체를 의미한다. 정규 표현식 `ar[.]`은 소문자 `a` 다음에 문자 `r`이 오고 그 뒤에 문자 `.`이 오는 패턴을 의미한다.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Test the regular expression](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 부정 문자 집합\n\n일반적으로, 캐럿 기호(^)는 문자열의 시작지점을 나타내지만, 왼쪽 대괄호 바로 뒤에 위치했을때는 해당 문자 집합의 부정(negation)을 나타낸다. 예를 들어, 정규 표현식 `[^c]ar`은 문자 `c`를 제외한 어떠한 문자뒤에 문자 `a`가 오고, 그 뒤에 문자 `r`이 오는 패턴을 의미한다.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 반복\n\n메타 문자 `+`, `*` 또는 `?`은 하위패턴(subpattern)이 몇 번 발생하는지 지정하는데 사용된다. 이러한 메타 문자들은 상황에 따라 다르게 동작한다.\n\n### 2.3.1 별 부호\n\n`*` 부호는 부호 앞에 위치한 매처(matcher)가 0번 이상 반복된 문자열과 매치된다. 정규 표현식 `a*`은 소문자 `a`가 0번 이상 반복되는 패턴을 의미한다. 하지만, 만약 이 별 부호가 문자 집합(character set) 직후에 나오는 경우에는 문자 집합 전체의 반복을 찾게된다. 예를 들어, 정규 표현식 `[a-z]*`은 소문자들이 갯수와 상관없이 연속으로 반복되는 패턴을 의미한다.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Test the regular expression](https://regex101.com/r/7m8me5/1)\n\n`*` 부호는 메타 문자 `.`와 함께 모든 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 또한, `*` 부호는 공백 문자 `\\s`와 함께 공백 문자들로 이루어진 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 예를 들어, 정규 표현식 `\\s*cat\\s*`는 0번 이상 공백문자가 나온 이후에 소문자 `c`, 소문자 `a`, 소문자 `t`가 자체로 나오고 그 뒤에 다시 0번 이상의 공백문자가 나오는 패턴을 의미한다.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Test the regular expression](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 덧셈 부호\n\n`+` 부호는 부호 앞에 위치한 문자가 한번 이상 반복되는 패턴을 만드는데 사용된다. 예를 들어, 정규 표현식 `c.+t`는 소문자 `c`가 나오고, 그 뒤에 한개 이상의 문자가 나온 후, 소문자 `t`가 나오는 패턴을 의미한다. 여기서 문자 `t`는 해당 문장의 제일 마지막 글자 `t`라는것을 명확히할 필요가 있다.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 물음표\n\n정규 표현식에서 메타 문자 `?`는 선행 문자를 선택적으로 만드는 역할을 한다. 물음표는 부호 앞에 쓰여진 문자가 선택적으로 나오는 패턴을 나타내는데 사용된다. 예를 들어, 정규 표현식 `[T]?he`는 대문자 `T`가 선택적으로 나온 이후에, 그 뒤에 소문자 `h`, 그 뒤에 소문자 `e`가 나오는 패턴을 의미한다.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 중괄호\n\n정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/juM86s/1)\n\n두번째 숫자를 생략하는 것이 가능하다. 예를 들어, 정규 표현식 `[0-9]{2,}`는 2번 이상의 숫자가 연속으로 나오는 패턴을 의미한다. 만약 여기서 쉼표를 삭제하는 경우, 정규 표현식 `[0-9]{3}`은 숫자가 정확히 3번 연속해서 나오는 패턴을 의미한다.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Sivu30/1)\n\n## 2.5 캡쳐링 그룹\n\n캡쳐링 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자 뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 캡쳐링 그룹 뒤에 정량자를 넣는 경우에는 캡쳐링 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 \"ab\"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/tUxrBG/1)\n\n캡처링 그룹은 부모 언어에서 사용하기 위해 문자를 일치시킬뿐만 아니라 문자를 캡처한다는 점에 유의해야 한다. 부모 언어는 파이썬이나 자바 스크립트 또는 함수 정의에서 정규 표현식을 구현하는 거의 모든 언어가 될 수 있다.\n\n### 2.5.1 논-캡쳐링 그룹\n\n논-캡쳐링 그룹은 오직 문자열에 매칭되지만, 그룹을 캡쳐하지 않는 캡쳐링 그룹이다. 논-캡쳐링 그룹은 `(...)` 괄호안에 `?:` 로 표시된다. 예를 들어 정규식 `(?:c|g|p)ar` 는 `(c|g|p)ar`와 같은 문자열을 매칭하는 것에서 유사하지만, 캡쳐링 그룹을 만들지 않는다.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/Rm7Me8/1)\n\n논-캡처링 그룹은 찾기 및 변경 기능에서 사용하거나 캡처 그룹 함께 사용하여 다른 종류의 출력 생성시 overview를 유지할 때 유용하다. 또한 [4. 전후방탐색](#4-전후방탐색)를 보아라.\n\n## 2.6 대안 부호\n\n정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합(Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 특수 문자 이스케이핑\n\n백 슬래시 `\\`는 정규 표현식에서 다음에 나오는 부호를 이스케이핑하는데 사용된다. 백 슬래시는 예약 문자들인 `{ } [ ] / \\ + * . $ ^ | ?`를 메타 부호가 아닌 문자 그 자체로 매칭되도록 명시한다. 특수 문자를 매칭 캐릭터로 사용하기 위해서는 백 슬래시 `\\`를 해당 특수 문자 앞에 붙이면 된다. 예를 들어, 정규 표현식 `.`은 개행을 제외한 어떤 문자와 매칭된다. 입력 문자열에 포함된 `.` 문자를 매치시키는 정규 표현식 `(f|c|m)at\\.?`은 소문자 `f`, `c` 또는 `m` 이후에 소문자 `a`와 `t`가 차례로 등장하고 이후에 문자 `.`가 선택적으로 나타나는 패턴을 의미한다.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 앵커 부호\n\n정규 표현식에서 앵커는 매칭 문자가 표현식의 시작 문자인지 혹은 끝 문자인지 명시하는데 사용된다. 앵커는 두가지 종류가 있다: 첫번째 종류인 캐럿 부호 `^`는 매칭 문자가 입력 문자열의 첫 시작 문자인지 나타내는데 사용되며 두번째 종류인 달러 부호 `$`는 해당 매칭 문자가 입력 문자의 마지막 문자라는 것을 명시하는데 사용된다.\n\n### 2.8.1 캐럿 부호\n\n캐럿 부호 `^`는 매칭 문자가 표현식의 시작이라는 것을 명시하는데 사용된다. 만약 (a가 시작 문자인지 확인하는) 정규 표현식 `^a`를 입력 문자열 `abc`에 적용하면, 이 정규 표현식은 `a`를 매칭 결과값으로 내보낸다. 반면, 정규 표현식 `^b`를 위의 입력 문자열에 적용하면, 아무런 매칭도 일어나지 않는다. 왜냐하면 입력 문자열 `abc`에서 \"b\"는 처음 시작 문자가 아니기 때문이다. 또 다른 정규 표현식인 `^(T|t)he`를 살펴보자. 이 정규 표현식은 대문자 `T` 또는 소문자 `t`가 입력 문자열의 시작으로 나오고, 그 뒤에 문자 `h`와 문자 `e`가 차례로 나오는 패턴을 의미한다.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 달러 부호\n\n달러 부호 `$`는 입력 문자열의 마지막 문자가 매칭 문자로 끝나는지 확인하는데 사용된다. 예를 들어, 정규 표현식 `(at\\.)$`는 소문자 `a`와 `t` 그리고 문자 `.`가 순서대로 입력 문자열의 맨 마지막에 나오는지 확인하는 패턴을 의미한다.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/t0AkOd/1)\n\n## 3. 단축형 문자열 집합\n\n정규 표현식은 일반적으로 사용되는 문자열 집합들을 간편하게 사용할 수 있도록 여러 단축형들을 제공한다. 단축형 문자열 집합은 아래와 같다.\n\n|단축형|설명|\n|:----:|----|\n|.|개행을 제외한 모든 문자|\n|\\w|영숫자 문자와 매치: `[a-zA-Z0-9_]`|\n|\\W|영숫자 문자가 아닌 문자와 매치: `[^\\w]`|\n|\\d|숫자와 매치: `[0-9]`|\n|\\D|숫자가 아닌 문자와 매치: `[^\\d]`|\n|\\s|공백 문자와 매치: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|공백 문자가 아닌 문자와 매치: `[^\\s]`|\n\n## 4. 전후방탐색\n\n때때로 전후방탐색Lookaround이라고 알려진 후방탐색Lookbehind과 전방탐색Lookahead은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) **_넌-캡쳐링 그룹_** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\\$)[0-9\\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.\n\n|부호|설명|\n|:----:|----|\n|?=|긍정형 전방탐색|\n|?!|부정형 전방탐색|\n|?<=|긍정형 후방탐색|\n|?\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/IDDARt/1)\n\n### 4.2 부정형 전방탐색\n\n부정형 전방탐색는 입력 문자열로부터 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 전방탐색는 우리가 긍정형 전방탐색를 정의하는 방식과 동일하게 정의된다. 하지만, 유일한 차이점은 등호 부호 `=` 대신 부정 부호 `!` 문자를 사용한다는 것이다, 즉 `(?!...)`. 정규 표현식 `[T|t]he(?!\\sfat)`를 살펴보도록 하자. 이 정규 표현식은 공백 문자와 `fat` 문자열이 연속으로 나오지 않는 모든 `The` 혹은 `the` 문자열과 매치된다.\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/V32Npg/1)\n\n### 4.3 긍정형 후방탐색\n\n긍정형 후방탐색는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 후방탐색는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/avH165/1)\n\n### 4.4 부정형 후방탐색\n\n부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(?\n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[Test the regular expression](https://regex101.com/r/8Efx5G/1)\n\n## 5. 플래그\n\n플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용 가능하며 정규 표현식의 일부분이다.\n\n|플래그|설명|\n|:----:|----|\n|i|대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정.|\n|g|전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.|\n|m|멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.|\n\n### 5.1 대소문자 구분없음\n\n수정자 `i`는 대소문자 구분없는 매칭을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/The/gi`는 대문자 `T`, 소문자 `h`, 소문자 `e`가 차례로 나오는 패턴을 의미한다. 여기서 정규 표현식 마지막에 있는 `i` 플래그가 정규 표현식 엔진에게 대소문자를 구분하지 않도록 알려준다. `g` 플래그는 전체 입력 문자열 내부에서 패턴을 검색하기 위해 설정되었다.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 전체 검색\n\n수정자 `g`는 첫번째 매칭후에 멈추지 않고 계속해서 모든 매칭을 검색하는 전체 검색을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/.(at)/g`는 개행을 제외한 문자가 나오고, 그 뒤에 소문자 `a`, 소문자 `t`가 나오는 패턴을 의미한다. 여기에서 `g` 플래그를 정규 표현식의 마지막에 설정했기 때문에, 이 패턴은 입력 문자열 전체에서 나타나는 모든 패턴을 찾아낸다.\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dO1nef/1)\n\n### 5.3 멀티 라인\n\n수정자 `m`은 멀티 라인 매치를 수행하는데 사용된다. 이전에 이야기 했던 것처럼, 앵커 `(^, $)`는 패턴의 시작과 끝을 확인하는데 사용된다. 하지만 만약 우리가 각 라인마다 이 앵커가 동작하게하고 싶으면 `m` 플래그를 설정하면된다. 예를 들어, 정규 표현식 `/at(.)?$/gm`은 소문자 `a`와 소문자 `t`가 차례로 나오고, 선택적으로 개행을 제외한 문자가 나오는 패턴을 의미한다. 여기서 플래그 `m`으로 인해서 정규 표현식 엔진은 입력 문자열의 각 라인에 대해서 해당 패턴을 매칭하게 된다.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/E88WE2/1)\n\n## 6. 탐욕적 vs 게으른 매칭\n기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat. \n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat. \n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/2)\n\n## 기여 방법\n\n* 이슈 리포팅\n* 코드 개선해서 풀 리퀘스트 열기\n* 소문내기\n* ziishaned@gmail.com 메일로 직접 연락하기 또는 [](https://twitter.com/ziishaned)\n\n## 라이센스\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-pl.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Wyrażenie](\"../img/regexp-pl.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/dmRygT/1)\n\nWyrażenie regularne `123` pasuje do łańcucha `123`. Wyrażenie regularne\njest dopasowywane do danego łańcucha poprzez porównanie każdego znaku,\njeden po drugim, w wyrażeniu i łańcuchu. Wyrażenia są zwykle wrażliwe\nna wielkość znaków, więc wyrażenie `The` nie pasuje do łańcucha `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/1paXsy/1)\n\n## 2. Metaznaki\n\nMetaznaki to składowe elementy wyrażeń regularnych. Znaki te, nie oznaczają\nsiebie samych, są natomiast interpretowane w specjalny sposób.\nNiektóre znaki mają specjalne znaczenie i są zapisywane w kwadratowych nawiasach.\nMetaznaki to:\n\n|Metaznaki|Opis|\n|:----:|----|\n|.|Dowolny znak z wyjątkiem nowej linii.|\n|[ ]|Zakres. Każdy znak zapisany w kwadratowym nawiasie.|\n|[^ ]|Odwrócony zakres. Każdy znak, który nie znajduje się w kwadratowym nawiasie.|\n|*|0 lub więcej poprzedzających znaków.|\n|+|1 lub więcej poprzedzających znaków.|\n|?|0 lub 1 poprzedzających znaków.|\n|{n,m}|Minimum \"n\" ale nie więcej niż \"m\" poprzedzających znaków.|\n|(xyz)|Grupowanie znaków. Znaki xyz dokładnie w tej kolejności.|\n|||Alternatywa. Znaki przed symbolem lub za symbolem.|\n|\|Znak ucieczki. Umożliwia używanie zarezerwowanych znaków
[ ] ( ) { } . * + ? ^ $ \\ |.|\n|^|Oznacza początek wzorca.|\n|$|Oznacza koniec wzorca.|\n\n## 2.1 Kropka\n\nKropka `.` jest najprostszym przykładem metaznaku. Oznacza dowolny znak z wyłączeniem entera\ni znaków nowej linii. Na przykład, wyrażenie regularne `.ar` oznacza: dowolny znak, następującą\npo niej literę `a`, następującą po niej literę `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Zestaw znaków\n\nZestawy znaków nazywane też klasami znaków. Nawiasy kwadratowe służą do określenia zestawów znaków.\nUżycie myślnika wewnątrz zestawu, określa jego zakres. Kolejność znaków w nawiasach kwadratowych\nnie ma znaczenia. Na przykład wyrażenie `[Tt]he` oznacza: dużą literę `T` lub małą `t`,\nnastępującą po niej literę `h`, następującą po niej literę `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/2ITLQ4/1)\n\nJednak kropka w zestawie znaków, oznacza dosłownie kropkę. Wyrażenie regularne\n`ar[.]` oznacza: małą literę `a`, następującą po niej literę `r`,\nnastępującą po niej `.` kropkę.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Odwrócony zestaw znaków\n\nGeneralnie znak karety oznacza początek wyrażenia, ale gdy zostanie użyty zaraz\nza otwierającym nawiasem kwadratowym, odwraca zestaw znaków. Na przykład\nwyrażenie `[^c]ar` oznacza: każdy znak z wyjątkiem `c`,\nnastępującą po niej literę `a`, następującą po niej literę `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Powtórzenia\n\nNastępujące metaznaki `+`, `*` czy `?` określają ile razy wzorzec może się powtórzyć.\nTe metaznaki zachowują się różnie, w zależności od sytuacji.\n\n### 2.3.1 Gwiazdka\n\nSymbol `*` oznacza zero lub więcej powtórzeń poprzedzających znaków. Wyrażenie\nregularne `a*` oznacza: zero lub więcej powtórzeń poprzedzającej małej\nlitery `a`. Ale jeśli występuje po zestawie znaków lub klasie, to oznacza\npowtórzenia całego zestawu lub klasy. Na przykład, wyrażenie regularne\n`[a-z]*` oznacza: każdy ciąg znaków pisany małymi literami.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/7m8me5/1)\n\nSymbol `*` może być użyty z metaznakiem `.` by oznaczyć każdy łańcuch\nznaków `.*`. Symbol `*` może być użyty ze znakiem `\\s`\nby znaleźć łańcuch zawierający spacje. Na przykład, wyrażenie\n`\\s*cat\\s*` oznacza: zero lub więcej spacji, następującą po niej małą literę `c`,\nnastępującą po niej małą literę `a`, następującą po niej małą literę `t`,\nnastępujące po niej zero lub więcej spacji.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Plus\n\nSymbol `+` oznacza jeden lub więcej powtórzeń poprzedzających znaków. Na przykład,\nwyrażenie `c.+t` oznacza: małą literę `c`, następujący po niej przynajmniej jeden\ndowolny znak, następującą po nim małą literę `t`. W tym wypadku `t` jest ostatnim\n`t` w zdaniu.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Znak zapytania\n\nW wyrażeniach regularnych znak `?` sprawia, że poprzedzający znak jest opcjonalny.\nTen symbol oznacza zero lub jedno wystąpienie poprzedzającego znaku. Na przykład,\nwyrażenie regularne `[T]?he` oznacza: opcjonalną dużą literę `T`, następującą\npo niej małą literę `h`, następującą po niej małą literę `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Klamry\n\nW wyrażeniach regularnych, klamry zwane również kwantyfikatorami, używane są\ndo określenia, ile razy znak lub grupa znaków może się powtórzyć.\nNa przykład wyrażenie regularne `[0-9]{2,3}` oznacza: przynajmniej\n2 znaki, ale nie więcej niż 3 (znaki z zakresu od 0 do 9).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/juM86s/1)\n\nMożemy opuścić drugą liczbę. Na przykład regularne wyrażenie `[0-9]{2,}`\noznacza: 2 lub więcej znaków. Jeżeli dodatkowo usuniemy przecinek,\nto wyrażenie `[0-9]{3}` oznacza: dokładnie 3 znaki z zakresu 0 do 9.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Grupa znaków\n\nGrupa znaków to grupa podwzorców, które zapisywane są w nawiasach `(...)`.\nJak wspominaliśmy wyżej, jeśli w wyrażeniu regularnym wstawimy kwantyfikator po\nznaku, wtedy powtórzy on ten znak. Ale gdy wstawimy kwantyfikator po grupie znaków,\nwtedy cała grupa zostanie powtórzona. Na przykład wyrażenie regularne `(ab)*`\noznacza zero lub więcej powtórzeń grupy \"ab\". Możemy także użyć metaznaku\nalternatywy `|` wewnątrz grupy. Na przykład wyrażenie `(c|g|p)ar` oznacza: małą literę `c`,\n`g` lub `p`, następującą po niej literę `a`, następującą po niej literę `r`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Alternatywa\n\nW wyrażeniach regularnych pionowa kreska `|` oznacza alternatywę.\nDziała jak warunek pomiędzy różnymi wyrażeniami. Teraz możesz pomyśleć, że\nto działa tak samo jak zestaw znaków. Różnica polega na tym, że zestaw znaków\ndziała na poziomie znaków, natomiast alternatywa na poziomie wyrażenia. Na przykład\nwyrażenie regularne `(T|t)he|car` oznacza: dużą literę `T` lub małą `t`,\nnastępującą po niej literę `h`, następującą po niej literę `e` lub `c`, następującą\npo niej literę `a`, następującą po niej literę `r`.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Znak ucieczki\n\nUkośnik `\\` w wyrażeniach regularnych jest znakiem ucieczki. Pozwala on\nużywać w wyrażeniu zarezerwowanych znaków takich jak `{ } [ ] / \\ + * . $ ^ | ?`.\nAby użyć znaku specjalnego w wyrażeniu, postaw `\\` przed nim.\n\nNa przykład wyrażenie `.` dopasowuje każdy znak z wyjątkiem nowej linii.\nŻeby dopasować kropkę `.` w wyrażeniu regularnym, trzeba wstawić przed nią ukośnik.\nWyrażenie `(f|c|m)at\\.?` oznacza: małe litery `f` lub `c` lub `m`, następującą po niej\nliterę `a`, następującą po niej literę `t`, następującą kropkę `.`, która jest opcjonalna.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Kotwice\n\nW wyrażeniach regularnych używamy kotwic aby sprawdzić czy dopasowywany symbol\njest pierwszym lub ostatnim symbolem w łańcuchu. Są dwa typy: pierwszy to\nkareta `^`, która sprawdza czy znak jest początkiem łańcucha, drugi to dolar `$`,\nktóry sprawdza czy znak jest ostatnim elementem łańcucha.\n\n### 2.8.1 Kareta\n\nKareta `^` sprawdza czy znak jest początkiem łańcucha. Jeżeli użyjemy takiego\nwyrażenia `^a` (jeśli a jest pierwszym znakiem) na łańcuchu `abc` to dopasuje\nnam `a`. Ale jeśli użyjemy takiego wyrażenia `^b` na tym samym łańcuchu, to nie\nzwróci nam nic. Ponieważ w łańcuchu `abc` \"b\" nie jest pierwszym symbolem.\nSpójrzmy teraz na wyrażenie `^(T|t)he` które oznacza: dużą literę `T` lub małą\n`t`, która jest początkiem łańcucha, następującą po niej literę `h`, następującą\npo niej literę `e`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dolar\n\nSymbol dolara `$` używany jest do sprawdzenia czy dopasowywany znak jest ostatni\nw łańcuchu. Na przykład, wyrażenie regularne `(at\\.)$` oznacza: małą literę `a`,\nnastępującą po niej literę `t`, następującą po niej kropkę `.` i na dodatek\ndopasowanie musi być końcem łańcucha.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/t0AkOd/1)\n\n## 3. Skróty\n\nW wyrażeniach regularnych znajdziemy także skróty dla popularnych zestawów znaków,\nktóre ułatwiają pracę z wyrażeniami regularnymi. Skróty wyglądają następująco:\n\n|Skrót|Opis|\n|:----:|----|\n|.|Każdy znak z wyjątkiem nowej linii|\n|\\w|Znaki alfanumeryczne: `[a-zA-Z0-9_]`|\n|\\W|Znaki nie alfanumeryczne: `[^\\w]`|\n|\\d|Cyfry: `[0-9]`|\n|\\D|Nie cyfry: `[^\\d]`|\n|\\s|Dowolny biały znak: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Każdy znak oprócz białych: `[^\\s]`|\n\n## 4. Lookaround\n\nLookbehind i lookahead (nazywane również lookaround) to specyficzne typy\n***niezwracających grup*** (dopasowują wzorzec, ale nie zwracają wartości).\nLookaround używane są w sytuacji, gdy mamy wzorzec i jest on poprzedzony innym wzorcem,\nlub następuje po nim kolejny wzorzec. Na przykład, chcemy mieć wszystkie\nnumery, które są poprzedzone znakiem `$` w takim łańcuchu `$4.44 and $10.88`.\nUżyjemy takiego wyrażenia regularnego `(?<=\\$)[0-9\\.]*` które oznacza: znajdź\nwszystkie liczby ze znakiem `.` poprzedzone znakiem `$`. W wyrażeniach regularnych\nwyróżniamy:\n\n|Symbol|Opis|\n|:----:|----|\n|?=|Lookahead|\n|?!|Odwrócony lookahead|\n|?<=|Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Odwrócony lookahead\n\nUżywany jest, gdy potrzebujemy dopasowania z łańcucha, po których nie następują\nżadne wzorce. Odwrócony lookahead definiujemy w nawiasach, stosując znak negacji\n`!` po znaku zapytania, na przykład: `(?!...)`. Popatrzmy na następujące wyrażenie\n`(T|t)he(?!\\sfat)` które oznacza: znajdź wszystkie słowa `The` lub `the` w łańcuchu,\npo których nie następuje słowo `fat`, poprzedzone spacją.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Lookbehind\n\nLookbehind używany jest do odnalezienia wszystkich dopasowań poprzedzonych konkretnym\nwzorcem. Wyrażenie lookbehind zapisujemy tak: `(?<=...)`. Na przykład, wyrażenie\n`(?<=(T|t)he\\s)(fat|mat)` oznacza: znajdź wszystkie słowa `fat` lub `mat` w łańcuchu,\nktóre znajdują się po słowach `The` lub `the`.\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/avH165/1)\n\n### 4.4 Odwrócony lookbehind\n\nOdwrócony używany jest do odnalezienia wszystkich dopasowań niepoprzedzonych konkretnym\nwzorcem. Odwrócony lookbehind zapisujemy tak: `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flagi\n\nFlagi nazywane są także modyfikatorami, ponieważ zmieniają wynik wyrażenia regularnego.\nFlagi mogą być używane w każdej kombinacji i są integralną częścią wyrażeń regularnych.\n\n|Flaga|Opis|\n|:----:|----|\n|i|Wielkość znaków: Sprawia, że dopasowanie nie jest wrażliwe na wielkość znaków.|\n|g|Przeszukanie globalne: Wyszukiwanie wzorca w całym łańcuchu.|\n|m|Multilinia: Sprawia, że kotwice działają na każdej linii.|\n\n### 5.1 Wielkość znaków\n\nModyfikator `i` używany jest, gdy wielkość liter nie ma znaczenia. Na przykład\nwyrażenie `/The/gi` oznacza: dużą literę `T`, następującą po niej literę `h`,\nnastępującą po niej literę `e`. A na końcu wyrażenia, flaga `i` żeby ignorować\nwielkość znaków. Jak widać, została też użyta flaga `g` ponieważ chcemy przeszukać\ncały łańcuch.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Przeszukiwanie globalne\n\nModyfikator `g` używany jest do przeszukiwania całego łańcucha (znajdź wszystko,\na nie tylko zatrzymuj się na pierwszym). Na przykład wyrażenie `/.(at)/g`\noznacza: każdy znak z wyjątkiem nowej linii, następującą po nim literę `a`,\nnastępującą po niej literę `t`. Ponieważ użyliśmy na końcu wyrażenia flagi `g`,\nwyszukane zostaną wszystkie dopasowania w łańcuchu, a nie tylko pierwszy (domyślne zachowanie).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multilinia\n\nModyfikator `m` używany jest do dopasowywania w wielu liniach. Jak wspominaliśmy\nwcześniej, kotwice `(^, $)` używane są do sprawdzania czy wzorzec jest początkiem\nlub końcem łańcucha. Jeśli chcemy, żeby kotwice zadziałały w każdej linii, używamy\nwtedy flagi `m`. Na przykład wyrażenie `/at(.)?$/gm` oznacza: małą literę `a`,\nnastępującą po niej małą literę `t`, opcjonalnie dowolny znak z wyjątkiem nowej linii.\nI ponieważ użyliśmy flagi `m` dopasowywane będą wzorce na końcu każdej linii w łańcuchu.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Przetestuj wyrażenie](https://regex101.com/r/E88WE2/1)\n\n## Kontrybucja\n\n* Zgłaszanie błędów\n* Otwieranie pull request z poprawkami\n* Dzielenie się poradnikiem\n* Skontaktuj się ze mną ziishaned@gmail.com lub [](https://twitter.com/ziishaned)\n\n## Licencja\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-pt_BR.md", "content": "
\n
\n \n \n \n
\n
\n![\"Regular](\"http://i.imgur.com/8UaOzpq.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/dmRygT/1)\n\nA 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`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/1paXsy/1)\n\n## 2. Metacaracteres\n\nMetacaracteres 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.\nOs metacaracteres são os seguintes:\n\n|Metacaracter|Descrição|\n|:----:|----|\n|.|Corresponde a qualquer caractere, exceto uma quebra de linha|\n|[ ]|Classe de caracteres. Corresponde a qualquer caractere contido dentro dos colchetes.|\n|[^ ]|Classe de caracteres negada. Corresponde a qualquer caractere que não está contido dentro dos colchetes.|\n|*|Corresponde a 0 ou mais repetições do símbolo anterior.|\n|+|Corresponde a 1 ou mais repetições do símbolo anterior.|\n|?|Faz com que o símbolo anterior seja opcional.|\n|{n,m}|Chaves. Corresponde a no mínimo \"n\" mas não mais que \"m\" repetições do símbolo anterior.|\n|(xyz)|Grupo de caracteres. Corresponde aos caracteres xyz nesta exata ordem.|\n|||Alternância. Corresponde aos caracteres antes ou os caracteres depois do símbolo|\n|\|Escapa o próximo caractere. Isso permite você utilizar os caracteres reservados
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Corresponde ao início da entrada.|\n|$|Corresponde ao final da entrada.|\n\n## 2.1 Ponto final\n\nO 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`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Conjunto de caracteres\n\nConjuntos 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`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/2ITLQ4/1)\n\nNo 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 `.`.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Teste a RegExp](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Conjunto de caracteres negados\n\nNo 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`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Repetições\n\nSeguindo 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.\n\n### 2.3.1 O Asterisco\n\nO 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.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Teste a RegExp](https://regex101.com/r/7m8me5/1)\n\nO 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.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Teste a RegExp](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 O Sinal de Adição\n\nO 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`.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 O Ponto de Interrogação\n\nEm 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`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Chaves\n\nEm 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).\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste a RegExp](https://regex101.com/r/juM86s/1)\n\nNó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.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste a RegExp](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Teste a RegExp](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Grupo de Caracteres\n\nGrupo 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`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 Alternância\n\nEm 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`.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Escapando Caracteres Especiais\n\nEm 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.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Âncoras\n\nEm 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.\n\n### 2.8.1 Acento Circunflexo\n\nO 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`.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Teste a RegExp](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Sinal de Dólar\n\nO 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.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/t0AkOd/1)\n\n## 3. Forma Abreviada de Conjunto de Caracteres\n\nAs 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:\n\n|Abreviação|Descrição|\n|:----:|----|\n|.|Qualquer caractere, exceto nova linha|\n|\\w|Corresponde a caracteres alfanuméricos: `[a-zA-Z0-9_]`|\n|\\W|Corresponde a caracteres não alfanuméricos: `[^\\w]`|\n|\\d|Corresponde a dígitos: `[0-9]`|\n|\\D|Corresponde a não dígitos: `[^\\d]`|\n|\\s|Corresponde a caracteres de espaços em branco: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Corresponde a caracteres de espaços não em branco: `[^\\s]`|\n\n## 4. Olhar ao Redor\n\nLookbehind (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:\n\n|Símbolo|Descrição|\n|:----:|----|\n|?=|Lookahead Positivo|\n|?!|Lookahead Negativo|\n|?<=|Lookbehind Positivo|\n|?\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Lookahead Negativo\n\nO 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.\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Lookbehind Positivo\n\nLookbehind 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`.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/avH165/1)\n\n### 4.4 Lookbehind Negativo\n\nLookbehind 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 `(?\n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[Teste a RegExp](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flags\n\nFlags (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.\n\n|Flag|Descrição|\n|:----:|----|\n|i|Case insensitive: Define que o padrão será case-insensitive.|\n|g|Busca global: Procura o padrão em toda a string de entrada.|\n|m|Multilinhas: Os metacaracteres de âncora funcionam em cada linha.|\n\n### 5.1 Indiferente a Maiúsculas\n\nO 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.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Busca Global\n\nO 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.\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multilinhas\n\nO 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.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/E88WE2/1)\n\n### 6. Guloso vs Não-Guloso\n\nPor 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.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Teste a RegExp](https://regex101.com/r/AyAdgJ/2)\n\n\n## Contribution\n\n* Reporte bugs\n* Abra pull request com melhorias\n* Espalhe a palavra\n* Me encontre diretamente em ziishaned@gmail.com ou [](https://twitter.com/ziishaned)\n\n## Licença\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-ru.md", "content": "
\n
\n \n \n \n
\n ![\"Регулярное](\"../img/regexp-ru.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/dmRygT/1)\n\nРегулярное выражение `123` соответствует строке `123`. Регулярное выражение\nсопоставляется с входной строкой посимвольно. Каждый символ в регулярном\nвыражении сравнивается с каждым символом во входной строке, один символ за\nдругим. Регулярные выражения обычно чувствительны к регистру, поэтому регулярное\nвыражение `The` не будет соответствовать строке `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/1paXsy/1)\n\n## 2. Метасимволы\n\nМетасимволы — это строительные блоки для регулярных выражений. Метасимволы не\nищутся в строке как есть, они интерпретируются особым образом. Некоторые\nметасимволы имеют особое значение и пишутся в квадратных скобках. Существуют\nследующие метасимволы:\n\n|Метасимвол|Описание|\n|:----:|----|\n|.|Точка соответствует любому отдельному символу, кроме перевода строки.|\n|[ ]|Класс символов. Заменяет любой из символов, заключенных в квадратных скобках.|\n|[^ ]|Отрицание класа символов. Соответствует любом символу, не содержащемуся в квадратных скобках.|\n|\\*|Искать 0 или более повторов предыдущего символа.|\n|+|Искать 1 или более повторов предыдущего символа.|\n|?|Делает предыдущий символ необязательным.|\n|{n,m}|Скобки. Искать не менее \"n\" и не более \"m\" повторов предыдущего символа.|\n|(xyz)|Группа символов. Искать только символы xyz в указанном порядке.|\n|||Чередование. Искать либо знаки до этого символа, либо знаки после символа.|\n|\|Экранирование следующего символа. Позволяет искать специальные знаки:
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Обозначает начало пользовательского ввода.|\n|$|Обозначает конец пользовательского ввода.|\n\n## 2.1 Точка\n\nТочка `.` — это простейший пример метасимвола. Метасимвол `.`\nнаходит любой отдельный символ. Точка не будет находить символы возврата каретки\n(CR) или перевода строки (LF). Например, регулярное выражение `.ar` обозначает\n\"любой символ, за которым следуют буквы `a` и `r`\".\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Набор символов.\n\nНабор символов, также называется классом символов. Для определения набора\nсимволов используются квадратные скобки. Дефис используется для указания\nдиапазона символов. Порядок следования символов, заданный в квадратных скобках,\nне важен. Например, регулярное выражение `[Tt]he` интерпретируется как\n\"заглавная `T` или строчная `t`, за которой следуют буквы `h` и `e`\".\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/2ITLQ4/1)\n\nТочка внутри набора символов, внезапно, обозначает непосредственно точку как\nсимвол. Регулярное выражение `ar[.]` обозначает строчную `a`, за которой следует\n`r`, за которой следует `.` (символ точки).\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Отрицание набора символов\n\nКарет `^` обозначает начало строки, но если вы поставите его после открывающей\nквадратной скобки, он инвертирует набор символов. Например, регулярное выражение\n`[^c]ar` обозначает \"любой символ, кроме `c`, за которым следуют буквы `a` и `r`\".\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Повторения\n\nСимволы `+`, `*` и `?` используются для обозначения того, сколько раз появляется\nсимвол перед ними. Эти метасимволы ведут себя в разных ситуациях по-разному.\n\n### 2.3.1 Звёздочка\n\nСимвол `*` обозначает ноль или более повторений предыдущего символа. Регулярное\nвыражение `a*` толкуется как \"ноль или более повторений предыдущего строчного\nсимвола `a`\". Если же символ появляется после набора или класса символов, он\nищет повторения всего набора символов. Например, регулярное выражение `[a-z]*`\nозначает \"любое количество строчных букв\".\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/7m8me5/1)\n\nСимволы можно комбинировать. Например, метасимвол `*` может использоваться с\nметасимволом `.` для поиска строки с произвольным содержанием: `.*`. Символ `*`\nможет использоваться с символом пробела `\\s`, чтобы искать строки с символами\nпробела. Например, выражение `\\s*cat\\s*` означает: \"ноль или более пробелов, за\nкоторыми следует слово `cat`, за которым следует ноль или более символов\nпробела\".\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Плюс\n\nСимвол `+` соответствует одному или более повторению предыдущего символа.\nНапример, регулярное выражение `c.+t` интерпретируется так: \"строчная `c`, за\nкоторой следует по крайней мере один любой символ, следом за которым(и) идёт\nсимвол `t`. Стоит уточнить, что в данном шаблоне, `t` является последним `t` в\nстроке.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Знак вопроса\n\nВ регулярном выражении метасимвол `?` делает предыдущий символ необязательным.\nЭтот символ соответствует нулю или одному вхождению предыдущего символа.\nНапример, регулярное выражение `[T]?he` означает: \"необязательная заглавная\nбуква `T`, за которой следуют символы `h` и `e`\".\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Фигурные скобки\n\nВ фигурных скобках, которые также называются квантификаторами, указывается,\nсколько раз символ или группа символов могут повторяться. Например, регулярное\nвыражение `[0-9]{2,3}` означает: \"от 2 до 3 цифр в диапазоне от 0 до 9.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/juM86s/1)\n\nМы можем опустить второе число (цифру 3), тогда регулярное выражение `[0-9]{2,}`\nбудет значить \"2 или более цифр\". А если мы удалим запятую, регулярное выражение\n`[0-9]{3}` будет искать ровно 3 цифры.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Скобочные группы\n\nСкобочные группы — это группы подшаблонов, которые написаны в круглых скобках\n`(...)`. Как мы уже говорили ранее, в регулярном выражении, квантификатор после\nсимвола, ищет повторы символа перед квантификатором. Если мы поставим\nквантификатор после скобочной группы, он будет искать повторы всей группы. К\nпримеру, регулярное выражение `(ab)*` соответствует нулю или более повторений\nстроки \"ab\". Мы также можем использовать метасимвол чередования `|` внутри\nскобочной группы. Так, регулярное выражение `(c|g|p)ar` означает: \"любая из\nстрочных букв `c`, `g` или `p`, за которой следуют буквы `a` и `r`\".\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/tUxrBG/1)\n\nОбратите внимание, что скобочные группы не только находят, но и захватывают\nсимволы для использования в языке программирования. Таким языком может быть\nPython, JavaScript и практически любой язык, в котором регулярные выражения\nможно использовать в параметрах функций.\n\n### 2.5.1 Незахватывающие скобочные группы\n\nБывает так, что группу определить нужно, а вот захватывать её содержимое в\nмассив не требуется. Подобный трюк осуществляется при помощи специальной\nкомбинации `?:` в круглых скобках `(...)`. Так, регулярное выражение\n`(?:c|g|p)ar` будет искать те же шаблоны, что и `(c|g|p)ar`, но группа захвата\nпри этом создана не будет.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/Rm7Me8/1)\n\nНезахватывающие группы могут пригодиться, в ситуациях типа найти-и-заменить, или\nвместе со скобочными группами, чтобы не засорять массив из захваченных данных\nненужными строками. Смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).\n\n## 2.6 Перечисление\n\nВ регулярных выражениях вертикальная черта `|` используется для определения\nперечисления (выбора). Перечисление похоже на оператор ИЛИ между выражениями.\nМожет создаться впечатление, что перечисление — это то же, что и набор символов.\nНо набор символов работает на уровне конкретных символов, а перечисление\nработает на уровне выражений. К примеру, регулярное выражение `(T|t)he|car`\nзначит: либо \"заглавная `T` ИЛИ строчная `t`, с продолжением из `h` и `e`\", либо\n\"строчная `c`, затем строчная `a`, за которой следует строчная `r`\". Во входных\nданных будут искаться оба шаблона, для удобства заключённые в кавычки.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Экранирование спецсимволов\n\nОбратный слэш `\\` используется в регулярных выражениях для экранирования\nследующего символа. Это позволяет формировать шаблоны с поиском специальных\nсимволов, таких как `{ } [ ] / \\ + * . $ ^ | ?`. Для использования спецсимвола в\nшаблоне необходимо указать символ `\\` перед ним.\n\nНапример: символ `.` является специальным и соответствует любому знаку, кроме\nсимвола новой строки. Чтобы найти точку во входных данных, воспользуется\nвыражением `(f|c|m)at\\.?`: \"строчный символ `f`, `c` или `m`, за которым следует\nстрочные буквы `a` и `t`, с необязательной `.` точкой в конце\".\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Якоря\n\nЯкоря в регулярных выражениях используются для проверки, является ли\nсоответствующий символ первым или последним символом входной строки. Есть два\nтипа якорей: каретка `^` — проверяет, является ли соответствующий символ первым\nсимволом в тексте, и доллар `$` — проверяет, является ли соответствующий символ\nпоследним символом входной строки.\n\n### 2.8.1 Каретка\n\nСимвол каретки `^` используется для проверки, является ли соответствующий символ\nпервым символом входной строки. Если мы применяем следующее регулярное выражение\n`^a` ('a' является первым символом) для строки `abc`, совпадение будет\nсоответствовать букве `a`. Если же мы используем регулярное выражение `^b` на\nтой же строке, мы не получим совпадения, поскольку во входящей строке `abc` \"b\"\nне является первым символом. Рассмотрим другое регулярное выражение: `^(T|t)he`,\nоно значит \"заглавная `T` или строчная `t` как первый символ, за которым следуют\nбуквы `h` и `e`\". Cоответственно:\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Доллар\n\nСимвол доллара `$` используется для проверки, является ли соответствующий символ\nпоследним символом входной строки. Например, регулярное выражение `(at\\.)$`\nзначит: \"последовательность из строчной `a`, строчной `t`, точки `.`, находящая\nв конце строки\". Пример:\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/t0AkOd/1)\n\n## 3. Наборы сокращений и диапазоны\n\nВ регулярных выражениях есть сокращения для часто используемых наборов символов:\n\n|Сокращение|Описание|\n|:----:|----|\n|.|Любой символ, кроме символа перевода строки|\n|\\w|Английская буква либо цифра: `[a-zA-Z0-9_]`|\n|\\W|Любой символ, кроме английских букв и цифр: `[^\\w]`|\n|\\d|Цифра: `[0-9]`|\n|\\D|Поиск всего, что не является цифрой: `[^\\d]`|\n|\\s|Пробел либо символ начала строки: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Любой символ, кроме пробела и символа начала строки: `[^\\s]`|\n\n## 4. Опережающие и ретроспективные проверки\n\nОпережающие и ретроспективные проверки (lookbehind, lookahead) — это особый вид\n***незахватывающих скобочных групп*** (находящих совпадения, но не добавляющих\nв массив совпадений). Данные проверки используются, когда мы знаем, что шаблон\nпредшествует или сопровождается другим шаблоном. Например, мы хотим получить\nцену в долларах `$` из следующей входной строки `$4.44 and $10.88`. Для этого\nиспользуем следующее регулярное выражение `(?<=\\$)[0-9\\.]*`, означающее\nполучение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара\n`$`. Существуют следующие виды проверок:\n\n|Символ|Описание|\n|:----:|----|\n|?=|Положительное опережающее условие|\n|?!|Отрицательное опережающее условие|\n|?<=|Положительное ретроспективное условие|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Отрицательное опережающее условие\n\nОтрицательное опережающее условие работает по обратному принципу: используется,\nкогда нам нужно получить все совпадения из входной строки, за которыми НЕ\nследует определенный шаблон. Отрицательное опережающее условие определяется\nтаким же образом, как и положительное, с той лишь разницей, что вместо равенства\n`=` мы ставим восклицательный знак `!` (логическое отрицание): `(?!...)`.\nПример: `(T|t)he(?!\\sfat)` — ищем слова `The` или `the`, за которыми не следует\nпробел и слово `fat`.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Положительное ретроспективное условие\n\nПоложительное ретроспективное условие используется чтобы найти все совпадения,\nкоторым предшествует определенный шаблон. Условие определяется как `(?<=...)`.\nНапример, выражение `(?<=(T|t)he\\s)(fat|mat)` означает: \"найти все слова `fat`\nили `mat` из входной строки, которым предшествует слово `The` или `the`\".\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/avH165/1)\n\n### 4.4 Отрицательное ретроспективное условие\n\nОтрицательное ретроспективное условие используется, чтобы найти все совпадения,\nкоторым НЕ предшествует определенный шаблон. Условие определяется так:\n`(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/8Efx5G/1)\n\n## 5. Флаги\n\nФлаги, также называемые модификаторами, изменяют принцип работы регулярного\nвыражения. Эти флаги могут быть использованы в любом порядке или комбинации, и\nявляются неотъемлемой частью регулярных выражений.\n\n|Флаг|Описание|\n|:----:|----|\n|i|Поиск без учета регистра.|\n|g|Глобальный поиск: искать все вхождения шаблона в тексте, а не только первое совпадение.|\n|m|Мультистроковый поиск: якоря применяются к строкам, а не ко всему тексту.|\n\n### 5.1 Поиск без учета регистра\n\nМодификатор `i` используется для поиска без учета регистра. Например, регулярное\nвыражение `/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце\nрегулярного выражения флаг `i`, указывающий библиотеке регулярных выражений\nигнорировать регистр символов. Дополнительно для поиска шаблона во всем входном\nтексте, использован флаг `g`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Глобальный поиск\n\nМодификатор `g` используется для выполнения глобального сопоставления (найти все\nсовпадения, а не останавливаться после первого). К примеру, регулярное выражение\n`/.(at)/g` означает: \"любой символ (кроме начала новой строки), следом строчная\n`a` и `t`\". Благодаря флагу `g`, такое регулярное выражение найдёт все\nсовпадения во входной строке, а не остановится на первом (что является\nповедением по умолчанию).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Мультистроковый поиск\n\nМодификатор `m` используется для многострочного поиска. Как мы обсуждали ранее,\nякоря `(^, $)` используются для проверки, является ли шаблон началом или концом\nвходных данных. Но если мы хотим, чтобы якоря работали в каждой строке, мы\nиспользуем флаг `m`. Например, регулярное выражение `/at(.)?$/gm` означает:\n\"строчная `a`, следом строчная `t` и необязательный любой символ (кроме начала\nновой строки)\". Благодаря флагу `m` библиотека регулярных выражений будет искать\nданный шаблон в конце каждой строки в тексте.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Запустить регулярное выражение](https://regex101.com/r/E88WE2/1)\n\n## 6. Жадная и ленивая квантификация\nПо умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно\nбудет искать самые длинные возможные совпадения. Мы можем использовать `?` для\nленивого поиска, который будет искать наименьшие возможные совпадения во входных\nданных.\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n\n[Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n\n[Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/2)\n\n\n## Участвуйте в жизни репозитория\n\n* Откройте пулл реквест с исправлением\n* Обсуждайте идеи в issues\n* Распространяйте знания и ссылку на репозиторий\n* Приходите с отзывами к [](https://twitter.com/ziishaned)\n\n## Лицензия\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-tr.md", "content": "
\n
\n \n \n \n
\n
\n ![\"Regular](\"../img/regexp-tr.png\")
\n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/dmRygT/1)\n\n`123` düzenli ifadesi `123` harf öbeğiyle eşleşir. Düzenli ifade birbiri ardına,\ngirilen harf öbeğindeki her karakter düzenli ifadenin içindeki her karakterle\nkarşılaştırılarak eşleştirilir. Düzenli ifadeler normal olarak büyük/küçük harfe\nduyarlıdırlar, yani `The` düzenli ifadesi `the` harf öbeğiyle eşleşmez.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta Karakterler\n\nMeta karakterler düzenli ifadelerin yapı taşlarıdırlar. Meta karakterler\nkendileri için değil bunun yerine bazı özel yollarla yorumlanırlar. Bazı meta\nkarakterler özel anlamları vardır ve bunlar köşeli parantez içinde yazılırlar.\n\nMeta karakterler aşağıdaki gibidir:\n\n|Meta karakter|Açıklama|\n|:----:|----|\n|.|Satır başlangıcı hariç herhangi bir karakterle eşleşir.|\n|[ ]|Köşeli parantezler arasında bulunan herhangi bir karakterle eşleşir.|\n|[^ ]|Köşeli parantez içerisinde yer alan `^` işaretinden sonra girilen karakterler haricindeki karakterlerle eşleşir.|\n|*|Kendisinden önce yazılan karakterin sıfır veya daha fazla tekrarı ile eşleşir.|\n|+|Kendisinden önce yazılan karakterin bir veya daha fazla olan tekrarı ile eşleşir.|\n|?|Kendisinden önce yazılan karakterin varlık durumunu opsiyonel kılar.|\n|{n,m}|Kendisinden önce yazılan karakterin en az `n` en fazla `m` değeri kadar olmasını ifade eder.|\n|(xyz)|Verilen sırayla `xyz` karakterleriyle eşleşir.|\n||| Karakterden önce veya sonra verilen ifadelerin herhangi biriyle eşleşebilir. İfadeye Yada anlamı katar.|\n|\|
[ ] ( ) { } . * + ? ^ $ \\ | özel karakterin aranmasını sağlar.|\n|^|Girilen verinin başlangıcını ifade eder.|\n|$|Girilen verinin sonunu ifade eder.|\n\n## 2.1 Nokta\n\nNokta `.` meta karakterlerin en basit örneğidir. `.` meta karakteri satır\nbaşlangıcı hariç herhangi bir karakterle eşleşir. Örneğin, `.ar` düzenli\nifadesinin anlamı: herhangi bir karakterin ardından `a` harfi ve `r` harfi\ngelir.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Karakter Takımı\n\nKarakter takımları ayrıca Karakter sınıfı olarak bilinir. Karakter takımlarını\nbelirtmek için köşeli ayraçlar kullanılır. Karakterin aralığını belirtmek için\nbir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının\nsıralaması önemli değildir.\n\nÖrneğin, `[Tt]he` düzenli ifadesinin anlamı: bir büyük `T` veya küçük `t`\nharflerinin ardından sırasıyla `h` ve `e` harfi gelir.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/2ITLQ4/1)\n\nBununla birlikte, bir karakter takımı içerisindeki bir periyot bir tam periyot\ndemektir.\n\n`ar[.]` düzenli ifadesinin anlamı: Küçük `a` karakteri ardından `r` harfi gelir,\nardından bir `.` karakteri gelir.\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Dışlanmış Karakter Seti\n\nGenellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, ama köşeli\nparantez içinde kullanıldığında verilen karakter takımını hariç tutar.\n\nÖrneğin, `[^c]ar` ifadesinin anlamı: `c` harfinden hariç herhangi bir harfin\nardından `a`, ardından `r` gelir.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 Tekrarlar\n\n`+`, `*` ya da `?` meta karakterlerinden sonra bir alt desenin kaç defa tekrar\nedebileceğini belirtmek için kullanılır. Bu meta karakterler farklı durumlarda\nfarklı davranırlar.\n\n### 2.3.1 Yıldız İşareti\n\n`*` sembolü, kendinden önce girilen eşlemenin sıfır veya daha fazla tekrarıyla\neşleşir. Ama bir karakter seti ya da sınıf sonrasına girildiğinde, tüm karakter\nsetinin tekrarlarını bulur.\n\n`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla\ntekrarları, `[a-z]*` düzenli ifadesinin anlamı ise bir satırdaki herhangi bir\nsayıdaki küçük harfler anlamına gelir.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/7m8me5/1)\n\n`*` sembolü `.` meta karakteri ile `.*` karakterinin herhangi harf öbeğine\neşleştirmek için kullanılabilir. `*` sembolü boşluk karakteriyle `\\s` bir harf\nöbeğinde boşluk karakterlerini eşleştirmek için kullanılabilir.\n\nÖrneğin, `\\s*cat\\s*` düzenli ifadesinin anlamı: sıfır veya daha fazla boşluk\nardından küçük `c` karakteri gelir, ardından küçük `a` karakteri gelir, ardından\nküçük `t` karakteri gelir, ardından sıfır veya daha fazla boşluk gelir.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 Artı İşareti\n\n`+` sembolü, kendinden önce girilen eşlemenin bir veya daha fazla tekrarıyla\neşleşir.\n\nÖrneğin, `c.+t` ifadesinin anlamı: küçük `c` harfi, ardından en az bir karakter\ngelir, ardından küçük `t` karakteri gelir. Örnekte açıklamak gereken önemli\nnokta: `t` harfi cümledeki son `t` harfi olacaktır. `c` ve `t` harfi arasında en\naz bir karakter vardır.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 Soru İşareti\n\nDüzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel\nolarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örneğiyle\neşleşir.\n\nÖrneğin, `[T]?he` ifadesinin anlamı: opsiyonel büyük `T` harfi, ardından küçük\n`h` karakteri gelir, ardından küçük `e` karakteri gelir.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 Süslü Parantez\n\nDüzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler, bir\nkarakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için\nkullanılırlar.\n\nÖrneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 9 aralığındaki karakterlerden, en\naz 2 en fazla 3 defa ile eşleş.\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/juM86s/1)\n\nİkinci numarayı boş bırakabiliriz.\n\nÖrneğin, `[0-9]{2,}` ifadesinin anlamı: En az 2 veya daha fazla defa eşleş.\nDüzenli ifadeden virgülü kaldırırsak `[0-9]{3}`: doğrudan 3 defa eşleşir.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/Sivu30/1)\n\n## 2.5 Karakter Grubu\n\nKarakter grubu parantezler içine yazılmış alt desenler grubudur. Daha önce\ntasarım deseninde değindiğimiz gibi, bir karakterden önce bir miktar belirleyici\nkoyarsak önceki karakteri tekrar eder. Fakat miktar belirleyiciyi bir karakter\ngrubundan sonra koyarsak tüm karakter grubunu tekrarlar.\n\nÖrneğin: `(ab)*` düzenli ifadesi \"ab\" karakterinin sıfır veya daha fazla\ntekrarıyla eşleşir.\n\nAyrıca karakter grubu içinde `|` meta karakterini kullanabiliriz.\n\nÖrneğin, `(c|g|p)ar` düzenli ifadesinin anlamı: küçük `c`, `g` veya `p`\nkarakteri, ardından `a` karakteri, ardından `r` karakteri gelir.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/tUxrBG/1)\n\nNot olarak yakalanan gruplar yalnızca eşleşmez, ayrıca yakalanan karakterler ana dil içinde kullanılır.Bu ana dil Python, JavaScript ve neredeyse herhangi bir dilde düzenli ifadelerin fonksiyon tanımlamalarında olabilir.\n\n### 2.5.1 Karakter Grubu Olmayanlar\n\nKarakter grubu olmayan bir grup, karakterlerle eşleşen ancak grubu yakalayamayan bir yakalama grubudur. Karakter grubu olmayan bir grup parantez içinde`(...)` önce `?` ve ardından `:` ile gösterilir. Örneğin, `(?:c|g|p)ar` düzenli ifadesi, aynı karakterlerle eşleştiği ancak bir yakalama grubu oluşturmayacağı için `(c|g|p)ar` ifadesine benzer.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/Rm7Me8/1)\n\nKarakter grubu olmayanlar bul-ve-değiştir işlevselliğinde kullanıldığında veya karakter gruplarıyla karıştırıldığında, herhangi bir başka tür çıktı üretirken genel görünümü korumak için kullanışlı olabilir.\nAyrıca bakınız [4. Bakınmak](#4-bakınmak).\n\n## 2.6 Değişim\n\nDüzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için\nkullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an,\nkarakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor\nolabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter\ngrubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır.\n\nÖrneğin, `(T|t)he|car` düzenli ifadesinin anlamı: Büyük `T` ya da küçük `t`\nkarakteri, ardından küçük `h` karakteri, ardından küçük `e` ya da `c` karakteri,\nardından küçük `a`, ardından küçük `r` karakteri gelir.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Özel Karakter Hariç Tutma\n\n`\\` işareti sonraki karakteri hariç tutmak için kullanılır. Bu bir semboülü\nayrılmış karakterlerde `{ } [ ] / \\ + * . $ ^ | ?` dahil olmak üzere eşleşen bir\nkarakter olarak belirtmemizi sağlar. Bir özel karakteri eşleşen bir karakter\nolarak kullanmak için önüne `\\` işareti getirin.\n\nÖrneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek\niçin kullanılır. Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.`\nayrılmış karakterini hariç tutmamız gerekir. Bunun için nokta önüne `\\`\nişaretini koymamız gereklidir.\n\n`(f|c|m)at\\.?` düzenli ifadesinin anlamı: küçük `f`, `c`ya da `m` harfi,\nardından küçük `a` harfi, ardından küçük `t` harfi, ardından opsiyonel `.`\nkarakteri gelir.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 Sabitleyiciler\n\nDüzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü\nveya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri\nkullanırız. Sabitleyiciler iki çeşittir: İlk çeşit, eşleşen karakterin girişin\nilk karakteri olup olmadığını kontrol eden şapka `^` karakteri, ikinci çeşit ise\neşleşen karakterin girişin son karakteri olup olmadığını kontrol eden dolar `$`\nkarakteridir.\n\n### 2.8.1 Şapka İşareti\n\nŞapka `^` işareti eşleşen karakterin giriş harf öbeğinin ilk karakteri olup\nolmadığını kontrol etmek için kullanılır. Eğer `^a` düzenli ifadesini `abc` harf\nöbeğine uygularsak `a` ile eşleşir. Ama `^b` ifadesini uygularsak bir eşleşme\nbulamayız. Bunun nedeni `abc` harf öbeğinde `b` karakterinin başlangıç karakteri\nolmamasıdır.\n\nBir başka örnek üzerinden ilerlersek,\n\n`^(T|t)he` düzenli ifadesinin anlamı: büyük `T` ya da `t` karakteri giriş harf\nöbeğinin ilk karakteri olmak üzere, ardından küçük `h`, ardından küçük `e`\nkarakteri gelir.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dolar İşareti\n\nDolar `$` işareti eşleşen karakterin giriş harf öbeğinin son karakteri olup\nolmadığını kontrol etmek için kullanılır.\n\nÖrneğin, `(at\\.)$` ifadesinin anlamı: küçük bir `a` karakteri, ardından küçük\nbir `t` karakteri, ardıdan nokta `.` karakteri gelir ve bu eşleşme harf öbeğinin\nsonunda olmalıdır.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/t0AkOd/1)\n\n## 3. Kısaltma Karakter Takımları\n\nRegex, sık olarak kullanılan düzenli ifadeler için özel karakter setleri ve\nkısaltmalar sağlar.\n\nKullanılan karakter setlerinin kısaltmaları aşağıdaki gibidir:\n\n|Kısaltma|Açıklama|\n|:----:|----|\n|.|Satır başı hariç herhangi bir karakter|\n|\\w|Alfanumerik karakterlerle eşleşir: `[a-zA-Z0-9_]`|\n|\\W|Alfanumerik olmayan karakterlerle eşleşir: `[^\\w]`|\n|\\d|Rakamlarla eşlelir: `[0-9]`|\n|\\D|Rakam olmayan karakterlerle eşleşir: `[^\\d]`|\n|\\s|Boşluk karakteri ile eşleşir: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Boşluk karakteri olmayan karakterlerle eşleşir: `[^\\s]`|\n\n## 4. Bakınmak\n\nBakınma sembolleri, bir ifade öncesinde veya sonrasında başka bir ifademiz\nolduğunda kullanılırlar.\n\nÖrneğin, `$4.44 ve $10.88` girişlerinden `$` karakteri önündeki tüm sayıları\nalmak istiyoruz, bu durumda `(?<=\\$)[0-9\\.]*` ifadesini kullanırız.\n\n`(?<=\\$)[0-9\\.]*` ifadesinin anlamı: `.` karakterini içeren ve `$` karakteriyle\ndevam eden tüm sayıları al demektir.\n\nDüzenli ifadelerde kullanılan bakınma sembolleri aşadaki gibidir:\n\n|Sembol|Açıklama|\n|:----:|----|\n|?=|Pozitif İleri Bakınma (Verdiğimiz ifade sonrası arar ve `eşleşme varsa` sonuç döndürür.)|\n|?!|Negatif İleri Bakınma (Verdiğimiz ifade sonrası arar ve `eşleşme yoksa` sonuç döndürür.)|\n|?<=|Pozitif Geri Bakınma (Verdiğimiz ifade öncesini arar ve `eşleşme varsa` sonuç döndürür.)|\n|?\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negatif İleri Bakınma\n\nNegatif ileri bakınma sembolü positive lookahead tersine, verdiğimiz desenle devam\netmemesi durumunda eşleşir. Bu sembol pozitif ileri bakınma gibi tanımlanır ama `=`\nişareti yerine `!` kullanılır.\n\n`[T|t]he(?!\\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T`\nharfi, ardından `h` harfi gelir, ardından `e` harfi gelir, ardından öncesinde\nboşluk olan bir `fat` öbeği olmamalıdır.\n\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Pozitif Geri Bakınma\n\nPozitif geri bakınma, belirli bir desenden önceki eşleşmeleri almak için\nkullanılır. `(?<=...)` ile gösterilir.\n\nÖrneğin, `(?<=[T|t]he\\s)(fat|mat)` ifadesinin anlamı: Öncesinde `The` veya `the`\nöbekleri olan tüm `fat` veya `mat` öbeklerini getir.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/avH165/1)\n\n### 4.4 Negatif Geri Bakınma\n\nNegatif geri bakınma, belirli bir desenden önce olmayan eşleşmeleri almak için\nkullanılır. `(?<=!..)` ile gösterilir.\n\nÖrneğin, `(?\n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/8Efx5G/1)\n\n## 5. İşaretler\n\nİşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü bir düzenli\nifadenin çıktısını düzenlerler. Bu işaretler herhangi bir sırada veya\nkombinasyonda kullanılabilirler ve Düzenli İfadelerin ayrılmaz bir\nparçasıdırlar.\n\n|İşaret|Açıklama|\n|:----:|----|\n|i|Büyük küçük harf duyarlılık: Eşleştirmeleri küçük/büyük harfe karşı duyarsız yapar.|\n|g|Genel Arama: Girilen harf öbeği boyunca bir desen arar.|\n|m|Çok satırlı: Sabitleyici meta karakteri her satırda çalışır.|\n\n### 5.1 Büyük/Küçük Harf Duyarlılığı\n\n`i` işaretleyicisi büyük/küçük harfe duyarsız eşleştirme yapmak için kullanılır.\n\nÖrneğin, `/The/gi` ifadesi: büyük `T` harfi, ardından küçük `h` harfi, ardından\nküçük `e` harfi gelir. ifadenin sonunda yer alan `i` işareti büyük-küçük harfe\nkarşı duyarsız olması gerektiğini belirtir. Ayrıca `g` işaretinide\nkullandığımızı görebilirsiniz, tüm text içinde bu aramayı yapmak istediğimiz\niçin `g` işaretini ayrıca belirtiyoruz.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Genel Arama\n\n`g` işareti bir giriş içinde eşleşen tüm varsayonları bulmak için kullanılır.\n`g` işareti kullanılmazsa ilk eşleşme bulunduktan sonra arama sona erer.\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Çok Satırlı\n\n`m` işareti çok satırlı bir eşleşme bulmak için kullanılır. Daha önce\nsabitleyicilerde gördüğümüz gibi `(^, $)` sembolleri aradığımız desenin harf\nöbeğinin başında veya sonunda olup olmadığını kontrol etmemiz için kullanılır.\nBu sabitleyicilerin tüm satırlarda çalışması için `m` işaretini kullanırız.\n\nÖrneğin, `/at(.)?$/gm` ifadesinin anlamı: küçük `a` harfi, ardından küçük `t`\nharfi gelir, ardından opsiyonel olarak yeni satır hariç herhangi birşey\ngelebilir. `m` işaretini kullandığımız için bir girişin her satırının sonunda\neşleştirir.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/E88WE2/1)\n\n## 6. Açgözlü vs Tembel Eşleştirme\n\nVarsayılan olarak, bir düzenli ifade açgözlü bir eşleştirme yapacaktır, bu da eşleşmenin mümkün olduğu kadar çok olacağı anlamına gelir. Tembel bir şekilde eşleştirmek için `?` kullanabiliriz, bu da eşleşme olabildiğince kısa olacaktır.\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Düzenli ifadeyi test edin](https://regex101.com/r/AyAdgJ/2)\n\n## Katkı Sağla\n\n* Hataları Raporla\n* İyileştirmeler iç Pull Request aç\n* Paylaş\n* Geri bildirim için [](https://twitter.com/ziishaned)'den eriş\n\n## Lisans\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/README-vn.md", "content": "
\n
\n \n \n \n
\n
\n \n
\n\"the\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dmRygT/1)\n\nBiểu thức chính quy `123` khớp với chuỗi `123`. Biểu thức chính quy được khớp với chuỗi đầu vào bằng cách so sánh từng ký tự trong biểu thức chính quy với từng ký tự trong chuỗi đầu vào, lần lượt từng ký tự. Biểu thức chính quy thường phân biệt chữ hoa chữ thường nên biểu thức chính quy `The` sẽ không khớp với chuỗi `the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/1paXsy/1)\n\n## 2. Meta Characters\n\nCác ký tự `meta` là các khối xây dựng của các biểu thức chính quy. Các ký tự `meta` không biểu diễn chính nó mà thay vào đó được diễn giải theo một cách đặc biệt nào đó. Một số ký tự `meta` có ý nghĩa đặc biệt và được viết bên trong dấu ngoặc vuông. Các ký tự meta như sau:\n\n|Meta character|Description|\n|:----:|----|\n|.|Khớp với tất cả các kí tự trừ dấu xuống dòng.|\n|[ ]|Lớp kí tự. Khớp với bất kỳ ký tự nào nằm giữa dấu ngoặc vuông.|\n|[^ ]|Lớp kí tự phủ định. Khớp với bất kỳ ký tự nào không có trong dấu ngoặc vuông.|\n|*|Khớp 0 hoặc nhiều lần lặp lại của kí tự trước.|\n|+|Khớp 1 hoặc nhiều lần lặp lại của kí tự trước.|\n|?|Làm cho kí tự trước tùy chọn.|\n|{n,m}|Braces. Khớp ít nhất là \"n\" nhưng không nhiều hơn \"m\" lặp lại của kí tự trước.|\n|(xyz)|Nhóm kí tự. Khớp các ký tự xyz theo thứ tự chính xác đó.|\n|||Thay thế. Khớp các ký tự trước hoặc ký tự sau ký hiệu.|\n|\|Thoát khỏi kí tự tiếp theo. Điều này cho phép bạn khớp các ký tự dành riêng
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|Khớp với sự bắt đầu của đầu vào.|\n|$|Khớp với kết thúc đầu vào.|\n\n## 2.1 Full stop\n\n\nFull stop `.` là ví dụ đơn giản nhất về ký tự meta. Kí tự meta `.`\nkhớp với bất kì kí tự nào. Nó sẽ không khớp kí tự trả về (return) hoặc xuống dòng (newline)\n\nVí dụ, biểu thức chính quy `.ar` có ý nghĩa: bất kỳ ký tự nào, theo sau là chữ `a`, tiếp theo là chữ `r`.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 Character set\n\nBộ ký tự cũng được gọi là lớp kí tự. Dấu ngoặc vuông được sử dụng để chỉ định bộ ký tự. Sử dụng dấu gạch nối bên trong bộ ký tự để chỉ định phạm vi của các ký tự. Thứ tự của phạm vi ký tự trong dấu ngoặc vuông không quan trọng. \n\nVí dụ: biểu thức chính quy `[Tt]he` có nghĩa là: chữ hoa `T` hoặc chữ thường `t`, theo sau là chữ `h`, tiếp theo là chữ `e`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/2ITLQ4/1)\n\n\nTuy nhiên, khoảng thời gian bên trong một bộ ký tự có nghĩa là một khoảng thời gian theo nghĩa đen. Biểu thức chính quy `ar[.]` Có nghĩa là: ký tự chữ thường `a`, theo sau là chữ `r`, theo sau là kí tự `.` .\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[Test the regular expression](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 Negated character set\n\nNói chung, biểu tượng dấu mũ biểu thị sự bắt đầu của chuỗi, nhưng khi nó được gõ sau dấu ngoặc vuông mở, nó sẽ phủ định bộ ký tự. Ví dụ: biểu thức chính quy `[^ c]ar` có nghĩa là: bất kỳ ký tự nào ngoại trừ `c`, theo sau là ký tự `a`, theo sau là chữ `r`.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/nNNlq3/1)\n\n\n\n\n## 2.3 Repetitions\n\nTheo dõi các ký tự meta, `+`, `*` hoặc `?` được sử dụng để xác định số lần mô hình con (subpattern) có thể xảy ra. Những kí tự meta này hành động khác nhau trong các tình huống khác nhau.\n\n\n### 2.3.1 The Star\n\nBiểu tượng `*` khớp 0 hoặc nhiều lần lặp lại của trình so khớp trước. Biểu thức chính quy `a*` có nghĩa là: 0 hoặc nhiều lần lặp lại ký tự chữ thường trước `a`. Nhưng nếu nó xuất hiện sau một bộ ký tự hoặc lớp thì nó sẽ tìm thấy sự lặp lại của toàn bộ bộ ký tự. Ví dụ: biểu thức chính quy `[a-z]*` có nghĩa là: bất kỳ số lượng chữ cái viết thường trong một hàng.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[Test the regular expression](https://regex101.com/r/7m8me5/1)\n\nBiểu tượng `*` có thể được sử dụng với ký tự meta. để khớp với bất kỳ chuỗi ký tự nào `.*` . Biểu tượng `*` có thể được sử dụng với ký tự khoảng trắng `\\s` để khớp với một chuỗi các ký tự khoảng trắng. \n\nVí dụ: biểu thức `\\s*cat\\s*` có nghĩa là: không hoặc nhiều khoảng trắng, theo sau là ký tự chữ thường `c`, theo sau là ký tự chữ thường `a`, theo sau là ký tự chữ thường `t`, tiếp theo là 0 hoặc nhiều khoảng trắng.\n\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[Test the regular expression](https://regex101.com/r/gGrwuz/1)\n\n\n\n\n### 2.3.2 The Plus\n\n\nBiểu tượng `+` khớp với một hoặc nhiều lần lặp lại của ký tự trước. \n\nVí dụ: biểu thức chính quy `c.+t` có nghĩa là: chữ thường chữ `c`, theo sau là ít nhất một ký tự, tiếp theo là ký tự chữ thường `t`. Nó cần phải được làm rõ rằng `t` là `t` cuối cùng trong câu.\n\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 The Question Mark\n\nTrong biểu thức chính quy các ký tự meta `?` làm cho ký tự trước là một tùy chọn. Biểu tượng này khớp với 0 hoặc một thể hiện (instance ) của ký tự trước. Ví dụ: biểu thức chính quy `[T]?he` có nghĩa là: Tùy chọn chữ hoa chữ `T`, theo sau là ký tự chữ thường `h`, tiếp theo là ký tự chữ thường `e`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/kPpO2x/1)\n\n\n## 2.4 Braces\n\n\nTrong các dấu ngoặc nhọn thông thường còn được gọi là bộ định lượng được sử dụng để chỉ định số lần mà một ký tự hoặc một nhóm ký tự có thể được lặp lại. Ví dụ: biểu thức chính quy `[0-9]{2,3}` có nghĩa là: Ghép ít nhất 2 chữ số nhưng không quá 3 (ký tự trong phạm vi từ 0 đến 9).\n\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/juM86s/1)\n\n\nChúng ta có thể bỏ qua số thứ hai. Ví dụ: biểu thức chính quy `[0-9]{2,}` có nghĩa là: Ghép 2 chữ số trở lên. Nếu chúng tôi cũng xóa dấu phẩy, biểu thức chính quy `[0-9]{3}` có nghĩa là: Ghép chính xác 3 chữ số.\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[Test the regular expression](https://regex101.com/r/Sivu30/1)\n\n\n## 2.5 Capturing Group\n\nMột nhóm capturing là một nhóm các mẫu con được viết bên trong Dấu ngoặc đơn `(...)`. Giống như chúng ta đã thảo luận trước đó trong biểu thức chính quy nếu chúng ta đặt một bộ định lượng sau một ký tự thì nó sẽ lặp lại ký tự trước. Nhưng nếu chúng ta đặt bộ định lượng sau một nhóm capturing thì nó lặp lại toàn bộ nhóm capturing. Ví dụ: biểu thức chính quy `(ab)*` khớp với 0 hoặc nhiều lần lặp lại của ký tự \"ab\". Chúng ta cũng có thể sử dụng luân phiên `|` kí tự meta trong nhóm capturing. Ví dụ: biểu thức chính quy `(c|g|p)ar` có nghĩa là: ký tự chữ thường `c`, `g` hoặc `p`, theo sau là ký tự `a`, tiếp theo là ký tự `r`.\n\n\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/tUxrBG/1)\n\n\nLưu ý rằng các nhóm capturing không chỉ khớp mà còn capturing các ký tự để sử dụng trong ngôn ngữ gốc. Ngôn ngữ gốc có thể là python hoặc javascript hoặc hầu như bất kỳ ngôn ngữ nào thực hiện các biểu thức chính quy trong định nghĩa hàm.\n\n\n### 2.5.1 Non-capturing group\n\nNhóm không capturing là nhóm capturing chỉ khớp với các ký tự, nhưng không capturing được nhóm. Một nhóm không capturing được ký hiệu là `?` theo sau là `:` trong ngoặc đơn `(...)`. \n\nVí dụ: biểu thức chính quy `(?:c|g|p)ar` tương tự như `(c|g|p)ar` ở chỗ nó khớp với các ký tự giống nhau nhưng sẽ không tạo nhóm capturing.\n\n
\n\"(?:c|g|p)ar\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/Rm7Me8/1)\n\nCác nhóm không capturing có thể có ích khi được sử dụng trong chức năng tìm và thay thế hoặc khi trộn với các nhóm capturing để giữ tổng quan khi sản xuất bất kỳ loại đầu ra nào khác. Xem thêm [4. Lookaround](#4-lookaround). \n\n\n## 2.6 Alternation\n\nTrong một biểu thức chính quy, thanh dọc `|` được sử dụng để xác định xen kẽ. Sự xen kẽ giống như một câu lệnh OR giữa nhiều biểu thức. Bây giờ, bạn có thể nghĩ rằng bộ ký tự và luân phiên hoạt động theo cùng một cách. Nhưng sự khác biệt lớn giữa bộ ký tự và xen kẽ là bộ ký tự hoạt động ở cấp độ ký tự nhưng xen kẽ hoạt động ở cấp độ biểu thức. \n\nVí dụ: biểu thức chính quy `(T|t)he|car` có nghĩa là: hoặc (ký tự chữ `T` hoặc chữ thường `t`, theo sau là ký tự chữ thường `h`, tiếp theo là ký tự chữ thường `e`) OR (ký tự chữ thường `c`, tiếp theo là ký tự chữ thường `a`, theo sau bằng ký tự viết thường `r`). Lưu ý rằng tôi đặt dấu ngoặc đơn cho rõ ràng, để cho thấy rằng một trong hai biểu thức trong ngoặc đơn có thể được đáp ứng và nó sẽ khớp.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 Escaping special character\n\n\nDấu gạch chéo ngược `\\` được sử dụng trong biểu thức chính quy để thoát ký tự tiếp theo. Điều này cho phép chúng tôi chỉ định một biểu tượng là một ký tự phù hợp bao gồm các ký tự dành riêng `{} [] / \\ *. $ ^ | ?` . Để sử dụng một ký tự đặc biệt, ta dùng `\\` làm ký tự trùng khớp trước kí tự ta muốn dùng.\n\nVí dụ, biểu thức chính quy `.` được sử dụng để khớp với bất kỳ ký tự nào ngoại trừ dòng mới. Bây giờ để phù hợp `.` trong một chuỗi đầu vào, biểu thức chính quy `(f|c|m)at\\.?` có nghĩa là: chữ thường `f`, `c` hoặc `m`, theo sau là ký tự chữ thường `a`, tiếp theo là chữ thường chữ `t`, theo sau là tùy chọn `.` tính cách.\n\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/DOc5Nu/1)\n\n\n## 2.8 Anchors\n\n\nTrong các biểu thức chính quy, chúng tôi sử dụng các anchors để kiểm tra xem biểu tượng phù hợp là biểu tượng bắt đầu hay biểu tượng kết thúc của chuỗi đầu vào. Các anchors có hai loại: Loại thứ nhất là Caret `^` kiểm tra xem ký tự khớp có phải là ký tự bắt đầu của đầu vào không và loại thứ hai là Dollar `$` kiểm tra xem ký tự khớp có phải là ký tự cuối cùng của chuỗi đầu vào không.\n\n\n\n\n### 2.8.1 Caret\n\n\nBiểu tượng Caret `^` được sử dụng để kiểm tra xem ký tự khớp có phải là ký tự đầu tiên của chuỗi đầu vào không. Nếu chúng ta áp dụng biểu thức chính quy sau `^a` ( nếu a là ký hiệu bắt đầu) cho chuỗi đầu vào `abc` thì nó khớp với `a`. Nhưng nếu chúng ta áp dụng biểu thức chính quy `^b` trên chuỗi đầu vào ở trên thì nó không khớp với bất cứ thứ gì. Bởi vì trong chuỗi đầu vào `abc` \"b\" không phải là ký hiệu bắt đầu. Chúng ta hãy xem một biểu thức chính quy khác `^(T|t)he` có nghĩa là: ký tự chữ hoa `T` hoặc ký tự chữ thường `t` là ký hiệu bắt đầu của chuỗi đầu vào, tiếp theo là ký tự chữ thường `h`, tiếp theo là ký tự chữ thường `e`.\n\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[Test the regular expression](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 Dollar\n\n\nBiểu tượng Dollar `$` được sử dụng để kiểm tra xem ký tự khớp có phải là ký tự cuối cùng của chuỗi đầu vào không. Ví dụ: biểu thức chính quy `(at\\.)$` có nghĩa là: ký tự chữ thường `a`, theo sau là ký tự chữ thường `t`, theo sau là `.` ký tự và bộ so khớp phải là cuối chuỗi.\n\n\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/t0AkOd/1)\n\n## 3. Shorthand Character Sets\n\n\n\nBiểu thức chính quy cung cấp các shorthand cho các bộ ký tự thường được sử dụng, cung cấp các shorthand thuận tiện cho các biểu thức thông thường được sử dụng. Các bộ ký tự shorthand như sau:\n\n\n|Shorthand|Description|\n|:----:|----|\n|.| Bất kỳ kí tự nào ngoại trừ dòng mới|\n|\\w|Khớp các ký tự chữ và số: `[a-zA-Z0-9_]`|\n|\\W|Khớp các ký tự không phải chữ và số: `[^\\w]`|\n|\\d|khớp với số trong khoảng: `[0-9]`|\n|\\D|Khớp không có chữ số: `[^\\d]`|\n|\\s|Khớp các ký tự khoảng trắng: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|Khớp với ký tự không phải khoảng trắng: `[^\\s]`|\n\n## 4. Lookaround\n\nLookbehind và lookahead (còn được gọi là lookaround) là các loại nhóm ***không capturing*** cụ thể (Được sử dụng để khớp với mẫu nhưng không được bao gồm trong danh sách phù hợp). `Lookarounds` sử dụng khi chúng ta có điều kiện mẫu này được đi trước hoặc theo sau bởi một mẫu khác. \n\nVí dụ: chúng tôi muốn nhận tất cả các số có trước ký tự `$` từ chuỗi đầu vào sau `$4,44 và $10,88`. Chúng tôi sẽ sử dụng biểu thức chính quy sau `(?<=\\$)[0-9\\.]*` có nghĩa là: lấy tất cả các số có chứa `.` ký tự và đứng trước ký tự `$`. Sau đây là những cái nhìn được sử dụng trong các biểu thức thông thường:\n\n|Kí hiệu|Mô tả|\n|:----:|----|\n|?=|Positive Lookahead|\n|?!|Negative Lookahead|\n|?<=|Positive Lookbehind|\n|?\n\"(T|t)he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/IDDARt/1)\n\n### 4.2 Negative Lookahead\n\n\n`Negative lookahead` được sử dụng khi chúng ta cần lấy tất cả các kết quả khớp từ chuỗi đầu vào không được theo sau bởi một mẫu. `Negative lookahead` được định nghĩa giống như chúng ta định nghĩa `positive lookahead` nhưng sự khác biệt duy nhất là thay vì bằng ký tự `=` chúng ta sử dụng kí tự phủ định `!` tức là `(?! ...)`. \n\nChúng ta hãy xem biểu thức chính quy sau đây: `(T|t)he(?!\\sfat)` có nghĩa là: lấy tất cả các từ `The` hoặc `the` từ chuỗi đầu vào không được đứng trước bởi từ `fat` trước một ký tự khoảng trắng.\n\n
\n\"(T|t)he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/V32Npg/1)\n\n### 4.3 Positive Lookbehind\n\n`Positive lookbehind` được sử dụng để có được tất cả mẫu khớp cái mà theo sau bởi một mẫu cụ thể. `Positive lookbehind` được biểu thị bởi `(?<=...)`. \n\nVí dụ: biểu thức chính quy `(?<=(T|t)he\\s)(fat|mat)` có nghĩa là: lấy tất cả các từ `fat` hoặc `mat` từ chuỗi đầu vào, cái mà sau từ `The` hoặc `the`.\n\n\n\n
\n\"(?<=(T|t)he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/avH165/1)\n\n### 4.4 Negative Lookbehind\n\n\n`Negative lookbehind` được sử dụng để có được tất cả các từ khớp không có trước một mẫu cụ thể. `Negative lookbehind` được ký hiệu là `(?\n\"(?<!(T|t)he\\s)(cat)\" => The cat sat on cat.\n\n\n[Test the regular expression](https://regex101.com/r/8Efx5G/1)\n\n## 5. Flags\n\n\nCờ (flags) cũng được gọi là bổ nghĩa (modifiers) vì chúng sửa đổi đầu ra của biểu thức chính quy. Các cờ này có thể được sử dụng theo bất kỳ thứ tự hoặc kết hợp nào và là một phần không thể thiếu của RegExp.\n\n\n\n|Cờ|Mô tả|\n|:------:|----|\n|i|Case insensitive: Đặt khớp với mẫu không phân biệt chữ hoa chữ thường.|\n|g|Global Search: Tìm kiếm một mẫu trong suốt chuỗi đầu vào.|\n|m|Multiline: ký tự Anchor meta hoạt động trên mỗi dòng.|\n\n### 5.1 Case Insensitive\n\n\nCông cụ sửa đổi `i` được sử dụng để thực hiện khớp không phân biệt chữ hoa chữ thường. \n\nVí dụ: biểu thức chính quy `/The/gi` có nghĩa là: chữ hoa chữ `T`, theo sau là ký tự chữ thường `h`, tiếp theo là ký tự `e`. Và ở cuối biểu thức chính quy, cờ `i` báo cho công cụ biểu thức chính quy bỏ qua trường hợp này. Như bạn có thể thấy, chúng tôi cũng đã cung cấp cờ `g` vì chúng tôi muốn tìm kiếm mẫu trong toàn bộ chuỗi đầu vào.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 Global search\n\n\nCông cụ sửa đổi `g` được sử dụng để thực hiện khớp toàn cầu (tìm tất cả các từ có thể khớp thay vì dừng sau lần khớp đầu tiên). \n\nVí dụ: biểu thức chính quy `/.(at)/g` có nghĩa là: bất kỳ ký tự nào ngoại trừ dòng mới, theo sau là ký tự chữ thường `a`, tiếp theo là ký tự chữ thường `t`. Vì chúng tôi đã cung cấp cờ `g` ở cuối biểu thức chính quy nên bây giờ nó sẽ tìm thấy tất cả các kết quả khớp trong chuỗi đầu vào, không chỉ là đầu tiên (là hành vi mặc định).\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/dO1nef/1)\n\n### 5.3 Multiline\n\n\nCông cụ sửa đổi `m` được sử dụng để thực hiện khớp nhiều dòng. Như chúng ta đã thảo luận về các anchors `(^, $)` trước đó, được sử dụng để kiểm tra xem mẫu là phần đầu của phần đầu vào hay phần cuối của chuỗi đầu vào. Nhưng nếu chúng ta muốn các anchors hoạt động trên mỗi dòng, chúng ta sử dụng cờ `m`. \n\nVí dụ: biểu thức chính quy `/at(.)?$/gm` có nghĩa là: ký tự chữ thường `a`, theo sau là ký tự chữ thường `t`, tùy chọn mọi thứ trừ dòng mới. Và vì cờ `m` bây giờ công cụ biểu thức chính quy khớp với mẫu ở cuối mỗi dòng trong một chuỗi.\n\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/E88WE2/1)\n\n\n\n\n## 6. Greedy vs lazy matching\n\n\nTheo mặc định, regex sẽ thực hiện greedy matching, có nghĩa là nó sẽ khớp càng lâu càng tốt. chúng ta có thể sử dụng `?` để khớp theo cách lười biếng có nghĩa là càng ngắn càng tốt\n\n\n\n\n
\n\"/(.*at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/1)\n\n
\n\"/(.*?at)/\" => The fat cat sat on the mat.\n\n\n[Test the regular expression](https://regex101.com/r/AyAdgJ/2)\n\n\n## Contribution\n\n* Open pull request with improvements\n* Discuss ideas in issues\n* Spread the word\n* Reach out with any feedback [](https://twitter.com/ziishaned)\n\n## License\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n\n\n\n\n\n\n" }, { "path": "translations/README-zh-simple.md", "content": "
\n
\n \n \n \n
\n
\n \n
\n\"the\" => The fat cat sat on the mat. \n\n\n[在线练习](https://regex101.com/r/dmRygT/1)\n\n正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较.\n\n正则表达式是大小写敏感的, 所以`The`不会匹配`the`.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/1paXsy/1)\n\n## 2. 元字符\n\n正则表达式主要依赖于元字符. \n元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍:\n\n|元字符|描述|\n|:----:|----|\n|.|句号匹配任意单个字符除了换行符.|\n|[ ]|字符种类. 匹配方括号内的任意字符.|\n|[^ ]|否定的字符种类. 匹配除了方括号里的任意字符|\n|*|匹配>=0个重复的在*号之前的字符.|\n|+|匹配>1个重复的+号前的字符.\n|?|标记?之前的字符为可选.|\n|{n,m}|匹配num个中括号之前的字符 (n <= num <= m).|\n|(xyz)|字符集, 匹配与 xyz 完全相等的字符串.|\n|||或运算符,匹配符号前或后的字符.|\n|\|转义字符,用于匹配一些保留的字符
[ ] ( ) { } . * + ? ^ $ \\ ||\n|^|从开始行开始匹配.|\n|$|从末端开始匹配.|\n\n## 2.1 点运算符 `.`\n\n`.`是元字符中最简单的例子. \n`.`匹配任意单个字符, 但不匹配换行符.\n例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串.\n\n\n\".ar\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/xc9GkU/1)\n\n## 2.2 字符集\n\n字符集也叫做字符类.\n方括号用来指定一个字符集.\n在方括号中使用连字符来指定字符集的范围.\n在方括号中的字符集不关心顺序.\n例如, 表达式`[Tt]he` 匹配 `the` 和 `The`.\n\n
\n\"[Tt]he\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/2ITLQ4/1)\n\n方括号的句号就表示句号.\n表达式 `ar[.]` 匹配 `ar.`字符串\n\n
\n\"ar[.]\" => A garage is a good place to park a car.\n\n\n[在线练习](https://regex101.com/r/wL3xtE/1)\n\n### 2.2.1 否定字符集\n\n一般来说 `^` 表示一个字符串的开头, 但它用在一个方括号的开头的时候, 它表示这个字符集是否定的.\n例如, 表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符.\n\n
\n\"[^c]ar\" => The car parked in the garage.\n\n\n[在线练习](https://regex101.com/r/nNNlq3/1)\n\n## 2.3 重复次数\n\n后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数. \n这些元字符在不同的情况下有着不同的意思.\n\n### 2.3.1 `*` 号\n\n`*`号匹配 在`*`之前的字符出现`大于等于0`次.\n例如, 表达式 `a*` 匹配以0或更多个a开头的字符, 因为有0个这个条件, 其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串.\n\n
\n\"[a-z]*\" => The car parked in the garage #21.\n\n\n[在线练习](https://regex101.com/r/7m8me5/1)\n\n`*`字符和`.`字符搭配可以匹配所有的字符`.*`.\n`*`和表示匹配空格的符号`\\s`连起来用, 如表达式`\\s*cat\\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串.\n\n
\n\"\\s*cat\\s*\" => The fat cat sat on the concatenation.\n\n\n[在线练习](https://regex101.com/r/gGrwuz/1)\n\n### 2.3.2 `+` 号\n\n`+`号匹配`+`号之前的字符出现 >=1 次个字符.\n例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串.\n\n
\n\"c.+t\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/Dzf9Aa/1)\n\n### 2.3.3 `?` 号\n\n在正则表达式中元字符 `?` 标记在符号前面的字符为可选, 即出现 0 或 1 次.\n例如, 表达式 `[T]?he` 匹配字符串 `he` 和 `The`.\n\n
\n\"[T]he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/cIg9zm/1)\n\n
\n\"[T]?he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/kPpO2x/1)\n\n## 2.4 `{}` 号\n\n在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数.\n例如, 表达式 `[0-9]{2,3}` 匹配 2~3 位 0~9 的数字.\n\n\n
\n\"[0-9]{2,3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/juM86s/1)\n\n我们可以省略第二个参数.\n例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字.\n\n如果逗号也省略掉则表示重复固定的次数. \n例如, `[0-9]{3}` 匹配3位数字\n\n\n\"[0-9]{2,}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/Gdy4w5/1)\n\n\n\"[0-9]{3}\" => The number was 9.9997 but we rounded it off to 10.0.\n\n\n[在线练习](https://regex101.com/r/Sivu30/1)\n\n## 2.5 `(...)` 捕获组\n\n捕获组是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入捕获组则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.\n\n我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.\n\n\n\"(c|g|p)ar\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/tUxrBG/1)\n\n## 2.6 `|` 或运算符\n\n或运算符就表示或, 用作判断条件.\n\n例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`.\n\n
\n\"(T|t)he|car\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/fBXyX0/1)\n\n## 2.7 转码特殊字符\n\n反斜线 `\\` 在表达式中用于转码紧跟其后的字符. 用于指定 `{ } [ ] / \\ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\\`.\n\n例如 `.` 是用来匹配除换行符外的所有字符的. 如果想要匹配句子中的 `.` 则要写成 `\\.`.\n\n
\n\"(f|c|m)at\\.?\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/DOc5Nu/1)\n\n## 2.8 锚点\n\n在正则表达式中, 想要匹配指定开头或结尾的字符串就要使用到锚点. `^` 指定开头, `$` 指定结尾.\n\n### 2.8.1 `^` 号\n\n`^` 用来检查匹配的字符串是否在所匹配字符串的开头.\n\n例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头.\n\n例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串.\n\n
\n\"(T|t)he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/5ljjgB/1)\n\n
\n\"^(T|t)he\" => The car is parked in the garage.\n\n\n[在线练习](https://regex101.com/r/jXrKne/1)\n\n### 2.8.2 `$` 号\n\n同理于 `^` 号, `$` 号用来匹配字符是否是最后一个.\n\n例如, `(at\\.)$` 匹配以 `at.` 结尾的字符串.\n\n
\n\"(at\\.)\" => The fat cat. sat. on the mat.\n\n\n[在线练习](https://regex101.com/r/y4Au4D/1)\n\n
\n\"(at\\.)$\" => The fat cat. sat. on the mat.\n\n\n[在线练习](https://regex101.com/r/t0AkOd/1)\n\n## 3. 简写字符集\n\n正则表达式提供一些常用的字符集简写. 如下:\n\n|简写|描述|\n|:----:|----|\n|.|除换行符外的所有字符|\n|\\w|匹配所有字母数字, 等同于 `[a-zA-Z0-9_]`|\n|\\W|匹配所有非字母数字, 即符号, 等同于: `[^\\w]`|\n|\\d|匹配数字: `[0-9]`|\n|\\D|匹配非数字: `[^\\d]`|\n|\\s|匹配所有空格字符, 等同于: `[\\t\\n\\f\\r\\p{Z}]`|\n|\\S|匹配所有非空格字符: `[^\\s]`|\n\n## 4. 前后关联约束(前后预查)\n\n前置约束和后置约束都属于**非捕获组**(用于匹配不在匹配列表中的格式).\n前置约束用于判断所匹配的格式是否在另一个确定的格式之后.\n\n例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\\$)[0-9\\.]*`.\n这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次.\n\n前后关联约束如下:\n\n|符号|描述|\n|:----:|----|\n|?=|前置约束-存在|\n|?!|前置约束-排除|\n|?<=|后置约束-存在|\n|?\n\"[T|t]he(?=\\sfat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/IDDARt/1)\n\n### 4.2 `?!...` 前置约束-排除\n\n前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式\n`前置约束-排除` 定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`. \n\n表达式 `[T|t]he(?!\\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.\n\n
\n\"[T|t]he(?!\\sfat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/V32Npg/1)\n\n### 4.3 `?<= ...` 后置约束-存在\n\n后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式.\n例如, 表达式 `(?<=[T|t]he\\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.\n\n
\n\"(?<=[T|t]he\\s)(fat|mat)\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/avH165/1)\n\n### 4.4 `?\n\"(?<![T|t]he\\s)(cat)\" => The cat sat on cat.\n\n\n[在线练习](https://regex101.com/r/8Efx5G/1)\n\n## 5. 标志\n\n标志也叫修饰语, 因为它可以用来修改表达式的搜索结果.\n这些标志可以任意的组合使用, 它也是整个正则表达式的一部分.\n\n|标志|描述|\n|:----:|----|\n|i|忽略大小写.|\n|g|全局搜索.|\n|m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始.|\n\n### 5.1 忽略大小写 (Case Insensitive)\n\n修饰语 `i` 用于忽略大小写.\n例如, 表达式 `/The/gi` 表示在全局搜索 `The`, 在后面的 `i` 将其条件修改为忽略大小写, 则变成搜索 `the` 和 `The`, `g` 表示全局搜索.\n\n
\n\"The\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/dpQyf9/1)\n\n
\n\"/The/gi\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/ahfiuh/1)\n\n### 5.2 全局搜索 (Global search)\n\n修饰符 `g` 常用于执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). \n例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.\n\n
\n\"/.(at)/\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/jnk6gM/1)\n\n
\n\"/.(at)/g\" => The fat cat sat on the mat.\n\n\n[在线练习](https://regex101.com/r/dO1nef/1)\n\n### 5.3 多行修饰符 (Multiline)\n\n多行修饰符 `m` 常用于执行一个多行匹配.\n\n像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.\n\n例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟0个或1个 `.` 的字符串, 并返回全部结果.\n\n
\n\"/.at(.)?$/\" => The fat\n cat sat\n on the mat.\n\n\n[在线练习](https://regex101.com/r/hoGMkP/1)\n\n
\n\"/.at(.)?$/gm\" => The fat\n cat sat\n on the mat.\n\n\n[在线练习](https://regex101.com/r/E88WE2/1)\n\n## 额外补充\n\n* *正整数*: `^\\d+$`\n* *负整数*: `^-\\d+$`\n* *手机国家号*: `^+?[\\d\\s]{3,}$`\n* *手机号*: `^+?[\\d\\s]+(?[\\d\\s]{10,}$`\n* *整数*: `^-?\\d+$`\n* *用户名*: `^[\\w\\d_.]{4,16}$`\n* *数字和英文字母*: `^[a-zA-Z0-9]*$`\n* *数字和应为字母和空格*: `^[a-zA-Z0-9 ]*$`\n* *密码*: `^(?=^.{6,}$)((?=.*[A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z]))^.*$`\n* *邮箱*: `^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4})*$`\n* *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]?))*$`\n* *纯小写字母*: `^([a-z])*$`\n* *纯大写字母*: `^([A-Z])*$`\n* *URL*: `^(((http|https|ftp):\\/\\/)?([[a-zA-Z0-9]\\-\\.])+(\\.)([[a-zA-Z0-9]]){2,4}([[a-zA-Z0-9]\\/+=%&_\\.~?\\-]*))*$`\n* *VISA 信用卡号*: `^(4[0-9]{12}(?:[0-9]{3})?)*$`\n* *日期 (MM/DD/YYYY)*: `^(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?[0-9]{2}$`\n* *日期 (YYYY/MM/DD)*: `^(19|20)?[0-9]{2}[- /.](0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])$`\n* *MasterCard 信用卡号*: `^(5[1-5][0-9]{14})*$`\n\n## 贡献\n\n* 报告问题\n* 开放合并请求\n* 传播此文档\n* 直接和我联系 ziishaned@gmail.com 或 [](https://twitter.com/ziishaned)\n\n## 许可证\n\nMIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)\n" }, { "path": "translations/how-to.md", "content": "Please put new translation README files here.\n\nTo start a new translation, please:\n\n1. Make an issue (for collaboration with other translators)\n2. Make a pull request to collaborate and commit to.\n3. Let me know when it's ready to pull.\n\nThank you!" } ]