From f4c1d1e274cea921e04d87f8488a948d832c4cb9 Mon Sep 17 00:00:00 2001 From: GrayLand Date: Thu, 10 Aug 2017 16:19:24 +0800 Subject: [PATCH 001/185] 1-> Translated to Chinese. --- 01.png | Bin 0 -> 20284 bytes README-zh-simple.md | 488 ++++++++++++++++++++++++++++++++++++++++++++ README.md | 3 + 3 files changed, 491 insertions(+) create mode 100644 01.png create mode 100644 README-zh-simple.md diff --git a/01.png b/01.png new file mode 100644 index 0000000000000000000000000000000000000000..0d1c9340772a1ab2237859ed4f2e45cfc6fa50cd GIT binary patch literal 20284 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 literal 0 HcmV?d00001 diff --git a/README-zh-simple.md b/README-zh-simple.md new file mode 100644 index 00000000..2ae80013 --- /dev/null +++ b/README-zh-simple.md @@ -0,0 +1,488 @@ +
+

+Learn Regex +


+ +## 什么是正则表达式? + +> 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子. + + +一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式. +例如"Regular expression"是一个完整的句子, 但我们常使用缩写的术语"regex"或"regexp". +正则表达式可以用来替换文本中的字符串,验证形式,提取字符串等等. + +想象你正在写一个应用, 然后你想设定一个用户命名的规则, 让用户名包含字符,数字,下划线和连字符,以及限制字符的个数,好让名字看起来没那么丑. +我们使用以下正则表达式来验证一个用户名: + +

+

+Regular expression +

+ +以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`. +但不匹配`Jo`, 因为它包含了大写的字母而且太短了. + +目录 +================= + + * [1. 基本匹配](#1-基本匹配) + * [2. 元字符](#2-元字符) + * [2.1 点运算符 .](#21-点运算符-) + * [2.2 字符集](#22-字符集) + * [2.2.1 否定字符集](#221-否定字符集) + * [2.3 重复次数](#23-重复次数) + * [2.3.1 * 号](#231--号) + * [2.3.2 号](#232--号) + * [2.3.3 ? 号](#233--号) + * [2.4 {} 号](#24--号) + * [2.5 (...) 特征标群](#25--特征标群) + * [2.6 | 或运算符](#26--或运算符) + * [2.7 转码特殊字符](#27-转码特殊字符) + * [2.8 锚点](#28-锚点) + * [2.8.1 ^ 号](#281--号) + * [2.8.2 $ 号](#282--号) +* [3. 简写字符集](#3-简写字符集) +* [4. 前后关联约束(前后预查)](#4-前后关联约束前后预查) + * [4.1 ?=... 前置约束(存在)](#41--前置约束存在) + * [4.2 ?!... 前置约束-排除](#42--前置约束-排除) + * [4.3 ?<= ... 后置约束-存在](#43---后置约束-存在) + * [4.4 ?<!... 后置约束-排除](#44--后置约束-排除) +* [5. 标志](#5-标志) + * [5.1 忽略大小写 (Case Insensitive)](#51-忽略大小写-case-insensitive) + * [5.2 全局搜索 (Global search)](#52-全局搜索-global-search) + * [5.3 多行修饰符 (Multiline)](#53-多行修饰符-multiline) +* [额外补充](#额外补充) +* [贡献](#贡献) +* [许可证](#许可证) + +## 1. 基本匹配 + +正则表达式其实就是在执行搜索时的格式, 它由一些字母和数字组合而成. +例如: 一个正则表达式 `the`, 它表示一个规则: 由字母`t`开始,接着是`h`,再接着是`e`. + +
+"the" => The fat cat sat on the mat. 
+
+ +[在线练习](https://regex101.com/r/dmRygT/1) + +正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较. + +正则表达式是大小写敏感的, 所以`The`不会匹配`the`. + +
+"The" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/1paXsy/1) + +## 2. 元字符 + +正则表达式主要依赖于元字符. +元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍: + +|元字符|描述| +|:----:|----| +|.|句号匹配任意单个字符除了换行符.| +|[ ]|字符种类. 匹配方括号内的任意字符.| +|[^ ]|否定的字符种类. 匹配除了方括号里的任意字符| +|*|匹配>=0个重复的在*号之前的字符.| +|+|匹配>1个重复的+号前的字符. +|?|标记?之前的字符为可选.| +|{n,m}|匹配num个中括号之前的字符 (n <= num <= m).| +|(xyz)|字符集, 匹配与 xyz 完全相等的字符串.| +|||或运算符,匹配符号前或后的字符.| +|\|转义字符,用于匹配一些保留的字符 [ ] ( ) { } . * + ? ^ $ \ || +|^|从开始行开始匹配.| +|$|从末端开始匹配.| + +## 2.1 点运算符 `.` + +`.`是元字符中最简单的例子. +`.`匹配任意单个字符, 但不匹配换行符. +例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串. + +
+".ar" => The car parked in the garage.
+
+ +[在线练习](https://regex101.com/r/xc9GkU/1) + +## 2.2 字符集 + +字符集也叫做字符类. +方括号用来指定一个字符集. +在方括号中使用连字符来指定字符集的范围. +在方括号中的字符集不关心顺序. +例如, 表达式`[Tt]he` 匹配 `the` 和 `The`. + +
+"[Tt]he" => The car parked in the garage.
+
+ +[在线练习](https://regex101.com/r/2ITLQ4/1) + +方括号的句号就表示句号. +表达式 `ar[.]` 匹配 `ar.`字符串 + +
+"ar[.]" => A garage is a good place to park a car.
+
+ +[在线练习](https://regex101.com/r/wL3xtE/1) + +### 2.2.1 否定字符集 + +一般来说 `^` 表示一个字符串的开头, 但它用在一个方括号的开头的时候, 它表示这个字符集是否定的. +例如, 表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符. + +
+"[^c]ar" => The car parked in the garage.
+
+ +[在线练习](https://regex101.com/r/nNNlq3/1) + +## 2.3 重复次数 + +后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数. +这些元字符在不同的情况下有着不同的意思. + +### 2.3.1 `*` 号 + +`*`号匹配 在`*`之前的字符出现`大于等于0`次. +例如, 表达式 `a*` 匹配以0或更多个a开头的字符, 因为有0个这个条件, 其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串. + +
+"[a-z]*" => The car parked in the garage #21.
+
+ +[在线练习](https://regex101.com/r/7m8me5/1) + +`*`字符和`.`字符搭配可以匹配所有的字符`.*`. +`*`和表示匹配空格的符号`\s`连起来用, 如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串. + +
+"\s*cat\s*" => The fat cat sat on the concatenation.
+
+ +[在线练习](https://regex101.com/r/gGrwuz/1) + +### 2.3.2 `+` 号 + +`+`号匹配`+`号之前的字符出现 >=1 次个字符. +例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串. + +
+"c.+t" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/Dzf9Aa/1) + +### 2.3.3 `?` 号 + +在正则表达式中元字符 `?` 标记在符号前面的字符为可选, 即出现 0 或 1 次. +例如, 表达式 `[T]?he` 匹配字符串 `he` 和 `The`. + +
+"[T]he" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/cIg9zm/1) + +
+"[T]?he" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/kPpO2x/1) + +## 2.4 `{}` 号 + +在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数. +例如, 表达式 `[0-9]{2,3}` 匹配 2~3 位 0~9 的数字. + + +
+"[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[在线练习](https://regex101.com/r/juM86s/1) + +我们可以省略第二个参数. +例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字. + +如果逗号也省略掉则表示重复固定的次数. +例如, `[0-9]{3}` 匹配3位数字 + +
+"[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[在线练习](https://regex101.com/r/Gdy4w5/1) + +
+"[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[在线练习](https://regex101.com/r/Sivu30/1) + +## 2.5 `(...)` 特征标群 + +特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`. + +我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`. + +
+"(c|g|p)ar" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/tUxrBG/1) + +## 2.6 `|` 或运算符 + +或运算符就表示或, 用作判断条件. + +例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`. + +
+"(T|t)he|car" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/fBXyX0/1) + +## 2.7 转码特殊字符 + +反斜线 `\` 在表达式中用于转码紧跟其后的字符. 用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`. + +例如 `.` 是用来匹配除换行符外的所有字符的. 如果想要匹配句子中的 `.` 则要写成 `\.`. + +
+"(f|c|m)at\.?" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/DOc5Nu/1) + +## 2.8 锚点 + +在正则表达式中, 想要匹配指定开头或结尾的字符串就要使用到锚点. `^` 指定开头, `$` 指定结尾. + +### 2.8.1 `^` 号 + +`^` 用来检查匹配的字符串是否在所匹配字符串的开头. + +例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 应为在字符串 `abc` 中并不是以 `b` 开头. + +例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串. + +
+"(T|t)he" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/5ljjgB/1) + +
+"^(T|t)he" => The car is parked in the garage.
+
+ +[在线练习](https://regex101.com/r/jXrKne/1) + +### 2.8.2 `$` 号 + +同理于 `^` 号, `$` 号用来匹配字符是否是最后一个. + +例如, `(at\.)$` 匹配以 `at.` 结尾的字符串. + +
+"(at\.)" => The fat cat. sat. on the mat.
+
+ +[在线练习](https://regex101.com/r/y4Au4D/1) + +
+"(at\.)$" => The fat cat. sat. on the mat.
+
+ +[在线练习](https://regex101.com/r/t0AkOd/1) + +## 3. 简写字符集 + +正则表达式提供一些常用的字符集简写. 如下: + +|简写|描述| +|:----:|----| +|.|除换行符外的所有字符| +|\w|匹配所有字母数字, 等同于 `[a-zA-Z0-9_]`| +|\W|匹配所有非字母数字, 即符号, 等同于: `[^\w]`| +|\d|匹配数字: `[0-9]`| +|\D|匹配非数字: `[^\d]`| +|\s|匹配所有空格字符, 等同于: `[\t\n\f\r\p{Z}]`| +|\S|匹配所有非空格字符: `[^\s]`| + +## 4. 前后关联约束(前后预查) + +前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式). +前置约束用于判断所匹配的格式是否在另一个确定的格式之后. + +例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`. +这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次. + +前后关联约束如下: + +|符号|描述| +|:----:|----| +|?=|前置约束-存在| +|?!|前置约束-排除| +|?<=|后置约束-存在| +|? +"[T|t]he(?=\sfat)" => The fat cat sat on the mat. + + +[在线练习](https://regex101.com/r/IDDARt/1) + +### 4.2 `?!...` 前置约束-排除 + +前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式 +`前置约束-排除` 定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`. + +表达式 `[T|t]he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`. + +
+"[T|t]he(?!\sfat)" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/V32Npg/1) + +### 4.3 `?<= ...` 后置约束-存在 + +后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式. +例如, 表达式 `(?<=[T|t]he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`. + +
+"(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/avH165/1) + +### 4.4 `? +"(?<![T|t]he\s)(cat)" => The cat sat on cat. + + +[在线练习](https://regex101.com/r/8Efx5G/1) + +## 5. 标志 + +标志也叫修饰语, 因为它可以用来修改表达式的搜索结果. +这些标志可以任意的组合使用, 它也是整个正则表达式的一部分. + +|标志|描述| +|:----:|----| +|i|忽略大小写.| +|g|全局搜索.| +|m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始.| + +### 5.1 忽略大小写 (Case Insensitive) + +修饰语 `i` 用于忽略大小写. +例如, 表达式 `/The/gi` 表示在全局搜索 `The`, 在后面的 `i` 将其条件修改为忽略大小写, 则变成搜索 `the` 和 `The`, `g` 表示全局搜索. + +
+"The" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/dpQyf9/1) + +
+"/The/gi" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/ahfiuh/1) + +### 5.2 全局搜索 (Global search) + +修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). +例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果. + +
+"/.(at)/" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/jnk6gM/1) + +
+"/.(at)/g" => The fat cat sat on the mat.
+
+ +[在线练习](https://regex101.com/r/dO1nef/1) + +### 5.3 多行修饰符 (Multiline) + +多行修饰符 `m` 常用语执行一个多行匹配. + +像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`. + +例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟一个或多个 `.` 的字符串, 并返回全部结果. + +
+"/.at(.)?$/" => The fat
+                cat sat
+                on the mat.
+
+ +[在线练习](https://regex101.com/r/hoGMkP/1) + +
+"/.at(.)?$/gm" => The fat
+                  cat sat
+                  on the mat.
+
+ +[在线练习](https://regex101.com/r/E88WE2/1) + +## 额外补充 + +* *正整数*: `^\d+$` +* *负整数*: `^-\d+$` +* *手机国家号*: `^+?[\d\s]{3,}$` +* *手机号*: `^+?[\d\s]+(?[\d\s]{10,}$` +* *整数*: `^-?\d+$` +* *用户名*: `^[\w\d_.]{4,16}$` +* *数字和英文字母*: `^[a-zA-Z0-9]*$` +* *数字和应为字母和空格*: `^[a-zA-Z0-9 ]*$` +* *密码*: `^(?=^.{6,}$)((?=.*[A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z]))^.*$` +* *邮箱*: `^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})*$` +* *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]?))*$` +* *纯小写字母*: `^([a-z])*$` +* *纯大写字母*: `^([A-Z])*$` +* *URL*: `^(((http|https|ftp):\/\/)?([[a-zA-Z0-9]\-\.])+(\.)([[a-zA-Z0-9]]){2,4}([[a-zA-Z0-9]\/+=%&_\.~?\-]*))*$` +* *VISA 信用卡号*: `^(4[0-9]{12}(?:[0-9]{3})?)*$` +* *日期 (MM/DD/YYYY)*: `^(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?[0-9]{2}$` +* *日期 (YYYY/MM/DD)*: `^(19|20)?[0-9]{2}[- /.](0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])$` +* *MasterCard 信用卡号*: `^(5[1-5][0-9]{14})*$` + +## 贡献 + +* 报告问题 +* 开放合并请求 +* 传播此文档 +* 直接和我联系 ziishaned@gmail.com 或 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned) + +## 许可证 + +MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com) diff --git a/README.md b/README.md index 1a9ba3db..84cfc679 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,9 @@ Learn Regex


+ +[中文版](README-zh-simple.md) + ## What is Regular Expression? > Regular expression is a group of characters or symbols which is used to find a specific pattern from a text. From e698d5da285e08426f01d1bf49b627b3ef1403f8 Mon Sep 17 00:00:00 2001 From: Mayur Date: Thu, 17 Aug 2017 15:58:54 +0530 Subject: [PATCH 002/185] FIX typo in Escaping special character section (#63) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 31cd31cd..3fde9403 100644 --- a/README.md +++ b/README.md @@ -259,7 +259,7 @@ or lowercase character `c`, followed by lowercase character `a`, followed by low ## 2.7 Escaping special character -Backslash `\` is used in regular expression to escape the next character. This allows to to specify a symbol as a matching character +Backslash `\` is used in regular expression to escape the next character. This allows us to specify a symbol as a matching character including reserved characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching character prepend `\` before it. For example, the regular expression `.` is used to match any character except newline. Now to match `.` in an input string the regular expression `(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase character `a`, followed by lowercase letter From 9483a3fa16268b43979e5428db5b80a6663be09f Mon Sep 17 00:00:00 2001 From: Sahib Yar Date: Thu, 17 Aug 2017 15:29:42 +0500 Subject: [PATCH 003/185] deleted the bonus from table of contents (#62) As you now you have removed the bonus section, which contained the examples, the bonus tag should be removed from the table of contents also. --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index 3fde9403..ece50f70 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,6 @@ contains uppercase letter and also it is too short. - [Case Insensitive](#51-case-insensitive) - [Global search](#52-global-search) - [Multiline](#53-multiline) -- [Bonus](#bonus) ## 1. Basic Matchers From 7ddb3f6bf5556aa62d67ab6fee8fb4091ee5a9ab Mon Sep 17 00:00:00 2001 From: Allan Date: Fri, 18 Aug 2017 10:11:36 +0800 Subject: [PATCH 004/185] Add some compatible character set (#64) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改一处错别字 添加部分简写字符集 --- README-cn.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/README-cn.md b/README-cn.md index e075d23a..2fbcee53 100644 --- a/README-cn.md +++ b/README-cn.md @@ -277,7 +277,7 @@ `^` 用来检查匹配的字符串是否在所匹配字符串的开头. -例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 应为在字符串 `abc` 中并不是以 `b` 开头. +例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头. 例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串. @@ -324,6 +324,12 @@ |\D|匹配非数字: `[^\d]`| |\s|匹配所有空格字符, 等同于: `[\t\n\f\r\p{Z}]`| |\S|匹配所有非空格字符: `[^\s]`| +|\f|匹配一个换页符| +|\n|匹配一个换行符| +|\r|匹配一个回车符| +|\t|匹配一个制表符| +|\v|匹配一个垂直制表符| +|\p|匹配 CR/LF (等同于 `\r\n`)，用来匹配 DOS 行终止符| ## 4. 前后关联约束(前后预查) From e67ac5d408e36e8403b3682548a0c41e3e39bec9 Mon Sep 17 00:00:00 2001 From: Loic Humbert Date: Fri, 18 Aug 2017 18:16:07 +0200 Subject: [PATCH 005/185] French translation (#59) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * created file for translation * Added french link * Intro translated * Intro translated * §1 * §2 * Titles translated * §2.1 * Fixed tick issue in title star * Fixed tick issue in title star * §2.2 * Fixed multilignes link * Organized language choice * §2.2.1 * 2.3 => 2.3.1 * §2.3.2 * §2.3.3 * §2.7 * 2.4 => 2.7 * 2.8.1 * 2.8.2 => 4 * 4.2 => 4.3 * 4.4 * changed 'Recherche globale' to 'Correspondance globale' * 5.1 * 5 * 5.1 * 5.3 * FINISHED git commit -am 5.3git commit -am 5.3git commit -am 5.3 FUCK YEAH git commit -am 5.3git commit -am 5.3git commit -am 5.3! :DDD * corrected typos * changed modèle for schéma * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo * corrected typo --- README-cn.md | 21 +-- README-es.md | 3 +- README-fr.md | 468 +++++++++++++++++++++++++++++++++++++++++++++++++++ README-ja.md | 3 +- README.md | 4 +- 5 files changed, 486 insertions(+), 13 deletions(-) create mode 100644 README-fr.md diff --git a/README-cn.md b/README-cn.md index 2fbcee53..57b0b34f 100644 --- a/README-cn.md +++ b/README-cn.md @@ -6,12 +6,13 @@ ## 翻译: * [English](README.md) -* [Spanish](README-es.md) +* [Español](README-es.md) +* [Français](README-fr.md) * [中文版](README-cn.md) * [日本語](README-ja.md) ## 什么是正则表达式? - + > 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子. @@ -69,7 +70,7 @@ 例如: 一个正则表达式 `the`, 它表示一个规则: 由字母`t`开始,接着是`h`,再接着是`e`. 
-"the" => The fat cat sat on the mat. 
+"the" => The fat cat sat on the mat.
[在线练习](https://regex101.com/r/dmRygT/1) @@ -106,7 +107,7 @@ ## 2.1 点运算符 `.` -`.`是元字符中最简单的例子. +`.`是元字符中最简单的例子. `.`匹配任意单个字符, 但不匹配换行符. 例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串. @@ -152,7 +153,7 @@ ## 2.3 重复次数 -后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数. +后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数. 这些元字符在不同的情况下有着不同的意思. ### 2.3.1 `*` 号 @@ -218,7 +219,7 @@ 我们可以省略第二个参数. 例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字. -如果逗号也省略掉则表示重复固定的次数. +如果逗号也省略掉则表示重复固定的次数. 例如, `[0-9]{3}` 匹配3位数字 
@@ -353,7 +354,7 @@
 `?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
 
 返回结果只瞒住第一部分表达式.
-定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
+定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`.
 
 前置约束的内容写在括号中的等号后面.
 例如, 表达式 `[T|t]he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
@@ -367,7 +368,7 @@
 ### 4.2 `?!...` 前置约束-排除
 
 前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式
-`前置约束-排除`  定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`. 
+`前置约束-排除`  定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
 
 表达式 `[T|t]he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
 
@@ -429,7 +430,7 @@
 
 ### 5.2 全局搜索 (Global search)
 
-修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). 
+修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部).
 例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.
 
 
@@ -446,7 +447,7 @@
 
 ### 5.3 多行修饰符 (Multiline)
 
-多行修饰符 `m` 常用语执行一个多行匹配. 
+多行修饰符 `m` 常用语执行一个多行匹配.
 
 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
 
diff --git a/README-es.md b/README-es.md
index 64ca5965..6988406c 100644
--- a/README-es.md
+++ b/README-es.md
@@ -6,7 +6,8 @@
 ## Translations:
 
 * [English](README.md)
-* [Español](README-es.md) 
+* [Español](README-es.md)
+* [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 
diff --git a/README-fr.md b/README-fr.md
new file mode 100644
index 00000000..931abd1b
--- /dev/null
+++ b/README-fr.md
@@ -0,0 +1,468 @@
+

+

+Learn Regex
+


+
+## Traductions:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+
+## Qu'est-ce qu'une expression régulière?
+
+> Une expression régulière est un groupement de caractères ou symboles utilisés pour trouver un schéma spécifique dans un texte.
+
+Une expression régulière est un schéma qui est comparée à une chaîne de caractères de gauche à droite. Le mot "Expression régulière"
+est un terme entier, souvent abrégé par "regex" ou "regexp". Une expression régulière est utilisée pour remplacer un texte à l'intérieur
+d'une *string* (une chaîne de caractères), valider un formulaire, extraire une portion de string basée sur un schéma, et bien plus encore.
+
+Imaginons que nous écrivons une application et que nous voulons définir des règles pour le choix d'un pseudonyme. Nous voulons autoriser
+le pseudonyme à contenir des lettres, des nombres, des underscores et des traits d'union. Nous voulons aussi limiter le nombre
+de caractères dans le pseudonyme pour qu'il n'ait pas l'air moche. Nous utilisons l'expression régulière suivante pour valider un pseudonyme:
+


+

+Regular expression
+

+
+L'expression régulière ci-dessus peut accepter les strings `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car
+cette string contient une lettre majuscule et elle est trop courte.
+
+## Table des matières
+
+- [Introduction](#1-introduction)
+- [Meta-caractères](#2-meta-caractères)
+  - [Full stop](#21-full-stop)
+  - [Inclusion de caractères](#22-inclusion-de-caractères)
+    - [Exclusion de caractères](#221-exclusion-de-caractères)
+  - [Répétitions](#23-répétitions)
+    - [Astérisque](#231-Asterisque)
+    - [Le Plus](#232-le-plus)
+    - [Le Point d'Interrogation](#233-le-point-d'interrogation)
+  - [Accolades](#24-accolades)
+  - [Groupement de caractères](#25-groupement-de-caractères)
+  - [Alternation](#26-alternation)
+  - [Caractère d'échappement](#27-caractère-d'échappement)
+  - [Ancres](#28-ancres)
+    - [Circonflexe](#281-circonflexe)
+    - [Dollar](#282-dollar)
+- [Liste de caractères abrégés](#3-liste-de-caractères-abrégés)
+- [Recherche](#4-recherche)
+  - [Recherche avant positive](#41-recherche-avant-positive)
+  - [Recherche avant négative](#42-recherche-avant-négative)
+  - [Recherche arrière positive](#43-recherche-arrière-positive)
+  - [Recherche arrière négative](#44-recherche-arrière-négative)
+- [Drapeaux](#5-drapeaux)
+  - [Insensible à la casse](#51-insensible-à-la-casse)
+  - [Correspondance globale](#52-recherche-globale)
+  - [Multilignes](#53-multilignes)
+
+## 1. Introduction
+
+Une expression régulière est un schéma de caractères utilisés pour effectuer une recherche dans un text.
+Par exemple, l'expression régulière `the` signifie: la lettre `t`, suivie de la lettre `h`, suivie de la lettre `e`.
+
+
+"the" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/dmRygT/1)
+
+L'expression régulière `123` coïncide à la chaîne `123`. Chaque caractère de l'expression régulière est comparée à la chaine 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 chaine de caractère `the`.
+
+
+"The" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta-caractères
+
+Les meta-caractères sont les bloques 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.
+Significations des meta-caractères:
+
+|Meta-caractère|Description|
+|:----:|----|
+|.|Un point coïncide avec n'importe quel caractère unique à part le retour à la ligne.|
+|[ ]|Classe de caractères. Coïncide avec n'importe quels caractères entre crochets.|
+|[^ ]|Négation de classe de caractère. Coïncide avec n'importe quels caractères qui n'est pas entre les crochets.|
+|*|Coïncide avec 0 ou plus répétitions du caractère précédent.|
+|+|Coïncide avec 1 ou plus répétitions du caractère précédent.|
+|?|Rend le caractère précédent optionnel.|
+|{n,m}|Accolades. Coïncide avec au moins "n" mais pas plus que "m" répétition(s) du caractère précédent.|
+|(xyz)|Groupe de caractères. Coïncide avec les caractères "xyz" dans l'ordre exact.|
+|||Alternation (ou). Coïncide soit avec le caractère avant ou après le symbol.|
+|\|Échappe le prochain caractère. Cela permet de faire coïncider des caractères réservés tels que [ ] ( ) { } . * + ? ^ $ \ ||
+|^|Coïncide avec le début de la chaîne de caractères.|
+|$|Coïncide avec la fin de la chaîne de caractères.|
+
+## 2.1 Full stop
+
+Le 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`.
+
+
+".ar" => The car parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Inclusions de caractères
+
+Les 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` minucule, suivi par la lettre `h`, suivie par la lettre `e`.
+
+
+"[Tt]he" => The car parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/2ITLQ4/1)
+
+L'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, suvie par un `.` (point).
+
+
+"ar[.]" => A garage is a good place to park a car.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Exclusion de caractères
+
+En règle générale, le caractère circonflexe représente le début d'une chaîne de caractères. Néanmoins, lorsqu'il est utilisé après le crochet ouvrant, il permet d'exclure la gamme de caractère(s). 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`.
+
+
+"[^c]ar" => The car parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Répétitions
+
+Les 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.
+
+### 2.3.1 Astérisque
+
+Le 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
+du 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.
+Par exemple, l'expression régulière `[a-z]*` signifie: n'importe combien de lettres minuscules.
+
+
+"[a-z]*" => The car parked in the garage #21.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/7m8me5/1)
+
+Le symbole `*` peut être utilisé avec le meta-caractère `.` pour correspondre à n'importe quelle chaîne de caractères `.*`. Le symbole `*` peut être utilisé avec le
+caractère espace vide `\s` pour correspondre à une chaîne d'espaces vides. Par exemple, l'expression `\s*cat\s*` signifie: zéro ou plus
+d'espaces, suivis du caractère `c` minuscule, suivi par le caractère `a` minuscule, suivi par le caractère `t` minuscule, suivi par
+zéro ou plus d'espaces.
+
+
+"\s*cat\s*" => The fat cat sat on the concatenation.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Le Plus
+
+Le 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, suivi par la lettre `t` minuscule. Le `t` coïncide par conséquent avec le dernier `t` de la phrase.
+
+
+"c.+t" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Le point d'interrogation
+
+Le meta-caractère `?` rend le caractère précédent optionel. 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 optionelle, suivie par la lettre `h` minuscule, suivie par la lettre `e` minuscule.
+
+
+"[T]he" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/cIg9zm/1)
+
+
+"[T]?he" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Accolades
+
+Dans une expression régulière, les accolades, qui sont aussi appelée quantifieurs, sont utilisées pour spécifier le nombre de fois qu'un
+caractè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
+(caractères dans la gamme de 0 à 9).
+
+
+"[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/juM86s/1)
+
+Nous 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
+la virgule l'expression régulière `[0-9]{3}` signifie: Trouve exactement 3 chiffres.
+
+
+"[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/Gdy4w5/1)
+
+
+"[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Groupement de caractères
+
+Un groupement de caractères est un groupe de sous-schémas qui sont écris dans des parenthèses `(...)`. Nous avions mentionné plus tôt que, dans une expression régulière,
+si 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
+il répète le groupement de caractères entier. Par exemple, l'expression régulière `(ab)*` trouve zéro ou plus de répétitions des caractères "ab".
+Nous 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,
+`g` ou `p`, suivi par le caractère `a`, suivi par le caractère `r`.
+
+
+"(c|g|p)ar" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Alternation
+
+Dans 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,
+nous 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
+est 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
+`(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
+ou le caractère `c` minuscule, suivi par le caractère `a` minuscule, suivit par le caractère `r` minuscule.
+
+
+"(T|t)he|car" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Caractère d'échappement
+
+L'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
+y compris les caractères réservés `{ } [ ] / \ + * . $ ^ | ?`. Pour utiliser un caractère spécial comme caractère à trouver, préfixer `\` avant celui-ci.
+Par 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 string
+l'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
+`t` minuscule, suivie par le caractère optionnel `.`.
+
+
+"(f|c|m)at\.?" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Ancres
+
+Dans les expressions régulières, nous utilisons des ancres pour vérifier si le symbole trouvé est le premier ou dernier symbole de la
+string. Il y a 2 types d'ancres: Le premier type est le circonflexe `^` qui cherche si le caractère est le premier
+caractère de la string et le deuxième type est le Dollar `$` qui vérifie si le caractère est le dernier caractère de la string.
+
+### 2.8.1 Circonflexe
+
+Le symbole circonflexe `^` est utilisé pour vérifier si un caractère est le premier caractère de la string. Si nous appliquons l'expression régulière
+suivante `^a` (si a est le premier symbole) à la string `abc`, ça coïncide. Mais si nous appliquons l'expression régulière `^b` sur cette même string,
+ça ne coïncide pas. Parce que dans la string `abc` "b" n'est pas le premier symbole. Regardons une autre expression régulière
+`^(T|t)he` qui signifie: le caractère `T` majuscule ou le caractère `t` minuscule est le premier symbole de la string,
+suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.
+
+
+"(T|t)he" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/5ljjgB/1)
+
+
+"^(T|t)he" => The car is parked in the garage.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dollar
+
+Le symbole Dollar `$` est utilisé pour vérifier si un caractère est le dernier caractère d'une string. Par exemple, l'expression régulière
+`(at\.)$` signifie: un caractère `a` minuscule, suivi par un caractère `t` minuscule, suivi par un caractère `.` et tout cela doit être
+à la fin de la string.
+
+
+"(at\.)" => The fat cat. sat. on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/y4Au4D/1)
+
+
+"(at\.)$" => The fat cat. sat. on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/t0AkOd/1)
+
+##  3. Liste de caractères abrégés
+
+Les expressions régulières fournissent des abréviations pour les listes de caractères, ce qui offres des raccourcis pratiques pour
+les expressions régulières souvent utilisées. Ces abréviations sont les suivantes:
+
+|Abréviation|Description|
+|:----:|----|
+|.|N'importe quel caractère à part le retour de ligne|
+|\w|Caractères alphanumériques: `[a-zA-Z0-9_]`|
+|\W|Caractères non-alphanumériques: `[^\w]`|
+|\d|Chiffres: `[0-9]`|
+|\D|Non-numériques: `[^\d]`|
+|\s|Espace vide: `[\t\n\f\r\p{Z}]`|
+|\S|Tout sauf espace vide: `[^\s]`|
+
+## 4. Recherche
+
+La 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
+pour 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
+par un autre schéma. Par exemple, nous voulons tous les chiffres qui sont précédés par le caractère `$` dans la string suivante `$4.44 and $10.88`.
+Nous 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
+par le caractère `$`. Les recherches que nous trouvons dans les expressions régulières sont les suivantes:
+
+|Symbole|Description|
+|:----:|----|
+|?=|Recherche en avant positive|
+|?!|Recherche en avant négative|
+|?<=|Recherche en arrière positive|
+|?
+"[T|t]he(?=\sfat)" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Recherche en avant négative
+
+La recherche en avant négative est utilisée quand nous avons besoin de trouver une string qui n'est pas suivie d'un schéma. La recherche en avant négative
+est 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 égual `=` nous utilisons le caractère de négation `!`
+i.e. `(?!...)`. Regardons l'expression régulière suivante `[T|t]he(?!\sfat)` qui signifie: trouve tous les mots `The` ou `the` de la string
+qui ne sont pas suivis du mot `fat` précédé d'un espace.
+
+
+"[T|t]he(?!\sfat)" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Recherche en arrière positive
+
+La recherche en arrière positive est utilisée pour trouver une string précédée d'un schéma. La recherche en arrière positive se note
+`(?<=...)`. Par exemple, l'expression régulière `(?<=[T|t]he\s)(fat|mat)` signifie: trouve tous les mots `fat` ou `mat` de la string qui
+se trouve après le mot `The` ou `the`.
+
+
+"(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
+

+
+[Essayer l'expression régulière](https://regex101.com/r/avH165/1)
+
+### 4.4 Recherche en arrière négative
+
+La recherche en arrière négative est utilisée pour trouver une string qui n'est pas précédée d'un schéma. La recherche en arrière négative se note
+`(?
+"(?<![T|t]he\s)(cat)" => The cat sat on cat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/8Efx5G/1) + +## 5. Drapeaux + +Les drapeaux sont aussi appelés modifieurs car ils modifient la sortie d'une expression régulière. Ces drapeaux peuvent être utilisés +dans n'importe quel ordre et combinaison et font partie intégrante de la RegExp. + +|Drapeau|Description| +|:----:|----| +|i|Insensible à la casse: Définit que la correspondance sera insensible à la casse.| +|g|Recherche globale: Recherche la correspondance dans la string entière.| +|m|Multiligne: Meta-caractère ancre qui agit sur toutes les lignes.| + +### 5.1 Insensible à la casse + +Le modifieur `i` est utilisé pour faire une correspondance insensible à la casse. Par exemple, l'expression régulière `/The/gi` signifie: la lettre +`T` majuscule, suivie par le caractère `h` minscule, suivi par le caractère `e` minuscule. Et à la fin de l'expression régulière, le drapeau `i` dit au +moteur 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 +la string entière. + +
+"The" => The fat cat sat on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/dpQyf9/1) + +
+"/The/gi" => The fat cat sat on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/ahfiuh/1) + +### 5.2 Correspondance globale + +Le modifieur `g` est utilisé pour faire une recherche globale (trouver toutes les strings plutôt que de s'arrêter à la première correspondance ). Par exemple, +l'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 +`t` minuscule. Grâce au drapeau `g` à la fin de l'expression régulière maintenant il trouvera toutes les correspondances de toute la string. + +
+"/.(at)/" => The fat cat sat on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/jnk6gM/1) + +
+"/.(at)/g" => The fat cat sat on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/dO1nef/1) + +### 5.3 Multilignes + +Le 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 +se trouve au début ou à la fin de la string. Mais si nous voulons que l'ancre soit sur chaque ligne nous utilisons le drapeau `m`. Par exemple, l'expression régulière +`/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. +Grâce au drapeau `m` maintenant le moteur d'expression régulière trouve le schéma à chaque début de ligne dans la string. + +
+"/.at(.)?$/" => The fat
+                cat sat
+                on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/hoGMkP/1) + +
+"/.at(.)?$/gm" => The fat
+                  cat sat
+                  on the mat.
+
+ +[Essayer l'expression régulière](https://regex101.com/r/E88WE2/1) + +## Contribution + +* Signaler les problèmes (issues) +* Ouvrir des "pull requests" pour les améliorations +* Parlez-en autour de vous ! +* Contactez moi en anglais à ziishaned@gmail.com ou [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned) + +## License + +MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com) diff --git a/README-ja.md b/README-ja.md index 523928ea..bdce2acc 100644 --- a/README-ja.md +++ b/README-ja.md @@ -6,7 +6,8 @@ ## 翻訳 * [English](README.md) -* [Español](README-es.md) +* [Español](README-es.md) +* [Français](README-fr.md) * [中文版](README-cn.md) * [日本語](README-ja.md) diff --git a/README.md b/README.md index ece50f70..7a05ff3b 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,8 @@ ## Translations: * [English](README.md) -* [Español](README-es.md) +* [Español](README-es.md) +* [Français](README-fr.md) * [中文版](README-cn.md) * [日本語](README-ja.md) @@ -260,6 +261,7 @@ or lowercase character `c`, followed by lowercase character `a`, followed by low Backslash `\` is used in regular expression to escape the next character. This allows us to specify a symbol as a matching character including reserved characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching character prepend `\` before it. + For example, the regular expression `.` is used to match any character except newline. Now to match `.` in an input string the regular expression `(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase character `a`, followed by lowercase letter `t`, followed by optional `.` character. From 4b641cd11de81057d9f5213766839d296b5c0a85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicolas=20Borbo=C3=ABn?= Date: Sat, 19 Aug 2017 01:59:19 +0200 Subject: [PATCH 006/185] RegExp image in french, typo corrected (#67) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Some typo corrected * Typographics rules (as space before :) * égual - égal --- README-fr.md | 86 ++++++++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/README-fr.md b/README-fr.md index 931abd1b..729e2dda 100644 --- a/README-fr.md +++ b/README-fr.md @@ -24,7 +24,7 @@ le pseudonyme à contenir des lettres, des nombres, des underscores et des trait de caractères dans le pseudonyme pour qu'il n'ait pas l'air moche. Nous utilisons l'expression régulière suivante pour valider un pseudonyme:

-Regular expression +Expression régulière

L'expression régulière ci-dessus peut accepter les strings `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car @@ -62,7 +62,7 @@ cette string contient une lettre majuscule et elle est trop courte. ## 1. Introduction Une expression régulière est un schéma de caractères utilisés pour effectuer une recherche dans un text. -Par exemple, l'expression régulière `the` signifie: la lettre `t`, suivie de la lettre `h`, suivie de la lettre `e`. +Par exemple, l'expression régulière `the` signifie : la lettre `t`, suivie de la lettre `h`, suivie de la lettre `e`. 
 "the" => The fat cat sat on the mat.
@@ -70,7 +70,7 @@ Par exemple, l'expression régulière `the` signifie: la lettre `t`, suivie de l
 
 [Essayer l'expression régulière](https://regex101.com/r/dmRygT/1)
 
-L'expression régulière `123` coïncide à la chaîne `123`. Chaque caractère de l'expression régulière est comparée à la chaine 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 chaine de caractère `the`.
+L'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`.
 
 
 "The" => The fat cat sat on the mat.
@@ -100,7 +100,7 @@ Significations des meta-caractères:
 
 ## 2.1 Full stop
 
-Le 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`.
+Le 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`.
 
 
 ".ar" => The car parked in the garage.
@@ -110,7 +110,7 @@ Le full stop `.` est l'exemple le plus simple d'un meta-caratère. Le `.` coïnc
 
 ## 2.2 Inclusions de caractères
 
-Les 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` minucule, suivi par la lettre `h`, suivie par la lettre `e`.
+Les 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, suivi par la lettre `h`, suivie par la lettre `e`.
 
 
 "[Tt]he" => The car parked in the garage.
@@ -118,7 +118,7 @@ Les inclusions de caractères sont également appelées classes de caractères.
 
 [Essayer l'expression régulière](https://regex101.com/r/2ITLQ4/1)
 
-L'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, suvie par un `.` (point).
+L'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).
 
 
 "ar[.]" => A garage is a good place to park a car.
@@ -128,7 +128,7 @@ L'utilisation du point dans une inclusion de caractère signifie toutefois un `.
 
 ### 2.2.1 Exclusion de caractères
 
-En règle générale, le caractère circonflexe représente le début d'une chaîne de caractères. Néanmoins, lorsqu'il est utilisé après le crochet ouvrant, il permet d'exclure la gamme de caractère(s). 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`.
+En règle générale, le caractère circonflexe représente le début d'une chaîne de caractères. Néanmoins, lorsqu'il est utilisé après le crochet ouvrant, il permet d'exclure la gamme de caractère(s). 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`.
 
 
 "[^c]ar" => The car parked in the garage.
@@ -143,9 +143,9 @@ différemment selon la situation dans laquelle ils sont utilisés.
 
 ### 2.3.1 Astérisque
 
-Le 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
+Le 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
 du 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.
-Par exemple, l'expression régulière `[a-z]*` signifie: n'importe combien de lettres minuscules.
+Par exemple, l'expression régulière `[a-z]*` signifie : n'importe combien de lettres minuscules.
 
 
 "[a-z]*" => The car parked in the garage #21.
@@ -154,7 +154,7 @@ Par exemple, l'expression régulière `[a-z]*` signifie: n'importe combien de le
 [Essayer l'expression régulière](https://regex101.com/r/7m8me5/1)
 
 Le symbole `*` peut être utilisé avec le meta-caractère `.` pour correspondre à n'importe quelle chaîne de caractères `.*`. Le symbole `*` peut être utilisé avec le
-caractère espace vide `\s` pour correspondre à une chaîne d'espaces vides. Par exemple, l'expression `\s*cat\s*` signifie: zéro ou plus
+caractère espace vide `\s` pour correspondre à une chaîne d'espaces vides. Par exemple, l'expression `\s*cat\s*` signifie : zéro ou plus
 d'espaces, suivis du caractère `c` minuscule, suivi par le caractère `a` minuscule, suivi par le caractère `t` minuscule, suivi par
 zéro ou plus d'espaces.
 
@@ -166,7 +166,7 @@ zéro ou plus d'espaces.
 
 ### 2.3.2 Le Plus
 
-Le 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, suivi par la lettre `t` minuscule. Le `t` coïncide par conséquent avec le dernier `t` de la phrase.
+Le 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, suivi par la lettre `t` minuscule. Le `t` coïncide par conséquent avec le dernier `t` de la phrase.
 
 
 "c.+t" => The fat cat sat on the mat.
@@ -176,7 +176,7 @@ Le meta-caractère `+` correspond à une ou plusieurs répétitions du caractèr
 
 ### 2.3.3 Le point d'interrogation
 
-Le meta-caractère `?` rend le caractère précédent optionel. 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 optionelle, suivie par la lettre `h` minuscule, suivie par la lettre `e` minuscule.
+Le 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.
 
 
 "[T]he" => The car is parked in the garage.
@@ -193,7 +193,7 @@ Le meta-caractère `?` rend le caractère précédent optionel. Ce symbole perme
 ## 2.4 Accolades
 
 Dans une expression régulière, les accolades, qui sont aussi appelée quantifieurs, sont utilisées pour spécifier le nombre de fois qu'un
-caractè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
+caractè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
 (caractères dans la gamme de 0 à 9).
 
 
@@ -202,8 +202,8 @@ caractère ou un groupe de caractères peut être répété. Par exemple, l'expr
 
 [Essayer l'expression régulière](https://regex101.com/r/juM86s/1)
 
-Nous 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
-la virgule l'expression régulière `[0-9]{3}` signifie: Trouve exactement 3 chiffres.
+Nous 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
+la virgule l'expression régulière `[0-9]{3}` signifie : trouve exactement 3 chiffres.
 
 
 "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -219,10 +219,10 @@ la virgule l'expression régulière `[0-9]{3}` signifie: Trouve exactement 3 chi
 
 ## 2.5 Groupement de caractères
 
-Un groupement de caractères est un groupe de sous-schémas qui sont écris dans des parenthèses `(...)`. Nous avions mentionné plus tôt que, dans une expression régulière,
+Un groupement de caractères est un groupe de sous-schémas qui sont écrits dans des parenthèses `(...)`. Nous avions mentionné plus tôt que, dans une expression régulière,
 si 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
 il répète le groupement de caractères entier. Par exemple, l'expression régulière `(ab)*` trouve zéro ou plus de répétitions des caractères "ab".
-Nous 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,
+Nous 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,
 `g` ou `p`, suivi par le caractère `a`, suivi par le caractère `r`.
 
 
@@ -236,7 +236,7 @@ Nous pouvons aussi utiliser le meta-caractère d'alternation `|` à l'intérieur
 Dans 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,
 nous 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
 est 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
-`(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
+`(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
 ou le caractère `c` minuscule, suivi par le caractère `a` minuscule, suivit par le caractère `r` minuscule.
 
 
@@ -250,7 +250,7 @@ ou le caractère `c` minuscule, suivi par le caractère `a` minuscule, suivit pa
 L'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
 y compris les caractères réservés `{ } [ ] / \ + * . $ ^ | ?`. Pour utiliser un caractère spécial comme caractère à trouver, préfixer `\` avant celui-ci.
 Par 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 string
-l'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
+l'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
 `t` minuscule, suivie par le caractère optionnel `.`.
 
 
@@ -262,7 +262,7 @@ l'expression régulière `(f|c|m)at\.?` signifie: la lettre minuscule `f`, `c` o
 ## 2.8 Ancres
 
 Dans les expressions régulières, nous utilisons des ancres pour vérifier si le symbole trouvé est le premier ou dernier symbole de la
-string. Il y a 2 types d'ancres: Le premier type est le circonflexe `^` qui cherche si le caractère est le premier
+string. Il y a 2 types d'ancres : Le premier type est le circonflexe `^` qui cherche si le caractère est le premier
 caractère de la string et le deuxième type est le Dollar `$` qui vérifie si le caractère est le dernier caractère de la string.
 
 ### 2.8.1 Circonflexe
@@ -270,7 +270,7 @@ caractère de la string et le deuxième type est le Dollar `$` qui vérifie si l
 Le symbole circonflexe `^` est utilisé pour vérifier si un caractère est le premier caractère de la string. Si nous appliquons l'expression régulière
 suivante `^a` (si a est le premier symbole) à la string `abc`, ça coïncide. Mais si nous appliquons l'expression régulière `^b` sur cette même string,
 ça ne coïncide pas. Parce que dans la string `abc` "b" n'est pas le premier symbole. Regardons une autre expression régulière
-`^(T|t)he` qui signifie: le caractère `T` majuscule ou le caractère `t` minuscule est le premier symbole de la string,
+`^(T|t)he` qui signifie : le caractère `T` majuscule ou le caractère `t` minuscule est le premier symbole de la string,
 suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.
 
 
@@ -288,7 +288,7 @@ suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.
 ### 2.8.2 Dollar
 
 Le symbole Dollar `$` est utilisé pour vérifier si un caractère est le dernier caractère d'une string. Par exemple, l'expression régulière
-`(at\.)$` signifie: un caractère `a` minuscule, suivi par un caractère `t` minuscule, suivi par un caractère `.` et tout cela doit être
+`(at\.)$` signifie : un caractère `a` minuscule, suivi par un caractère `t` minuscule, suivi par un caractère `.` et tout cela doit être
 à la fin de la string.
 
 
@@ -306,24 +306,24 @@ Le symbole Dollar `$` est utilisé pour vérifier si un caractère est le dernie
 ##  3. Liste de caractères abrégés
 
 Les expressions régulières fournissent des abréviations pour les listes de caractères, ce qui offres des raccourcis pratiques pour
-les expressions régulières souvent utilisées. Ces abréviations sont les suivantes:
+les expressions régulières souvent utilisées. Ces abréviations sont les suivantes :
 
 |Abréviation|Description|
 |:----:|----|
 |.|N'importe quel caractère à part le retour de ligne|
-|\w|Caractères alphanumériques: `[a-zA-Z0-9_]`|
-|\W|Caractères non-alphanumériques: `[^\w]`|
-|\d|Chiffres: `[0-9]`|
-|\D|Non-numériques: `[^\d]`|
-|\s|Espace vide: `[\t\n\f\r\p{Z}]`|
-|\S|Tout sauf espace vide: `[^\s]`|
+|\w|Caractères alphanumériques : `[a-zA-Z0-9_]`|
+|\W|Caractères non-alphanumériques : `[^\w]`|
+|\d|Chiffres : `[0-9]`|
+|\D|Non-numériques : `[^\d]`|
+|\s|Espace vide : `[\t\n\f\r\p{Z}]`|
+|\S|Tout sauf espace vide : `[^\s]`|
 
 ## 4. Recherche
 
 La 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
 pour 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
 par un autre schéma. Par exemple, nous voulons tous les chiffres qui sont précédés par le caractère `$` dans la string suivante `$4.44 and $10.88`.
-Nous 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
+Nous 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
 par le caractère `$`. Les recherches que nous trouvons dans les expressions régulières sont les suivantes:
 
 |Symbole|Description|
@@ -337,8 +337,8 @@ par le caractère `$`. Les recherches que nous trouvons dans les expressions ré
 
 La recherche en avant assure que la première partie de l'expression soit suivie par l'expression recherchée. La valeur retournée
 contient uniquement le texte qui correspond à la première partie de l'expression. Pour définir une recherche en avant positive, on utilise
-des parenthèses. Entre ces parenthèses, un point d'interrogation avec un signe égual est utilisé comme ça: `(?=...)`. L'expression de recherche
-est écrite après le signe égual dans les parenthèses. Par exemple, l'expression régulière `[T|t]he(?=\sfat)` signifie: trouve optionnellement
+des parenthèses. Entre ces parenthèses, un point d'interrogation avec un signe égal est utilisé comme cela : `(?=...)`. L'expression de recherche
+est écrite après le signe égal dans les parenthèses. Par exemple, l'expression régulière `[T|t]he(?=\sfat)` signifie : trouve optionnellement
 la lettre `t` minuscule ou la lettre `T` majuscule, suivie par la lettre `h` minuscule, suivie par la lettre `e`. Entre parenthèses nous définissons
 la recherche en avant positive qui dit quelle est l'expression à chercher. `The` ou `the` qui sont suivies par le mot `fat` précédé d'un espace.
 
@@ -351,8 +351,8 @@ la recherche en avant positive qui dit quelle est l'expression à chercher. `The
 ### 4.2 Recherche en avant négative
 
 La recherche en avant négative est utilisée quand nous avons besoin de trouver une string qui n'est pas suivie d'un schéma. La recherche en avant négative
-est 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 égual `=` nous utilisons le caractère de négation `!`
-i.e. `(?!...)`. Regardons l'expression régulière suivante `[T|t]he(?!\sfat)` qui signifie: trouve tous les mots `The` ou `the` de la string
+est 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 `!`
+i.e. `(?!...)`. Regardons l'expression régulière suivante `[T|t]he(?!\sfat)` qui signifie : trouve tous les mots `The` ou `the` de la string
 qui ne sont pas suivis du mot `fat` précédé d'un espace.
 
 
@@ -364,7 +364,7 @@ qui ne sont pas suivis du mot `fat` précédé d'un espace.
 ### 4.3 Recherche en arrière positive
 
 La recherche en arrière positive est utilisée pour trouver une string précédée d'un schéma. La recherche en arrière positive se note
-`(?<=...)`. Par exemple, l'expression régulière `(?<=[T|t]he\s)(fat|mat)` signifie: trouve tous les mots `fat` ou `mat` de la string qui
+`(?<=...)`. Par exemple, l'expression régulière `(?<=[T|t]he\s)(fat|mat)` signifie : trouve tous les mots `fat` ou `mat` de la string qui
 se trouve après le mot `The` ou `the`.
 
 
@@ -376,7 +376,7 @@ se trouve après le mot `The` ou `the`.
 ### 4.4 Recherche en arrière négative
 
 La recherche en arrière négative est utilisée pour trouver une string qui n'est pas précédée d'un schéma. La recherche en arrière négative se note
-`(?
@@ -392,14 +392,14 @@ dans n'importe quel ordre et combinaison et font partie intégrante de la RegExp
 
 |Drapeau|Description|
 |:----:|----|
-|i|Insensible à la casse: Définit que la correspondance sera insensible à la casse.|
-|g|Recherche globale: Recherche la correspondance dans la string entière.|
-|m|Multiligne: Meta-caractère ancre qui agit sur toutes les lignes.|
+|i|Insensible à la casse : Définit que la correspondance sera insensible à la casse.|
+|g|Recherche globale : Recherche la correspondance dans la string entière.|
+|m|Multiligne : Meta-caractère ancre qui agit sur toutes les lignes.|
 
 ### 5.1 Insensible à la casse
 
-Le modifieur `i` est utilisé pour faire une correspondance insensible à la casse. Par exemple, l'expression régulière `/The/gi` signifie: la lettre
-`T` majuscule, suivie par le caractère `h` minscule, suivi par le caractère `e` minuscule. Et à la fin de l'expression régulière, le drapeau `i` dit au
+Le modifieur `i` est utilisé pour faire une correspondance insensible à la casse. Par exemple, l'expression régulière `/The/gi` signifie : la lettre
+`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
 moteur 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
 la string entière.
 
@@ -418,7 +418,7 @@ la string entière.
 ### 5.2 Correspondance globale
 
 Le modifieur `g` est utilisé pour faire une recherche globale (trouver toutes les strings plutôt que de s'arrêter à la première correspondance ). Par exemple,
-l'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
+l'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
 `t` minuscule. Grâce au drapeau `g` à la fin de l'expression régulière maintenant il trouvera toutes les correspondances de toute la string.
 
 
@@ -437,7 +437,7 @@ l'expression régulière `/.(at)/g` signifie: n'importe quel caractère sauf le
 
 Le 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
 se trouve au début ou à la fin de la string. Mais si nous voulons que l'ancre soit sur chaque ligne nous utilisons le drapeau `m`. Par exemple, l'expression régulière
-`/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.
+`/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.
 Grâce au drapeau `m` maintenant le moteur d'expression régulière trouve le schéma à chaque début de ligne dans la string.
 
 

From 9968a235b6bc12b95fbfe3fb9a09a4daf7bcdae5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicolas=20Borbo=C3=ABn?=
 
Date: Sat, 19 Aug 2017 11:15:19 +0200
Subject: [PATCH 007/185] Homogenized images (#69)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* RegExp image for French plus

* Some typo corrected
* Typographics rules (as space before :)
* égual - égal

* Images folder added, img src updated

* § formatted to 80 lines
---
 README-es.md         |   2 +-
 README-fr.md         |   2 +-
 README-ja.md         |   2 +-
 README.md            | 282 ++++++++++++++++++------------
 img/img_original.png | Bin 0 -> 6634 bytes
 img/regexp-en.png    | Bin 0 -> 32144 bytes
 img/regexp-es.png    | Bin 0 -> 34234 bytes
 img/regexp-fr.png    | Bin 0 -> 32922 bytes
 img/regexp.svg       | 397 +++++++++++++++++++++++++++++++++++++++++++
 9 files changed, 573 insertions(+), 112 deletions(-)
 create mode 100644 img/img_original.png
 create mode 100644 img/regexp-en.png
 create mode 100644 img/regexp-es.png
 create mode 100644 img/regexp-fr.png
 create mode 100644 img/regexp.svg

diff --git a/README-es.md b/README-es.md
index 6988406c..82ec6f66 100644
--- a/README-es.md
+++ b/README-es.md
@@ -21,7 +21,7 @@ Imagina que estas escribiendo una aplicación y quieres agregar reglas para cuan
 
 


 

-Regular expression
+  Expresión regular
 

 
 De la expresión regular anterior, se puede aceptar las cadenas 'john_doe', 'jo-hn_doe' y 'john12_as'. La expresión no coincide con el nombre de usuario 'Jo', porque es una cadena de caracteres que contiene letras mayúsculas y es demasiado corta.
diff --git a/README-fr.md b/README-fr.md
index 729e2dda..126ca62b 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -24,7 +24,7 @@ le pseudonyme à contenir des lettres, des nombres, des underscores et des trait
 de caractères dans le pseudonyme pour qu'il n'ait pas l'air moche. Nous utilisons l'expression régulière suivante pour valider un pseudonyme:
 


 

-Expression régulière
+  Expressions régulières
 

 
 L'expression régulière ci-dessus peut accepter les strings `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car
diff --git a/README-ja.md b/README-ja.md
index bdce2acc..8fb870b2 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -27,7 +27,7 @@
 
 


 

-Regular expression
+  Regular expression
 

 
 この正規表現によって `john_doe, jo-hn_doe, john12_as` などは許容されることになります。
diff --git a/README.md b/README.md
index 7a05ff3b..823ce08c 100644
--- a/README.md
+++ b/README.md
@@ -15,20 +15,26 @@
 
 > Regular expression is a group of characters or symbols which is used to find a specific pattern from a text.
 
-A regular expression is a pattern that is matched against a subject string from left to right. The word "Regular expression" is a
-mouthful, you will usually find the term abbreviated as "regex" or "regexp". Regular expression is used for replacing a text within
-a string, validating form, extract a substring from a string based upon a pattern match, and so much more.
+A regular expression is a pattern that is matched against a subject string from
+left to right. The word "Regular expression" is a mouthful, you will usually
+find the term abbreviated as "regex" or "regexp". Regular expression is used for
+replacing a text within a string, validating form, extract a substring from a
+string based upon a pattern match, and so much more.
+
+Imagine you are writing an application and you want to set the rules for when a
+user chooses their username. We want to allow the username to contain letters,
+numbers, underscores and hyphens. We also want to limit the number of characters
+in username so it does not look ugly. We use the following regular expression to
+validate a username:
 
-Imagine you are writing an application and you want to set the rules for when a user chooses their username. We want to
-allow the username to contain letters, numbers, underscores and hyphens. We also want to limit the number of
-characters in username so it does not look ugly. We use the following regular expression to validate a username:
 


 

-Regular expression
+  Regular expression
 

 
-Above regular expression can accept the strings `john_doe`, `jo-hn_doe` and `john12_as`. It does not match `Jo` because that string
-contains uppercase letter and also it is too short.  
+Above regular expression can accept the strings `john_doe`, `jo-hn_doe` and
+`john12_as`. It does not match `Jo` because that string contains uppercase
+letter and also it is too short.
 
 ## Table of Contents
 
@@ -61,8 +67,9 @@ contains uppercase letter and also it is too short.
 
 ## 1. Basic Matchers
 
-A regular expression is just a pattern of characters that we use to perform search in a text.  For example, the regular expression
-`the` means: the letter `t`, followed by the letter `h`, followed by the letter `e`.
+A regular expression is just a pattern of characters that we use to perform
+search in a text.  For example, the regular expression `the` means: the letter
+`t`, followed by the letter `h`, followed by the letter `e`.
 
 
 "the" => The fat cat sat on the mat.
@@ -70,9 +77,11 @@ A regular expression is just a pattern of characters that we use to perform sear
 
 [Test the regular expression](https://regex101.com/r/dmRygT/1)
 
-The regular expression `123` matches the string `123`. The regular expression is matched against an input string by comparing each
-character in the regular expression to each character in the input string, one after another. Regular expressions are normally
-case-sensitive so the regular expression `The` would not match the string `the`.
+The regular expression `123` matches the string `123`. The regular expression is
+matched against an input string by comparing each character in the regular
+expression to each character in the input string, one after another. Regular
+expressions are normally case-sensitive so the regular expression `The` would
+not match the string `the`.
 
 
 "The" => The fat cat sat on the mat.
@@ -82,9 +91,10 @@ case-sensitive so the regular expression `The` would not match the string `the`.
 
 ## 2. Meta Characters
 
-Meta characters are the building blocks of the regular expressions.  Meta characters do not stand for themselves but instead are
-interpreted in some special way. Some meta characters have a special meaning and are written inside square brackets.
-The meta characters are as follows:
+Meta characters are the building blocks of the regular expressions.  Meta
+characters do not stand for themselves but instead are interpreted in some
+special way. Some meta characters have a special meaning and are written inside
+square brackets. The meta characters are as follows:
 
 |Meta character|Description|
 |:----:|----|
@@ -103,9 +113,10 @@ The meta characters are as follows:
 
 ## 2.1 Full stop
 
-Full stop `.` is the simplest example of meta character. The meta character `.` matches any single character. It will not match return 
-or newline characters. For example, the regular expression `.ar` means: any character, followed by the letter `a`, followed by the 
-letter `r`.
+Full stop `.` is the simplest example of meta character. The meta character `.`
+matches any single character. It will not match return or newline characters.
+For example, the regular expression `.ar` means: any character, followed by the
+letter `a`, followed by the letter `r`.
 
 
 ".ar" => The car parked in the garage.
@@ -115,9 +126,11 @@ letter `r`.
 
 ## 2.2 Character set
 
-Character sets are also called character class. Square brackets are used to specify character sets. Use a hyphen inside a character set to
-specify the characters' range. The order of the character range inside square brackets doesn't matter. For example, the regular
-expression `[Tt]he` means: an uppercase `T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+Character sets are also called character class. Square brackets are used to
+specify character sets. Use a hyphen inside a character set to specify the
+characters' range. The order of the character range inside square brackets
+doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
+`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
 
 
 "[Tt]he" => The car parked in the garage.
@@ -125,7 +138,9 @@ expression `[Tt]he` means: an uppercase `T` or lowercase `t`, followed by the le
 
 [Test the regular expression](https://regex101.com/r/2ITLQ4/1)
 
-A period inside a character set, however, means a literal period. The regular expression `ar[.]` means: a lowercase character `a`, followed by letter `r`, followed by a period `.` character.
+A period inside a character set, however, means a literal period. The regular
+expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
+followed by a period `.` character.
 
 
 "ar[.]" => A garage is a good place to park a car.
@@ -135,9 +150,10 @@ A period inside a character set, however, means a literal period. The regular ex
 
 ### 2.2.1 Negated character set
 
-In general, the caret symbol represents the start of the string, but when it is typed after the opening square bracket it negates the
-character set. For example, the regular expression `[^c]ar` means: any character except `c`, followed by the character `a`, followed by
-the letter `r`.
+In general, the caret symbol represents the start of the string, but when it is
+typed after the opening square bracket it negates the character set. For
+example, the regular expression `[^c]ar` means: any character except `c`,
+followed by the character `a`, followed by the letter `r`.
 
 
 "[^c]ar" => The car parked in the garage.
@@ -147,14 +163,17 @@ the letter `r`.
 
 ## 2.3 Repetitions
 
-Following meta characters `+`, `*` or `?` are used to specify how many times a subpattern can occur. These meta characters act
-differently in different situations.
+Following meta characters `+`, `*` or `?` are used to specify how many times a
+subpattern can occur. These meta characters act differently in different
+situations.
 
 ### 2.3.1 The Star
 
-The symbol `*` matches zero or more repetitions of the preceding matcher. The regular expression `a*` means: zero or more repetitions
-of preceding lowercase character `a`. But if it appears after a character set or class then it finds the repetitions of the whole
-character set. For example, the regular expression `[a-z]*` means: any number of lowercase letters in a row.
+The symbol `*` matches zero or more repetitions of the preceding matcher. The
+regular expression `a*` means: zero or more repetitions of preceding lowercase
+character `a`. But if it appears after a character set or class then it finds
+the repetitions of the whole character set. For example, the regular expression
+`[a-z]*` means: any number of lowercase letters in a row.
 
 
 "[a-z]*" => The car parked in the garage #21.
@@ -162,10 +181,12 @@ character set. For example, the regular expression `[a-z]*` means: any number of
 
 [Test the regular expression](https://regex101.com/r/7m8me5/1)
 
-The `*` symbol can be used with the meta character `.` to match any string of characters `.*`. The `*` symbol can be used with the
-whitespace character `\s` to match a string of whitespace characters. For example, the expression `\s*cat\s*` means: zero or more
-spaces, followed by lowercase character `c`, followed by lowercase character `a`, followed by lowercase character `t`, followed by
-zero or more spaces.
+The `*` symbol can be used with the meta character `.` to match any string of
+characters `.*`. The `*` symbol can be used with the whitespace character `\s`
+to match a string of whitespace characters. For example, the expression
+`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
+followed by lowercase character `a`, followed by lowercase character `t`,
+followed by zero or more spaces.
 
 
 "\s*cat\s*" => The fat cat sat on the concatenation.
@@ -175,8 +196,10 @@ zero or more spaces.
 
 ### 2.3.2 The Plus
 
-The symbol `+` matches one or more repetitions of the preceding character. For example, the regular expression `c.+t` means: lowercase
-letter `c`, followed by at least one character, followed by the lowercase character `t`. It needs to be clarified that `t` is the last `t` in the sentence.
+The symbol `+` matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+at least one character, followed by the lowercase character `t`. It needs to be
+clarified that `t` is the last `t` in the sentence.
 
 
 "c.+t" => The fat cat sat on the mat.
@@ -186,9 +209,11 @@ letter `c`, followed by at least one character, followed by the lowercase charac
 
 ### 2.3.3 The Question Mark
 
-In regular expression the meta character `?` makes the preceding character optional. This symbol matches zero or one instance of
-the preceding character. For example, the regular expression `[T]?he` means: Optional the uppercase letter `T`, followed by the lowercase
-character `h`, followed by the lowercase character `e`.
+In regular expression the meta character `?` makes the preceding character
+optional. This symbol matches zero or one instance of the preceding character.
+For example, the regular expression `[T]?he` means: Optional the uppercase
+letter `T`, followed by the lowercase character `h`, followed by the lowercase
+character `e`.
 
 
 "[T]he" => The car is parked in the garage.
@@ -204,9 +229,10 @@ character `h`, followed by the lowercase character `e`.
 
 ## 2.4 Braces
 
-In  regular expression braces that are also called quantifiers are used to specify the number of times that a
-character or a group of characters can be repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least 2 digits but not more than 3 (
-characters in the range of 0 to 9).
+In regular expression braces that are also called quantifiers are used to
+specify the number of times that a character or a group of characters can be
+repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
+2 digits but not more than 3 ( characters in the range of 0 to 9).
 
 
 "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -214,8 +240,9 @@ characters in the range of 0 to 9).
 
 [Test the regular expression](https://regex101.com/r/juM86s/1)
 
-We can leave out the second number. For example, the regular expression `[0-9]{2,}` means: Match 2 or more digits. If we also remove
-the comma the regular expression `[0-9]{3}` means: Match exactly 3 digits.
+We can leave out the second number. For example, the regular expression
+`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
+regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 
 "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -231,10 +258,13 @@ the comma the regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 ## 2.5 Character Group
 
-Character group is a group of sub-patterns that is written inside Parentheses `(...)`. As we discussed before that in regular expression
-if we put a quantifier after a character then it will repeat the preceding character. But if we put quantifier after a character group then
-it repeats the whole character group. For example, the regular expression `(ab)*` matches zero or more repetitions of the character "ab".
-We can also use the alternation `|` meta character inside character group. For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+Character group is a group of sub-patterns that is written inside Parentheses `(...)`.
+As we discussed before that in regular expression if we put a quantifier after a
+character then it will repeat the preceding character. But if we put quantifier
+after a character group then it repeats the whole character group. For example,
+the regular expression `(ab)*` matches zero or more repetitions of the character
+"ab". We can also use the alternation `|` meta character inside character group.
+For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
 `g` or `p`, followed by character `a`, followed by character `r`.
 
 
@@ -245,11 +275,15 @@ We can also use the alternation `|` meta character inside character group. For e
 
 ## 2.6 Alternation
 
-In regular expression Vertical bar `|` is used to define alternation. Alternation is like a condition between multiple expressions. Now,
-you may be thinking that character set and alternation works the same way. But the big difference between character set and alternation
-is that character set works on character level but alternation works on expression level. For example, the regular expression
-`(T|t)he|car` means: uppercase character `T` or lowercase `t`, followed by lowercase character `h`, followed by lowercase character `e`
-or lowercase character `c`, followed by lowercase character `a`, followed by lowercase character `r`.
+In regular expression Vertical bar `|` is used to define alternation.
+Alternation is like a condition between multiple expressions. Now, you may be
+thinking that character set and alternation works the same way. But the big
+difference between character set and alternation is that character set works on
+character level but alternation works on expression level. For example, the
+regular expression `(T|t)he|car` means: uppercase character `T` or lowercase
+`t`, followed by lowercase character `h`, followed by lowercase character `e` or
+lowercase character `c`, followed by lowercase character `a`, followed by
+lowercase character `r`.
 
 
 "(T|t)he|car" => The car is parked in the garage.
@@ -259,12 +293,16 @@ or lowercase character `c`, followed by lowercase character `a`, followed by low
 
 ## 2.7 Escaping special character
 
-Backslash `\` is used in regular expression to escape the next character. This allows us to specify a symbol as a matching character 
-including reserved characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching character prepend `\` before it. 
+Backslash `\` is used in regular expression to escape the next character. This
+allows us to specify a symbol as a matching character including reserved
+characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
+character prepend `\` before it.
 
-For example, the regular expression `.` is used to match any character except newline. Now to match `.` in an input string the regular
-expression `(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase character `a`, followed by lowercase letter 
-`t`, followed by optional `.` character.
+For example, the regular expression `.` is used to match any character except
+newline. Now to match `.` in an input string the regular expression
+`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
+character `a`, followed by lowercase letter `t`, followed by optional `.`
+character.
 
 
 "(f|c|m)at\.?" => The fat cat sat on the mat.
@@ -274,18 +312,22 @@ expression `(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by l
 
 ## 2.8 Anchors
 
-In regular expressions, we use anchors to check if the matching symbol is the starting symbol or ending symbol of the
-input string. Anchors are of two types: First type is Caret `^` that check if the matching character is the start
-character of the input and the second type is Dollar `$` that checks if matching character is the last character of the
-input string.
+In regular expressions, we use anchors to check if the matching symbol is the
+starting symbol or ending symbol of the input string. Anchors are of two types:
+First type is Caret `^` that check if the matching character is the start
+character of the input and the second type is Dollar `$` that checks if matching
+character is the last character of the input string.
 
 ### 2.8.1 Caret
 
-Caret `^` symbol is used to check if matching character is the first character of the input string. If we apply the following regular
-expression `^a` (if a is the starting symbol) to input string `abc` it matches `a`. But if we apply regular expression `^b` on above
-input string it does not match anything. Because in input string `abc` "b" is not the starting symbol. Let's take a look at another
-regular expression `^(T|t)he` which means: uppercase character `T` or lowercase character `t` is the start symbol of the input string,
-followed by lowercase character `h`, followed by lowercase character `e`.
+Caret `^` symbol is used to check if matching character is the first character
+of the input string. If we apply the following regular expression `^a` (if a is
+the starting symbol) to input string `abc` it matches `a`. But if we apply
+regular expression `^b` on above input string it does not match anything.
+Because in input string `abc` "b" is not the starting symbol. Let's take a look
+at another regular expression `^(T|t)he` which means: uppercase character `T` or
+lowercase character `t` is the start symbol of the input string, followed by
+lowercase character `h`, followed by lowercase character `e`.
 
 
 "(T|t)he" => The car is parked in the garage.
@@ -301,9 +343,10 @@ followed by lowercase character `h`, followed by lowercase character `e`.
 
 ### 2.8.2 Dollar
 
-Dollar `$` symbol is used to check if matching character is the last character of the input string. For example, regular expression
-`(at\.)$` means: a lowercase character `a`, followed by lowercase character `t`, followed by a `.` character and the matcher
-must be end of the string.
+Dollar `$` symbol is used to check if matching character is the last character
+of the input string. For example, regular expression `(at\.)$` means: a
+lowercase character `a`, followed by lowercase character `t`, followed by a `.`
+character and the matcher must be end of the string.
 
 
 "(at\.)" => The fat cat. sat. on the mat.
@@ -319,8 +362,9 @@ must be end of the string.
 
 ##  3. Shorthand Character Sets
 
-Regular expression provides shorthands for the commonly used character sets, which offer convenient shorthands for commonly used
-regular expressions. The shorthand character sets are as follows:
+Regular expression provides shorthands for the commonly used character sets,
+which offer convenient shorthands for commonly used regular expressions. The
+shorthand character sets are as follows:
 
 |Shorthand|Description|
 |:----:|----|
@@ -334,11 +378,15 @@ regular expressions. The shorthand character sets are as follows:
 
 ## 4. Lookaround
 
-Lookbehind and lookahead sometimes known as lookaround are specific type of ***non-capturing group*** (Use to match the pattern but not
-included in matching list). Lookaheads are used when we have the condition that this pattern is preceded or followed by another certain
-pattern. For example, we want to get all numbers that are preceded by `$` character from the following input string `$4.44 and $10.88`.
-We will use following regular expression `(?<=\$)[0-9\.]*` which means: get all the numbers which contain `.` character and  are preceded
-by `$` character. Following are the lookarounds that are used in regular expressions:
+Lookbehind and lookahead sometimes known as lookaround are specific type of
+***non-capturing group*** (Use to match the pattern but not included in matching
+list). Lookaheads are used when we have the condition that this pattern is
+preceded or followed by another certain pattern. For example, we want to get all
+numbers that are preceded by `$` character from the following input string
+`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
+which means: get all the numbers which contain `.` character and  are preceded
+by `$` character. Following are the lookarounds that are used in regular
+expressions:
 
 |Symbol|Description|
 |:----:|----|
@@ -349,12 +397,16 @@ by `$` character. Following are the lookarounds that are used in regular express
 
 ### 4.1 Positive Lookahead
 
-The positive lookahead asserts that the first part of the expression must be followed by the lookahead expression. The returned match
-only contains the text that is matched by the first part of the expression. To define a positive lookahead, parentheses are used. Within
-those parentheses, a question mark with equal sign is used like this: `(?=...)`. Lookahead expression is written after the equal sign inside
-parentheses. For example, the regular expression `[T|t]he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase letter `T`,
-followed by letter `h`, followed by letter `e`. In parentheses we define positive lookahead which tells regular expression engine to match
-`The` or `the` which are followed by the word `fat`.
+The positive lookahead asserts that the first part of the expression must be
+followed by the lookahead expression. The returned match only contains the text
+that is matched by the first part of the expression. To define a positive
+lookahead, parentheses are used. Within those parentheses, a question mark with
+equal sign is used like this: `(?=...)`. Lookahead expression is written after
+the equal sign inside parentheses. For example, the regular expression
+`[T|t]he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
+letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
+define positive lookahead which tells regular expression engine to match `The`
+or `the` which are followed by the word `fat`.
 
 
 "[T|t]he(?=\sfat)" => The fat cat sat on the mat.
@@ -364,10 +416,13 @@ followed by letter `h`, followed by letter `e`. In parentheses we define positiv
 
 ### 4.2 Negative Lookahead
 
-Negative lookahead is used when we need to get all matches from input string that are not followed by a pattern. Negative lookahead
-defined same as we define positive lookahead but the only difference is instead of equal `=` character we use negation `!` character
-i.e. `(?!...)`. Let's take a look at the following regular expression `[T|t]he(?!\sfat)` which means: get all `The` or `the` words from
-input string that are not followed by the word `fat` precedes by a space character.
+Negative lookahead is used when we need to get all matches from input string
+that are not followed by a pattern. Negative lookahead defined same as we define
+positive lookahead but the only difference is instead of equal `=` character we
+use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+regular expression `[T|t]he(?!\sfat)` which means: get all `The` or `the` words
+from input string that are not followed by the word `fat` precedes by a space
+character.
 
 
 "[T|t]he(?!\sfat)" => The fat cat sat on the mat.
@@ -377,9 +432,10 @@ input string that are not followed by the word `fat` precedes by a space charact
 
 ### 4.3 Positive Lookbehind
 
-Positive lookbehind is used to get all the matches that are preceded by a specific pattern. Positive lookbehind is denoted by
-`(?<=...)`. For example, the regular expression `(?<=[T|t]he\s)(fat|mat)` means: get all `fat` or `mat` words from input string that
-are after the word `The` or `the`.
+Positive lookbehind is used to get all the matches that are preceded by a
+specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
+regular expression `(?<=[T|t]he\s)(fat|mat)` means: get all `fat` or `mat` words
+from input string that are after the word `The` or `the`.
 
 
 "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
@@ -389,9 +445,10 @@ are after the word `The` or `the`.
 
 ### 4.4 Negative Lookbehind
 
-Negative lookbehind is used to get all the matches that are not preceded by a specific pattern. Negative lookbehind is denoted by
-`(?
 "(?<![T|t]he\s)(cat)" => The cat sat on cat.
@@ -401,8 +458,9 @@ are not after the word `The` or `the`.
 
 ## 5. Flags
 
-Flags are also called modifiers because they modify the output of a regular expression. These flags can be used in any order or
-combination, and are an integral part of the RegExp.
+Flags are also called modifiers because they modify the output of a regular
+expression. These flags can be used in any order or combination, and are an
+integral part of the RegExp.
 
 |Flag|Description|
 |:----:|----|
@@ -412,10 +470,12 @@ combination, and are an integral part of the RegExp.
 
 ### 5.1 Case Insensitive
 
-The `i` modifier is used to perform case-insensitive matching. For example, the regular expression `/The/gi` means: uppercase letter
-`T`, followed by lowercase character `h`, followed by character `e`. And at the end of regular expression the `i` flag tells the
-regular expression engine to ignore the case. As you can see we also provided `g` flag because we want to search for the pattern in
-the whole input string.
+The `i` modifier is used to perform case-insensitive matching. For example, the
+regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
+character `h`, followed by character `e`. And at the end of regular expression
+the `i` flag tells the regular expression engine to ignore the case. As you can
+see we also provided `g` flag because we want to search for the pattern in the
+whole input string.
 
 
 "The" => The fat cat sat on the mat.
@@ -431,10 +491,11 @@ the whole input string.
 
 ### 5.2 Global search
 
-The `g` modifier is used to perform a global match (find all matches rather than stopping after the first match). For example, the
-regular expression`/.(at)/g` means: any character except new line, followed by lowercase character `a`, followed by lowercase
-character `t`. Because we provided `g` flag at the end of the regular expression now it will find every matches from whole input
-string.
+The `g` modifier is used to perform a global match (find all matches rather than
+stopping after the first match). For example, the regular expression`/.(at)/g`
+means: any character except new line, followed by lowercase character `a`,
+followed by lowercase character `t`. Because we provided `g` flag at the end of
+the regular expression now it will find every matches from whole input string.
 
 
 "/.(at)/" => The fat cat sat on the mat.
@@ -450,10 +511,13 @@ string.
 
 ### 5.3 Multiline
 
-The `m` modifier is used to perform a multi-line match. As we discussed earlier anchors `(^, $)` are used to check if pattern is
-the beginning of the input or end of the input string. But if we want that anchors works on each line we use `m` flag. For example, the
-regular expression `/at(.)?$/gm` means: lowercase character `a`, followed by lowercase character `t`, optionally anything except new
-line. And because of `m` flag now regular expression engine matches pattern at the end of each line in a string.
+The `m` modifier is used to perform a multi-line match. As we discussed earlier
+anchors `(^, $)` are used to check if pattern is the beginning of the input or
+end of the input string. But if we want that anchors works on each line we use
+`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
+character `a`, followed by lowercase character `t`, optionally anything except
+new line. And because of `m` flag now regular expression engine matches pattern
+at the end of each line in a string.
 
 
 "/.at(.)?$/" => The fat
diff --git a/img/img_original.png b/img/img_original.png
new file mode 100644
index 0000000000000000000000000000000000000000..da1c5fa2ac5822e8bccf3661f0ac720a011fc484
GIT binary patch
literal 6634
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
YOzWi69QwZXSr>J3aIr5xbnfbZ0WEGq1poj5

literal 0
HcmV?d00001

diff --git a/img/regexp-en.png b/img/regexp-en.png
new file mode 100644
index 0000000000000000000000000000000000000000..f2331491b387f1fd9cb7b843fe86893ca7fad475
GIT binary patch
literal 32144
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

literal 0
HcmV?d00001

diff --git a/img/regexp-es.png b/img/regexp-es.png
new file mode 100644
index 0000000000000000000000000000000000000000..3efa6eed322c852ffb7689b108d34aa0a844c76b
GIT binary patch
literal 34234
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ⅲOo}+zjETXvtEYZiOJMqI{EuGG!0^
z9;hWbp;Nf*`(+q)1C^44(yL$?W1AiM3;;0a7rGH*9VRBepaVBpeuEj|L+?#wZONme
z-RFZrquxo9IKg?8C@$_eAa(0~d_*&+Umf7@FB(ATo~Bei@`t&>OgCf+20Y*7?BemB
zGigUt9y`zK2m(d3@q?*pdxA2Gw(GoGQ=j?f=H`}#QJ0^Ti$0rJC2J^tr;a+#b;o`@
zja^axfM~_MXZBY4XV2CpZpg0S;PSAmqS6C7l93_{$_57~7O+y##-4<8mA#Lt#rDjr#8rK=PA3orqKn+Fr0ypml15ow?a^`io_EZTx1ra9*Vy)!ta_3bt3;*?RW>BRYI;dCejT)%00%cIeKBsfK9VddmV{PCT@;P1mt{
z3GUW9@|}c38qFDq~mR*HpX>ApJGPmMQA}kgTevkLJ!17I
zoQp*Shs66#JLgvI{;K~kY0E{SbVD!tumAl&1!Dih)SUkhY1;quZ*CYf%2SJ
R%nHS{Ni!$LjsN-g{{YNvA{YPw

literal 0
HcmV?d00001

diff --git a/img/regexp.svg b/img/regexp.svg
new file mode 100644
index 00000000..f08690b5
--- /dev/null
+++ b/img/regexp.svg
@@ -0,0 +1,397 @@
+
+
+
+
+  regexp
+  
+  
+  
+    
+      
+        image/svg+xml
+        
+        regexp
+        https://github.com/zeeshanu/learn-regex
+        
+          
+            ponsfrilus
+          
+        
+        08.2017
+      
+    
+  
+  
+  
+    
+    
+    
+    
+    
+    
+  
+  
+    asdasda    
+      
+        
+          Start of the line
+          3 to 15 characters long
+          End of the line
+          Letters, numbers, underscores, hypens
+          ^[a-z0-9_-]{3,15]$
+        
+      
+    
+  
+  
+  
+

From 94e262611cd1935615ad6c33d9d88883b621cac2 Mon Sep 17 00:00:00 2001
From: yuhwan 
Date: Sun, 20 Aug 2017 01:05:40 +0900
Subject: [PATCH 008/185] Add Korean(ko) translation (#71)

* Create Korean ReadMe

* Add link to README-ko.md
---
 README-cn.md |   1 +
 README-es.md |   1 +
 README-fr.md |   1 +
 README-ja.md |   1 +
 README-ko.md | 410 +++++++++++++++++++++++++++++++++++++++++++++++++++
 README.md    |   1 +
 6 files changed, 415 insertions(+)
 create mode 100644 README-ko.md

diff --git a/README-cn.md b/README-cn.md
index 57b0b34f..6f233a39 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -10,6 +10,7 @@
 * [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
+* [한국어](README-ko.md)
 
 ## 什么是正则表达式?
 
diff --git a/README-es.md b/README-es.md
index 82ec6f66..52e82a4a 100644
--- a/README-es.md
+++ b/README-es.md
@@ -10,6 +10,7 @@
 * [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
+* [한국어](README-ko.md)
 
 ## What is Regular Expression?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/README-fr.md b/README-fr.md
index 126ca62b..115ab92a 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -10,6 +10,7 @@
 * [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
+* [한국어](README-ko.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/README-ja.md b/README-ja.md
index 8fb870b2..c77d9707 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -10,6 +10,7 @@
 * [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
+* [한국어](README-ko.md)
 
 ## 正規表現とは
 
diff --git a/README-ko.md b/README-ko.md
new file mode 100644
index 00000000..3030c43a
--- /dev/null
+++ b/README-ko.md
@@ -0,0 +1,410 @@
+

+

+Learn Regex
+


+
+## Translations:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+
+## 정규표현식이란 무엇인가?
+
+> 정규표현식은 텍스트에서 특정 패턴을 찾아내는데 사용되는 문자 혹은 기호들의 집합이다.
+
+정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp"로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
+
+당신이 하나의 어플리케이션을 작성하고 있고 사용자가 사용자명을 선택할 때 사용되는 규칙들을 정하고 싶다고 상상해보자. 예를 들어, 우리는 사용자명에 문자, 숫자, 밑줄 문자(\_), 그리고 하이픈이 포함되는것은 허용하고 싶다. 또한, 사용자명의 글자수를 제한해서 사용자명이 지저분해보이지 않도록 하고 싶다. 이때 아래 정규표현식을 사용해 입력된 사용자명이 해당 규칙에 맞는지 검사할 수 있다.
+
+


+

+  Regular expression
+

+
+위의 정규 표현식은 `john_doe`, `jo-hn_doe`, 그리고 `john12_as` 문자열을 받아들일 수 있다. `Jo`는 대문자를 포함하고 있고 길이가 너무 짧기 때문에 위의 정규표현식과 매칭되지 않는다.
+
+
+## 목차
+
+- [기본 매쳐](#1-기본-매쳐)
+- [메타 문자](#2-메타-문자)
+  - [마침표](#21-마침표)
+  - [문자 집합](#22-문자-집합)
+    - [부정 문자 집합](#221-부정-문자-집합)
+  - [반복](#23-반복)
+    - [별 부호](#231-별-부호)
+    - [덧셈 부호](#232-덧셈-부호)
+    - [물음표](#233-물음표)
+  - [중괄호](#24-중괄호)
+  - [문자 그룹](#25-문자-그룹)
+  - [대안 부호](#26-대안-부호)
+  - [특수 문자 이스케이핑](#27-특수-문자-이스케이핑)
+  - [앵커 부호](#28-앵커-부호)
+    - [캐럿 부호](#281-캐럿-부호)
+    - [달러 부호](#282-달러-부호)
+- [단축형 문자열 집합](#3-단축형-문자열-집합)
+- [룩어라운드](#4-룩어라운드)
+  - [긍정형 룩어헤드](#41-긍정형-룩어헤드)
+  - [부정형 룩어헤드](#42-부정형-룩어헤드)
+  - [긍정형 룩비하인드](#43-긍정형-룩비하인드)
+  - [부정형 룩비하인드](#44-부정형-룩비하인드)
+- [플래그](#5-플래그)
+  - [대소문자 구분없음](#51-대소문자-구분없음)
+  - [전체 검색](#52-전체-검색)
+  - [멀티 라인](#53-멀티-라인)
+
+## 1. 기본 매쳐
+
+하나의 정규 표현식은 단지 텍스트 내부의 검색을 수행하기 위한 문자열의 패턴이다. 예를 들어, 정규 표현식 `the`는 문자 `t` 다음에 문자 `h`, 그 다음에 문자 `e`가 나오는 것을 의미한다.
+
+
+"the" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/dmRygT/1)
+
+정규 표현식 `123`은 문자열 `123`에 매칭된다. 정규 표현식은 정규 표현식의 각 문자(Character)와 입력된 문자열의 각 문자(Character)를 비교함으로써 해당 문자열과 매칭된다. 정규 표현식들은 일반적으로 대소문자를 구분하기 때문에, 정규 표현식 `The`는 문자열 `the`와 매칭되지 않는다.
+
+
+"The" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/1paXsy/1)
+
+## 2. 메타 문자
+
+메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 
+아래는 이러한 메타 문자열들이다:
+
+|메타 문자|설명|
+|:----:|----|
+|.|온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|
+|[ ]|문자 클래스. 대괄호 사이에 있는 문자들로 매치.|
+|[^ ]|부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|
+|*|이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|
+|+|이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|
+|?|이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|
+|{n,m}|중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|
+|(xyz)|문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|
+|||대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|
+|\|다음 문자 이스케이프(Escape). 예약된 문자열들 [ ] ( ) { } . * + ? ^ $ \ |을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
+|^|입력의 시작과 매치.|
+|$|입력의 끝과 매치.|
+
+## 2.1 마침표
+
+마침표(`.`)는 메타 문자의 가장 간단한 예다. 메타 문자 `.`는 어떠한 단일 문자와도 매치되지만 리턴 혹은 개행 문자와는 매치되지 않는다. 예를 들어, 정규 표현식 `.ar`은 어떠한 단일 문자 다음에 문자 `a`가 오고, 그 다음에 문자 `r`이 오는 패턴을 의미한다.
+
+
+".ar" => The car parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 문자 집합
+
+문자 집합은 문자 클래스라고도 불린다. 대괄호는 이 문자 집합을 명시하기 위해 사용된다. 문자열 집합내에 사용된 하이픈은 문자들의 범위를 지정하는데 사용된다. 대괄호 내부에 명시된 문자들의 순서는 중요하지 않다. 예를 들어, 정규 표현식 `[Tt]he`는 대문자 `T` 혹은 소문자 `t`가 나온 다음에, 문자 `h`가 나오고 그 뒤에 문자 `e`가 나오는 패턴을 의미한다.
+
+
+"[Tt]he" => The car parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+
+하지만, 문자 집합 내부에서 사용되는 온점(Period)은 온점 그 자체를 의미한다. 정규 표현식 `ar[.]`은 소문자 `a` 다음에 문자 `r`이 오고 그 뒤에 문자 `.`이 오는 패턴을 의미한다.
+
+
+"ar[.]" => A garage is a good place to park a car.
+

+
+[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 부정 문자 집합
+
+일반적으로, 캐럿 기호(^)는 문자열의 시작지점을 나타내지만, 왼쪽 대괄호 바로 뒤에 위치했을때는 해당 문자 집합의 부정(negation)을 나타낸다. 예를 들어, 정규 표현식 `[^c]ar`은 문자 `c`를 제외한 어떠한 문자뒤에 문자 `a`가 오고, 그 뒤에 문자 `r`이 오는 패턴을 의미한다.
+
+
+"[^c]ar" => The car parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 반복
+
+메타 문자 `+`, `*` 또는 `?`은 하위패턴(subpattern)이 몇 번 발생하는지 지정하는데 사용된다. 이러한 메타 문자들은 상황에따라 다르게 동작한다.
+
+### 2.3.1 별 부호
+
+`*` 부호는 부호 앞에 위치한 매처(matcher)가 0번 이상 반복된 문자열과 매치된다. 정규 표현식 `a*`은 소문자 `a`가 0번 이상 반복되는 패턴을 의미한다. 하지만, 만약 이 별 부호가 문자 집합(character set) 직후에 나오는 경우에는 문자 집합 전체의 반복을 찾게된다. 예를 들어, 정규 표현식 `[a-z]*`은 소문자들이 갯수와 상관없이 연속으로 반복되는 패턴을 의미한다.
+
+
+"[a-z]*" => The car parked in the garage #21.
+

+
+[Test the regular expression](https://regex101.com/r/7m8me5/1)
+
+`*` 부호는 메타 문자 `.`와 함께 모든 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 또한, `*` 부호는 공백 문자 `\s`와 함께 공백 문자들로 이루어진 문자열과 매치되는 패턴을 만드는데 사용될 수 있다. 예를 들어, 정규 표현식 `\s*cat\s*`는 0번 이상 공백문자가 나온 이후에 소문자 `c`, 소문자 `a`, 소문자 `t`가 자체로 나오고 그 뒤에 다시 0번 이상의 공백문자가 나오는 패턴을 의미한다.
+
+
+"\s*cat\s*" => The fat cat sat on the concatenation.
+

+
+[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 덧셈 부호
+
+`+` 부호는 부호 앞에 위치한 문자가 한번 이상 반복되는 패턴을 만드는데 사용된다. 예를 들어, 정규 표현식 `c.+t`는 소문자 `c`가 나오고, 그 뒤에 한개 이상의 문자가 나온 후, 소문자 `t`가 나오는 패턴을 의미한다. 여기서 문자 `t`는 해당 문장의 제일 마지막 글자 `t`라는것을 명확히할 필요가 있다.
+  w
+
+"c.+t" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 물음표
+
+정규 표현식에서 메타 문자 `?`는 선행 문자를 선택적으로 만드는 역할을 한다. 물음표는 부호 앞에 쓰여진 문자가 선택적으로 나오는 패턴을 나타내는데 사용된다. 예를 들어, 정규 표현식 `[T]?he`는 대문자 `T`가 선택적으로 나온 이후에, 그 뒤에 소문자 `h`, 그 뒤에 소문자 `e`가 나오는 패턴을 의미한다.
+
+
+"[T]he" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+
+
+"[T]?he" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 중괄호
+
+정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다. 
+
+
+"[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Test the regular expression](https://regex101.com/r/juM86s/1)
+
+두번째 숫자를 생략하는것이 가능하다. 예를 들어, 정규 표현식 `[0-9]{2,}`는 2번 이상의 숫자가 연속으로 나오는 패턴을 의미한다. 만약 여기서 쉼표를 삭제하는 경우, 정규 표현식 `[0-9]{3}`은 숫자가 정확히 3번 연속해서 나오는 패턴을 의미한다.
+
+
+"[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+
+
+"[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
+

+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+
+## 2.5 문자 그룹
+
+문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다. 
+
+
+"(c|g|p)ar" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 대안 부호
+
+정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합 (Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다. 
+
+
+"(T|t)he|car" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 특수 문자 이스케이핑
+
+백 슬래시 `\`는 정규 표현식에서 다음에 나오는 부호를 이스케이핑하는데 사용된다. 백 슬래시는 예약 문자들인 `{ } [ ] / \ + * . $ ^ | ?`를 메타 부호가 아닌 문자 그 자체로 매칭되도록 명시한다. 특수 문자를 매칭 캐릭터로 사용하기 위해서는 백 슬래시 `\`를 해당 특수 문자 앞에 붙이면 된다. 예를 들어, 정규 표현식 `.`은 개행을 제외한 어떤 문자와 매칭된다. 입력 문자열에 포함된 `.` 문자를 매치시키는 정규 표현식 `(f|c|m)at\.?`은 소문자 `f`, `c` 또는 `m` 이후에 소문자 `a`와 `t`가 차례로 등장하고 이후에 문자 `.`가 선택적으로 나타나는 패턴을 의미한다. 
+
+
+"(f|c|m)at\.?" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 앵커 부호
+
+정규 표현식에서 앵커는 매칭 문자가 표현식의 시작 문자인지 혹은 끝 문자인지 명시하는데 사용된다. 앵커는 두가지 종류가 있다: 첫번째 종류인 캐럿 부호 `^`는 매칭 문자가 입력 문자열의 첫 시작 문자인지 나타내는데 사용되며 두번째 종류인 달러 부호 `$`는 해당 매칭 문자가 입력 문자의 마지막 문자라는 것을 명시하는데 사용된다.
+
+### 2.8.1 캐럿 부호
+
+캐럿 부호 `^`는 매칭 문자가 표현식의 시작이라는 것을 명시하는데 사용된다. 만약 (a가 시작 문자인지 확인하는) 정규 표현식 `^a`를 입력 문자열 `abc`에 적용하면, 이 정규 표현식은 `a`를 매칭 결과값으로 내보낸다. 반면, 정규 표현식 `^b`를 위의 입력 문자열에 적용하면, 아무런 매칭도 이러나지 않는다. 왜냐하면 입력 문자열 `abc`에서 "b"는 처음 시작 문자가 아니기 때문이다. 또 다른 정규 표현식인 `^(T|t)he`를 살펴보자. 이 정규 표현식은 대문자 `T` 또는 소문자 `t`가 입력 문자열의 시작으로 나오고, 그 뒤에 문자 `h`와 문자 `e`가 차례로 나오는 패턴을 의미한다.
+
+
+"(T|t)he" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+
+
+"^(T|t)he" => The car is parked in the garage.
+

+
+[Test the regular expression](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 달러 부호
+
+달러 부호 `$`는 입력 문자열의 마지막 문자가 매칭 문자로 끝나는지 확인하는데 사용된다. 예를 들어, 정규 표현식 `(at\.)$`는 소문자 `a`와 `t` 그리고 문자 `.`가 순서대로 입력 문자열의 맨 마지막에 나오는지 확인하는 패턴을 의미한다.
+
+
+"(at\.)" => The fat cat. sat. on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+
+
+"(at\.)$" => The fat cat. sat. on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+
+## 3. 단축형 문자열 집합
+
+정규 표현식은 일반적으로 사용되는 문자열 집합들을 간편하게 사용할 수 있도록 여러 단축형들을 제공한다. 단축형 문자열 집합은 아래와 같다.
+
+|단축형|설명|
+|:----:|----|
+|.|개행을 제외한 모든 문자|
+|\w|영숫자 문자와 매치: `[a-zA-Z0-9_]`|
+|\W|영숫자 문자가 아닌 문자와 매치: `[^\w]`|
+|\d|숫자와 매치: `[0-9]`|
+|\D|숫자가 아닌 문자와 매치: `[^\d]`|
+|\s|공백 문자와 매치: `[\t\n\f\r\p{Z}]`|
+|\S|공백 문자가 아닌 문자와 매치: `[^\s]`|
+
+## 4. 룩어라운드
+
+때때로 룩어라운드라고 알려진 룩비하인드와 룩어헤드는 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 룩어라운드는 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 룩어라운드들이다.
+
+|부호|설명|
+|:----:|----|
+|?=|긍정형 룩어헤드|
+|?!|부정형 룩어헤드|
+|?<=|긍정형 룩비하인드|
+|?
+"[T|t]he(?=\sfat)" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/IDDARt/1)
+
+### 4.2 부정형 룩어헤드
+
+부정형 룩어헤드는 입력 문자열로부터 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 룩어헤드는 우리가 긍정형 룩어헤드를 정의하는 방식과 동일하게 정의된다. 하지만, 유일한 차이점은 등호 부호 `=` 대신 부정 부호 `!` 문자를 사용한다는 것이다, 즉 `(?!...)`. 정규 표현식 `[T|t]he(?!\sfat)`를 살펴보도록 하자. 이 정규 표현식은 공백 문자와 `fat` 문자열이 연속으로 나오지 않는 모든 `The` 혹은 `the` 문자열과 매치된다.
+
+
+"[T|t]he(?!\sfat)" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+
+### 4.3 긍정형 룩비하인드
+
+긍정형 룩비하인드는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 룩비하인드는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다. 
+
+
+"(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+
+### 4.4 부정형 룩비하인드
+
+부정형 룩비하인드는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 룩비하인드는 `(?
+"(?<![T|t]he\s)(cat)" => The cat sat on cat.
+

+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+
+## 5. 플래그
+
+플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용가능하며 정규 표현식의 일부분이다.
+
+|플래그|설명|
+|:----:|----|
+|i|대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정.|
+|g|전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.|
+|m|멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.|
+
+### 5.1 대소문자 구분없음
+
+수정자 `i`는 대소문자 구분없는 매칭을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/The/gi`는 대문자 `T`, 소문자 `h`, 소문자 `e`가 차례로 나오는 패턴을 의미한다. 여기서 정규 표현식 마지막에 있는 `i` 플래그가 정규 표현식 엔진에게 대소문자를 구분하지 않도록 알려준다. `g` 플래그는 전체 입력 문자열내부에서 패턴을 검색하기 위해 설정되었다.
+
+
+"The" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+
+
+"/The/gi" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 전체 검색
+
+수정자 `g`는 첫번째 매칭후에 멈추지 않고 계속해서 모든 매칭을 검색하는 전체 검색을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/.(at)/g`는 개행을 제회한 문자가 나오고, 그 뒤에 소문자 `a`, 소문자 `t`가 나오는 패턴을 의미한다. 여기에서 `g` 플래그를 정규 표현식의 마지막에 설정했기 때문에, 이 패턴은 입력 문자열 전체에서 나타나는 모든 패턴을 찾아낸다.
+
+
+"/.(at)/" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+
+
+"/.(at)/g" => The fat cat sat on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/dO1nef/1)
+
+### 5.3 멀티 라인
+
+수정자 `m`은 멀티 라인 매치를 수행하는데 사용된다. 이전에 이야기 했던 것처럼, 앵커 `(^, $)`는 패턴의 시작과 끝을 확인하는데 사용된다. 하지만 만약 우리가 각 라인마다 이 앵커가 동작하게하고 싶으면 `m` 플래그를 설정하면된다. 예를 들어, 정규 표현식 `/at(.)?$/gm`은 소문자 `a`와 소문자 `t`가 차례로 나오고, 선택적으로 개행을 제외한 문자가 나오는 패턴을 의미한다. 여기서 플래그 `m`으로 인해서 정규 표현식 엔진은 입력 문자열의 각 라인에 대해서 해당 패턴을 매칭하게 된다.
+
+
+"/.at(.)?$/" => The fat
+                cat sat
+                on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+
+
+"/.at(.)?$/gm" => The fat
+                  cat sat
+                  on the mat.
+

+
+[Test the regular expression](https://regex101.com/r/E88WE2/1)
+
+## 기여 방법
+
+* 이슈 리포팅
+* 코드 개선해서 풀 리퀘스트 열기
+* 소문내기
+* ziishaned@gmail.com 메일로 직접 연락하기 또는 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## 라이센스
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/README.md b/README.md
index 823ce08c..d1d958db 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,7 @@
 * [Français](README-fr.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
+* [한국어](README-ko.md)
 
 ## What is Regular Expression?
 

From 9265b137340134fbb33b6442d2deedc3e42c44f9 Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" 
Date: Sun, 20 Aug 2017 22:52:56 +0900
Subject: [PATCH 009/185] Update "5. lookaround" in README-ko.md (#74)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Update "5. lookaround" in README-ko.md

- 전방탐색, 후방탐색 단어 변경

* Update README-ko.md
---
 README-ko.md | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/README-ko.md b/README-ko.md
index 3030c43a..faf03b3e 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -16,7 +16,7 @@
 
 > 정규표현식은 텍스트에서 특정 패턴을 찾아내는데 사용되는 문자 혹은 기호들의 집합이다.
 
-정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp"로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
+정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp", "정규식"로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
 
 당신이 하나의 어플리케이션을 작성하고 있고 사용자가 사용자명을 선택할 때 사용되는 규칙들을 정하고 싶다고 상상해보자. 예를 들어, 우리는 사용자명에 문자, 숫자, 밑줄 문자(\_), 그리고 하이픈이 포함되는것은 허용하고 싶다. 또한, 사용자명의 글자수를 제한해서 사용자명이 지저분해보이지 않도록 하고 싶다. 이때 아래 정규표현식을 사용해 입력된 사용자명이 해당 규칙에 맞는지 검사할 수 있다.
 
@@ -47,11 +47,11 @@
     - [캐럿 부호](#281-캐럿-부호)
     - [달러 부호](#282-달러-부호)
 - [단축형 문자열 집합](#3-단축형-문자열-집합)
-- [룩어라운드](#4-룩어라운드)
-  - [긍정형 룩어헤드](#41-긍정형-룩어헤드)
-  - [부정형 룩어헤드](#42-부정형-룩어헤드)
-  - [긍정형 룩비하인드](#43-긍정형-룩비하인드)
-  - [부정형 룩비하인드](#44-부정형-룩비하인드)
+- [전후방탐색](#4-전후방탐색)
+  - [긍정형 전방탐색](#41-긍정형-전방탐색)
+  - [부정형 전방탐색](#42-부정형-전방탐색)
+  - [긍정형 후방탐색](#43-긍정형-후방탐색)
+  - [부정형 후방탐색](#44-부정형-후방탐색)
 - [플래그](#5-플래그)
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
@@ -285,20 +285,20 @@
 |\s|공백 문자와 매치: `[\t\n\f\r\p{Z}]`|
 |\S|공백 문자가 아닌 문자와 매치: `[^\s]`|
 
-## 4. 룩어라운드
+## 4. 전후방탐색
 
-때때로 룩어라운드라고 알려진 룩비하인드와 룩어헤드는 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 룩어라운드는 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 룩어라운드들이다.
+때때로 전후방탐색(Lookaround)이라고 알려진 후방탐색(Lookbehind)과 전방탐색(Lookahead)은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 룩어라운드는 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 룩어라운드들이다.
 
 |부호|설명|
 |:----:|----|
-|?=|긍정형 룩어헤드|
-|?!|부정형 룩어헤드|
-|?<=|긍정형 룩비하인드|
-|?
 "[T|t]he(?=\sfat)" => The fat cat sat on the mat.
@@ -306,9 +306,9 @@
 
 [Test the regular expression](https://regex101.com/r/IDDARt/1)
 
-### 4.2 부정형 룩어헤드
+### 4.2 부정형 전방탐색
 
-부정형 룩어헤드는 입력 문자열로부터 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 룩어헤드는 우리가 긍정형 룩어헤드를 정의하는 방식과 동일하게 정의된다. 하지만, 유일한 차이점은 등호 부호 `=` 대신 부정 부호 `!` 문자를 사용한다는 것이다, 즉 `(?!...)`. 정규 표현식 `[T|t]he(?!\sfat)`를 살펴보도록 하자. 이 정규 표현식은 공백 문자와 `fat` 문자열이 연속으로 나오지 않는 모든 `The` 혹은 `the` 문자열과 매치된다.
+부정형 전방탐색는 입력 문자열로부터 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 전방탐색는 우리가 긍정형 전방탐색를 정의하는 방식과 동일하게 정의된다. 하지만, 유일한 차이점은 등호 부호 `=` 대신 부정 부호 `!` 문자를 사용한다는 것이다, 즉 `(?!...)`. 정규 표현식 `[T|t]he(?!\sfat)`를 살펴보도록 하자. 이 정규 표현식은 공백 문자와 `fat` 문자열이 연속으로 나오지 않는 모든 `The` 혹은 `the` 문자열과 매치된다.
 
 
 "[T|t]he(?!\sfat)" => The fat cat sat on the mat.
@@ -316,9 +316,9 @@
 
 [Test the regular expression](https://regex101.com/r/V32Npg/1)
 
-### 4.3 긍정형 룩비하인드
+### 4.3 긍정형 후방탐색
 
-긍정형 룩비하인드는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 룩비하인드는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다. 
+긍정형 후방탐색는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 후방탐색는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다. 
 
 
 "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
@@ -326,9 +326,9 @@
 
 [Test the regular expression](https://regex101.com/r/avH165/1)
 
-### 4.4 부정형 룩비하인드
+### 4.4 부정형 후방탐색
 
-부정형 룩비하인드는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 룩비하인드는 `(?
 "(?<![T|t]he\s)(cat)" => The cat sat on cat.

From 4b95975c4cf5f8eef67f11dc305cb9a2eb599c97 Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" 
Date: Mon, 21 Aug 2017 01:05:53 +0900
Subject: [PATCH 010/185] Update README-ko.md (#75)

- modify spelling
---
 README-ko.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/README-ko.md b/README-ko.md
index faf03b3e..0a5e284a 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -16,7 +16,7 @@
 
 > 정규표현식은 텍스트에서 특정 패턴을 찾아내는데 사용되는 문자 혹은 기호들의 집합이다.
 
-정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp", "정규식"로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
+정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp", "정규식"으로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
 
 당신이 하나의 어플리케이션을 작성하고 있고 사용자가 사용자명을 선택할 때 사용되는 규칙들을 정하고 싶다고 상상해보자. 예를 들어, 우리는 사용자명에 문자, 숫자, 밑줄 문자(\_), 그리고 하이픈이 포함되는것은 허용하고 싶다. 또한, 사용자명의 글자수를 제한해서 사용자명이 지저분해보이지 않도록 하고 싶다. 이때 아래 정규표현식을 사용해 입력된 사용자명이 해당 규칙에 맞는지 검사할 수 있다.
 
@@ -48,10 +48,10 @@
     - [달러 부호](#282-달러-부호)
 - [단축형 문자열 집합](#3-단축형-문자열-집합)
 - [전후방탐색](#4-전후방탐색)
-  - [긍정형 전방탐색](#41-긍정형-전방탐색)
-  - [부정형 전방탐색](#42-부정형-전방탐색)
-  - [긍정형 후방탐색](#43-긍정형-후방탐색)
-  - [부정형 후방탐색](#44-부정형-후방탐색)
+  - [긍정형 전방탐색](#41-긍정형-전방탐색)
+  - [부정형 전방탐색](#42-부정형-전방탐색)
+  - [긍정형 후방탐색](#43-긍정형-후방탐색)
+  - [부정형 후방탐색](#44-부정형-후방탐색)
 - [플래그](#5-플래그)
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
@@ -135,7 +135,7 @@
 
 ## 2.3 반복
 
-메타 문자 `+`, `*` 또는 `?`은 하위패턴(subpattern)이 몇 번 발생하는지 지정하는데 사용된다. 이러한 메타 문자들은 상황에따라 다르게 동작한다.
+메타 문자 `+`, `*` 또는 `?`은 하위패턴(subpattern)이 몇 번 발생하는지 지정하는데 사용된다. 이러한 메타 문자들은 상황에 따라 다르게 동작한다.
 
 ### 2.3.1 별 부호
 
@@ -183,7 +183,7 @@
 
 ## 2.4 중괄호
 
-정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다. 
+정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.
 
 
 "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -207,7 +207,7 @@
 
 ## 2.5 문자 그룹
 
-문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다. 
+문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
 
 
 "(c|g|p)ar" => The car is parked in the garage.
@@ -217,7 +217,7 @@
 
 ## 2.6 대안 부호
 
-정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합 (Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다. 
+정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합(Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다.
 
 
 "(T|t)he|car" => The car is parked in the garage.
@@ -227,7 +227,7 @@
 
 ## 2.7 특수 문자 이스케이핑
 
-백 슬래시 `\`는 정규 표현식에서 다음에 나오는 부호를 이스케이핑하는데 사용된다. 백 슬래시는 예약 문자들인 `{ } [ ] / \ + * . $ ^ | ?`를 메타 부호가 아닌 문자 그 자체로 매칭되도록 명시한다. 특수 문자를 매칭 캐릭터로 사용하기 위해서는 백 슬래시 `\`를 해당 특수 문자 앞에 붙이면 된다. 예를 들어, 정규 표현식 `.`은 개행을 제외한 어떤 문자와 매칭된다. 입력 문자열에 포함된 `.` 문자를 매치시키는 정규 표현식 `(f|c|m)at\.?`은 소문자 `f`, `c` 또는 `m` 이후에 소문자 `a`와 `t`가 차례로 등장하고 이후에 문자 `.`가 선택적으로 나타나는 패턴을 의미한다. 
+백 슬래시 `\`는 정규 표현식에서 다음에 나오는 부호를 이스케이핑하는데 사용된다. 백 슬래시는 예약 문자들인 `{ } [ ] / \ + * . $ ^ | ?`를 메타 부호가 아닌 문자 그 자체로 매칭되도록 명시한다. 특수 문자를 매칭 캐릭터로 사용하기 위해서는 백 슬래시 `\`를 해당 특수 문자 앞에 붙이면 된다. 예를 들어, 정규 표현식 `.`은 개행을 제외한 어떤 문자와 매칭된다. 입력 문자열에 포함된 `.` 문자를 매치시키는 정규 표현식 `(f|c|m)at\.?`은 소문자 `f`, `c` 또는 `m` 이후에 소문자 `a`와 `t`가 차례로 등장하고 이후에 문자 `.`가 선택적으로 나타나는 패턴을 의미한다.
 
 
 "(f|c|m)at\.?" => The fat cat sat on the mat.
@@ -241,7 +241,7 @@
 
 ### 2.8.1 캐럿 부호
 
-캐럿 부호 `^`는 매칭 문자가 표현식의 시작이라는 것을 명시하는데 사용된다. 만약 (a가 시작 문자인지 확인하는) 정규 표현식 `^a`를 입력 문자열 `abc`에 적용하면, 이 정규 표현식은 `a`를 매칭 결과값으로 내보낸다. 반면, 정규 표현식 `^b`를 위의 입력 문자열에 적용하면, 아무런 매칭도 이러나지 않는다. 왜냐하면 입력 문자열 `abc`에서 "b"는 처음 시작 문자가 아니기 때문이다. 또 다른 정규 표현식인 `^(T|t)he`를 살펴보자. 이 정규 표현식은 대문자 `T` 또는 소문자 `t`가 입력 문자열의 시작으로 나오고, 그 뒤에 문자 `h`와 문자 `e`가 차례로 나오는 패턴을 의미한다.
+캐럿 부호 `^`는 매칭 문자가 표현식의 시작이라는 것을 명시하는데 사용된다. 만약 (a가 시작 문자인지 확인하는) 정규 표현식 `^a`를 입력 문자열 `abc`에 적용하면, 이 정규 표현식은 `a`를 매칭 결과값으로 내보낸다. 반면, 정규 표현식 `^b`를 위의 입력 문자열에 적용하면, 아무런 매칭도 일어나지 않는다. 왜냐하면 입력 문자열 `abc`에서 "b"는 처음 시작 문자가 아니기 때문이다. 또 다른 정규 표현식인 `^(T|t)he`를 살펴보자. 이 정규 표현식은 대문자 `T` 또는 소문자 `t`가 입력 문자열의 시작으로 나오고, 그 뒤에 문자 `h`와 문자 `e`가 차례로 나오는 패턴을 의미한다.
 
 
 "(T|t)he" => The car is parked in the garage.
@@ -287,7 +287,7 @@
 
 ## 4. 전후방탐색
 
-때때로 전후방탐색(Lookaround)이라고 알려진 후방탐색(Lookbehind)과 전방탐색(Lookahead)은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 룩어라운드는 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 룩어라운드들이다.
+때때로 전후방탐색Lookaround이라고 알려진 후방탐색Lookbehind과 전방탐색Lookahead은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
 
 |부호|설명|
 |:----:|----|
@@ -298,7 +298,7 @@
 
 ### 4.1 긍정형 전방탐색
 
-긍정형 전방탐색는 표현식의 첫 부분뒤에 전방탐색 표현식이 뒤따라 나오는지 확인하는데 사용된다. 매칭의 결과값은 표현식의 첫 부분과 매칭된 텍스트만이 포함된다. 긍정형 전방탐색를 정의하기 위해서는 괄호가 사용된다. 이 괄호 안에서, 물음표 부호 `?`와 등호 `=`가 다음과 같이 사용된다: `(?=...)`. 전방탐색 표현식은 괄호내부의 등호 `=` 부호 뒤에 쓰면된다. 예를 들어, 정규 표현식 `[T|t]he(?=\sfat)`는 대문자 `T` 혹은 소문자 `t` 뒤에 문자 `h`, 문자 `e`가 나오는 패턴을 의미한다. 괄호안에서 우리는 정규 표현식 엔진에게 바로 뒤에 공백문자와 문자열 `fat`이 나오는 `The` 또는 `the`만 매치하도록 알리는 긍정형 전방탐색를 정의하였다.
+긍정형 전방탐색는 표현식의 첫 부분뒤에 전방탐색 표현식이 뒤따라 나오는지 확인하는데 사용된다. 매칭의 결과값은 표현식의 첫 부분과 매칭된 텍스트만이 포함된다. 긍정형 전방탐색를 정의하기 위해서는 괄호가 사용된다. 이 괄호 안에서, 물음표 부호 `?`와 등호 `=`가 다음과 같이 사용된다: `(?=...)`. 전방탐색 표현식은 괄호 내부의 등호 `=` 부호 뒤에 쓰면된다. 예를 들어, 정규 표현식 `[T|t]he(?=\sfat)`는 대문자 `T` 혹은 소문자 `t` 뒤에 문자 `h`, 문자 `e`가 나오는 패턴을 의미한다. 괄호 안에서 우리는 정규 표현식 엔진에게 바로 뒤에 공백문자와 문자열 `fat`이 나오는 `The` 또는 `the`만 매치하도록 알리는 긍정형 전방탐색를 정의하였다.
 
 
 "[T|t]he(?=\sfat)" => The fat cat sat on the mat.
@@ -318,7 +318,7 @@
 
 ### 4.3 긍정형 후방탐색
 
-긍정형 후방탐색는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 후방탐색는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다. 
+긍정형 후방탐색는 특정 패턴뒤에 나오는 문자열 매치를 가져오기 위해서 사용된다. 긍정형 후방탐색는 `(?<=...)`로 표시된다. 예를 들어, 정규 표현식 `(?<=[T|t]he\s)(fat|mat)`는 입력 문자열에서 `The` 혹은 `the` 뒤에 공백이 나오고, 그 뒤에 `fat` 또는 `mat`이 나오는 패턴을 의미한다.
 
 
 "(?<=[T|t]he\s)(fat|mat)" => The fat cat sat on the mat.
@@ -338,7 +338,7 @@
 
 ## 5. 플래그
 
-플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용가능하며 정규 표현식의 일부분이다.
+플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용 가능하며 정규 표현식의 일부분이다.
 
 |플래그|설명|
 |:----:|----|
@@ -348,7 +348,7 @@
 
 ### 5.1 대소문자 구분없음
 
-수정자 `i`는 대소문자 구분없는 매칭을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/The/gi`는 대문자 `T`, 소문자 `h`, 소문자 `e`가 차례로 나오는 패턴을 의미한다. 여기서 정규 표현식 마지막에 있는 `i` 플래그가 정규 표현식 엔진에게 대소문자를 구분하지 않도록 알려준다. `g` 플래그는 전체 입력 문자열내부에서 패턴을 검색하기 위해 설정되었다.
+수정자 `i`는 대소문자 구분없는 매칭을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/The/gi`는 대문자 `T`, 소문자 `h`, 소문자 `e`가 차례로 나오는 패턴을 의미한다. 여기서 정규 표현식 마지막에 있는 `i` 플래그가 정규 표현식 엔진에게 대소문자를 구분하지 않도록 알려준다. `g` 플래그는 전체 입력 문자열 내부에서 패턴을 검색하기 위해 설정되었다.
 
 
 "The" => The fat cat sat on the mat.
@@ -364,7 +364,7 @@
 
 ### 5.2 전체 검색
 
-수정자 `g`는 첫번째 매칭후에 멈추지 않고 계속해서 모든 매칭을 검색하는 전체 검색을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/.(at)/g`는 개행을 제회한 문자가 나오고, 그 뒤에 소문자 `a`, 소문자 `t`가 나오는 패턴을 의미한다. 여기에서 `g` 플래그를 정규 표현식의 마지막에 설정했기 때문에, 이 패턴은 입력 문자열 전체에서 나타나는 모든 패턴을 찾아낸다.
+수정자 `g`는 첫번째 매칭후에 멈추지 않고 계속해서 모든 매칭을 검색하는 전체 검색을 수행하는데 사용된다. 예를 들어, 정규 표현식 `/.(at)/g`는 개행을 제외한 문자가 나오고, 그 뒤에 소문자 `a`, 소문자 `t`가 나오는 패턴을 의미한다. 여기에서 `g` 플래그를 정규 표현식의 마지막에 설정했기 때문에, 이 패턴은 입력 문자열 전체에서 나타나는 모든 패턴을 찾아낸다.
 
 
 "/.(at)/" => The fat cat sat on the mat.

From 18f576efd96464ca62c4c27db6c579edfa97ae0e Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" 
Date: Mon, 21 Aug 2017 11:02:57 +0900
Subject: [PATCH 011/185] Fix typo in README-ko.md (#76)

---
 README-ko.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README-ko.md b/README-ko.md
index 0a5e284a..9cace762 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -3,7 +3,7 @@
 Learn Regex
 


 
-## Translations:
+## 번역:
 
 * [English](README.md)
 * [Español](README-es.md)
@@ -18,7 +18,7 @@
 
 정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp", "정규식"으로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
 
-당신이 하나의 어플리케이션을 작성하고 있고 사용자가 사용자명을 선택할 때 사용되는 규칙들을 정하고 싶다고 상상해보자. 예를 들어, 우리는 사용자명에 문자, 숫자, 밑줄 문자(\_), 그리고 하이픈이 포함되는것은 허용하고 싶다. 또한, 사용자명의 글자수를 제한해서 사용자명이 지저분해보이지 않도록 하고 싶다. 이때 아래 정규표현식을 사용해 입력된 사용자명이 해당 규칙에 맞는지 검사할 수 있다.
+당신이 하나의 어플리케이션을 작성하고 있고 사용자가 사용자명을 선택할 때 사용되는 규칙들을 정하고 싶다고 상상해보자. 예를 들어, 우리는 사용자명에 문자, 숫자, 밑줄 문자(\_), 그리고 하이픈이 포함되는 것은 허용하고 싶다. 또한, 사용자명의 글자수를 제한해서 사용자명이 지저분해보이지 않도록 하고 싶다. 이때 아래 정규표현식을 사용해 입력된 사용자명이 해당 규칙에 맞는지 검사할 수 있다.
 
 


 

@@ -77,7 +77,7 @@
 
 ## 2. 메타 문자
 
-메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 
+메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다.
 아래는 이러한 메타 문자열들이다:
 
 |메타 문자|설명|
@@ -191,7 +191,7 @@
 
 [Test the regular expression](https://regex101.com/r/juM86s/1)
 
-두번째 숫자를 생략하는것이 가능하다. 예를 들어, 정규 표현식 `[0-9]{2,}`는 2번 이상의 숫자가 연속으로 나오는 패턴을 의미한다. 만약 여기서 쉼표를 삭제하는 경우, 정규 표현식 `[0-9]{3}`은 숫자가 정확히 3번 연속해서 나오는 패턴을 의미한다.
+두번째 숫자를 생략하는 것이 가능하다. 예를 들어, 정규 표현식 `[0-9]{2,}`는 2번 이상의 숫자가 연속으로 나오는 패턴을 의미한다. 만약 여기서 쉼표를 삭제하는 경우, 정규 표현식 `[0-9]{3}`은 숫자가 정확히 3번 연속해서 나오는 패턴을 의미한다.
 
 
 "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -207,7 +207,7 @@
 
 ## 2.5 문자 그룹
 
-문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
+문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자 뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹 뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
 
 
 "(c|g|p)ar" => The car is parked in the garage.

From 4726270279c3b30a53e64c15e317518a3a23ed78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicolas=20Borbo=C3=ABn?=
 
Date: Mon, 21 Aug 2017 13:46:21 +0200
Subject: [PATCH 012/185] Images fix (#77)

* Images fix

* Merge fixed
---
 README-cn.md      |   4 ++--
 img/regexp-en.png | Bin 32144 -> 32399 bytes
 img/regexp-es.png | Bin 34234 -> 34485 bytes
 img/regexp-fr.png | Bin 32922 -> 33191 bytes
 img/regexp.svg    |  24 ++++++++++++------------
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/README-cn.md b/README-cn.md
index 6f233a39..92a62432 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -26,7 +26,7 @@
 
 


 

-Regular expression
+  Regular expression
 

 
 以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.
@@ -88,7 +88,7 @@
 
 ## 2. 元字符
 
-正则表达式主要依赖于元字符.  
+正则表达式主要依赖于元字符.
 元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍:
 
 |元字符|描述|
diff --git a/img/regexp-en.png b/img/regexp-en.png
index f2331491b387f1fd9cb7b843fe86893ca7fad475..c38c90fb009dd72770ec7c32f5323ed968b5b07e 100644
GIT binary patch
literal 32399
zcmdSB2~6%5she+
zN~KAp@xHe6|F3oLy6diW);a%k?mE``uHR4P)85a1p7;ATy?3aFy5iQ&Oq&UU*s81~
zr$rF!JP3j!lX@e*A|5bThX0{-l2z8B#vdUP|XGbS-A)$-b&X-)w4_Y|b3wc^uIbAw`*+t0C>ipHq
zg8zOo-NoUZ1hJ1$mOH8A{&3=}hmnr%8rAgn_0&AnJnWg&gLj_|R?!6CUy6O^a8GqH
zTGM)1oA+_v&wJK3p@s@J%IUHE&%Onx^j8&cT9?vvaNWqC8?9g1;_hAF6Mue>%v5K1
z=SSm~=Y0|_l5+`8t>zqowEH;lCpCp==QXiL)cvVxATyctHYf4H=q4$#OmkN&^_wL;z{Jy_?
zV6nRVcbK``Darfyo`a@UH|aPP%)T|<8D>#0I(+2Fhg8MwF)OUBtX<_UIW6-E;x3!{
z^>Y34@&u3Cbv=rt4Gqck&)TWnTV&B#=r|zDEaAH4`Sa&(KG&{Y`!)8Fic{g{%MdzF
zk=WLzrkC^MofL$9Ps#Pr(9jx-gLxNQ6WJvtnP1L*YpShHdC1w;dxul;(53hLc%N%~
z{u;eglfQ?RH3C0X^Ytss@87@c6WQqL{W%pQ9$9~UyfIukX?AYz%AcRc))EpDd(WLa
z$K@l`SXXB@(vpy=n-g0lyPqRv^W)kB9(#}4y?lG`$ep-2svubkMn=Zt;^G_!4{n>8
znW5gYMb6#b{f@GUyZiBS=dpE!`{FO&Y@IAEy@5D=b90WKQd=tGnalVtrlWTHEp*mX
zc~5&~FI?a*cbkgXF1sJmVW8p$C%R6QUPU?GP^zB
z-`>-Xz{Ay)Kbss?!GAX2tRwea)0;Q1{3zBJdd}N?Dljz__gVUFZ`V_@>Bcq|zDAy`
zMZac(@=B>Nb|UmI5YNL_Vu`jDx~
zInh%}6B`>_JhXN1(Ylc&-w2Pn?=jkeI{KEDX}|jBf3)*gpU70gI$ru*X76$1q@3JF
z9b8ah;UU8B>C>kw{%3FFnwzVHheB$
zs(snkmglzr{PH{?K7Kc@=2d$;!^-0PsiohO;kSJM{QTO~+Ny~E8Tj@s@YYrnR-;&}Dy-S)}J$y;$Io>^VHon6*ey~*3b
zsx`H=1V=^fSo}2>&|7)Uc4Dp6cg-g)BV#>*3*emGzIpTAc`j#X=fJqQIFrE&_Zg1M
zU(31dFJ8R3o={Jc&ZE!B$T+|xYNKQ6jg9dt-}nXX-n}%6ii$UP3$HVN;VM{slXjhA
zBy0Wk^;EQsj8sRC94WEurcYJ4b(dB1?0)i2wY0UZmIMR^g)hB-#PKHR#*LwdTYEE&
zUmPuWoeX>7Hf4_WeCEA$G+Qq(?5wFb!>JqF1j~H;(^cc98`*sOv4Z4+1Z>>eKR!;g
zeS4%<-(EVpEOx%aZ7kx{g!!-058`nyPEI?Bl0|%4qRQV+lWV8r$$G*|3k#!ydNMLHd8RoG{Cb(uzQZwRDTyMpnsqZZRBV~i!otFIs&NO~
z-B&U*c|JUMx>(xzq^xY$=cf*xpDVMUIFD&joG7vFR3AT#QovW#k*%B4b=B$nTU^tl
zlL2)oBSHA1B88Rts4p!gWqgxW%3yNj^`}odUbC+caLCA*jxV7EPU?)tR$%ppCc2+=
zJ-N6YPw198(Y3ESL@I2Yt$==ELmcAo5E*v=~XGK_)WalAut
z`A_v)J&I-jj~{&eQPI(XSP4#XaVC6XP42lT?~AQeB|U#p<20QzGuy|l7Edn2uZeDL
zhd)LJtE;QHBMRc7j4$hWXF+Gy@~yqc4tXy+ews
z6*;-gEJMo*2gxqh%Q%l}6j^`dE){f;|NE!UH$65W<4lr`?sqKrAeN0Ol6U-t
z`%FrMc(kAgYLj_w;3kd(2NYc;g@n!o1_x&gqIB{b4|U`j8q^zUd3bo#e*J1p(0VWa
zqQhT`hiYnSwD{Go2*7zpQP4V#
zw8XGn`#o{*Qd?RmK`!eft=|tEs_2M7G_vDP-)}b02pX0t<>Hf^fU%HpMt+&#Ml4FZ?`Ozr*FQ|URcWj(|1o{QZ}?7OvJ
zFf28dv!lSY;P73|WDT8=mMJV)?02)Ji6^a(G@AN$nV6W2etmI_FhfzXVohTAaCbNR
zl&M+ljl1@bjNDG(6v?^@96h?LdUcVXFdJ)2=kw;G=#M%heO)&BC5n#Y-&w2m@+QAg
zvC=!NxKPlno0*0yB2;9la}7#26VojcQ;$%i_*^2`WLUQ{iJb8C6!-V{-?CGT?n8K%
z>;Vsg+&EgB_(KfhQPj*oo*K8VhE+=llU`?khwB-#q}Jas5=ed!k-PD8Z&_Tg~s6B62f;lc$b
zDgoTvDbKpSOibA$A#cv0?0#~!*QnBqWRr=VtiC!N_KVZ5={CE~xQMXubyRY{k;vPj
zAxge{&PkH#i}T|a1GPc=&m7rPQd8-enQ!9w;@4B{*|TT2jE|&=&tEGPb1jEXHJo<;
z4K#&TZ+2y|MTrMhcYU&M&yMLGJWM&vSQHf%)j)T*Irh!BZTr
zAhV*{pFfwlt?=vqy?f^urU#hDb-8ZKS{S2O7X5rxE1Z+8L=iQ!jwo}z8IOXALn!+t6rdHlA|ER>o
z%Oc8&`8i2ERCAUWFWQQ3dV1A{(L$rGbF+Ju$oVTb$4WUkvZ?uu@1E6&WR*H}^_!C2
z=d!J6gC7km`+V1=@EbLrTsTchMU@Jyz&B#oTXAlDar2)mIhUfHD0j_|KJOQ{P@Yzi
zeJ*17;HZ6x%4~F=kr2nQt<{AK!GVE+<|7}5e(aT#Thz^pk|Z46+^DA4@-%;pmWRBU
zeRB;@)@Db=^0L>L7j9=V#9egTf<{zj|2ECm1W?h+W>&fy88H(tTUyj7>plpDZQRO4
zxUYtM?(MDmGN_?$p}jz7EuZ3*2XJ%e-o4Orm+@F9AY-A}u&;G#K`3$S{dzPbRJLu~
z*5-TQzyU_XjNc
z=|(H39$Y_^{^7~RGdw#t@87?_e_>{5W2K&EbY#a=U-fo&x##to(WsZINy&XaOL-4d
z**QFCbVm0(U>E6EdY0PN_WPr6ah-ngKIg2^t@&rqo+(ADZD&5NG2s%!$%+5tha2xM
zLjSAy(|gUJ-joTILTfPl^xO0g>8gy+oU%k&*H8Ru~sVaPP&yj{lMbSDnzDG`(
zUhFD7Pxu|{^U^j5&M&-qa|>|cYqKjn2i$!YrrCc_bXydTM+f7qW2aL{`kFE%Mkw$e
zJH}YOwkknSPv3l45=7%{GFvD2fdfNNTBQT3t7SHBXT1ru@v^3dg6uekgV+jKSA4rcgk(HC9j6G-^78pp0TVg+axb4v&8OQz;c3p)OXh~o?C+5DtOD{ER
zj9}qEZLDdqIcS|~tibhx0-@E_C5K<*o!gIGcG@>ixE+-mRN
zh|b&hzr5b{!cE9$ZN;r(wwZslBk#d4{qDv_Dzv7LpG&Kjeo8z9B{^GQBL5~YktF<_D!tT>%SuO>(o%uMR
zDHF>$6vnZ)`7-!lH#cjY`zSo|v2jgbh4$
zvBeBMIpo%@`WXJRB4vp?=rlJ)PZ_%U=P>K%#DS3OsYQSC;fy*5AS;qGZn;tpCCl=%Ti*O>5Hj
z6EJjXj>Jwq6MmC#!^5GdBZi*uXjU1Xy5@;bRj*YM`!;Ub{ph#5j!yJ1R*gRw!D4WF
z9=96m+LjoBf1B$j)gK+E@rc3d69sQeBQ6c$I(u4kD%fpj)b^_RQX6MgeM=^f&`SV`%
zFY$T0@bK_g*iW=gCK>{h45l|jmFILJW6Sm$KWic4LE?6}R0
z&Qj0tt1F8xSflk~Vq!#MEC0D?!?V)^uMGa2op_%dU{~2YJ?%(-yVSN*p)=oDw(4r)}7Z{LoI*?zY~x~=5VSWLKCgc|fLwXb`}IPk
zV329~KdcDE7$_-G2XEaQ43NUHe}7uVD|WPnL(c{`=-T8NK5eKEXQUupU0vOm7p{nr
z>VuB(q1UM@dDG?fUJ^U#=%gAOOYznJYK`Lm`+j2XKX~xKPJ)jw+iM+rwxz7BtmEi=
zc2wzTHy)jagGSH%fL_QwG0d`gPy9I#suMa)moHxqxp_0XjFXdd;KvUGABsw|t5>f&
zet)}%tPhL_jZS!ZNwP|NQPa@SJS#7+MF~NTfsO$tY+xfxO)4TItx1jOvv(dmpaF2K
zm}`-ck5yGyZ@9~)8kX1h<_!%Y0SiDe+MuFJGRx$t+gA2xyW&#RNhcd^eOK{E!tpEXqPS1{
zqYK~>HcK$4Xr0HeOCRj-C)n87oX6TW96Wfi@X3=?IQ>{aT3T8^)M%6w>Vbg)?Bis0
z7a4pgu!uZL>DHazGl8_!+qT7)p%&h%sHmWq`uf3
zF)@WrPfs5X9RruZA$Xap7-?o@74-P@gIeH(x_RE6n+5a>Pejr&b*wD?A+?}y-@d(k
z{dyCmCPj3CQod^=Ei7{K@-<(+FefG^78VupmZ|CK?E91K&_~qpAfBE{=B|?Io
zodN||R$YA?fNe(G;60Rf6pXRHQa~f|`T4g%`8chhQtR~%3{p@H99>+3fCO8LvZLbT
zLmnJ+;D8Jj5fMQW0JYPnOAiVKzQn&k4U9zPPlc>fJTx{o77`XFi@lhen@eIZkxTE1
z@87?BhMFe4eXACD;|8ac6wA@0M=yOy3F?^QN(Uk(fjG1!d2s82!NC;W=L-w&WNASw
zMeFc?^2AB`@^wm0uJ4nRf`pPUDAOD8rKM}Xd@&ln
z4~{`gN(sBia|){Xh!6;8C-6{0A!pD8$+E|+ElpJi(aP>Wa3CBc(zIfE_6=XB2G7nE
z-?i02uyy&WgTSx!Q%z9d(
z%3pW&%bl}8&9r%U?AgPc;0Aq-Zuf2;BV*%q@BIAyVy7Eh_Hf`a=?)e_=r|R;g?Dzf
z9f}|njpe^{?X14j{nz6qJ&FrUN}`Qho10bC62x`Ui?Rfd+4qQ0oB(7~ko1_9Q%jUQ
z2f0vQPZ1rc4!cmaVHY@UFh2d76vO7A-G?nh-0@kvr94ZBeHU6DX3cq5hjihvZp4L!
zf__r?sjnBp>b=M5sB3KGgfiLD(c%7gIL>P1`0?XPYYBKp(7uK~WoZ+BC>6;7U-(E0
z|9}8GNFQM8{b)Uxz-L&0=2}AbaYS!I^{55fBRBn%C;Tpz4wdt}pgXQ7GS5BXhH$kR
zqN$vM0w}<`lP6EcAGsLOqZf^)RWZ}Bmsa)>Hr%0O#}xJTcMlE@rcrR3de6tGJlD<9
zBNbZ|TY!BgpUyUYwIFbzRw*I!Sv0$sUs1>1N7#1%U9e0EA=AJh!M
zv{NyBy6>}f`9I~H-CkB!_RMKyTT7x;I1b1FZt?iF-?=@jiJF?4;K5Ht{8Fsm#F8IV
z{N%|M@-WNEkzjJ+*T*vyM4myZEYwYBACfH3Gq66dh8UriB+Wu<(A61$mH8%>C?SrJ
zf2raQ8rNbci&SmIS#3y>4>z;7-zp>|M9n@u`hk;ZT}pEu@7P*Ygi2j_0uNIoL!AY*
zij-i^pFa-(SkO?e$^qgHh@(|4hkuDiGKdF5V&bEhzl4BafD~P_Gk(+3qA=B4NtUmp
z_C1fl|44bT_SLH^=wrVoKQksLC-a?IN55mo!0>R8gxk-TZ{KdgX~{ILmL?T?hdycd
zYuCoV6#NM~+oH^^nN`SDFbD;Qkvs+De*g*$GOG)zcnXY!9KKTbG2@I&{>Q#PQ-bzu
zxeNbn1qllYT9g)!Lx(h6CjeWt_?6KzRCX$!=dypzznr1LQ}^=v`ugEFajML3?u*){
zEs~-X$QG|eVnTvonL}TG+uba?*V+xYfgAs6B=JDWpHlt+ti_B2e{~K*f#X~H*wz-9
zl$4}%R9f0(nAu7-Q8t+tM~p*2K+V0a_>Y
zYhoo)KXCjx+S=N5e)>WT(F(U1h}CBgR62c{0nhp1VRe@SRMcDK72lRUOdnhX_x5bTRB>80jei(J&
zjEeANS5c~5(N3Ma`&+>Xv2DW8KSH5JH?y*#|LfY*Ydu8Q9HSfRDzb3l%Tb#}$2idT
z@uO};V`C#A3k}7Ii7(H!Gs@@Y=Hww`fhfQ^h#6|$-wF)-Q0kgqMmbG6l(uLcXoO0x
z6LF?KcTD=wFKvu7%9Kr#q`fH#VY{wFw?+g^D)b3jNLta8Lh;{99r{crIgQx^~eGq@56`uVEI6ha`qnB{3wBYkExf*pig-2
z&pSx5Q&IHt_sG}VfU3kY-S6>erN#7XB)(Dn*8(sMHgQGPK4I9y^rswD7uU;)ycexQ5
zxDSdok){|??m1c7sgY+O8ndFVt`3Esg6Idn5^uLQH}^kiTuu-zNiqd9l4xo%6dTJg
zbr*Bl+1Zf_Cy-ck1i%js@g8^|2QF@b=?8ky5X4Ku4-Dy&qyrQmB2k9EQ)IX$npayy
zy>sx}H%fv$@OU_?JBsyI7srJNKWvMJO~nV);`g}-zyEbE+qAl>;qQ?bF5?>sJ||jM
zNq1VPnT2I#9qy9=iE%cx?ct>1H&%~&v@h@kFyGI<>PRg14%lNg(6ZlGUUPdW?cKAl
zQ#Yc=#o1X7l};ovV{
zYz7WGeP4uE(<^96d{^4Tq(g#&rzdC7aRw%z_9>ugYZRDBk^0->=Mw83L_aQ#Y1{!{
zD4H4m{@om>bhp^m{r8XBZw5aZV-mIPK*I>`8HaGY&Rx3Juut~XsdS$Jl=-gbP8mJb
zSWuNzx2dl$GRpGNwQVa}(3Z|aDhdgq2E7>~tuqac+buF1OVXF^K)iH@n)>;4vz4Yq
zPjh|`FF#-kO7)r&!1oQ_Od>H{1}Au6mS|?gh+=e5EO@n
zD%`zlpB36&ySVEu92~Y&QBhfk#o*=uI!TeCxVTwPshjEX8S?!5w#Eye$~hc#R#h`w
zJ0qguFiEv=InzmN%T)LQ{U;Z;lKog)Tbt~aAR{mLI#eV-4SnG9S0F*!+rXmuT&lv>
zTUMf#8Hth}>xg=FFB4Q5-s>5I!ml|w0*Z=@YjH+}J!UN*O1N!%{rWXoLQM*i?XK`F
zbD74^K0D|X7ZZaWMy|j!-?b|B;b^BcJXt0Vfm_gfr{_COUw!(tlV+E|%ev4Vx(bOt
z3j;S6zCUmX%T@dvRPY+61MW2#tz!s+_(}M5y5FsHu>6BVL!uoCad8>%1jppM#V^{}
zgkf`B674kk`1o}DPobZpyG3nwZrsKkf@-^$G%Oq)50MNUV%HFqwyt6;8dCl#jr`)0
zepCK)tJamGai|;ge%~$imG5o2>k4vs=Olw&7F3n?Yj-oewlJ}<7=QCXYalefaeke>
zn~<>e(ZcI=8tt-vd3kwu8JX(0v4cHj_Iq&x{))_RxEUVK-!2O0ZU#t{AV{;?b#o$V
zPIxg-OibLwX0i2BGhk}&l=>L(MDjng0Fb5EZ`{IDCSP0v1v?l<+}481-%NfZQF;Z?
z&apKcNbT&(P=k4=Mn{9HP$lIfFKN~0j#Kspr+dyPNpc*{MAuPS%Uh=Z5L?{-I5T#G
zRpZKmGl~766*jGOvPw>)E~D>HX6)WFiEVq_XZbiWDoGW8)$tTOB`8*p|8$9j-n>aU
z?bRPBPI@5oKB|KN%33s5(2Lp=oxsv1ul-h=EJFKONBsWzHRt!0C)~|{jC_2m8pL&bBRk#Y|ooGAu59Op1W3$2Jspyp+ptTg!eQyD%!j=EV*>2
z$LXj;uK*XfMZ?Vxyuod4zpS!KV2QzPTSox?rf7eK)1(Nz2a!_J;ETmkZy@cB`_A;!
zK-o@kK9gR#ae6IbmZtgLyP)do>V{c|ikaY@Ltp>}^DZ=H&DP~q(1~ucNbDk}|BfW7
zs+L=8wKa~_$7oBZylZV0(p(9;1rHZBqN%Crw)E2=@A>w#q<#PP-MjQyd2doI6fqlu
z^`om?=;Y)yFfx+ybi9)1-#u<+K2D3>*a+ZC(nc~XfmF0KtP=k$vG{D`;rMQMmb
zW-kfnsb1re;n4dcO4ufF>{hPTTue+_&0
z;F#(rcQD*oA=7Ozd}B&4x(p8va(Itb&vzIW%L$>kz6##@3fFty$|}9g3s{;gA;e3G
zsfqyLoHwkKk25lcfFEi~tUp=~|M--}xmDqw)U~6y3xUd!&C-0!%X6)yw~yUJ%Aq*p
zF9cq_K!4TYFudRer6UeQo9ddezD_BsTgWZeA%O4gOtWe;GX9l*=SuYL<@
zsJfMQ^7*^>ifL32w>Nt17E
z7!7hrgI?YJt%tk<;5K*M_4OZ}dvbxaE+3ys
z+UDl=hu+izA3!z&lH5T`vA!)^BYs*;hUY}+A_
zKy{P{4^lHn^Zt*=ub?Aw!Mh-Z_I=#k3QR0$ou^A2`dCqTYT|`0(xgqe;8F89kG`kC
z&Zz;63TSFlN=r+71Z++6=z;O^oZ<^pz;$Gp;+yjxs8}~{-MXccbllL;kd(5Md=`0u
zErRe+K>1Qp-{VEB>6e$6Nt@(fVkL^E(-8Oo6)vS|>Br}%LSWwmQ&W*-OG9~vvUC#I
z;E>x-BOuA4+8`Pwb#=WxUuh)SzOIZHRCDm~P{Xup#9;}CGyDpE3pT;@@85c#Jr{p}
zc1VRY*j4Q-V{UGqc6k#}X;eZd41Wkh7C5e5mDi4ee$awOtE#HPYmEa
zW_x*ii>k96v2NRs8@2!ef95*Lq^73UKQM3|>sNzN5O@P6QMtYUupYPU=zGqXOn(S@
z8My&&fCJDNn}r@RqH9S5Vx^7IHfuwJ4hl&veE5(#{{DR?XTCUCXy3knk3F8%u6wSs
zWARx;vW2MS3Ywz(?}>Bwstfp=FY@y9(*XB_?bXBkh)6zlBi2ocfz@y}M9E?2X8E9n
z!-U59L7rRzdZ8d$%?q1YHCziyrSmOD^|zj@PWENKq@^jXicY79?u(s&;dYGLO*+6$
z#I=IRdtIJ>wH@TWti+%hTHc{+zwNBm6;M~ZdU|3n#>Z^LFM>EPs}Zr0D)FgN*jnC=
zJQ1uHRLMsbwK>k{HRLB1Ui)*I87zS8FDUPKAo(L8M_M2d^4yWdX_lx{3HlcS)TKsH
zs1~7`W{EASHPZjR=|EkZ-rnBgNq^Oc_=S~C5@n!@w1-a`t6FcIx`Tuvcq
z?%#K2=H_1g)BRCc>&dDn#=$WJHqF7ocdVImJAo(NEKJWa^a`46NJtYki8whp4$DIH
z#h;tBQTRy?4$iv&lfIp)1rQKruc)99tI7-+iD7G$WcH_jPbjPL|D+rFA9)1#sM+N_
zs7~rIL5(lAuSyT)+wS8Ny5)x8|8s*K=0`qt%XuJ8xG9tbPWG!eZ*siW<6-kzOhhTh
z)I!g2oEelyW#m;VUD
zT1@LS_Ui{6(PHYDrp!XFNWQH&LMZa1MwdxHp~O0h0#|8|jh?x3@;fZPyQAIR-C15O
z-SlU44l}!-j8Pac{S$mpQEm~cTY8zOv9YSj0A=gDceggNYHkw7MOh3t$8dR0{1_Xv
z_PZ3K#E8Df#n;GYEysoZ!M7E?0u6FhCpeFgV+cq}G7a@f!@=MaE=}DTe34$AZrVk;~|s
zL%%VzwKd#`AaGg9%AJjVGHoF$p~|efDv%uEp>(=``S>x4{Oz~PWZJmTB)(lOkxQ@h
zn9bB0#|MZMWrG*7pfQPg@M&%+BduhaPo$5+%=|XiJw*$SRE&X+&Q5$O{dsA8Kb-`nEP--^zw~(?dRTH&zwcr`}TaRg}-8&soiVNR3z*u38SWmnRmP4+lajM
zxBWyv#z+f?EcTXu=HP&YJM`i%`Ypj7s!tK-
zFA}=`p7TG*2m;^K?dfl?caR0yZFhQ^MdLOB!!orYQs=0tt4ot3#Ue9s*JnN};^2dK
z?%&@`?3VUAzPi-6W+QMQ@B|z(Xy&BSMA|e+bs&w(r^(!q0%(rRpnp~tFKn=Fumk~!
zHzIYJ3AHclM{kw4gkG-x^^*Y`&m$G$85VCMr#9Qfvy2qb!eF>i+9VmSh9Pn2$j4Q|
z#HgqM2<5httH3x~_4?iR-NhS7v;z4x-5ZB;v@IP(T;C6Ra@;uq#Ge`v3oOL8F{<=r
zK+A&~f8)V}y*NbvZoM8WmjvM%x5vzcN_2iA-+e9~BR+tu6^60Htfm
zvYu*N9hzQA)%PG8#!st$U>v6)0NM2c%g?+%kYv`HC^ZUUwWE_q?XNU|k$mX*zI6n3
zipo#yXW$iC;`T}<;xFRuJ6Krqv=nQq6C~W2Mz`@*K`mkY+XFQ)1nPc_vH%QPTC{Qb
z25n%h84~p>OD>j}*N1UT@gqArA|A;sre&FctcV8h6PT79Z+0$UL$sm};_$C4OY)1b
z1A?-$tnUKGR*N~}E
zxVif}q=9T^!zwQ^m|ChvZW-zc`vPyT;yar6HTd(e4CZiu&-KZ#4-7{C<1t92k@xARRhm;hHEH#{_^N1xBTXYtfDk90z;_`iD1U+~im^wk!
z)z$T5iIvpUKB>O_H3;iBM$g2Awc+NTfYH%Q)}{lEPq0VHJW8{;Na~%$#Qe4cnb_G2
zh;z*Jt*tVGs>J;s85tQ$jgnwFep)q?LTK|XaNkl06%VKY0X<45hXH85<0#+hGZ+6zlduOL>EnzWA&i`Z34q;^Qf
zv;X_|U_7=gNe*s4Ee}z4`j`&VVZ0`%1>y3_a5IDOg}1xASD`hAM@L7SkMl1-E5m(T
zIWjVQ#uu#$l;JehA!L^}1S+EKq2q#$9#A(s(S1Y{`>eYZjG0ej1jk-BS)-{%%Oq$C^$+UJoB7J#V!7&}3CKZw?inHt7<^`I`)5$Q1dEULumXY8Z-9yf
zFF>fM2a8r+dFDF$KG`$ep)Q23SRbLSRNd!bxa2rR9vj<%{rg7+FC6wEyHcA&^-3_Q
zKlWVylt~Ajociq9vt&*WCLoev>xq8U5jc^DeIVx0N2+~NFfmE|#48C~3Q?{TT3Ynb
zJI-5J1b{@Rz_vrI>Bh++!VjQ!2zjRVEH!Lg-Hm4^zP>nHCI!<4_*B2=XJ-K$l-)4U
za22f0=NnLyV)y+>LAqU)Q}+6ZAP)#+Y{C%0JnX9h7)5PW2=rvL7)_@j%^qjZXy@Ht
z2Nr@nI8)^3&z~)@15jD=OIqJY+E%apHY82ao`}fEW25uVRu?ZG_}uaP!z?+L0H*W$
zw=NhTqBEq`rmh}w(y;OMGqMAZ;IWZet@O1a+ujN>tOn2NF{C1a!ew5<1o)>(Vdqo9
zk7U5QT)Z7m&aB`P+1c4o4vG1$%rjOk4AMCN__PTLUy`<;G^a?E`R*~2;O5MC#B0GZ
zX8+W;*HOij*nK(C<6oXX5qOQHPoR2dyB@4WyBDbEHi~C(%=BZwF;v}POsMiP0}E*;
zlM#7wo}#?*{kn2o9>zhmUC*whme@o5M2utWQ-{6=9Gghg0CN-^V6>M>zN?`q96yd&
zdQudgVb$eB6-MWI_9^8fYBUg3&f9KM-9b&NfpgdM2lR`{&g=yE(49>tCsC0aNXi-&
zWpP{o7Z(?oeEKWc*ps>~wx7%L?3Pf4H-;X7rVsDaD*bl_uu-hCWK0md!F9MxK~q&r
z>SYe(CajJ~9v&Vh)ADeas7RFv)G@oFbqlYsux3YN2{^!RN%z7DW`waxEt-t8BTuVq
zuq8CCHdZoQ2W_(m2iy7ueo|iA$Dq)R!o+)C*E+GFctJ)9vtCHJtcTTby|PjYKTEot
z-8_xZD+VB@HD+q2ZlMo=MWQmRtD&H#F7P#QM>!>vsY3?%t;BEYxnNoH%F&*M~bEW_u75T3|x2{&;B6nTcphDA^p3@Jbzt^
zS+!9?|09QZER_?})6<)kbX)|PaA?VR|M%9U?O08(nR-Sj19uWQ12Noizc;F)_G9Rm
zD(}4@g0isj(!Akn@o5JmUxtyJp`c~|ow7{|N$azfJ+6?(gL?AN;GjROsD9Mx!}s?u
zLbmGy?pXah!UoQsj3qXR;a^^_^nh0fJ$nPFJmib@?!64dLyR$7-6N{by6uC5j-DoKsDNDA~K%0?>UP^JBYVp7!oo
z3?p47%xq*f>>8>?(#GmD+o4`1<;i;pH-i*LS(#
z66%Vb{c6DpYxqSZ{8pZw+0_g*k)t|`fMt%@s~i^0B9~|{v?k^i_cb?f2BagW+e#3^
z*z)t|PryG}Ev>r^bhm=2HjNsdI6=S)H~A(;T63MIzV`2rlMxH-adHw0Ycyev3l~&1UC%7`ySE?^xzTA$D4MyoDF-378A207F
ztU%)#nH3$o1n2`dl9Jd+&!^wR?FOp)znmn(MhI1^$Wjqx>5E_%^T*Iq7Bj?3re2>V
z`?rZwdr9E{wtvn?PD_rKD8*kg>Guu@!IS?r)n}S9d>8#%w4)QkrTH5n<8qyhr6qVH
zx+p{ZqG^-)v1i4fQ>v|f5hWQ@lgdUwKv*ASZm#IYF{ki3yxUJb-$bCVY#
zpswz221CVx=d-LbKDi%l({phBC0+5DQp6<8pqGzwDFJR-u$c`7F!
z<@x|J;`=dVl}&Gme1K@|3(xs%y`;aGN()7N$(n)Y4y{qg&CE~G(g!e02DN!iCto1$
z(jvOfG;FQr-&FohxwX<785ueDzofYJ#+xhy
z*igml(*Wo;Y`oP<%q%Pe6BAot$S1tHfB!xiUBEP*U`1smVlxgT%^;IB6BQe1cIjkV
zHHujGlw>uGsiQOp12Qy6fJ6+T4jZ%^L&H2SCN{S0GdDf`5^GBSN-|&M-v_aP{_bt@hs4;;Om;uafaLH$Ak
zt9qOMMOT+T=_ehfeSG+;n;ZDb13TyEM|TKiJbp~FDbj>2DS&T1+E*=u4;~mD)wlH6
zv17-tpI`Tq@$=c?H#4hCQ>l>pGYy~S=Z4q9Z6oJdL>zi6DBTo=m@qDzuJdd|EA&%@
zXvmDZo$r8Vg#0}WSeSSW$8fZcy-z+>G%u&9Xo2u}aYq>my-~J#Tq%=anqvqtU0UJg
zTwu|3U=yQ|Nwhs<)s#Ormd?cf_dPd*^9@S*9;+vWWoc(*GxJxdkp5M8UO@@u_TcR@
z%Y{u&VV=gn(g8S%kHapdI!E&p+ddF2e9Y=mU}>o+8jY2A7uqMk_g$(?b-Ubma*YUB
z6;rl$ckcns(YW_Yn-KvjQfno7>oN{u+bW_b+#YER=y`)F}i@6cPfbk7;fKcIUZr1(-j{!nrkLufK@NiU4%cU@;_B@grnzt^&h|+!hnAc0t
z1uGDQJ6G}zin@BL9CJgtR^_CU3@1)CHjvENqM!=m;`}fHO*oA)f`@yOn7OoIs)9!cNwfR#wT_
zN0<&2hm>;@7xc2Oj&eJjv>aN_^2&M`3^O+Eba2%-K9=2GT}_WC
zHc?Z*L^(Kw0SFTEAuNm}zMQP=y31dlU5A7DrNTp7ZvHUY#rVj`8l*K|gHHRBW
zW=F}SJs`I7{Zn(`4v0Xl1H<7=aIm)C1Qjsv2lwDkKDjmRHeMZ&mSZtl+mLpx1LUgr
zU7ch5kbCY(=|^^4^WF&)ahD%yADs^pb$HzE9rM_f*2an_PWaXQR1O)@HriQ1LMu#A
zmG|i5=)x(zd2&ct#5hAka|Bf>rXA9jk=-6Zt%N=qG=X+LR)D^9&ykR{)@|wSH5rM=
zgRykM(NN5og|9}3h^Ik48R0zFO}02gZV3s)k!y?JqRy0r-B9{|Pj~b`vjEiU$+9{&
zfV{fr9!kMxs9v6>f%(NLb(jUS;2wczZ7?!_PcP327=&kTUiHb7C%WACHYPq**(KV(
zc`PzCbQ2iL4OCvnYdG-v&2rtyPm1bXN*@HTg&Alo>vQF6`nvIAR@{N_uDg08n(TTolwtwIJTaC^{M#6H9
zUv%^r!9Us6-HGYjonUba?(Wa@QX@?%gA{|aRl{fuVYniut!=sPu?A27&`tq
zzUPaDm)!Kd?TDzT?!D>{w=sbcfsV4v!xZU`x(bguG7W;!#!JR-164lqr_ZEWUcMYb
z^33KKe$vK8Qsf3~CFRJ6u=zBeUN$DtH|Z1N8>aDNeo8WGa>_nFw0n|a2X_BrMS!#x
zh1NNn6L1oWi!6+AL~=ji9AQ(|Us{b6J8}f^)`usIj2?cVYUl>7%2szB}1zv-oS(y8;<6w;!=&pDUs%R+Iiz972G6i_(|-0b^oBAF)sP`
zAm7b!m2aze7NASeKkpe6f6;EcJ)i!EdfC%)VZYs#%>^z9>KY(0dN#*ehfD~k$kQYk
zl!R$H76w0mE(VfO5a;P)g@*txm^W=`*rQrK
zi6Yi_n=k!rP6Lr>di$2lfi*Yv;IYQp9F*mDOA~?sysDV2vGeaj*0h(q+~Nhyx%_E-
zhlwsea#vutzxfSOZoQv~R77$D;!Wjx&}N#gLS?*Fl$AB_9iS!NzI{7QPMh&*TBx#)
z(LhT6Kw|*~m@n@j7oyuCnB5v>Pbr2>b^{RTJOZ|0TCo$t(-2+?-Dk`L8lmCt7o0qc
zFknDS*4bV65&t}GW{2fL_fA2K5b;&>tT^UyaC2l^tf;sB2D+RT#~L-&E4Y)DDFDfw8gB+qZAeZo9$9o9}*7ZkQX04Mk}K
zLCPTT1%{dFH2;z#PNdKegP0(vK471qT)sJWD4Vn(HJ|r0?z!VhCeUD_SS^w52Fnqn
zEvIvC=87O)%yR^kUVi>;s4`9LLy85y$1vkg%?)IhJA1!7K~9fgug9H|)45l~6&cd}
z1&($ExZT#kCvpdZ|7abhpwlG)p6a>X383_P
zbD2|eD&zva1^H#?;!5wDTaZ@}x-WI@_a*P2C_-X+o2`QYnKR#FE`A48NP{Fccpuif
zqd||}rS|xfOSEg(g=cZgbx;3
zjC4ku1IvYqYd?7x$tx%fV!AAtIy6(3=S%bC$OskEKiyTpL@G(!(J?Wmu@mExj!sVe
zsXSSS|G98Y3t6`IFn!Kir_;cV=_uYn96NRl(GLtRpVT?Gfs#^5@GDjtKN9D?&2MDA
zAb6P3whx+C4IfJ7bhvjNG~y}MCq3r+Fa{)^uK5|G#LP^13|8(kp&Uwl>rj$^ZvsELGb#qUibAt7bKOlDZNRCUOGD&
zF%_HDKHm`xfWnGz>Q{L^?7=aU-Jq7z*51#^+Uj^rx(uVo*cqEQx)2qtG)hSo#?IH3xN9)Qeom1`!V?ja^wGai#s~xI-#Fn&2;SY
z@?6=eF*lbtZd0LwSUf@C
ztsBZLo!{y$ZEa}`4L_IXH^{6be{xX~qje`i3el4fA>4&gbuv!&%z2ESeBBY2fwY;B
zMIG_PU{I0ExE_RuJrK#UoMPawR6;@p23Z$Ro}_S{>b(VAyARKe9G627fwalans~@_
z*&}=e;)0o|%uIrKh?z>T1A@Q|DXGL<^uQ$?clogsM3#y`5?S|!G2*ovh=|+1WrHXQ
zGjkB%Lv1|?q9}|w+JUk(X|DxZTqtNG4|FKJC?*V#!vbQmc+#faEWmd%Tm`2~4g$Dt
zEX#360yfBKPbojyn^;(GL0@G+TFXBdZ7{(O|q|uccy)Z3!CcziV(K^3NU&~7o=h%sNRoRTt6D0Eo
z$pWv1)~or3GwO96SY;g=6w-=NVVLZP;0cT7v-uqY!2UP*wTP(aEo%m$BS)Sbi1k>Q
zKA$j7>?0$v>26oA(i3&K#d?rw0n5Yp3_JmjuV4Tz!Kw!+N#G5n4bog}8lKJQ^~DQj
z@Z-;}41J2dg#kK(cB*17qNfay|U=xhN!NE3oEmr28XO08@9mNF0}-ii+i|r&$Nd_8qc%2YW#n??}Q#ra7YLJRbZ8QbC1X1s8aqCd^4A
zj?`R*sutEMC@B25=`*~0f_yCi@v^mb`w1(mn^=YQnRc(Q-9?Ps9PkuV`+{)6N#Uhp
z<@aYkYaF^yvw5b~tfaCHErz^wy#0#}DH`$`ii?YJhULh4Puwk6AIw5w7*;wuI*(wy
zl7U2nl1taa!ZwppGMLD(a0p4w!CE3I4qTRWhsj7Y{1#ZQ5l9=7c@`Y)I?(tln16)b
zp81U|7I;5^-`%_Pe
zpvRg@v!DlF=tfH_sDJqm9@KkXaOw5>eGot8H8t-v&lVRSMnH!jQ>Pfb&s#=4+(baX
zkcZHbC3v=kBRN>m1A-|7LAs^nXr|#Rv@K;pPn_O4#WKPUogDjkN{
zb~~0$+DqT+9LUHeD6z!8hDf%8qSBvuy@f1y)TZ_8*I&UpX7oHRf0@Ha*S=??$C`Tc
zNfQ?n$YOkdV*)BLI(W;9rwwFJZg{1lLh?MqB18xbrE?a&NGD>rMK5*V6v(00S2DXV
zd>TBzWEGZ%mi^zkZL^qD5jhz5W?1V!9ON7U@`VrtdHL=Bj#goQZXo?DGBjZOCa
z3Zk)>j2@46k?#>;4|L9%!PW2x3T_~_;B6!pCQyb+cMc>vv*Rcao_>YSG5c3ZI5Ff5
zJUj#_xue=~nx8>6vuC{TsRffK1Rxw)1+8D=Fz!G>
zCh%HwZ;qTUIt_W=#VD%h71^LyMX@%N2%8fx5s4Lf{QB+N+$%Sz>jm~gP9r5)dX2KPUPR9wEDxdkoN&c~3$E7Pe}RW{OD-
zfAZvrU-Pc4+1XhGQyGE`f7I7+z;#W}%|(6x-2M$4SV=|2lY2h%H2zfpI`+4#WKX|=
zVfZ}j)RYuQG}saS7x&LM(vX+}J>%>H)6#5sg%;${zutFJW@MK3+6~)@3^9`vUWjjS
z00Lk*M*%yBl=A@!K3!TtMj5XTWJLbvL-Hvqa!#0R&akO5+;S6Ck07d$h+=Y^exL5U
zwyF>78{)vg_wO4Ky&v;Q?=3s&?tUEdt1y|1_VB2|)CMBhWcG}V
zx@?OS*g5!
zDdivLci|Qmo(X*w^2z!54to?6I%-DQrQ9@qtHxq|v1d`tF=V(j*
zp|P=oc|{^RCPuk6P4@=gABqOdxsvqo;Z0x*5xXv0$k`v_404>C+o{hZ%NwD3(jw<*Ng77BFV88me=D_~1ElLa#)Q4RhIN&$+_4+PQ1j
zAh35kQ(%2V1Ba+612BX52u}pCEiMe3PSe1EoWwsaAu$ATFiw2BViYw~GvPeg-LHwl
zp$$0Icm99idUF5kc&5%p(urO@Ehp#82B@EX1iF0?{6~EC3eb3Y{x-ThCU-Wm%Nd{b
z2geSvVf+`e5BaYk*Bl)GFXpb`VoZ^8zXz#`%e@t(eE~711pM;M08j<_j!Ik?UXuSFa_`(iQ47AkEA0J+TvH^lMW?xU*mLrp-JcifcCaHcUm&#77Z*%%mod$CaUtn`vmy+uDXh)K7ssZeu+(G=z8&=ZY`TAe{bXQZAZI^_mv~Jtrt!#G447cI
z5wu0Cz>5P-RZR8tg2}mKU>kfFK}}u^Sdp)Q_`hm9_rIR+{*S+NNamDbEFIZGO-|)>
zRYFdMqJs`1(sa;_WGjba4z1)|4a>1Y`P9M(CDl-y8Yz8hn8UI}%_%ul;<`Uw|HAkC
z+qK)JdLLfz*Yo*&oL;%FZv_t>o_6OFec0fhy?XsxR@R+_S^&|D5LuGPN<+fdy$~*!
zX~ez6d)~aQbQ_8tysR`yasFJ)!Q|w2^imV)kLub*aPoIOxfOws%%C$4F{PLk9YSL2h>wNzp
zZj`T|-;rT!VD}igr7MyNVSi`V#P8b|i$|VO?hwmL@5b(g1hQ2~Kz;nUBb<1kCyGuPJtt25xS!eiPx%oUxfC%{
zPeeKj)qKDs5!W@I{C2ot5w2W>{9dqh>HH@lO+d7Q+mgHT03<<35-<#rZN)uiYfC9z
zi*&>{ARwCUm%ZEA#>RjfloSAmX1GnM1B3uGyo?qPaU;d
z8X~2FyJUdwl0A2;Xl5idvdXZqsiVU6X_}hI4zp9K~UTg^22|WFMb=
zO7_~;oXX)WAx0^5AnCazcnqoe!2i^|?xM(?gJ&A82XD?}i_y4wsfF~Y~hBYQ0*x3$Q9+ZVnMiA
zR5aPokaR5xGRey2x#9q&-&}|cQ1CLda3=8N(|~h_*){b_SnNGePhIz*f8Kqq{%g62
zYrFD;S($C3-lAv~q3}ku2wvIjMUtm#)&yiEnNrHZSGNv6M^U7sTr4ehipb<8ctwKP
z2>EVlSb`!jngL!_Z;ND^NQ;!BR!werDCxe3hutIfn74zkAeN>tAlKqNZc*HTL4UxX
z&ICg}{>p6Ju}-(O#Xi0sFEdM75hJ5?J)>va*KZhg1|6zwCEZufLx@-3qQC
z2}m+jEMGnxfaP1=MHz0P^opwiGzAGl-`9nCbZ-7y18%q{7z`=$4CVxv#Hl@>-{M_e_
zjgsQ++7QpU2B0J$EBoXyL=plKQ7_5&7=V`H=u0m+BuZ))qbVryLgG;#{gpj}Vy@ex
z#}5on5)leXI-YRm%7mZAs4``%z8GV{3gYO5tiOM*DA-tkq(LC*s0~*r86y;7XJ_Xq
z<~t$w1`V1PlEgcg{T->L@1jK;fWnT@CV~eDZ4dIejW|6DX4*e3&mup>qMw_fvyK7i
z(!F~|h>XZslc*sw`pP>r61Ic-lx6gx_XpzW}{yEWlqfuiyI5?a(
zJeA*{Mv;zgLtI=JxHuhPQA9O8AQP|=440rC(bxo)og!fzJW4dQasU7m?~QYJrFB81
zMKC`xPJVl#?W*}tRN6z4vuT4{Nva`L`4UjmdSXG}VIdA`BG37wLXdWdcX62xl`KTF
zqz6F66L|;UV(n!n4g9JFtoJQ4hwJPa>iXs6@KU)pvL(jXH$V^%1B7JLmah=FPr_Ll
z)u9d7!}x;b*=XJmusIt2nt|5y$iOVq!Qn(o^j0>|W4^`OU6BCKAIn2=%x~DuigL{N
zzyO}E-a=5yARq9t$`wdGJ_X^V(~3rlm_C?JNq4Z97|I#&JzGMQ)C{ciGMkcHHBnkb8HtL#G6d*@MQxYc195@wtyV
zZ}(0u-nQZ!*N_>`r^yMYD@AYO{@{He#jdislL-NK8?mTeKX)QED4h#t!2Fcm!>q)}
zCgKZ{NX(UJ0Eu+fDlquj={^MC6rbb^cp;EyeO1NIvpD~czd9DQ)?@?RLcEvE??>g{
zOR49m8QDU3byR%pB$Z(N-jiU2yjMg;n_=rNf*_zV>eyVIxsZ<=ZPh>%S7JE3a70-CnG);rs39`EQw{v=fz&iQFxYY8QZ
z_eV#%{aQZOu5_QXCB?-e_-gMQKHyMYlJXJ8<<5^MMM|ny0(n$k{x^ZZ$pIrKgXeZ=
z*?Fs^vyIQ(2AmCMyS7lGk!S?Xc**{$bFd*{N5kf0XMV_~Tue0@83GjFFRJ)Ud7s@VII+{N8(q|JU~v>77ePM#z&|Bt9BZYdsr7in&qRerVm
zA6(z*)Z-!Q&;Mz~eWv$v>FqN!6kU>og61!e@jX&!>oRcQ!0mZoq-%$R9b6=6S~@rwot~Si|IbxW?%?;#I-e-jH=M?4_NJyGkazL=PGdAUXEg|4`KyWEx)MyG
z<$6~;vpFET-|xXtBf#f3e)_=fu&bCb@v@&%!3-l7Eu!r#Z;4rRQ-Z&ix`a5l3zx19
zxHz%MGN%3|K)UM8^r~*h1ghsLY1yrQd3BUo$?hL=$>Iv=k^rfI`VU9&2hgo#vSCGVLRzkw`S4uQ`9|yl|dpDam
zch%y>p*kyy^s<#J5NT|fZaNW04g<*h>2*8N@t}I2bKZiJBW5q&khXhiq-)CecCBo5
z$f=fGHJ>|?j1N7dy$M$qm0v1kv6r5Bhl)OM^*wxP&9{lBSghysDj48~KpEAtn-nH3
z*Oive`oYTRmH+kuG?Xb*!KRI
zU@mB@poJIHgQmExo!*I6B3eq?wYv$F^jNM&^+d0XPyM%>F
zoxtHA0jh1s2WA*hc3r}EPtMBh&_yp<9l9Ytz88F=mR(KGkrR9#Ls9gtnqL*>x$H#G
zQ?0r-S3;lp^zG53ZT8%*iqv)jBhsu?v|A32jznansy7FRX#6P~;;yMYjrv`>EgURG
zH58namAMkVK`gG!_%y`l&Y!=;#Au9Z34419zg#0ho1W6=7k8_>G4yzNQbxr3JqMcYPTLg#f$Le;TR<^5fEEa`=()5tU|I
z-$L8)^6?QJ^%UA)YQSiLLysFE%CY3H1NQY7{9lKG+7gz
zZ0Fx8>5ThW|63UbRyV&9kR1RB$%n1Qyj%b{9mWh_(Ou!%=H)|`G*{FPe4JTp_|Kro
zJ@YR_xYdnGkIjhn4$*u`N((@?RYu9K^*fNU{|$mJp2!uqN5Wyt{KbXKIXTcAm+stY
zeLV8;*2jCty$vs0d4A^Kd>3sFM$B^4Z((P23x4k!^4r<5;~&8R%djJ}59lF);zeGA
zKol$jIeVvERZv^wX)vnL_Ol7bqejgMHjk|fBg%FzIl91m=Q)mm^r5niD36UiW3&Vh4JYXecDU=QjqoJn%>7x;qi
z=YMD&!j2AwE^#JFO<_L&*}W~X8czGCf`S4C4oVnte5waLe!G?Das!e=mJhLb<>7s4
zG?CAUGrv6CJL%a7()nzDcd-m_8{gZ}=Z7fUXF1lf-WT0~J^KiQ4oaY<$PJ<_mAQmX
z!w<(%X>M1|A?xi&&m^=jR5j+L1|I9QkwPkmQAHK2rW9s5O`m?E@?f6&5Z`LRjnpnQ
z!JC;EkU!|i#R)*wt5-_c{pzDBqgOIk=}rjf+?80h`R4v^Db|0?z;#w>>~wpWi+&>G
zDACaOk897&7{nwwec#9~Le+zWfrbwCD-s4{0j1~r53O&s-aUK$3_s8QAc??~PA+`^
zXT5q&JNxEzmtM(^{M-&OJ2u+{efe8gtx@dD-!@?L+0oR$H{YTlbuGWe4E
z(H|?E_n9TXEVi6E*Y2HpZyaj$#$=RL$xS`!OXQ0=-Wf`ihTE?10ob(s>G>F8!yrht1Vpq
zY6!WPcfq0LXtnj9%$g(m-fj#O`VVq+wqt#4#EC~u>ASLnMIWXVuxwJg?HtKg?zYOQ
z`xjF^z;Fg
zob6P`dU8}9D<%_p;Hv^vG1=?H6L(O)@;qr@`_g|xv|glX*qV;+uC7yGxxb&@m2sL^
zuQ=ayNFMx?*^nWLV^?U&n*fO-d3X!{c=y3;n9glm{vDy%u|=d?CAqs12WHQ(j7lOF
zX7KU57d)dQ%k%DCST!f)`Pcq2hWq!9^%X+3v^3Leo3*t$-P0xvTHx`|@2+~LrA*$c
ze_TD_)bK*pqcq8y34Y4obWM;$ySNRW>?JayUH4B@nF;^CDRbnbu}c9IS^QddFS8Cu
z9`!o!vx+nFl5FClisv6gzl-;;D-UQBDzDCl);M7QC}0L+29IIz3*7w*AoECavi;u0
z&f?samLcIQ&-H9@*xU3O9H-bKA@~vw60w_rHT=!>OAkU+O%}&|
zh-}bk_48j{H1+%+5-pAbR-{l6v>k;GB3hm`B_Yx}Cij85hnEg^zS-Yp*}nwQ)el(t
z+!@+w6OfW*){6HQIg>O<)COZfAAuD?nD)Qj;xS_|@q%KL0#TDjToh7-unG3Fk`zbI
z#w#GV3>Bc>OH2{^R3&*!q88vzeL-%;CFSY)xy1F#fev@hiU^7P;WW9Qks_4&5w^xb##=@zwF#HKT(OX-Haig-FL~7E#d;2-0~Of0}v#q
zto4xKI^fq1(vx6vWjl&NumnZ@fL}n+wl2#3>zqWS6mWNvPbLwt^mX(iDPs+vCdFZZcuDfw`n}co5uiH85(Mi=Zb=ax(XA(()
zFPc>~V)*c6OH_nD>aClH*JKB)XLTNF4U($%2V1CL{VVGGYQ!oUz0PB-t>^mP1pk}8
zm!}*T*zQRpD8jmaJV`CkE+AwG+?rZzTYPPXCiRzJp8t5D
zqcD>c1kWwcCLk_F-8lr9Hd)IpJ&*V2s@O0j)`kC2lXM`@;8yE{AYKmU3f_R=9D>%AP}Vrcyi`*ziyyKHHH>>K42@{pj{*@0be
z(xkrqF)ZC7{Ha$+-n#}ztw)AS=INMV2{!l1x3RWfk?LmHxrzQlh-SUBw>j4D!SvCe
z@O}2+I>x?9ijR-Kb-$uGv?}PxPdifTlxBFha!)b@nq0b6%xHEp-LUn{!yx!~C$&-a
zH+Zb&P@{%+nZOY1(BhhhTN!Fo5k?k8*%&cj6#Le!!W&_??
zY4Rxsi!E&2CZk99`R?go9Ox3TFj#4V=xTMUm{m(U=wltG~e8|b+0W0;gf
zJ($!kLd~QOyGl#2j1~sZ*Rd@lQj9kgFxCm8PD>|&R_o869VM22!4#N9KzgLDb=>
zZCc0544+O4_L!4J9UiedPhT5yLXK$_U_lPN1T#!O`7gMyoT(sZvp}Uu@+6M1z8sed
zZroO!qhJc(n5Yur20^_sp{KCENP~P^-SfsqSM0e
zfO|`yj)aQfBFQo2L#HlvhOUt;PRrM+60HCbZJ|~)_OoVnU)%h6Ks#-1IU9vn^(#Ds
zB%l$@q%*Fyv4`S|;=}C1U(Yy9mM!_P_+bf=DGKWil?n9M&Uws`W2yUBqmdQ~E-<9C
zhljMCNKEwsA>{lizzcyrNkH(fAGu-UMhP8}j4&qF1)T8Ep+g5T!SLfj-SQTH{k7Bx
zB}$GU3GU>uV1Wt4jez{LsB-EpGBnxZAzAM~dzKmc`>w->`+@Yd1>6?p!n$=@`UVDN
zP(X6PX?>qHB94+XWl?VPFR7Pw8HPU%_m8RcCc`I$yew^Ci__PBNc$INmcFdFq@hA|
zP^;xMHkd!jOvNRf-mnFs@#m6U@-u=hb|C&BWTlCmn+y3aB
z9lD(0fWI!R>Wvy*4xO+{%|-_WL(+{c<*`MaDI~i%!Z_%Yq3X!1-1cVPfA%_%P4$ut
zRWY^FB5q`=hyOl^#0>&3r}9uzPj-_ie0C3XO!8cqCCc#r%BiCv-_%f8dkIfN
zOhd(9FO94tIsnk1^gph8GdIbB7@IaZ)P_(3q=!LVLqj&sEq&bMe6%fPr|9AI-`)Gr
zY6Mx6`eM(Bawkz)ojf@K0rofd@>F4V3lHZYuo(UoWt-z>kG}|cc?!5u#99B#;GWwwfM|!it>54Lh8e17?
z!#D}*(O0>Cv!6rb(l6BgCE^=MGP5LS`==)DWLuNd!T7LF)Yn}PWy9G_@17P`WE`>M
z54uEVWv8F7Jn)1nn#6iTi=M^V+D!i9;|66f3(f3Q7W;2@w@uSEsO%ZYkL6@&Yt{+R
zUz?k5KV&^8?^Jl+{+GWuvKtujYDC1aSWa+PrcIh@
KpE1FA{eJ-|l+%p>

literal 32144
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

diff --git a/img/regexp-es.png b/img/regexp-es.png
index 3efa6eed322c852ffb7689b108d34aa0a844c76b..b8a76240fc38d2f8eff583137b74ca7ebdc34913 100644
GIT binary patch
literal 34485
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
4q4jOSUh9DW+{=OZi@
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
V9^=zzfx;gX$4xbh8#8C!e*tc?^nw5Y

literal 34234
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

literal 32922
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ⅲOo}+zjETXvtEYZiOJMqI{EuGG!0^
z9;hWbp;Nf*`(+q)1C^44(yL$?W1AiM3;;0a7rGH*9VRBepaVBpeuEj|L+?#wZONme
z-RFZrquxo9IKg?8C@$_eAa(0~d_*&+Umf7@FB(ATo~Bei@`t&>OgCf+20Y*7?BemB
zGigUt9y`zK2m(d3@q?*pdxA2Gw(GoGQ=j?f=H`}#QJ0^Ti$0rJC2J^tr;a+#b;o`@
zja^axfM~_MXZBY4XV2CpZpg0S;PSAmqS6C7l93_{$_57~7O+y##-4<8mA#Lt#rDjr#8rK=PA3orqKn+Fr0ypml15ow?a^`io_EZTx1ra9*Vy)!ta_3bt3;*?RW>BRYI;dCejT)%00%cIeKBsfK9VddmV{PCT@;P1mt{
z3GUW9@|}c38qFDq~mR*HpX>ApJGPmMQA}kgTevkLJ!17I
zoQp*Shs66#JLgvI{;K~kY0E{SbVD!tumAl&1!Dih)SUkhY1;quZ*CYf%2SJ
R%nHS{Ni!$LjsN-g{{YNvA{YPw

diff --git a/img/regexp.svg b/img/regexp.svg
index f08690b5..50ea7c7a 100644
--- a/img/regexp.svg
+++ b/img/regexp.svg
@@ -17,7 +17,7 @@
    version="1.1"
    inkscape:version="0.91 r13725"
    sodipodi:docname="regexp.svg"
-   inkscape:export-filename="/home/nbo/dev/learn-regex/img/regexp-fr.png"
+   inkscape:export-filename="/home/nbo/dev/learn-regex/img/regexp-es.png"
    inkscape:export-xdpi="90"
    inkscape:export-ydpi="90">
   
+     inkscape:window-maximized="1" />
   <metadata
      id="metadata7">
     <rdf:RDF>
@@ -216,7 +216,7 @@
                id="tspan4268"
                x="171.65625"
                y="204.00377"
-               style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:30.00000191px;font-family:monospace;-inkscape-font-specification:'monospace Bold'">^[a-z0-9_-]{3,15]$</tspan></text>
+               style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:30.00000191px;font-family:monospace;-inkscape-font-specification:'monospace Bold'">^[a-z0-9_-]{3,15}$</tspan></text>
         </g>
       </g>
     </g>
@@ -304,7 +304,7 @@
                y="204.00377"
                x="171.65625"
                id="tspan4253"
-               sodipodi:role="line">^[a-z0-9_-]{3,15]$</tspan></text>
+               sodipodi:role="line">^[a-z0-9_-]{3,15}$</tspan></text>
         </g>
       </g>
     </g>
@@ -390,7 +390,7 @@
              y="204.00377"
              x="171.65625"
              id="tspan4302"
-             sodipodi:role="line">^[a-z0-9_-]{3,15]$</tspan></text>
+             sodipodi:role="line">^[a-z0-9_-]{3,15}$</tspan></text>
       </g>
     </g>
   </g>

From cb21fb6ffcac31b88120af264f26a0dbde172c66 Mon Sep 17 00:00:00 2001
From: Gabriel Prates <gabsprates@gmail.com>
Date: Mon, 21 Aug 2017 08:48:17 -0300
Subject: [PATCH 013/185] Portuguese Translation (#51)

* starting translate

* add link to pt_BR

* translating...

* Intro: ok

* translating titles

* title links

* translating 'basic matches'

* translating 'meta characters'

* metacharacters' session finished

* repetitions' session finished

* braces' session finished

* character group' session finished

* details

* alternation' session finished

* escaping special character' session finished

* shorthands' session finished

* anchors' session finished

* license and contribution

* lookarounds' session finished

* readme details

* lookarounds' session finished

* update image link
---
 README-pt_BR.md | 410 ++++++++++++++++++++++++++++++++++++++++++++++++
 README.md       |   1 +
 2 files changed, 411 insertions(+)
 create mode 100644 README-pt_BR.md

diff --git a/README-pt_BR.md b/README-pt_BR.md
new file mode 100644
index 00000000..4f1e1d8b
--- /dev/null
+++ b/README-pt_BR.md
@@ -0,0 +1,410 @@
+<br/>
+<p align="center">
+<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+</p><br/>
+
+## Traduções:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+
+## O que é uma Expressão Regular?
+
+> Expressão Regular é um grupo de caracteres ou símbolos utilizado para encontrar um padrão específico a partir de um texto.
+
+Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. A expressão "Expressão regular" é longa e difícil de falar, você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
+
+Imagine que você está escrevendo uma aplicação e quer colocar regras para quando um usuário escolher seu username. Nós queremos permitir que o username contenha letras, números, underlines e hífens. Nós também queremos limitar o número de caracteres para não ficar muito feio. Então usamos a seguinte expressão regular para validar o username:
+
+<br/><br/>
+<p align="center">
+<img src="http://i.imgur.com/8UaOzpq.png" alt="Regular expression">
+</p>
+
+A expressão regular acima aceita as strings `john_doe`, `jo-hn_doe` e `john12_as`. Ela não aceita `Jo` porque essa string contém letras maiúsculas e também é muito curta.
+
+## Sumário
+
+- [Combinações Básicas](#1-combinações-básicas)
+- [Metacaracteres](#2-metacaracteres)
+  - [Ponto final](#21-ponto-final)
+  - [Conjunto de caracteres](#22-conjunto-de-caracteres)
+    - [Conjunto de caracteres negados](#221-conjunto-de-caracteres-negados)
+  - [Repetições](#23-repetições)
+    - [O Asterisco](#231-o-asterisco)
+    - [O Sinal de Adição](#232-o-sinal-de-adição)
+    - [O Ponto de Interrogação](#233-o-ponto-de-interrogação)
+  - [Chaves](#24-chaves)
+  - [Grupo de Caracteres](#25-grupo-de-caracteres)
+  - [Alternância](#26-alternância)
+  - [Escapando Caracteres Especiais](#27-escapando-caracteres-especiais)
+  - [Âncoras](#28-Âncoras)
+    - [Acento Circunflexo](#281-acento-circunflexo)
+    - [Sinal de Dólar](#282-sinal-de-dólar)
+- [Forma Abreviada de Conjunto de Caracteres](#3-forma-abreviada-de-conjunto-de-caracteres)
+- [Olhar ao Redor](#4-olhar-ao-redor)
+  - [Lookahead Positivo](#41-lookahead-positivo)
+  - [Lookahead Negativo](#42-lookahead-negativo)
+  - [Lookbehind Positivo](#43-lookbehind-positivo)
+  - [Lookbehind Negativo](#44-lookbehind-negativo)
+- [Flags](#5-flags)
+  - [Indiferente à Maiúsculas](#51-indiferente-à-maiúsculas)
+  - [Busca Global](#52-busca-global)
+  - [Multilinhas](#53-multilinhas)
+
+## 1. Combinações Básicas
+
+Uma expressão regular é apenas um padrão de caracteres que usamos para fazer busca em um texto. Por exemplo, a expressão regular `the` significa: a letra `t`, seguida da letra `h`, seguida da letra `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/dmRygT/1)
+
+A expressão regular `123` corresponde a 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 à maiúsculas), então a expressão regular `The` não vai bater com a string `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/1paXsy/1)
+
+## 2. Metacaracteres
+
+Metacaracteres são elementos fundamentais das expressões regulares. Metacaracteres não representam a si mesmos mas, ao invés disso, são interpretados de uma forma especial. Alguns metacaracteres tem um significado especial e são escritos dentro de colchetes.
+Os metacaracteres são os seguintes:
+
+|Metacaracter|Descrição|
+|:----:|----|
+|.|Corresponde a qualquer caractere, exceto uma quebra de linha|
+|[ ]|Classe de caracteres. Corresponde a qualquer caractere contido dentro dos colchetes.|
+|[^ ]|Classe de caracteres negada. Corresponde a qualquer caractere que não está contido dentro dos colchetes.|
+|*|Corresponde à 0 ou mais repetições do símbolo anterior.|
+|+|Corresponde à 1 ou mais repetições do símbolo anterior.|
+|?|Faz com que o símbolo anterior seja opcional.|
+|{n,m}|Chaves. Corresponde à no mínimo "n" mas não mais que "m" repetições do símbolo anterior.|
+|(xyz)|Grupo de caracteres. Corresponde aos caracteres xyz nesta exata ordem.|
+|||Alternância. Corresponde os caracteres antes ou os caracteres depois do símbolo|
+|\|Escapa o próximo caractere. Isso permite você utilizar os caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Corresponde ao início da entrada.|
+|$|Corresponde ao final da entrada.|
+
+## 2.1 Ponto final
+
+O ponto final `.` é um simples exemplo de metacaracteres. O metacaractere `.` corresponde à 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`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Conjunto de caracteres
+
+Conjuntos de caracteres também são chamados de classes de caracteres. Utilizamos colchetes para especificar conjuntos de caracteres. Use um hífen dentro de um conjunto de caracteres para especificar o intervalo de caracteres. A ordem dos caracteres dentro dos colchetes não faz diferença. Por exemplo, a expressão regular `[Tt]he` significa: um caractere maiúsculo `T` ou minúsculo `t`, seguido da letra `h`, seguida da letra `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/2ITLQ4/1)
+
+No entanto, um ponto final dentro de um conjunto de caracteres, significa apenas um ponto final. A expressão regular `ar[.]` significa: o caractere minúsculo `a`, seguido da letra `r`, seguida pelo caractere de ponto final `.`.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Conjunto de caracteres negados
+
+No geral, o símbolo do circunflexo representa o início da string, mas quando está logo após o colchete de abertura, ele faz a negação do conjunto de caracteres. Por exemplo, a expressão regular `[^c]ar` significa: qualquer caractere com exceção do `c`, seguido pelo caractere `a`, seguido da letra `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Repetições
+
+Seguindo os metacaracteres `+`, `*` ou `?` são utilizados para especificar quantas vezes um sub-padrão pode ocorrer. Esses metacaracteres atuam de formas diferentes em diferentes situações.
+
+### 2.3.1 O Asterisco
+
+O símbolo `*` corresponde à 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.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/7m8me5/1)
+
+O símbolo `*` pode ser usado junto do metacaractere `.` para encontrar qualquer string de caracteres `.*`. O símbolo `*` pode ser usado com o caractere de espaço em branco `\s` para encontrar uma string de caracteres em branco. Por exemplo, a expressão `\s*cat\s*` significa: zero ou mais espaços, seguidos do caractere minúsculo `c`, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `t`, seguido de zero ou mais espaços.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 O Sinal de Adição
+
+O símbolo `+` corresponde à 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`.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 O Ponto de Interrogação
+
+Em expressões regulares, o metacaractere `?` faz o caractere anterior ser opcional. Esse símbolo corresponde à 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`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Chaves
+
+Em expressões regulares, chaves, que também são chamadas de quantificadores, são utilizadas para especificar o número de vezes que o caractere, ou um grupo de caracteres, pode se repetir. Por exemplo, a expressão regular `[0-9]{2,3}` significa: Encontre no mínimo 2 dígitos, mas não mais que 3 (caracteres no intervalo de 0 à 9).
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/juM86s/1)
+
+Nós podemos retirar o segundo número. Por exemplo, a expressão regular `[0-9]{2,}` significa: Encontre 2 ou mais dígitos. Se removermos a vírgula a expressão regular `[0-9]{3}` significa: Encontre exatamente 3 dígitos.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Grupo de Caracteres
+
+Grupo de caracteres é um grupo de sub-padrão que é escrito dentro de parênteses `(...)`. Como falamos antes, se colocaramos um quantificador depois de um caractere, ele irá repetir o caractere anterior. Mas se colocarmos um quantificador depois de um grupo de caracteres, ele irá repetir todo o conjunto. Por exemplo, a expressão regular `(ab)*` corresponde à 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`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Alternância
+
+Em expressões regulares, a barra vertical `|` é usada para definir alternância. Alternância é como uma condição entre múltiplas expressões. Agora, você pode estar pensando que um conjunto de caracteres e a alternância funcionam da mesma forma. Mas a grande diferença entre eles é que o conjunto de caracteres trabalha no nível de caracteres, enquanto a alternância trabalha no nível das expressões. Por exemplo, a expressão regular `(T|t)he|car` significa: o caractere maiúsculo `T` ou minúsculo `t`, seguido do caractere minúsculo `h`, seguido do caractere minúsculo `e` ou o caractere minúsculo `c`, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `r`.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Escapando Caracteres Especiais
+
+Em expressões regulares, a contrabarra `\` é usada para escapar o próximo caractere. Isso possibilita especificar um símbolo como um caractere correspondente, incluindo os caracteres reservados `{ } [ ] / \ + * . $ ^ | ?`. Para usar um caractere especial como um caractere correspondente, utilize `\` antes dele. Por exemplo, a expressão regular `.` é usada para encontrar qualquer caractere, exceto nova linha. Agora, para encontrar `.` em uma string de entrada, a expressão regular `(f|c|m)at\.?` significa: letra minúscula `f`, `c` ou `m`, seguida do caractere minúsculo `a`, seguido da letra minúscula `t`, seguida do caractere `.` opcional.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Âncoras
+
+Em empressões regulares, usamos âncoras para verificar se o caractere encontrado está no início ou no final da string de entrada. As âncoras podem ser de dois tipos: O primeiro tipo é o Acento Circunflexo `^`, que verifica se o caractere encontrado está no início da string de entrada, e o segundo tipo é o Sinal de Dólar `$`, que verifica se o caractere encontrado é o último caractere da string.
+
+### 2.8.1 Acento Circunflexo
+
+O símbolo do Acento Circunflexo `^` é usado para verificar se o caractere encontrado é o primeiro caractere da string de entrada. Se aplicarmos a seguinte expressão regular `^a` (se a é o primeiro caractere) à string de entrada `abc`, ela encontra o `a`. Mas se nós aplicarmos a expressão regular `^b` na mesma string, ela não encontrará nada. Isso acontece porque, na string `abc`, "b" não é o caractere inicial. Vamos dar uma olhada em outra expressão regular, `^(T|t)he` que significa: o caractere maiúsculo `T` ou o caractere minúsculo `t` que é o primeiro símbolo da string de entrada, seguido do caractere minúsculo `h`, seguido do caractere minúsculo `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Sinal de Dólar
+
+O símbolo do Sinal de Dólar `$` é usado para verificar se o caractere encontrado é o último caractere da string de entrada. Por exemplo, a expressão regular `(at\.)$` significa: um caractere minúsculo `a`, seguido do caractere minúsculo `t`, seguido de um ponto final `.` e o grupo deve estar no final da string.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/t0AkOd/1)
+
+##  3. Forma Abreviada de Conjunto de Caracteres
+
+As expressões regulares fornecem abreviações para conjuntos de caracteres comumente usados, que oferecem atalhos convenientes para expressões regulares comumente usadas. As abreviações são as seguintes:
+
+|Abreviação|Descrição|
+|:----:|----|
+|.|Qualquer caractere, exceto nova linha|
+|\w|Corresponde à caracteres alfanuméricos: `[a-zA-Z0-9_]`|
+|\W|Corresponde à caracteres não alfanuméricos: `[^\w]`|
+|\d|Corresponde à dígitos: `[0-9]`|
+|\D|Corresponde à não dígitos: `[^\d]`|
+|\s|Corresponde à caracteres de espaços em branco: `[\t\n\f\r\p{Z}]`|
+|\S|Corresponde à caracteres de espaços não em branco: `[^\s]`|
+
+## 4. Olhar ao Redor
+
+Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrêncoas). 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 `$`. À seguir estão os lookarounds que são utilizados em expressões regulares:
+
+|Símbolo|Descrição|
+|:----:|----|
+|?=|Lookahead Positivo|
+|?!|Lookahead Negativo|
+|?<=|Lookbehind Positivo|
+|?<!|Lookbehind Negativo|
+
+### 4.1 Lookahead Positivo
+
+O lookahead positivo impõe que a primeira parte da expressão deve ser seguida pela expressão lookahead. A combinação retornada contém apenas o texto que encontrado pela primeira parte da expressão. Para definir um lookahead positivo, deve-se usar parênteses. Dentro desses parênteses, é usado um ponto de interrogação seguido de um sinal de igual, dessa forma: `(?=...)`. Expressões lookahead são escritas depois do sinal de igual dentro do parênteses. Por exemplo, a expressão regular `[T|t]he(?=\sfat)` significa: encontre a letra minúscula `t` ou a letra maiúscula `T`, seguida da letra `h`, seguida da letra `e`. Entre parênteses, nós definimos o lookahead positivo que diz para o motor de expressões regulares para encontrar `The` ou `the` que são seguidos pela palavra `fat`.
+
+<pre>
+"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Lookahead Negativo
+
+O lookahead negativo é usado quando nós precisamos encontrar todas as ocorrências da string de entrada que não são seguidas por um determinado padrão. O lookahead negativo é definido da mesma forma que definimos o lookahead positivo, mas a única diferença é que, no lugar do sinal de igual `=`, usamos o caractere de negação `!`, ex.: `(?!...)`. Vamos dar uma olhada na seguinte expressão regular `[T|t]he(?!\sfat)`, que significa: obtenha as palavras `The` ou `the` da string de entrada que não são seguidas pela palavra `fat`, precedida de um caractere de espaço.
+
+<pre>
+"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Lookbehind Positivo
+
+Lookbehind positivo é usado para encontrar todas as ocorrências que são precedidas por um padrão específico. O lookbehind positivo é indicado por `(?<=...)`. Por exemplo, a expressão regular `(?<=[T|t]he\s)(fat|mat)` significa: obtenha todas as palavras `fat` ou `mat` da string de entrada, que estão depois das palavras `The` ou `the`.
+
+<pre>
+"(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/avH165/1)
+
+### 4.4 Lookbehind Negativo
+
+Lookbehind negativo é usado para encontrar todas as ocorrências que não são precedidas por um padrão específico. O lookbehind negativo é indicado por `(?<!...)`. Por exemplo, a expressão regular `(?<!(T|t)he\s)(cat)` significa: obtenha todas as palavras `cat` da string de entrada, que não estão depois das palavras `The` ou `the`.
+
+<pre>
+"(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flags
+
+Flags (sinalizadores) também são chamados de modificadores, porque eles modificam o resultado da expressão regular. Essas flags podem ser usadas em qualquer ordem ou combinação, e são uma parte integrante da RegExp.
+
+|Flag|Descrição|
+|:----:|----|
+|i|Case insensitive: Define que o padrão será case-insensitive.|
+|g|Busca global: Procura o padrão em toda a string de entrada.|
+|m|Multilinhas: Os metacaracteres de âncora funcionam em cada linha.|
+
+### 5.1 Indiferente à Maiúsculas
+
+O modificador `i` é usado para tornar o padrão case-insensitive. Por exemplo, a expressão regular `/The/gi` significa: a letra maiúscula `T`, seguida do caractere minúsculo `h`, seguido do caractere `e`. E ao final da expressão regular, a flag `i` diz ao motor de expressões regulares para ignorar maiúsculas e minúsculas. Como você pode ver, nós também determinamos a flag `g` porque queremos procurar o padrão em toda a string de entrada.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Busca Global
+
+O modificador `g` é usado para realizar uma busca global (encontrar todas as ocorrências sem parar na primeira encontrada). Por exemplo, a expressão regular `/.(at)/g` significa: qualquer caractere, exceto nova linha, seguido do caractere minúsculo `a`, seguido do caractere minúsculo `t`. Por causa da flag `g` no final da expressão regular, agora ela vai encontrar todas as ocorrências em toda a string de entrada.
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multilinhas
+
+O modificador `m` é usado para realizar uma busca em várias linhas. Como falamos antes, as âncoras `(^, $)` são usadas para verificar se o padrão está no início ou no final da string de entrada. 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.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Teste a RegExp](https://regex101.com/r/E88WE2/1)
+
+## Contribution
+
+* Reporte bugs
+* Abra pull request com melhorias
+* Espalhe a palavra
+* Me encontre diretamente em ziishaned@gmail.com ou [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## Licença
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/README.md b/README.md
index d1d958db..cf6bb797 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)

From f6a2cb0ccbfa78467c82d2a81a62fb388321eb07 Mon Sep 17 00:00:00 2001
From: Jacob Kim <astyfx@gmail.com>
Date: Tue, 22 Aug 2017 13:21:49 +0900
Subject: [PATCH 014/185] Fix regex error in translation, ko (#79)

---
 README-ko.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README-ko.md b/README-ko.md
index 9cace762..ecac09ac 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -287,7 +287,7 @@
 
 ## 4. 전후방탐색
 
-때때로 전후방탐색<sub>Lookaround</sub>이라고 알려진 후방탐색<sub>Lookbehind</sub>과 전방탐색<sub>Lookahead</sub>은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$0[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
+때때로 전후방탐색<sub>Lookaround</sub>이라고 알려진 후방탐색<sub>Lookbehind</sub>과 전방탐색<sub>Lookahead</sub>은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$)[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
 
 |부호|설명|
 |:----:|----|

From 30fd8c4e26b644587ad28436d933089f2027a56f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=BD=BB=E9=94=AE=E5=BF=AB=E7=A0=81?=
 <xiaoranran1993@163.com>
Date: Tue, 22 Aug 2017 21:06:04 +0800
Subject: [PATCH 015/185] fix a misspell (#80)

---
 README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README-cn.md b/README-cn.md
index 92a62432..596c791a 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -354,7 +354,7 @@
 
 `?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
 
-返回结果只瞒住第一部分表达式.
+返回结果只满足第一部分表达式.
 定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`.
 
 前置约束的内容写在括号中的等号后面.

From c38baf18f496b2573a0b573e12a21fc6f51d9b62 Mon Sep 17 00:00:00 2001
From: Brian Strauch <bstrauch24@gmail.com>
Date: Tue, 22 Aug 2017 22:23:53 -0500
Subject: [PATCH 016/185] Fixed grammar in lookaround section (#84)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index cf6bb797..ce76da30 100644
--- a/README.md
+++ b/README.md
@@ -380,8 +380,8 @@ shorthand character sets are as follows:
 
 ## 4. Lookaround
 
-Lookbehind and lookahead sometimes known as lookaround are specific type of
-***non-capturing group*** (Use to match the pattern but not included in matching
+Lookbehind and lookahead (also called lookaround) are specific types of
+***non-capturing groups*** (Used to match the pattern but not included in matching
 list). Lookaheads are used when we have the condition that this pattern is
 preceded or followed by another certain pattern. For example, we want to get all
 numbers that are preceded by `$` character from the following input string

From 17571a9d82d4c53cc315226aa361a5380bf9b264 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmed <ziishaned@gmail.com>
Date: Thu, 24 Aug 2017 10:14:08 +0500
Subject: [PATCH 017/185] Fix #86 - Replace character set with character group

---
 README.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index ce76da30..3dde94bc 100644
--- a/README.md
+++ b/README.md
@@ -405,13 +405,13 @@ that is matched by the first part of the expression. To define a positive
 lookahead, parentheses are used. Within those parentheses, a question mark with
 equal sign is used like this: `(?=...)`. Lookahead expression is written after
 the equal sign inside parentheses. For example, the regular expression
-`[T|t]he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
+`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
 letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
 define positive lookahead which tells regular expression engine to match `The`
 or `the` which are followed by the word `fat`.
 
 <pre>
-"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
 [Test the regular expression](https://regex101.com/r/IDDARt/1)
@@ -422,12 +422,12 @@ Negative lookahead is used when we need to get all matches from input string
 that are not followed by a pattern. Negative lookahead defined same as we define
 positive lookahead but the only difference is instead of equal `=` character we
 use negation `!` character i.e. `(?!...)`. Let's take a look at the following
-regular expression `[T|t]he(?!\sfat)` which means: get all `The` or `the` words
+regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
 from input string that are not followed by the word `fat` precedes by a space
 character.
 
 <pre>
-"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
 [Test the regular expression](https://regex101.com/r/V32Npg/1)
@@ -436,11 +436,11 @@ character.
 
 Positive lookbehind is used to get all the matches that are preceded by a
 specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
-regular expression `(?<=[T|t]he\s)(fat|mat)` means: get all `fat` or `mat` words
+regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
 from input string that are after the word `The` or `the`.
 
 <pre>
-"(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
 [Test the regular expression](https://regex101.com/r/avH165/1)
@@ -453,7 +453,7 @@ regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
 string that are not after the word `The` or `the`.
 
 <pre>
-"(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
 </pre>
 
 [Test the regular expression](https://regex101.com/r/8Efx5G/1)

From fc7473cd78606f3b2647dce090771264f415d8a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=9CJDAT=20=C3=87=C4=B0=C3=87EK?=
 <mujdat.cicek@gmail.com>
Date: Fri, 25 Aug 2017 05:51:31 +0300
Subject: [PATCH 018/185] Translate to Turkish (#82)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* meta karakterlere kadar çevrildi

* typo fix

* 2.4'e kadar çevrildi

* 2.5

* typo fix

* çeviri tamamlandı

* linkler düzenlendi

* turkish translation completed

* some fixes
---
 README-cn.md      |   1 +
 README-es.md      |   1 +
 README-fr.md      |   1 +
 README-ja.md      |   1 +
 README-ko.md      |   1 +
 README-tr.md      | 478 ++++++++++++++++++++++++++++++++++++++++++++++
 README.md         |   1 +
 img/regexp-tr.png | Bin 0 -> 35338 bytes
 8 files changed, 484 insertions(+)
 create mode 100644 README-tr.md
 create mode 100644 img/regexp-tr.png

diff --git a/README-cn.md b/README-cn.md
index 596c791a..b6e5191f 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -11,6 +11,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## 什么是正则表达式?
 
diff --git a/README-es.md b/README-es.md
index 52e82a4a..6fc16ba4 100644
--- a/README-es.md
+++ b/README-es.md
@@ -11,6 +11,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## What is Regular Expression?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/README-fr.md b/README-fr.md
index 115ab92a..b225a9d0 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -11,6 +11,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/README-ja.md b/README-ja.md
index c77d9707..ea0b074e 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -11,6 +11,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## 正規表現とは
 
diff --git a/README-ko.md b/README-ko.md
index ecac09ac..c216f727 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -11,6 +11,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/README-tr.md b/README-tr.md
new file mode 100644
index 00000000..837ec942
--- /dev/null
+++ b/README-tr.md
@@ -0,0 +1,478 @@
+<br/>
+<p align="center">
+<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+</p><br/>
+
+## Çeviriler:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+* [Turkish](README-tr.md)
+
+## Düzenli İfade Nedir?
+
+> Düzenli ifade, bir metinden belirli bir deseni bulmak için kullanılan bir karakter veya sembol grubudur.
+
+Bir düzenli ifade soldan sağa söz konusu harf öbekleriyle eşleşen bir desendir. "Regular expression" söylemesi zor bir tabirdir, genellikle "regex" ya da "regexp" olarak kısaltılmış terimler olarak bulacaksınız. Düzenli ifade bir harf öbeğinde ki bir metin değiştirmek, form doğrulamak, bir desen eşleşmesine dayalı harf öbeğinden bir alt harf öbeği ayıklamak ve çok daha fazlası için kullanılır.
+
+Bir uygulama yazdığınızı hayal edin ve bir kullanıcı kullanıcı adını seçtiğinde kullanıcı adı için kurallar belirlemek istiyorsunuz. Kullanıcı adının harfler, sayılar, altçizgiler ve tireler içermesine izin vermek istiyoruz. Ayrıca, Kullanıcı adındaki karakter sayısını sınırlamak istiyoruz böylece çirkin görünmeyecek. Bir kullanıcı adını doğrulamak için aşağıdaki düzenli ifadeyi kullanıyoruz:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-tr.png" alt="Regular expression">
+</p>
+
+Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri kabul edebilir.
+`Jo` girişi uyuşmaz, çünkü harf öbeği büyük harf içeriyor ve aynı zamanda uzunluğu 3 karakterden az.
+
+## İçindekiler
+
+- [Temel Eşleştiriciler](#1-temel-eşleştiriciler)
+- [Meta Karakterler](#2-meta-karakterler)
+  - [Nokta](#21-nokta)
+  - [Karakter takımı](#22-karakter-takımı)
+    - [Negatiflenmiş karakter seti](#221-negatiflenmiş-karakter-seti)
+  - [Tekrarlar](#23-tekrarlar)
+    - [Yıldız İşareti](#231-yıldız-İşareti)
+    - [Artı İşareti](#232-artı-İşareti)
+    - [Soru İşareti](#233-soru-İşareti)
+  - [Süslü Parantez](#24-süslü-parantez)
+  - [Karakter Grubu](#25-karakter-grubu)
+  - [Değişim](#26-değişim)
+  - [Özel Karakter Hariç Tutma](#27-Özel-karakter-hariç-tutma)
+  - [Sabitleyiciler](#28-sabitleyiciler)
+    - [Ters v işareti](#281-Şapka-İşareti)
+    - [Dolar işareti](#282-dolar-İşareti)
+- [Kısaltma Karakter Takımları](#3-kısaltma-karakter-takımları)
+- [Bakınmak](#4-bakınmak)
+  - [Olumlu Bakınma](#41-positive-lookahead)
+  - [Olumsuz Bakınma](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
+- [İşaretler](#5-İşaretler)
+  - [Büyük/Küçük harf duyarlılığı](#51-büyükküçük-harf-duyarlılığı)
+  - [Bütünsel Arama](#52-genel-arama)
+  - [Çok satırlı](#53-Çok-satırlı)
+
+## 1. Temel Eşleştiriciler
+
+Bir düzenli ifade bir metin içinde arama yapabilmek için kullandığımız bir karakter desenidir.
+Örneğin, `the` düzenli ifadesi şu anlama gelir: `t` harfi ardından `h`, ardından `e` harfi gelir.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/dmRygT/1)
+
+`123` düzenli ifadesi `123` harf öbeğiyle eşleşir. Düzenli ifade birbiri ardına, girilen harf öbeğindeki her karakter düzenli ifadenin içindeki her karakterle karşılaştırılarak eşleştirilir. Düzenli ifadeler normal olarak büyük/küçük harfe duyarlıdırlar, yani `The` düzenli ifadesi `the` harf öbeğiyle eşleşmez.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta Karakterler
+
+Meta karakterler düzenli ifadelerin yapı taşlarıdırlar. Meta karakterler kendileri için değil bunun yerine bazı özel yollarla yorumlanırlar. Bazı meta karakterler özel anlamları vardır ve bunlar köşeli parantez içinde yazılırlar.
+
+Meta karakterler aşağıdaki gibidir:
+
+|Meta karakter|Açıklama|
+|:----:|----|
+|.|Satır sonuc hariç herhangi bir karakterle eşleşir.|
+|[ ]|Köşeli parantezler arasında bulunan herhangi bir karakterle eşleşir.|
+|[^ ]|Köşeli parantez içerisinde yer alan `^` işaretinden sonra girilen karakterler haricindeki karakterlerle eşleşir.|
+|*|Kendisinden önce yazılan karakterin sıfır veya daha fazla tekrarı ile eşleşir.|
+|+|Kendisinden önce yazılan karakterin bir veya daha fazla tekrarı ile eşleşir.|
+|?|Kendisinden önce yazılan karakterin varlık durumunu opsiyonel kılar.|
+|{n,m}|Kendisinden önce yazılan karakterin en az `n` en fazla `m` değeri kadar olmasını ifade eder.|
+|(xyz)|Verilen sırayla `xyz` karakterleriyle eşleşir.|
+|||`|` karakterinden önce veya sonra verilen ifadelerin herhangi biriyle eşleşir. Or anlamı verir.|
+|\|Sonraki karakteri kaçırır. Bu, ayrılmış karakterleri eşleştirmenizi sağlar <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Girilen verinin başlangıcını ifade eder.|
+|$|Girilen veririnin sonunu ifade eder.|
+
+## 2.1 Nokta
+
+Nokta `.` meta karakterin en basit örneğidir. `.` meta karakteri satır başlangıcı hariç herhangi bir karakterle eşleşir.
+Örneğin, `.ar` düzenli ifadesinin anlamı: herhangi bir karakterin ardından `a` harfi ve `r` harfi gelir.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Karakter Takımı
+
+Karakter takımları aryıca Karakter sınıfı olarak bilinir. Karakter takımlarını belirtmek için köşeli ayraçlar kullanılır.
+Karakterin aralığını belirtmek için bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının sıralaması önemli değildir. 
+
+Örneğin, `[Tt]he` düzenli ifadesinin anlamı: bir büyük `T` veya küçük `t` harflerinin ardından sırasıyla `h` ve `e` harfi gelir.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/2ITLQ4/1)
+
+Bununla birlikte, bir karakter takımı içerisindeki bir periyot bir tam periyot demektir.
+
+`ar[.]` düzenli ifadesinin anlamı: Küçük `a` karakteri ardından `r` harfi gelir, ardından bir `.` karakteri gelir.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negatiflenmiş karakter seti
+
+Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, ama köşeli parantez içinde kullanıldığında verilen karakter takımını hariç tutar.
+
+Örneğin, `[^c]ar` ifadesinin anlamı: `c` harfinden hariç herhangi bir harfin ardından `a`, ardından `r` gelir.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Tekrarlar
+
+`+`, `*` ya da `?` meta karakterlerinden sonra bir alt desenin kaç defa tekrar edebileceğini belirtmek için kullanılır. Bu meta karakterler farklı durumlarda farklı davranırlar.
+
+### 2.3.1 Yıldız İşareti
+
+`*` sembolü, kendinden önce girilen eşlemenin sıfır veya daha fazla tekrarıyla eşleşir. Ama bir karakter seti ya da sınıf sonrasına girildiğinde, tüm karakter setinin tekrarlarını bulur.
+
+`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla tekrarı. 
+`[a-z]*` düzenli ifadesinin anlamı: bir satırdaki herhangi bir sayıdaki küçük harfler.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/7m8me5/1)
+
+`*` sembolü `.` meta karakteri ile `.*` karakterinin herhangi harf öbeğine eşleştirmek için kullanılabilir. `*` sembolü boşluk karakteriyle `\s` bir harf öbeğinde boşluk karakterlerini eşleştirmek için kullanılabilir.
+
+Örneğin, `\s*cat\s*` düzenli ifadesinin anlamı: sıfır veya daha fazla boşluk ardından küçük `c` karakteri gelir, ardından küçük `a` karakteri gelir, ardından küçük `t` karakteri gelir, ardından sıfır veya daha fazla boşluk gelir.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Artı İşareti
+
+`+` sembolü, kendinden önce girilen eşlemenin bir veya daha fazla tekrarıyla eşleşir.
+
+Örneğin, `c.+t` ifadesinin anlamı: küçük `c` harfi, ardından en az bir karakter gelir, ardından küçük `t` karakteri gelir.
+Örnekte açıklamak gereken önemli nokta: `t` harfi cümledeki son `t` harfi olacaktır. `c` ve `t` harfi arasında en az bir karakter vardır.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Soru İşareti
+
+Düzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel olarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örbeğiyle eşleşir.
+
+Örneğin, `[T]?he` ifadesinin anlamı: opsiyonel büyük `T` harfi, ardından küçük `h` karakteri gelir, ardından küçük `e` karakteri gelir.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Süslü Parantez
+
+Düzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler, bir karakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için kullanılırlar.
+
+Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 0 aralığındaki karakterlerden, en az 2 en fazla 3 defa ile eşleş.
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/juM86s/1)
+
+İkinci numarayı boş bırakabiliriz.
+
+Örneğin, `[0-9]{2,}` ifadesinin anlamı: En az 2 veya daha fazla defa eşleş.
+Düzenli ifadeden virgülü kaldırırsak `[0-9]{3}`: doğrudan 3 defa eşleşir.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Karakter Grubu
+
+Karakter grubu parantezler içine yazılmış alt desenler grubudur. Daha önce tasarım deseninde değindiğimiz gibi, bir karakterden önce bir miktar belirleyici koyarsak önceki karakteri tekrar eder. Fakat miktar belirleyiciyi bir karakter grubundan sonra koyarsak tüm karakter grubunu tekrarlar.
+
+Örneğin: `(ab)*` düzenli ifadesi "ab" karakterinin sıfır veya daha fazla tekrarıyla eşleşir.
+
+Ayrıca karakter grubu içinde `|` meta karakterini kullanabiliriz.
+
+Örneğin, `(c|g|p)ar` düzenli ifadesinin anlamı: küçük `c`, `g` veya `p` karakteri, ardından `a` karakteri, ardından `r` karakteri gelir.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Değişim
+
+Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için kullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an, karakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor olabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter grubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır. 
+
+Örneğin, `(T|t)he|car` düzenli ifadesinin anlamı: Büyük `T` ya da küçük `t` karakteri, ardından küçük `h` karakteri, ardından küçük `e` ya da `c` karakteri, ardından küçük `a`, ardından küçük `r` karakteri gelir.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Özel Karakter Hariç Tutma
+
+`\` işareti sonraki karakteri hariç tutmak için kullanılır. Bu bir semboülü ayrılmış karakterlerde `{ } [ ] / \ + * . $ ^ | ?` dahil olmak üzere eşleşen bir karakter olarak belirtmemizi sağlar. Bir özel karakteri eşleşen bir karakter olarak kullanmak için önüne `\` işareti getirin.
+
+Örneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek için kullanılır. 
+Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.` ayrılmış karakterini hariç tutmamız gerekir. Bunun için nokta önüne `\` işaretini koymamız gereklidir.
+
+`(f|c|m)at\.?` düzenli ifadesinin anlamı: küçük `f`, `c`ya da `m` harfi, ardından küçük `a` harfi, ardından küçük `t` harfi, ardından opsiyonel `.` karakteri gelir.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Sabitleyiciler
+
+Düzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü veya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri kullanırız. 
+Sabitleyiciler iki çeşittir: İlk çeşit eşleşen karakterin girişin ilk karakteri olup olmadığını kontrol eden şapka `^` karakteri, ve ikinci çeşit eşleşen karakterin girişin son karakteri olup olmadığını kontrol eden dolar `$` karakteridir.
+
+### 2.8.1 Şapka İşareti
+
+Şapka `^` işareti eşleşen karakterin giriş harf öbeğinin ilk karakteri olup olmadığını kontrol etmek için kullanılır.
+Eğer `^a` düzenli ifadesini `abc` harf öbeğine uygularsak `a` ile eşleşir. Ama `^b` ifadesini uygularsak bir eşleşme bulamayız. Bunun nedeni `abc` harf öbeğinde `b` karakterinin başlangıç karakteri olmamasıdır.
+
+Bir başka örnek üzerinden ilerlersek, 
+
+`^(T|t)he` düzenli ifadesinin anlamı: büyük `T` ya da `t` karakteri giriş harf öbeğinin ilk karakteri olmak üzere, ardından küçük `h`, ardından küçük `e` karakteri gelir.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dolar İşareti
+
+Dolar `$` işareti eşleşen karakterin giriş harf öbeğinin son karakteri olup olmadığını kontrol etmek için kullanılır.
+
+Örneğin, `(at\.)$` ifadesinin anlamı: küçük bir `a` karakteri, ardından küçük bir `t` karakteri, ardıdan nokta `.` karakteri gelir ve bu eşleşme harf öbeğinin sonunda olmalıdır.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/t0AkOd/1)
+
+##  3. Kısaltma Karakter Takımları
+
+Regex, yaygın olarak kullanılan düzenli ifadeler için uygun kısaltmalar sunan sık kullanılan karakter setleri için kısaltmalar sağlar.
+
+Kullanılan karakter setleri kısaltmaları aşağıdaki gibidir:
+
+|Kısaltma|Açıklama|
+|:----:|----|
+|.|Satır başı hariç herhangi bir karakter|
+|\w|Alfanumerik karakterlerle eşleşir: `[a-zA-Z0-9_]`|
+|\W|Alfanumerik olmayan karakterlerle eşleşir: `[^\w]`|
+|\d|Rakamlarla eşlelir: `[0-9]`|
+|\D|Rakam olmayan karakterlerle eşleşir: `[^\d]`|
+|\s|Boşluk karakteri ile eşleşir: `[\t\n\f\r\p{Z}]`|
+|\S|Boşluk karakteri olmayan karakterlerle eşleşir: `[^\s]`|
+
+## 4. Bakınmak
+
+Bakınma sembolleri, bir ifade öncesinde veya sonrasında başka bir ifademiz olduğunda kullanılırlar.
+
+Örneğin, `$4.44 ve $10.88` girişlerinden `$` karakteri önündeki tüm sayıları almak istiyoruz, bu durumda `(?<=\$)[0-9\.]*` ifadesini kullanırız.
+
+`(?<=\$)[0-9\.]*` ifadesinin anlamı: `.` karakterini içeren ve `$` karakteriyle devam eden tüm sayıları al.
+
+Düzenli ifadelerde kullanılan bakınma sembolleri aşağıdadır:
+
+|Sembol|Açıklama|
+|:----:|----|
+|?=|Positive Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme varsa` sonuç döndürür.)|
+|?!|Negative Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme yoksa` sonuç döndürür.)|
+|?<=|Positive Lookbehind (Verdiğimiz ifade öncesini arar ve `eşleşme varsa` sonuç döndürür.)|
+|?<-!-|Negative Lookbehind Verdiğimiz ifade öncesini arar ve `eşleşme yoksa` sonuç döndürür.|
+
+### 4.1 Positive Lookahead
+
+Positive Lookahead, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi gerektiğini savunur. Bulunan eşleşme yalnızca ifadenin ilk bölümüyle eşleşen metin içerir. Olumlu bir bakınma tanımlamak için, içinde eşittir işareti yer alan parantezler `(?=...)` şeklinde kullanılır. Bakınma ifadesi parantezler içinde eşittir işaretinden sonra yazılır.
+
+Örneğin, `[T|t]he(?=\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T` harfi, ardından `h` harfi gelir, ardından `e` harfi gelir. Parantez içinde ise bu dizilimin bir boşluk karakterinden sonra `fat` öbeğiyle devam edeceğini tanımlıyoruz.
+
+<pre>
+"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Negative Lookahead
+
+Negative Lookahead sembolü positive lookahead tersine, verdiğimiz desenle devam etmemesi durumunda eşleşir. Bu sembol positive lookahead gibi tanımlanır ama `=` işareti yerine `!` kullanılır.
+
+`[T|t]he(?!\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T` harfi, ardından `h` harfi gelir, ardından `e` harfi gelir, ardından öncesinde boşluk olan bir `fat` öbeği olmamalıdır.
+
+
+<pre>
+"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Positive Lookbehind
+
+Positive Lookbehind, belirli bir desenden önceki eşleşmeleri almak için kullanılır. `(?<=...)` ile gösterilir.
+
+Örneğin, `(?<=[T|t]he\s)(fat|mat)` ifadesinin anlamı: Öncesinde `The` veya `the` öbekleri olan tüm `fat` veya `mat` öbeklerini getir.
+
+<pre>
+"(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/avH165/1)
+
+### 4.4 Negative Lookbehind
+
+Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak için kullanılır. `(?<=!..)` ile gösterilir.
+
+Örneğin, `(?<!(T|t)he\s)(cat)` ifadesinin anlamı: Öncesinde `The` veya `the` öbekleri yer almayan tüm `cat` öbeklerini getir.
+
+<pre>
+"(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/8Efx5G/1)
+
+## 5. İşaretler
+
+İşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü onlar bir düzenli ifadenin çıktısını düzenlerler. Bu işaretler herhangi bir sırada veya kombinasyonda kullanılabilirler, ve bunlar Düzenli İfadelerin ayrılmaz bir parçasıdırlar.
+
+|İşaret|Açıklama|
+|:----:|----|
+|i|Büyük küçük harf duyarlılık: Eşleştirmeleri küçük/büyük harfe karşı duyarsız yapar.|
+|g|Genel Arama: Girilen harf öbeği boyunca bir desen arar.|
+|m|Çok satırlı: Sabitleyici meta karakteri her satırda çalışır.|
+
+### 5.1 Büyük/Küçük harf duyarlılığı
+
+`ì` işaretleyicisi büyük/küçük harfe duyarsız eşleştirme yapmak için kullanılır.
+
+Örneğin, `/The/gi` ifadesi: büyük `T` harfi, ardından küçük `h` harfi, ardından küçük `e` harfi gelir. ifadenin sonunda yer alan `i` işareti büyük-küçük harfe karşı duyarsız olması gerektiğini belirtir. Ayrıca `g` işaretinide kullandığımızı görebilirsiniz, tüm text içinde bu aramayı yapmak istediğimiz için `g` işaretini ayrıca belirtiyoruz.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Genel Arama
+
+`g` işareti bir giriş içinde eşleşen tüm varsayonları bulmak için kullanılır. `g` işareti kullanılmazsa ilk eşleşme bulunduktan sonra arama sona erer.
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Çok Satırlı
+
+`m` işareti çok satırlı bir eşleşme sağlamak için kullanılır. Daha önce sabitleyicilerde gördüğümüz gibi `(^, $)` sembolleri aradığımız desenin harf öbeğinin başında veya sonunda olup olmadığını kontrol etmemiz için kullanılır. Bu sabitleyicilerin tüm satırlarda çalışması için `m` işaretini kullanırız.
+
+Örneğin, `/at(.)?$/gm` ifadesinin anlamı: küçük `a` harfi, ardından küçük `t` harfi gelir, ardından opsiyonel olarak yeni satır hariç herhangi birşey gelebilir. `m` işaretini kullandığımız için bir girişin her satırının sonunda eşleştirir.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/E88WE2/1)
+
+## Contribution
+
+* Report issues
+* Open pull request with improvements
+* Spread the word
+* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/README.md b/README.md
index 3dde94bc..56509981 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 
 ## What is Regular Expression?
 
diff --git a/img/regexp-tr.png b/img/regexp-tr.png
new file mode 100644
index 0000000000000000000000000000000000000000..9285dfcff22e583b793b9f2436e65e300a174d1e
GIT binary patch
literal 35338
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
W&ld#;8S`NPe~NNyvX#<iA^#6lH5G~g

literal 0
HcmV?d00001


From 2a787a27e94fde260915f309f2f5442bc1c0f1ae Mon Sep 17 00:00:00 2001
From: CoolGuy <admin@coolguy.pw>
Date: Fri, 25 Aug 2017 10:52:28 +0800
Subject: [PATCH 019/185] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E9=94=99=E8=AF=AF=20?=
 =?UTF-8?q?(#87)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

根据https://github.com/zeeshanu/learn-regex/issues/86，英文文档部分已经更新了，所以更新一下中文文档部分
---
 README-cn.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/README-cn.md b/README-cn.md
index b6e5191f..31c3d862 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -359,10 +359,10 @@
 定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`.
 
 前置约束的内容写在括号中的等号后面.
-例如, 表达式 `[T|t]he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
+例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
 
 <pre>
-"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
 [在线练习](https://regex101.com/r/IDDARt/1)
@@ -372,10 +372,10 @@
 前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式
 `前置约束-排除`  定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
 
-表达式 `[T|t]he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
+表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
 
 <pre>
-"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
 [在线练习](https://regex101.com/r/V32Npg/1)
@@ -383,10 +383,10 @@
 ### 4.3 `?<= ...` 后置约束-存在
 
 后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式.
-例如, 表达式 `(?<=[T|t]he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
+例如, 表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
 
 <pre>
-"(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
 [在线练习](https://regex101.com/r/avH165/1)
@@ -397,7 +397,7 @@
 例如, 表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`, 且其前不跟着 `The` 或 `the`.
 
 <pre>
-"(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
 </pre>
 
 [在线练习](https://regex101.com/r/8Efx5G/1)

From a3a7b3ac3c16d3de9665476130406697c48aee33 Mon Sep 17 00:00:00 2001
From: Mohamed Oun <mohamed3on@gmail.com>
Date: Sat, 26 Aug 2017 03:46:11 +0300
Subject: [PATCH 020/185] Fix a  grammar typo (#88)

Also added a small addition to clarify regex's default behavior without the g flag.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 56509981..2fa1b744 100644
--- a/README.md
+++ b/README.md
@@ -498,7 +498,7 @@ The `g` modifier is used to perform a global match (find all matches rather than
 stopping after the first match). For example, the regular expression`/.(at)/g`
 means: any character except new line, followed by lowercase character `a`,
 followed by lowercase character `t`. Because we provided `g` flag at the end of
-the regular expression now it will find every matches from whole input string.
+the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.

From aea085349c566b380994429337cb5a31343c4eb7 Mon Sep 17 00:00:00 2001
From: ahmedaboukora <31317398+ahmedaboukora@users.noreply.github.com>
Date: Sat, 26 Aug 2017 15:04:42 +0200
Subject: [PATCH 021/185] Update README-fr.md (#89)

* Update README-fr.md

hi, i'm ahmed, an french student, who learned regex.
I wanted correct some mistakes like the lack of plurial in some expressions, and bad linking into 2 words.
I corrected also the expression of string because in France for someone who don't know well computer science , the "string" means a clothes that people wear.
I checked the file and everything is okay.
I will check again tomorrow.
I hope help you again.
Ahmed

* Update README-fr.md

added  (string) after "chaines de caracteres"
---
 README-fr.md | 84 +++++++++++++++++++++++++---------------------------
 1 file changed, 41 insertions(+), 43 deletions(-)

diff --git a/README-fr.md b/README-fr.md
index b225a9d0..ea53f4e5 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -17,9 +17,9 @@
 
 > Une expression régulière est un groupement de caractères ou symboles utilisés pour trouver un schéma spécifique dans un texte.
 
-Une expression régulière est un schéma qui est comparée à une chaîne de caractères de gauche à droite. Le mot "Expression régulière"
+Une expression régulière est un schéma qui est comparé à une chaîne de caractères (string) de gauche à droite. Le mot "Expression régulière"
 est un terme entier, souvent abrégé par "regex" ou "regexp". Une expression régulière est utilisée pour remplacer un texte à l'intérieur
-d'une *string* (une chaîne de caractères), valider un formulaire, extraire une portion de string basée sur un schéma, et bien plus encore.
+d'une chaîne de caractères (string), valider un formulaire, extraire une portion de chaine de caractères (string) basée sur un schéma, et bien plus encore.
 
 Imaginons que nous écrivons une application et que nous voulons définir des règles pour le choix d'un pseudonyme. Nous voulons autoriser
 le pseudonyme à contenir des lettres, des nombres, des underscores et des traits d'union. Nous voulons aussi limiter le nombre
@@ -29,8 +29,7 @@ de caractères dans le pseudonyme pour qu'il n'ait pas l'air moche. Nous utiliso
   <img src="./img/regexp-fr.png" alt="Expressions régulières">
 </p>
 
-L'expression régulière ci-dessus peut accepter les strings `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car
-cette string contient une lettre majuscule et elle est trop courte.
+L'expression régulière ci-dessus peut accepter les chaines de caractères (string) `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car cette chaine de caractères (string) contient une lettre majuscule et elle est trop courte.
 
 ## Table des matières
 
@@ -63,7 +62,7 @@ cette string contient une lettre majuscule et elle est trop courte.
 
 ## 1. Introduction
 
-Une expression régulière est un schéma de caractères utilisés pour effectuer une recherche dans un text.
+Une expression régulière est un schéma de caractères utilisés pour effectuer une recherche dans un texte.
 Par exemple, l'expression régulière `the` signifie : la lettre `t`, suivie de la lettre `h`, suivie de la lettre `e`.
 
 <pre>
@@ -82,23 +81,23 @@ L'expression régulière `123` coïncide à la chaîne `123`. Chaque caractère
 
 ## 2. Meta-caractères
 
-Les meta-caractères sont les bloques 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.
+Les 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.
 Significations des meta-caractères:
 
 |Meta-caractère|Description|
 |:----:|----|
 |.|Un point coïncide avec n'importe quel caractère unique à part le retour à la ligne.|
-|[ ]|Classe de caractères. Coïncide avec n'importe quels caractères entre crochets.|
-|[^ ]|Négation de classe de caractère. Coïncide avec n'importe quels caractères qui n'est pas entre les crochets.|
+|[ ]|Classe de caractères. Coïncide avec n'importe quel caractère entre crochets.|
+|[^ ]|Négation de classe de caractère. Coïncide avec n'importe quel caractère qui n'est pas entre les crochets.|
 |*|Coïncide avec 0 ou plus répétitions du caractère précédent.|
 |+|Coïncide avec 1 ou plus répétitions du caractère précédent.|
 |?|Rend le caractère précédent optionnel.|
 |{n,m}|Accolades. Coïncide avec au moins "n" mais pas plus que "m" répétition(s) du caractère précédent.|
 |(xyz)|Groupe de caractères. Coïncide avec les caractères "xyz" dans l'ordre exact.|
-|||Alternation (ou). Coïncide soit avec le caractère avant ou après le symbol.|
+|||Alternation (ou). Coïncide soit avec le caractère avant ou après le symbole.|
 |\|Échappe le prochain caractère. Cela permet de faire coïncider des caractères réservés tels que <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Coïncide avec le début de la chaîne de caractères.|
-|$|Coïncide avec la fin de la chaîne de caractères.|
+|^|Coïncide avec le début de la chaîne de caractères (string).|
+|$|Coïncide avec la fin de la chaîne de caractères (string).|
 
 ## 2.1 Full stop
 
@@ -112,7 +111,7 @@ Le full stop `.` est l'exemple le plus simple d'un meta-caratère. Le `.` coïnc
 
 ## 2.2 Inclusions de caractères
 
-Les 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, suivi par la lettre `h`, suivie par la lettre `e`.
+Les 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -130,7 +129,7 @@ L'utilisation du point dans une inclusion de caractère signifie toutefois un `.
 
 ### 2.2.1 Exclusion de caractères
 
-En règle générale, le caractère circonflexe représente le début d'une chaîne de caractères. Néanmoins, lorsqu'il est utilisé après le crochet ouvrant, il permet d'exclure la gamme de caractère(s). 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`.
+En 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`.
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -140,14 +139,13 @@ En règle générale, le caractère circonflexe représente le début d'une cha
 
 ## 2.3 Répétitions
 
-Les 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.
+Les 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.
 
 ### 2.3.1 Astérisque
 
 Le 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
 du 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.
-Par exemple, l'expression régulière `[a-z]*` signifie : n'importe combien de lettres minuscules.
+Par exemple, l'expression régulière `[a-z]*` signifie : peu importe la chaine tant qu'il s'agit de lettres minuscules.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -155,7 +153,7 @@ Par exemple, l'expression régulière `[a-z]*` signifie : n'importe combien de l
 
 [Essayer l'expression régulière](https://regex101.com/r/7m8me5/1)
 
-Le symbole `*` peut être utilisé avec le meta-caractère `.` pour correspondre à n'importe quelle chaîne de caractères `.*`. Le symbole `*` peut être utilisé avec le
+Le 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
 caractère espace vide `\s` pour correspondre à une chaîne d'espaces vides. Par exemple, l'expression `\s*cat\s*` signifie : zéro ou plus
 d'espaces, suivis du caractère `c` minuscule, suivi par le caractère `a` minuscule, suivi par le caractère `t` minuscule, suivi par
 zéro ou plus d'espaces.
@@ -168,7 +166,7 @@ zéro ou plus d'espaces.
 
 ### 2.3.2 Le Plus
 
-Le 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, suivi par la lettre `t` minuscule. Le `t` coïncide par conséquent avec le dernier `t` de la phrase.
+Le 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.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -194,7 +192,7 @@ Le meta-caractère `?` rend le caractère précédent optionnel. Ce symbole perm
 
 ## 2.4 Accolades
 
-Dans une expression régulière, les accolades, qui sont aussi appelée quantifieurs, sont utilisées pour spécifier le nombre de fois qu'un
+Dans 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
 caractè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
 (caractères dans la gamme de 0 à 9).
 
@@ -221,9 +219,9 @@ la virgule l'expression régulière `[0-9]{3}` signifie : trouve exactement 3 ch
 
 ## 2.5 Groupement de caractères
 
-Un groupement de caractères est un groupe de sous-schémas qui sont écrits dans des parenthèses `(...)`. Nous avions mentionné plus tôt que, dans une expression régulière,
+Un 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,
 si 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
-il répète le groupement de caractères entier. Par exemple, l'expression régulière `(ab)*` trouve zéro ou plus de répétitions des caractères "ab".
+il 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".
 Nous 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,
 `g` ou `p`, suivi par le caractère `a`, suivi par le caractère `r`.
 
@@ -251,7 +249,7 @@ ou le caractère `c` minuscule, suivi par le caractère `a` minuscule, suivit pa
 
 L'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
 y compris les caractères réservés `{ } [ ] / \ + * . $ ^ | ?`. Pour utiliser un caractère spécial comme caractère à trouver, préfixer `\` avant celui-ci.
-Par 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 string
+Par 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)
 l'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
 `t` minuscule, suivie par le caractère optionnel `.`.
 
@@ -264,15 +262,15 @@ l'expression régulière `(f|c|m)at\.?` signifie : la lettre minuscule `f`, `c`
 ## 2.8 Ancres
 
 Dans les expressions régulières, nous utilisons des ancres pour vérifier si le symbole trouvé est le premier ou dernier symbole de la
-string. Il y a 2 types d'ancres : Le premier type est le circonflexe `^` qui cherche si le caractère est le premier
-caractère de la string et le deuxième type est le Dollar `$` qui vérifie si le caractère est le dernier caractère de la string.
+chaine 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
+caractè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).
 
 ### 2.8.1 Circonflexe
 
-Le symbole circonflexe `^` est utilisé pour vérifier si un caractère est le premier caractère de la string. Si nous appliquons l'expression régulière
-suivante `^a` (si a est le premier symbole) à la string `abc`, ça coïncide. Mais si nous appliquons l'expression régulière `^b` sur cette même string,
-ça ne coïncide pas. Parce que dans la string `abc` "b" n'est pas le premier symbole. Regardons une autre expression régulière
-`^(T|t)he` qui signifie : le caractère `T` majuscule ou le caractère `t` minuscule est le premier symbole de la string,
+Le 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
+suivante `^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),
+ç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
+`^(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),
 suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.
 
 <pre>
@@ -289,9 +287,9 @@ suivi par le caractère `h` minuscule, suivi par le caractère `e` minuscule.
 
 ### 2.8.2 Dollar
 
-Le symbole Dollar `$` est utilisé pour vérifier si un caractère est le dernier caractère d'une string. Par exemple, l'expression régulière
+Le 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
 `(at\.)$` signifie : un caractère `a` minuscule, suivi par un caractère `t` minuscule, suivi par un caractère `.` et tout cela doit être
-à la fin de la string.
+à la fin de la chaine de caractères (string).
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -324,7 +322,7 @@ les expressions régulières souvent utilisées. Ces abréviations sont les suiv
 
 La 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
 pour 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
-par un autre schéma. Par exemple, nous voulons tous les chiffres qui sont précédés par le caractère `$` dans la string suivante `$4.44 and $10.88`.
+par 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`.
 Nous 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
 par le caractère `$`. Les recherches que nous trouvons dans les expressions régulières sont les suivantes:
 
@@ -352,9 +350,9 @@ la recherche en avant positive qui dit quelle est l'expression à chercher. `The
 
 ### 4.2 Recherche en avant négative
 
-La recherche en avant négative est utilisée quand nous avons besoin de trouver une string qui n'est pas suivie d'un schéma. La recherche en avant négative
+La 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
 est 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 `!`
-i.e. `(?!...)`. Regardons l'expression régulière suivante `[T|t]he(?!\sfat)` qui signifie : trouve tous les mots `The` ou `the` de la string
+i.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)
 qui ne sont pas suivis du mot `fat` précédé d'un espace.
 
 <pre>
@@ -365,8 +363,8 @@ qui ne sont pas suivis du mot `fat` précédé d'un espace.
 
 ### 4.3 Recherche en arrière positive
 
-La recherche en arrière positive est utilisée pour trouver une string précédée d'un schéma. La recherche en arrière positive se note
-`(?<=...)`. Par exemple, l'expression régulière `(?<=[T|t]he\s)(fat|mat)` signifie : trouve tous les mots `fat` ou `mat` de la string qui
+La 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
+`(?<=...)`. 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
 se trouve après le mot `The` ou `the`.
 
 <pre>
@@ -377,8 +375,8 @@ se trouve après le mot `The` ou `the`.
 
 ### 4.4 Recherche en arrière négative
 
-La recherche en arrière négative est utilisée pour trouver une string qui n'est pas précédée d'un schéma. La recherche en arrière négative se note
-`(?<!...)`. Par exemple, l'expression régulière `(?<!(T|t)he\s)(cat)` signifie : trouve tous les mots `cat` de la string qui
+La 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
+`(?<!...)`. Par exemple, l'expression régulière `(?<!(T|t)he\s)(cat)` signifie : trouve tous les mots `cat` de la chaine de caractères (string) qui
 ne se trouvent pas après le mot `The` ou `the`.
 
 <pre>
@@ -395,7 +393,7 @@ dans n'importe quel ordre et combinaison et font partie intégrante de la RegExp
 |Drapeau|Description|
 |:----:|----|
 |i|Insensible à la casse : Définit que la correspondance sera insensible à la casse.|
-|g|Recherche globale : Recherche la correspondance dans la string entière.|
+|g|Recherche globale : Recherche la correspondance dans la chaine de caractères (string) entière.|
 |m|Multiligne : Meta-caractère ancre qui agit sur toutes les lignes.|
 
 ### 5.1 Insensible à la casse
@@ -403,7 +401,7 @@ dans n'importe quel ordre et combinaison et font partie intégrante de la RegExp
 Le modifieur `i` est utilisé pour faire une correspondance insensible à la casse. Par exemple, l'expression régulière `/The/gi` signifie : la lettre
 `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
 moteur 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
-la string entière.
+la chaine de caractères (string) entière.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -419,9 +417,9 @@ la string entière.
 
 ### 5.2 Correspondance globale
 
-Le modifieur `g` est utilisé pour faire une recherche globale (trouver toutes les strings plutôt que de s'arrêter à la première correspondance ). Par exemple,
+Le 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,
 l'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
-`t` minuscule. Grâce au drapeau `g` à la fin de l'expression régulière maintenant il trouvera toutes les correspondances de toute la string.
+`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).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -438,9 +436,9 @@ l'expression régulière `/.(at)/g` signifie : n'importe quel caractère sauf le
 ### 5.3 Multilignes
 
 Le 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
-se trouve au début ou à la fin de la string. Mais si nous voulons que l'ancre soit sur chaque ligne nous utilisons le drapeau `m`. Par exemple, l'expression régulière
+se 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
 `/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.
-Grâce au drapeau `m` maintenant le moteur d'expression régulière trouve le schéma à chaque début de ligne dans la string.
+Grâ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).
 
 <pre>
 "/.at(.)?$/" => The fat

From 591de7b1926311defdc441dc88e8178cf4dbe084 Mon Sep 17 00:00:00 2001
From: chroju <chor.chroju@gmail.com>
Date: Mon, 28 Aug 2017 01:24:13 +0900
Subject: [PATCH 022/185] Update README-ja.md (#91)

* Reflect the update in 499de93acd

* Reflect the update in c38baf18f4

* Reflect the update in 17571a9d82

* Reflect the update in a3a7b3ac3c
---
 README-ja.md | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/README-ja.md b/README-ja.md
index ea0b074e..ca94528a 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -193,6 +193,7 @@
 シンボル `+` は直前の文字が 1 個以上続くパターンにマッチします。
 例えば `c.+t` という正規表現は小文字の `c` の後に
 任意の 1 文字以上が続き、さらに `t` が続くことを意味します。
+この `t` は、その文における最後の `t` がマッチします。
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -220,6 +221,7 @@
 [正規表現の動作確認をする](https://regex101.com/r/kPpO2x/1)
 
 ## 2.4 括弧
+この`t`は、その文における最後の`t`であることが明確である必要があります。
 
 正規表現における括弧は数量子とも呼ばれますが、文字列がいくつ現れるかを示すために使用されます。
 例えば、`[0-9]{2,3}` という正規表現は 2 桁以上 3 桁以下の数字
@@ -359,7 +361,7 @@
 
 ## 4. 前後参照
 
-しばしば前後参照とも呼ばれる先読みと後読みは **非キャプチャグループ**
+先読みと後読み（前後参照とも呼ばれます）は **非キャプチャグループ**
 （パターンのマッチングはするがマッチングリストには含まれない）という
 特殊な扱いがなされる機能です。
 前後参照はあるパターンが別のあるパターンよりも先行または後続して現れることを示すために使用されます。
@@ -382,12 +384,12 @@
 肯定的な先読みを定義するには括弧を使用します。
 その括弧の中で疑問符と等号を合わせて `(?=...)` のようにします。
 先読みのパターンは括弧の中の等号の後に記述します。
-例えば `[T|t]he(?=\sfat)` という正規表現は小文字の `t` か大文字の `T` のどちらかの後に `h`, `e` が続きます。
+例えば `(T|t)he(?=\sfat)` という正規表現は小文字の `t` か大文字の `T` のどちらかの後に `h`, `e` が続きます。
 括弧内で肯定的な先読みを定義していますが、これは `The` または `the` の後に
 `fat` が続くことを表しています。
 
 <pre>
-"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
 [正規表現の動作確認をする](https://regex101.com/r/IDDARt/1)
@@ -397,11 +399,11 @@
 否定的な先読みはあるパターンが後続しない全てのマッチング文字列を取得するために使用します。
 否定的な先読みは肯定的な先読みと同じように定義しますが、 `=` の代わりに
 `!` を使うところが唯一の違いで、`(?!...)` と記述します。
-次の正規表現 `[T|t]he(?!\sfat)` について考えてみます。
+次の正規表現 `(T|t)he(?!\sfat)` について考えてみます。
 これはスペースを挟んで `fat` が後続することがない全ての `The` または `the` を得ることができます。
 
 <pre>
-"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
 [正規表現の動作確認をする](https://regex101.com/r/V32Npg/1)
@@ -410,11 +412,11 @@
 
 肯定的な後読みは特定のパターンが先行するような文字列を得るために使用します。
 定義の仕方は `(?<=...)` とします。
-例えば `(?<=[T|t]he\s)(fat|mat)` という正規表現は
+例えば `(?<=(T|t)he\s)(fat|mat)` という正規表現は
 `The` または `the` の後に続く全ての `fat` または `mat` が取得できます。
 
 <pre>
-"(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
 [正規表現の動作確認をする](https://regex101.com/r/avH165/1)
@@ -426,7 +428,7 @@
 例えば `(?<!(T|t)he\s)(cat)` は `The` または `the` に続いていない全ての `cat` が取得できます。
 
 <pre>
-"(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
 </pre>
 
 [正規表現の動作確認をする](https://regex101.com/r/8Efx5G/1)
@@ -466,8 +468,8 @@
 修飾子 `g` はグローバル検索（最初のマッチ列を検索する代わりに全マッチ列を検索する）を
 行うために使用します。
 例えば `/.(at)/g` という正規表現は、改行を除く任意の文字列の後に
-小文字の `a`, `t` が続きます。正規表現の最後にフラグ `g` を渡すことで
-入力文字列内の全マッチ列を検索するようにしています。
+小文字の `a`, `t` が続きます。正規表現の最後にフラグ `g` を渡すことで、
+最初のマッチだけではなく（これがデフォルトの動作です）、入力文字列内の全マッチ列を検索するようにしています。
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.

From 0487bd9566bf3e3a1e111193d200738de8d748d7 Mon Sep 17 00:00:00 2001
From: GrayLand <languilin1109@vip.qq.com>
Date: Fri, 1 Sep 2017 09:11:42 +0800
Subject: [PATCH 023/185] Resolve conflicts

---
 README.md | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/README.md b/README.md
index f66ad1df..2fa1b744 100644
--- a/README.md
+++ b/README.md
@@ -3,10 +3,6 @@
 <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
 </p><br/>
 
-<<<<<<< HEAD
-
-[中文版](README-zh-simple.md)
-=======
 ## Translations:
 
 * [English](README.md)
@@ -15,12 +11,8 @@
 * [Português do Brasil](README-pt_BR.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
-<<<<<<< HEAD
->>>>>>> zeeshanu/master
-=======
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
->>>>>>> zeeshanu/master
 
 ## What is Regular Expression?
 

From 752221a5e0865f9e5787aabc5754702220c9aaf5 Mon Sep 17 00:00:00 2001
From: GrayLand <languilin1109@vip.qq.com>
Date: Fri, 1 Sep 2017 09:17:41 +0800
Subject: [PATCH 024/185] Corrected the diagram in README-cn.md

---
 README-cn.md                |   2 +-
 01.png => img/regexp-cn.png | Bin
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename 01.png => img/regexp-cn.png (100%)

diff --git a/README-cn.md b/README-cn.md
index 31c3d862..73ffe73f 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -27,7 +27,7 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="./img/regexp-cn.png" alt="Regular expression">
 </p>
 
 以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.
diff --git a/01.png b/img/regexp-cn.png
similarity index 100%
rename from 01.png
rename to img/regexp-cn.png

From 773785bf15280b6e2db2eb0b3c006f6cc6d38c35 Mon Sep 17 00:00:00 2001
From: Bo <syncxplus@outlook.com>
Date: Tue, 5 Sep 2017 10:40:13 +0800
Subject: [PATCH 025/185] Correct some word error (#53)

---
 README-cn.md | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/README-cn.md b/README-cn.md
index 31c3d862..f0e3fa68 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -100,7 +100,7 @@
 |*|匹配>=0个重复的在*号之前的字符.|
 |+|匹配>=1个重复的+号前的字符.
 |?|标记?之前的字符为可选.|
-|{n,m}|匹配num个中括号之前的字符 (n <= num <= m).|
+|{n,m}|匹配num个大括号之前的字符 (n <= num <= m).|
 |(xyz)|字符集, 匹配与 xyz 完全相等的字符串.|
 |||或运算符,匹配符号前或后的字符.|
 |\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
@@ -180,7 +180,7 @@
 
 ### 2.3.2 `+` 号
 
-`+`号匹配`+`号之前的字符出现 >=1 次个字符.
+`+`号匹配`+`号之前的字符出现 >=1 次.
 例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串.
 
 <pre>
@@ -209,8 +209,7 @@
 ## 2.4 `{}` 号
 
 在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数.
-例如,  表达式 `[0-9]{2,3}` 匹配 2～3 位 0～9 的数字.
-
+例如,  表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -356,7 +355,7 @@
 `?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
 
 返回结果只满足第一部分表达式.
-定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`.
+定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
 
 前置约束的内容写在括号中的等号后面.
 例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.

From 0c3228afabd23fc0829e5dff84a47175839f392b Mon Sep 17 00:00:00 2001
From: Maria Batsou <mbatsou@gmail.com>
Date: Tue, 12 Sep 2017 19:00:50 +0300
Subject: [PATCH 026/185] Greek translation (#95)

* First commit

* Greek Translation

* Greek Translation
---
 README-cn.md    |   1 +
 README-es.md    |   1 +
 README-fr.md    |   1 +
 README-gr.md    | 552 ++++++++++++++++++++++++++++++++++++++++++++++++
 README-ja.md    |   1 +
 README-ko.md    |   1 +
 README-pt_BR.md |   1 +
 README-tr.md    |   1 +
 README.md       |   1 +
 9 files changed, 560 insertions(+)
 create mode 100644 README-gr.md

diff --git a/README-cn.md b/README-cn.md
index f0e3fa68..add4168c 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## 什么是正则表达式?
 
diff --git a/README-es.md b/README-es.md
index 6fc16ba4..b7c78e07 100644
--- a/README-es.md
+++ b/README-es.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## What is Regular Expression?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/README-fr.md b/README-fr.md
index ea53f4e5..6e7c65d6 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/README-gr.md b/README-gr.md
new file mode 100644
index 00000000..8fb7da26
--- /dev/null
+++ b/README-gr.md
@@ -0,0 +1,552 @@
+<br/>
+<p align="center">
+<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+</p><br/>
+
+## Μεταφράσεις:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+* [Turkish](README-tr.md)
+* [Greek](README-gr.md)
+
+## Τι είναι μια Κανονική Έκφραση (Regular Expression);
+
+> Μια κανονική έκφραση είναι μια ομάδα χαρακτήρων ή συμβόλων που χρησιμοποιούνται για την εύρεση ενός συγκεκριμένου μοτίβου χαρακτήρων μέσα σ'ένα κείμενο.
+
+Μια κανονική έκφραση, είναι μια σειρά χαρακτήρων τους οποίους αναζητούμε μέσα σε ένα κείμενο. Η αναζήτηση αυτή
+ξεκινά από τα αριστερά και συνεχίζει προς τα δεξιά. Ο όρος "Κανονική Έκφραση" είναι κάπως μεγάλος οπότε πολύ συχνά
+θα τον συναντήσετε στην συντομότερη μορφή του ως "regex" ή "regexp". Οι εκφράσεις αυτές χρησιμοποιούνται
+για αντικατάσταση λέξεων μέσα σε κείμενο, για επικυρώσεις τύπων, για αποκοπή ενός κομματιού
+string με βάση κάποιου μοτίβου αναζήτησης και για πολλά άλλα.
+
+Φανταστείτε ότι πρέπει να γράψουμε μια εφαρμογή και ότι θέλουμε να ορίσουμε κανόνες για την δημιουργία
+ονόματος χρήστη (username). Σ'αυτή την περίπτωση, θέλουμε να επιτρέψουμε την χρήση γραμμάτων και
+αριθμών καθώς και την παύλα και κάτω παύλα. Θέλουμε επίσης να περιορίσουμε τον αριθμό χαρακτήρων
+του ονόματος χρήστη ώστε να μην φαίνεται μεγάλο και άσχημο. Για να το κάνουμε αυτό, μπορούμε να χρησιμοποιήσουμε
+την παρακάτω κανονική έκφραση:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+Η παραπάνω κανονική έκφραση θα δεχτεί ως σωστά τα ονόματα χρήστη `john_doe`, `jo-hn_doe` και
+`john12_as`. Όμως δεν θα δεχτεί το `Jo` αφού περιέχει ένα κεφαλαίο γράμμα και είναι πολύ
+μικρό.
+
+## Πίνακας Περιεχομένων
+
+- [Βασικά Μοτίβα Αναζήτησης](#1-Βασικά-Μοτίβα-Αναζήτησης)
+- [Μεταχαρακτήρες](#2-Μεταχαρακτήρες)
+  - [Τελεία](#21-Τελεία)
+  - [Σύνολα Χαρακτήρων](#22-Σύνολα-Χαρακτήρων)
+    - [Σύνολο Χαρακτήρων προς Εξαίρεση](#221-Σύνολο-Χαρακτήρων-προς-Εξαίρεση)
+  - [Επαναλήψεις](#23-Επαναλήψεις)
+    - [Ο Αστερίσκος](#231-Ο-Αστερίσκος)
+    - [Το Σύμβολο της Πρόσθεσης](#232-Το-Σύμβολο-της-Πρόσθεσης)
+    - [Το Ερωτηματικό](#233-Το-Ερωτηματικό)
+  - [Αγκύλες](#24-Αγκύλες)
+  - [Ομάδα Χαρακτήρων](#25-Ομάδα-Χαρακτήρων)
+  - [Εναλλαγή](#26-Εναλλαγή)
+  - [Ειδικός Χαρακτήρας Διαφυγής](#27-Ειδικός-Χαρακτήρας-Διαφυγής)
+  - [Σύμβολα "Άγκυρες"](#28-Σύμβολα-"Άγκυρες")
+    - [Το Σύμβολο ^](#281-Το-Σύμβολο-^)
+    - [Το Δολάριο](#282-Το-Δολάριο)
+- [Συντομογραφίες Συνόλων Χαρακτήρων](#3-Συντομογραφίες-Συνόλων-Χαρακτήρων)
+- [Αναζήτηση](#4-Αναζήτηση)
+  - [Θετική Αναζήτηση προς τα Μπροστά](#41-Θετική-Αναζήτηση-προς-τα-Μπροστά)
+  - [Αρνητική Αναζήτηση προς τα Μπροστά](#42-Αρνητική-Αναζήτηση-προς-τα-Μπροστά)
+  - [Θετική Αναζήτηση προς τα Πίσω](#43-Θετική-Αναζήτηση-προς-τα-Πίσω)
+  - [Αρνητική Αναζήτηση προς τα Πίσω](#44-Αρνητική-Αναζήτηση-προς-τα-Πίσω)
+- [Σημαίες](#5-Σημαίες)
+  - [Χωρίς Διάκριση Πεζών-Κεφαλαίων](#51-Χωρίς-Διάκριση-Πεζών-Κεφαλαίων)
+  - [Καθολική Αναζήτηση](#52-Καθολική-Αναζήτηση)
+  - [Πολλές Γραμμές](#53-Πολλές-Γραμμές)
+
+## 1. Βασικά Μοτίβα Αναζήτησης
+
+Μια κανονική έκφραση είναι απλώς ένα μοτίβο, δηλαδή μια σειρά χαρακτήρων, που χρησιμοποιούμε ώστε να κάνουμε
+αναζήτηση σε ένα κείμενο (πχ για να βρούμε ένα γράμμα ή μια λέξη κλπ). Για παράδειγμα, η κανονική έκφραση `the`
+αναπαριστά: το γράμμα `t`, ακολουθούμενο από το γράμμα `h`, ακολουθούμενο από το γράμμα `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dmRygT/1)
+
+Η κανονική έκφραση `123` "ταιριάζει" με το string `123`. Η έκφραση αυτή
+αναζητείται μέσα σ'ένα string εισόδου αντιστοιχίζοντας κάθε χαρακτήρα της με κάθε
+χαρακτήρα του string. Οι κανονικές εκφράσεις συνήθως λαμβάνουν υπόψη το αν τα γράμματα είναι
+κεφαλαία ή πεζά και άρα η έκφραση `The` δεν θα ταίριαζε με το string `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/1paXsy/1)
+
+## 2. Μεταχαρακτήρες
+
+Οι μεταχαρακτήρες είναι τα δομικά στοιχεία των κανονικών εκφράσεων. Δεν αντιπροσωπεύουν
+τον εαυτό τους αλλά ερμηνεύονται με ειδικό τρόπο. Μερικοί από αυτούς, έχουν
+ειδικό νόημα και γι'αυτό γράφονται μέσα σε αγκύλες. Οι μεταχαρακτήρες είναι οι παρακάτω:
+
+|Μεταχαρακτήρας|Περιγραφή|
+|:----:|----|
+|.|Η τελεία είναι ισοδύναμη με οποιονδήποτε μεμονωμένο χαρακτήρα εκτός από αυτόν για αλλαγή γραμμής.|
+|[ ]|Κλάση χαρακτήρων. Είναι ισοδύναμη με οποιονδήποτε χαρακτήρα βρίσκεται μέσα σε αγκύλες.|
+|[^ ]|Κλάση χαρακτήρων εξαίρεσης. Είναι ισοδύναμη με οποιονδήποτε χαρακτήρα δεν βρίσκεται μέσα σε αγκύλες|
+|*|Ταιριάζει με 0 ή παραπάνω επαναλήψεις του προηγούμενου συμβόλου.|
+|+|Ταιριάζει με 1 ή παραπάνω επαναλήψεις του προηγούμενου συμβόλου.|
+|?|Κάνει το προηγούμενο σύμβολο προαιρετικό.|
+|{n,m}|Αγκύλες. Ταιριάζει με τουλάχιστον "n" αλλά όχι με παραπάνω από "m" επαναλήψεις του προηγούμενου συμβόλου.|
+|(xyz)|Ομάδα χαρακτήρων. Είναι ισοδύναμη με τους χαρακτήρες xyz ακριβώς με την σειρά στην οποία βρίσκονται.|
+|||Εναλλαγή. Ταιριάζει είτε με τους χαρακτήρες που βρίσκονται πριν είτε μετά το σύμβολο.|
+|\|Παραλείπει το ειδικό νόημα του χαρακτήρα. Αυτό μας επιτρέπει να ταιριάξουμε χαρακτήρες
+ειδικής χρήσης <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Αναζητά το μοτίβο που ακολουθεί στην αρχή μιας εισόδου.|
+|$|Αναζητά το μοτίβο που ακολουθεί στο τέλος μιας εισόδου.|
+
+## 2.1 Τελεία
+
+Η τελεία `.` είναι το πιο απλό παράδειγμα μεταχαρακτήρα. Είναι ισοδύναμη με οποιονδήποτε
+μεμονωμένο χαρακτήρα με εξαίρεση τον χαρακτήρα για επιστροφή στην αρχή της γραμμής
+και αυτόν για νέα σειρά. Για παράδειγμα, η κανονική έκφραση `.ar` αναπαριστά: οποιονδήποτε
+χαρακτήρα που ακολουθείται από το γράμμα `a`, που με την σειρά του ακολουθείται από το γράμμα `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Σύνολα Χαρακτήρων
+
+Τα σύνολα χαρακτήρων καλούνται αλλιώς και κλάσεις χαρακτήρων. Τα σύνολα αυτά γράφονται μέσα
+σε αγκύλες. Για τον ορισμό της εμβέλειας ενός τέτοιου συνόλου χρησιμοποιείται μια παύλα
+για να διαχωρίζει την αρχή από το τέλος. Η σειρά των χαρακτήρων, που βρίσκονται μέσα στην
+εμβέλεια του συνόλου που ορίζεται από τις αγκύλες, δεν έχει σημασία. Για παράδειγμα,
+η κανονική έκφραση `[Tt]he` αναπαριστά: ένα κεφαλαίο `T` ή ένα πεζό `t`, που ακολουθείται
+από το γράμμα `h`, που με τη σειρά του ακολουθείται από το γράμμα `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/2ITLQ4/1)
+
+Όμως, μια τελεία μέσα σε ένα σύνολο χαρακτήρων, είναι μια κλασική τελεία και δεν εκλαμβάνεται
+ως μεταχαρακτήρας. Η κανονική έκφραση `ar[.]` αναπαριστά: ένα πεζό γράμμα `a`, που
+ακολουθείται από το γράμμα `r`, που με την σειρά του ακολουθείται από τον χαρακτήρα `.`.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Σύνολο Χαρακτήρων προς Εξαίρεση
+
+Γενικά, το σύμβολο ^ αναπαριστά την αρχή ενός string, αλλά όταν βρίσκεται
+μέσα σε αγκύλες ([] όχι {}), αναπαριστά ένα σύνολο χαρακτήρων που θα εξαιρεθούν από την διαδικασία
+της αναζήτησης. Για παράδειγμα, η κανονική έκφραση `[^c]ar` αναπαριστά: οποιονδήποτε χαρακτήρα
+εκτός από το `c`, που ακολουθείται από τον χαρακτήρα `a`, που ακολουθείται από
+το `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Επαναλήψεις
+
+Οι μεταχαρακτήρες `+`, `*` και `?`, χρησιμοποιούνται για να προσδιοριστεί
+το πόσες φορές επαναλαμβάνεται ένα υπό-μοτίβο χαρακτήρων μέσα στο string εισόδου. Αυτοί οι
+μεταχαρακτήρες συμπεριφέρονται διαφορετικά ανάλογα με την περίσταση.
+
+### 2.3.1 Ο Αστερίσκος
+
+Το σύμβολο `*` ψάχνει για μηδέν ή παραπάνω επαναλήψεις της έκφρασης
+που βρίσκεται πριν από αυτό. Η κανονική έκφραση `a*` αναπαριστά: αναζήτηση για μηδέν ή παραπάνω
+επαναλήψεις του πεζού χαρακτήρα `a`. Όταν το σύμβολο * βρίσκεται μετά από ένα σύνολο
+ή κλάση χαρακτήρων, τότε εντοπίζει ολόκληρο το σύνολο όσες φορές και αν υπάρχει σε μια
+γραμμή. Για παράδειγμα, η κανονική έκφραση `[a-z]*` αναπαριστά: οποιονδήποτε συνδυασμό
+πεζών γραμμάτων που βρίσκονται στην σειρά.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/7m8me5/1)
+
+Το σύμβολο `*` μπορεί να χρησιμοποιηθεί σε συνδυασμό με τον χαρακτήρα `.` ώστε
+να αναζητηθεί μια ακολουθία χαρακτήρων. Μπορεί επίσης να χρησιμοποιηθεί με τον
+χαρακτήρα κενού `\s` ώστε να αναζητηθεί μια ακολουθία κενών. Για παράδειγμα, η
+έκφραση `\s*cat\s*` αναπαριστά: μηδέν ή περισσότερα κενά, που ακολουθούνται από
+τον πεζό χαρακτήρα `c`, που ακολουθείται από τον πεζό χαρακτήρα `a`, που ακολουθείται
+ από τον πεζό χαρακτήρα `t`, που ακολουθείται από μηδέν ή περισσότερα κενά.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Το Σύμβολο της Πρόσθεσης
+
+Με σύμβολο `+` γίνεται αναζήτηση για μία ή περισσότερες επαναλήψεις του προηγούμενου του χαρακτήρα.
+Για παράδειγμα, η κανονική έκφραση `c.+t` αναπαριστά: το πεζό γράμμα `c`, που ακολουθείται
+από τουλάχιστον ένα χαρακτήρα, που ακολουθείται από το πεζό γράμμα `t`. Πρέπει να διευκρινίσουμε
+ότι το `t` είναι το τελευταίο `t` της πρότασης.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Το Ερωτηματικό
+
+Σε μια κανονική έκφραση, ο μεταχαρακτήρας `?` κάνει τον χαρακτήρα που βρίσκεται πριν από αυτόν,
+προαιρετικό ως προς την εύρεσή του. Έτσι γίνεται αναζήτηση για μηδέν ή παραπάνω περιπτώσεις εμφάνισης
+του προηγούμενου από το ερωτηματικό χαρακτήρα. Για παράδειγμα, η κανονική έκφραση `[T]?he` αναπαριστά:
+το προαιρετικό κεφαλαίο `T`, που ακολουθείται από πεζό `h`, που ακολουθείται από
+πεζό `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Αγκύλες
+
+Οι αγκύλες στις κανονικές εκφράσεις ονομάζονται αλλιώς και "ποσοτικοποιητές" αφού
+χρησιμοποιούνται για την εύρεση όλων επαναλήψεων ενός χαρακτήρα ή μιας
+ομάδας χαρακτήρων μέσα σ'ένα κείμενο. Για παράδειγμα, η κανονική έκφραση `[0-9]{2,3}` αναπαριστά: την
+αναζήτηση τουλάχιστον 2 ψηφίων το ένα μετά το άλλο αλλά όχι παραπάνω από 3 (στους χαρακτήρες από το 0 ως το 9).
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/juM86s/1)
+
+Μπορούμε να παραλείψουμε τον δεύτερο αριθμό. Για παράδειγμα, η κανονική έκφραση
+`[0-9]{2,}` αναπαριστά: την αναζήτηση 2 ή περισσότερων ψηφίων το ένα μετά το άλλο. Αν αφαιρέσουμε και
+την κόμμα, τότε η κανονική έκφραση `[0-9]{3}` αναπαριστά: την σύγκριση ακριβώς 3 ψηφίων.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Ομάδα Χαρακτήρων
+
+Μια ομάδα χαρακτήρων είναι μια ομάδα υπό-μοτίβων που γράφονται μέσα σε παρενθέσεις `(...)`.
+Όπως είπαμε και προηγουμένως, σε μια κανονική έκφραση, αν τοποθετήσουμε έναν ποσοτικοποιητή μετά από έναν
+χαρακτήρα, τότε αυτός ο χαρακτήρας θα βρεθεί όσες φορές και αν υπάρχει μέσα στο κείμενο στο οποίο
+εκτελείται η αναζήτηση. Παρομοίως, αν τον βάλουμε μετά από μια ομάδα χαρακτήρων. Για παράδειγμα,
+η κανονική έκφραση `(ab)*` ταιριάζει με μηδέν ή παραπάνω επαναλήψεις του χαρακτήρα
+"ab". Ακόμη, μπορούμε να χρησιμοποιήσουμε τον μεταχαρακτήρα εναλλαγής `|` μέσα σε μια ομάδα χαρακτήρων.
+Για παράδειγμα, η κανονική έκφραση `(c|g|p)ar` αναπαριστά: τους πεζούς χαρακτήρες `c`,
+`g` ή `p`, που ακολουθούνται από τον χαρακτήρα `a`, που ακολουθείται από τον χαρακτήρα `r`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Εναλλαγή
+
+Στις κανονικές εκφράσεις, η κάθετη γραμμή `|`, ορίζει μια εναλλαγή.
+Έτσι δηλαδή γίνεται μια επιλογή μεταξύ πολλαπλών εκφράσεων. Ίσως σκέφτεστε ότι
+η εναλλαγή και τα σύνολα , λειτουργούν με τον ίδιο τρόπο. Αλλά η μεγάλη διαφορά τους
+είναι ότι τα σύνολα χαρακτήρων δουλεύουν με χαρακτήρες ενώ η εναλλαγή με εκφράσεις.
+Για παράδειγμα, η κανονική έκφραση `(T|t)he|car` αναπαριστά: τον κεφαλαίο χαρακτήρα `T`
+ή τον πεζό χαρακτήρα `t`, που ακολουθείται από πεζό χαρακτήρα `h`, που ακολουθείται από
+πεζό χαρακτήρα `e` ή πεζό χαρακτήρα `c`, που ακολουθείται από πεζό χαρακτήρα `a`, που
+ακολουθείται από πεζό χαρακτήρα `r`.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Ειδικός Χαρακτήρας Διαφυγής
+
+Το σύμβολο `\` χρησιμοποιείται στις κανονικές εκφράσεις ώστε να αγνοηθεί η ειδική σημασία
+που μπορεί να έχει ο χαρακτήρας που βρίσκεται μετά από αυτό. Αυτό μας επιτρέπει να αναζητήσουμε ένα
+σύμβολο, συμπεριλαμβανομένων των ειδικών χαρακτήρων `{ } [ ] / \ + * . $ ^ | ?`. Άρα για αναζήτηση
+ειδικών χαρακτήρων, τοποθετούμε ακριβώς πριν το σύμβολο `\`.
+
+Για παράδειγμα, η κανονική έκφραση `.` χρησιμοποιείται για αναζήτηση οποιουδήποτε χαρακτήρα εκτός από
+αυτόν για την νέα γραμμή. Η παρακάτω κανονική έκφραση ψάχνει για το σύμβολο της τελείας `.` σε ένα string εισόδου. Η
+`(f|c|m)at\.?` αναπαριστά: ένα πεζό γράμμα `f`, `c` ή `m`, που ακολουθείται από τον πεζό τον
+χαρακτήρα `a`, που ακολουθείται από το πεζό γράμμα `t`, που ακολουθείται από τον προαιρετικό χαρακτήρα `.`.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Σύμβολα "Άγκυρες"
+
+Σε μια κανονική έκφραση, χρησιμοποιούμε "άγκυρες" για να ελέγξουμε αν το σύμβολο που αναζητάμε είναι
+το πρώτο ή το τελευταίο σύμβολο ενός string. Οι άγκυρες είναι δύο τύπων:
+Πρώτα είναι το σύμβολο `^` που ελέγχει αν ο χαρακτήρας που ψάχνουμε είναι ο πρώτος
+χαρακτήρας της εισόδου και μετά είναι το σύμβολο του δολαρίου `$` που ελέγχει αν ο χαρακτήρας που
+ψάχνουμε είναι ο τελευταίος στο string εισόδου.
+
+### 2.8.1 Το Σύμβολο ^
+
+Το σύμβολο `^` χρησιμοποιείται για να ελέγξουμε αν ο χαρακτήρας που ψάχνουμε είναι ο πρώτος χαρακτήρας
+του string εισόδου. Αν δοκιμάσουμε την κανονική έκφραση `^a` (ψάχνουμε δηλαδή αν το a είναι το πρώτο
+σύμβολο) στο string εισόδου `abc`, τότε βλέπουμε ότι όντως το `a` είναι ο πρώτος χαρακτήρας. Αλλά
+αν δοκιμάσουμε την κανονική έκφραση `^b` στην παραπάνω είσοδο, τότε δεν θα πάρουμε κάποιο αποτέλεσμα.
+Αυτό συμβαίνει επειδή στην έκφραση `abc` το "b" δεν είναι ο πρώτος χαρακτήρας. Ας ρίξουμε μια ματιά
+στην κανονική έκφραση `^(T|t)he` η οποία ψάχνει για: έναν κεφαλαίο χαρακτήρα `T` ή έναν
+πεζό χαρακτήρα `t` που να είναι ο πρώτος χαρακτήρας της εισόδου και να ακολουθείται από
+έναν πεζό χαρακτήρα `h`, που ακολουθείται από έναν πεζό χαρακτήρα `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Το Δολάριο
+
+Το σύμβολο του δολαρίου `$` χρησιμοποιείται για να ελέγξουμε αν ο χαρακτήρας που αναζητάμε είναι ο τελευταίος
+χαρακτήρας του string εισόδου. Για παράδειγμα, η κανονική έκφραση `(at\.)$` αναπαριστά: έναν
+πεζό χαρακτήρα `a`, που ακολουθείται από έναν πεζό χαρακτήρα `t`, που ακολουθείται από μια τελεία `.`
+και όλα αυτά πρέπει να είναι οι τελευταίοι χαρακτήρες της εισόδου.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/t0AkOd/1)
+
+##  3. Συντομογραφίες Συνόλων Χαρακτήρων
+
+Οι κανονικές εκφράσεις χρησιμοποιούν κάποιες συντομογραφίες για τα σύνολα χαρακτήρων που
+χρησιμοποιούνται πιο συχνά και έτσι γίνονται πιο εύκολες και βολικές για τον χρήστη.
+Οι συντομογραφίες των συνόλων χαρακτήρων είναι οι παρακάτω:
+
+|Συντομογραφία|Περιγραφή|
+|:----:|----|
+|.|Αναζήτηση όλων των χαρακτήρων εκτός από αυτόν για νέα γραμμή|
+|\w|Αναζήτηση αλφαριθμητικών χαρακτήρων: `[a-zA-Z0-9_]`|
+|\W|Αναζήτηση μη αλφαριθμητικών χαρακτήρων: `[^\w]`|
+|\d|Αναζήτηση στα ψηφία: `[0-9]`|
+|\D|Αναζήτηση χαρακτήρων που δεν είναι αριθμοί: `[^\d]`|
+|\s|Αναζήτηση του χαρακτήρα του κενού: `[\t\n\f\r\p{Z}]`|
+|\S|Αναζήτηση χαρακτήρων που δεν είναι το κενό: `[^\s]`|
+
+## 4. Αναζήτηση
+
+Η προς τα μπροστά και προς τα πίσω αναζήτηση, είναι συγκεκριμένοι τύποι συνόλων που
+ονομάζονται ***non-capturing groups*** (Χρησιμοποιούνται για αναζήτηση κάποιου μοτίβου
+αλλά δεν συμπεριλαμβάνονται στην λίστα των χαρακτήρων που ψάχνουμε). Οι αναζητήσεις προς τα μπροστά, χρησιμοποιούνται
+όταν το μοτίβο έχει πριν ή μετά ένα ακόμη μοτίβο. Για παράδειγμα, αν θέλουμε να βρούμε όλους
+τους αριθμούς που βρίσκονται μετά τον χαρακτήρα `$` στο παρακάτω string
+`$4.44 and $10.88`, τότε θα χρησιμοποιήσουμε την κανονική έκφραση `(?<=\$)[0-9\.]*`
+η οποία: βρίσκει όλους τους αριθμούς που βρίσκονται μετά από το σύμβολο`$` και περιέχουν τον χαρακτήρα `.` .
+Παρακάτω μπορείτε να δείτε τους τύπους αναζήτησης στις κανονικές εκφράσεις:
+
+|Σύμβολο|Περιγραφή|
+|:----:|----|
+|?=|Θετική Αναζήτηση προς τα Μπροστά|
+|?!|Αρνητική Αναζήτηση προς τα Μπροστά|
+|?<=|Θετική Αναζήτηση προς τα Πίσω|
+|?<!|Αρνητική Αναζήτηση προς τα Πίσω|
+
+### 4.1 Θετική Αναζήτηση προς τα Μπροστά
+
+Η θετική αναζήτηση προς τα μπροστά, εγγυάται ότι το πρώτο μέρος της έκφρασης θα
+ακολουθείται από την ανάλογη έκφραση για προς τα μπροστά αναζήτηση. Το αποτέλεσμα
+περιλαμβάνει μόνο το κείμενο που ταιριάζει στο πρώτο κομμάτι της έκφρασης. Για να ορίσουμε
+μια τέτοια αναζήτηση, χρησιμοποιούμε παρενθέσεις. Μέσα σε αυτές, τοποθετούμε ένα ερωτηματικό
+και ένα ίσον όπως παρακάτω: `(?=...)`. Η έκφραση για προς τα μπροστά αναζήτηση, γράφεται μετά
+το σύμβολο του ίσον μέσα στις παρενθέσεις. Για παράδειγμα, η κανονική έκφραση
+`(T|t)he(?=\sfat)` αναπαριστά: είτε το πεζό γράμμα `t` είτε το κεφαλαίο γράμμα
+`T`, που ακολουθείται από το γράμμα `h`, που με την σειρά του ακολουθείται από το γράμμα `e`. Μέσα στις
+παρενθέσεις, ορίζουμε την θετική προς τα μπροστά αναζήτηση, η οποία λέει στον μηχανισμό αναζήτησης
+της κανονικής έκφρασης να βρει τα `The` ή τα `the` που ακολουθούνται από την λέξη `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Αρνητική Αναζήτηση προς τα Μπροστά
+
+Η αρνητική αναζήτηση προς τα μπροστά, χρησιμοποιείται όταν θέλουμε όλες τις εκφράσεις που
+ταιριάζουν με το μοτίβο που αναζητάμε, που όμως δεν ακολουθούνται από κάποιο άλλο μοτίβο.
+Αυτή η αναζήτηση ορίζεται όπως και η παραπάνω αλλά αντί για το σύμβολο `=` χρησιμοποιούμε το `!`,
+με αυτό τον τρόπο: `(?!...)`. Ας δούμε την κανονική έκφραση `(T|t)he(?!\sfat)` η οποία: επιστρέφει
+όλα τα `The` ή `the` που υπάρχουν στο string εισόδου και δεν ακολουθούνται από την λέξη `fat`
+μετά από κενό.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Θετική Αναζήτηση προς τα Πίσω
+
+Η θετική αναζήτηση προς τα πίσω, χρησιμοποιείται όταν θέλουμε να βρούμε όλες τις εκφράσεις που
+ταιριάζουν με ένα μοτίβο (που ορίζουμε εμείς) που βρίσκεται πριν από αυτές. Αυτή η αναζήτηση χρησιμοποιεί τα
+σύμβολα `(?<=...)`. Για παράδειγμα, η κανονική έκφραση `(?<=(T|t)he\s)(fat|mat)`:
+επιστρέφει όλες τις λέξεις `fat` ή `mat` που βρίσκονται μετά την λέξη `The` ή `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/avH165/1)
+
+### 4.4 Αρνητική Αναζήτηση προς τα Πίσω
+
+Η αρνητική αναζήτηση προς τα πίσω χρησιμοποιείται όταν θέλουμε να βρούμε όλες τις εκφράσεις που
+ταιριάζουν με το μοτίβο αναζήτησης, χωρίς όμως να υπάρχει άλλο μοτίβο (που ορίζουμε εμείς) πριν από αυτές.
+Αυτή η αναζήτηση χρησιμοποιεί τα σύμβολα  `(?<!...)`. Για παράδειγμα, η κανονική έκφραση
+`(?<!(T|t)he\s)(cat)`: επιστρέφει όλες τις λέξεις `cat` που δεν βρίσκονται μετά από την λέξη `The` ή `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/8Efx5G/1)
+
+## 5. Σημαίες
+
+Οι σημαίες καλούνται αλλιώς και τροποποιητές αφού επηρεάζουν τον τρόπο αναζήτησης των
+κανονικών εκφράσεων. Μπορούν να χρησιμοποιηθούν με οποιαδήποτε σειρά και σε οποιονδήποτε συνδυασμό
+συμβόλων και είναι αναπόσπαστο κομμάτι των RegExp.
+
+|Σημαία|Περιγραφή|
+|:----:|----|
+|i|Αλλάζει την αναζήτηση ώστε να μην ενδιαφέρεται για τον αν τα γράμματα είναι πεζά ή κεφαλαία.|
+|g|Καθολική αναζήτηση: Ψάχνει ένα μοτίβο σε ολόκληρο το string εισόδου.|
+|m|Πολλαπλές γραμμές: Οι μεταχαρακτήρες άγκυρας λειτουργούν σε όλες τις γραμμές.|
+
+### 5.1 Χωρίς Διάκριση Πεζών-Κεφαλαίων
+
+Ο τροποποιητής `i` χρησιμοποιείται για αναζήτηση που δεν κάνει διακρίσεις μεταξύ πεζών
+και κεφαλαίων γραμμάτων. Για παράδειγμα, η κανονική έκφραση `/The/gi` αναπαριστά: ένα
+κεφαλαίο γράμμα `T`, που ακολουθείται από έναν πεζό χαρακτήρα `h`, που ακολουθείται από τον χαρακτήρα `e`.
+Στο τέλος της κανονικής έκφρασης υπάρχει η σημαία `i` η οποία λέει στην κανονική
+έκφραση να αγνοήσει το αν ένας χαρακτήρας είναι πεζός ή κεφαλαίος. Όπως βλέπετε υπάρχει και η
+σημαία `g` ώστε η αναζήτηση του μοτίβου να γίνει σε όλο το string εισόδου.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Καθολική Αναζήτηση
+
+Ο τροποποιητής `g`χρησιμοποιείται για καθολική αναζήτηση (για να βρεθούν δηλαδή όλες οι
+περιπτώσεις που ταιριάζουν με το μοτίβο αναζήτησης και να μην σταματήσει στην πρώτη εύρεση). Για παράδειγμα, η
+κανονική έκφραση `/.(at)/g` αναπαριστά: οποιονδήποτε χαρακτήρα εκτός από αυτόν για
+νέα γραμμή, που ακολουθείται από τον πεζό χαρακτήρα `a`, που ακολουθείται από τον πεζό
+χαρακτήρα `t` και αφού στο τέλος της κανονικής έκφρασης υπάρχει η σημαία `g`,
+θα βρεθούν όλες οι περιπτώσεις που περιγράφονται από την παραπάνω κανονική έκφραση και όχι μόνο
+η πρώτη (που είναι η προκαθορισμένη συμπεριφορά όταν δεν υπάρχει η σημαία `g`).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Πολλές Γραμμές
+
+Ο τροποποιητής `m` χρησιμοποιείται για αναζήτηση σε πολλές γραμμές. Όπως είπαμε
+προηγουμένως, οι άγκυρες `(^, $)` χρησιμοποιούνται για να ελέγξουμε αν ένα μοτίβο
+βρίσκεται στην αρχή ή στο τέλος του string εισόδου. Αν θέλουμε οι άγκυρες αυτές να
+ισχύουν για κάθε γραμμή, τότε χρησιμοποιούμε την σημαία `m`. Για παράδειγμα, η
+κανονική έκφραση `/at(.)?$/gm` αναπαριστά: τον πεζό χαρακτήρα `a`, που ακολουθείται
+από τον πεζό χαρακτήρα `t` και προαιρετικά οτιδήποτε άλλο εκτός από τον χαρακτήρα για
+νέα γραμμή. Και αφού υπάρχει και η σημαία `m`, η κανονική έκφραση θα αναζητήσει
+το μοτίβο στο τέλος κάθε γραμμής του string.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Δοκιμή της κανονικής έκφρασης](https://regex101.com/r/E88WE2/1)
+
+## Contribution
+
+* Report issues
+* Open pull request with improvements
+* Spread the word
+* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/README-ja.md b/README-ja.md
index ca94528a..126cde8a 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## 正規表現とは
 
diff --git a/README-ko.md b/README-ko.md
index c216f727..7d0097ea 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/README-pt_BR.md b/README-pt_BR.md
index 4f1e1d8b..de90728d 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -12,6 +12,7 @@
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Greek](README-gr.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/README-tr.md b/README-tr.md
index 837ec942..956e85ea 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -12,6 +12,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/README.md b/README.md
index 2fa1b744..7abb97d0 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
+* [Greek](README-gr.md)
 
 ## What is Regular Expression?
 

From 8c1912d000ad13d74da169898d64ec07bcb55ef7 Mon Sep 17 00:00:00 2001
From: danieloi <danieloi@mail.uc.edu>
Date: Fri, 22 Sep 2017 21:24:31 -0400
Subject: [PATCH 027/185] Gammar edit (#96)

Added is to section 4.2
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7abb97d0..4e1a6f32 100644
--- a/README.md
+++ b/README.md
@@ -421,7 +421,7 @@ or `the` which are followed by the word `fat`.
 ### 4.2 Negative Lookahead
 
 Negative lookahead is used when we need to get all matches from input string
-that are not followed by a pattern. Negative lookahead defined same as we define
+that are not followed by a pattern. Negative lookahead is defined same as we define
 positive lookahead but the only difference is instead of equal `=` character we
 use negation `!` character i.e. `(?!...)`. Let's take a look at the following
 regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words

From 28f40b4f03548930218a4fd003635fc92cb49c63 Mon Sep 17 00:00:00 2001
From: "Luis F. Uceta" <uzluisf@users.noreply.github.com>
Date: Sat, 23 Sep 2017 21:19:33 -0400
Subject: [PATCH 028/185] Fixed minor typos in Spanish translation. (#97)

* Fixed minor typos in Spanish translation and added link to Portuguese translation.

* Fixed minor typos in Spanish translation and added link to Portuguese translation.
---
 README-es.md | 171 ++++++++++++++++++++++++++-------------------------
 1 file changed, 87 insertions(+), 84 deletions(-)

diff --git a/README-es.md b/README-es.md
index b7c78e07..48d54da2 100644
--- a/README-es.md
+++ b/README-es.md
@@ -3,23 +3,24 @@
 <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
 </p><br/>
 
-## Translations:
+## Traducciones:
 
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
 * [中文版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
 
-## What is Regular Expression?
+## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
 
-Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular", puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utiliza para remplazar un texto, dentro de un *string* (o cadena de caracteres), validar el formato, extraer un substring de un string completo basado en la coincidencia de una patrón, y muchas cosas más.
+Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para remplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
 
-Imagina que estas escribiendo una aplicación y quieres agregar reglas para cuando el usuario elija su nombre de usuario. Nosotros vamos a querer que el nombre de usuario contenga letras, números, guión bajo, y guíon medio. También vamos a querer limitar el número de caracteres en el nombre de usuario para que no se vea feo. Para ello usamos la siguiente expresión regular para validar el nombre de usuario
+Imagina que estás escribiendo una aplicación y quieres agregar reglas para cuando el usuario elija su nombre de usuario. Nosotros queremos permitir que el nombre de usuario contenga letras, números, guión bajo (raya), y guión medio. También queremos limitar el número de caracteres en el nombre de usuario para que no se vea feo. Para ello usamos la siguiente expresión regular para validar el nombre de usuario.
 
 
 <br/><br/>
@@ -27,41 +28,41 @@ Imagina que estas escribiendo una aplicación y quieres agregar reglas para cuan
   <img src="./img/regexp-es.png" alt="Expresión regular">
 </p>
 
-De la expresión regular anterior, se puede aceptar las cadenas 'john_doe', 'jo-hn_doe' y 'john12_as'. La expresión no coincide con el nombre de usuario 'Jo', porque es una cadena de caracteres que contiene letras mayúsculas y es demasiado corta.
+La expresión regular anterior puede aceptar las cadenas `john_doe`, `jo-hn_doe` y `john12_as`. Sin embargo, la expresión no coincide con el nombre de usuario `Jo` porque es una cadena de caracteres que contiene letras mayúsculas y es demasiado corta.
 
 ## Tabla de contenido
 
-- [Introducción](#1-introduccion)
-- [Meta caracteres](#2-meta-caracteres)
+- [Introducción](#1-introducción)
+- [Meta-caracteres](#2-meta-caracteres)
   - [Full stop](#21-full-stop)
   - [Conjunto de caracteres](#22-conjunto-de-caracteres)
     - [Conjunto de caracteres negados](#221-conjunto-de-caracteres-negado)
   - [Repeticiones](#23-repeticiones)
-    - [Asterísco](#231-asterisco)
+    - [Asterisco](#231-asterisco)
     - [Signo más](#232-signo-mas)
-    - [Signo de pregunta](#233-signo-de-pregunta)
+    - [Signo de interrogación](#233-signo-de-pregunta)
   - [Llaves](#24-llaves)
   - [Grupo de caracteres](#25-grupo-de-caracteres)
   - [Alternancia](#26-alternacia)
   - [Caracteres especiales de escape](#27-caracteres-especiales-de-escape)
   - [Anclas](#28-anclas)
     - [Símbolo de intercalación](#281-simbolo-de-intercalacion)
-    - [Símbolo dolar](#282-simbolo-dolar)
+    - [Símbolo del dólar](#282-simbolo-dolar)
 - [Conjunto de caracteres abreviados](#3-conjunto-de-caracteres-abreviados)
 - [Mirar alrededor](#4-mirar-alrededor)
   - [Mirar hacia delante positivo](#41-mirar-hacia-delante-positivo)
   - [Mirar hacia delante negativo](#41-mirar-hacia-delaten-negativo)
   - [Mirar hacia atrás positivo](#41-mirar-hacia-atras-positivo)
   - [Mirar hacia atrás negativo](#41-mirar-hacia-atras-negativo)
-- [Banderas](#5-banderas)
-  - [mayúsculas y minúsculas](#51-mayusculas-y-minusculas)
+- [Indicadores](#5-indicadores)
+  - [Mayúsculas y minúsculas](#51-mayusculas-y-minusculas)
   - [Búsqueda global](#52-busqueda-global)
-  - [Multilinea](#53-multilinea)
-- [Bonus](#bonus)
+  - [Multilínea](#53-multilinea)
+
 
 ## 1. Introducción
 
-Una expresión regular es sólo un patrón de caracteres que utilizamos para realizar búsquedas en un texto. Por ejemplo, la expresión regular «the» significa: la letra `t` seguida de la letra `h` seguida de la letra `e`.
+Una expresión regular es sólo un patrón de caracteres que utilizamos para realizar búsquedas en un texto. Por ejemplo, la expresión regular `the` significa: la letra `t`, seguida de la letra `h`, seguida de la letra `e`.
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -77,28 +78,28 @@ La expresión regular `123` coincide con la cadena `123`. La expresión regular
 
 [Prueba la expresión regular](https://regex101.com/r/1paXsy/1)
 
-## 2. Meta caracteres
+## 2. Meta-caracteres
 
-Los caracteres meta son los bloques de construcción de las expresiones regulares. Los meta caracteres no se sostienen a 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:
+Los meta-caracteres son los bloques de construcción de las expresiones regulares. Los meta-caracteres no se sostienen a 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:
 
-|Meta character|Description|
+|Meta-carácter|Descripción|
 |:----:|----|
-|.|Periodo. Coincide con cualquier caracter excepto un salto de línea.|
-|[ ]|Clase caracter. Coincide con cualquier caracter contenido entre corchetes.|
-|[^ ]|Clase caracter negado. Coincide con cualquier caracter que no está contenido dentro de los corchetes.|
+|.|Período. Coincide con cualquier carácter excepto un salto de línea.|
+|[ ]|Clase de caracteres. Coincide con cualquier carácter contenido entre corchetes.|
+|[^ ]|Clase de caracteres negados. Coincide con cualquier carácter que no está contenido dentro de los corchetes.|
 |*|Corresponde con 0 o más repeticiones del símbolo precedente.|
 |+|Corresponde con 1 o más repeticiones del símbolo precedente.|
 |?|Hace que el símbolo precedente sea opcional.|
-|{n,m}|Llaves.Corresponde al menos "n" pero no más de "m" repeticiones del símbolo precedente.|
-|(xyz)|Grupo caracter. Hace coincidir los caracteres xyz en ese orden exacto.|
+|{n,m}|Llaves. Corresponde al menos "n" pero no más de "m" repeticiones del símbolo precedente.|
+|(xyz)|Grupo carácter. Hace coincidir los caracteres xyz en ese orden exacto.|
 |||Alternancia. Corresponde a los caracteres anteriores o los caracteres después del símbolo.|
-|\|Escapa el siguiente caracter. Esto le permite hacer coincidir los caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|\|Escapa el siguiente carácter. Esto le permite hacer coincidir los caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
 |^|Hace coincidir el principio de la entrada.|
 |$|Corresponde al final de la entrada.|
 
 ## 2.1 Full stop
 
-Full stop `.` es el ejemplo más simple del meta-caracter. El caracter meta "." 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 caracter, seguido de la letra`a`, seguido de la letra "r".
+Full 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`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -108,7 +109,7 @@ Full stop `.` es el ejemplo más simple del meta-caracter. El caracter meta "."
 
 ## 2.2 Conjunto de caracteres
 
-Los conjuntos de caracteres también se llaman clase de caracteres. Los corchetes se utilizan para especificar conjuntos de caracteres. Utilice un guión 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: una letra mayúscula "T" o <minúscula> t, seguida de la letra "h" seguida de la letra "e"
+Los conjuntos de caracteres también se llaman clase de caracteres. Los corchetes se utilizan para especificar conjuntos de caracteres. Utilice un guión 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -116,7 +117,7 @@ Los conjuntos de caracteres también se llaman clase de caracteres. Los corchete
 
 [Prueba la expresión regular](https://regex101.com/r/2ITLQ4/1)
 
-Sin embargo, un período dentro de un conjunto de caracteres significa un período literal. La expresión regular `ar [.]` Significa: un carácter minúsculo `a`, seguido de la letra` r`, seguido de un carácter `.`.
+Sin 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 `.`.
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -126,7 +127,7 @@ Sin embargo, un período dentro de un conjunto de caracteres significa un perío
 
 ### 2.2.1 Conjunto de caracteres negados
 
-En 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 de la letra `r`.
+En 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`.
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -136,9 +137,9 @@ En general, el símbolo de intercalación representa el comienzo de la cadena, p
 
 ## 2.3 Repeticiones
 
-Siguiendo los 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.
+Los 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.
 
-### 2.3.1 Asterísco
+### 2.3.1 Asterisco
 
 El 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.
 
@@ -148,7 +149,7 @@ El símbolo `*` coincide con cero o más repeticiones del marcador anterior. La
 
 [Prueba la expresión regular](https://regex101.com/r/7m8me5/1)
 
-El símbolo `*` se puede utilizar con el meta-caracter `.` para que coincida con cualquier cadena de caracteres `.*`. El símbolo `*` se lo puede utilizar con el caracter 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.
+El 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.
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
@@ -158,7 +159,7 @@ El símbolo `*` se puede utilizar con el meta-caracter `.` para que coincida con
 
 ### 2.3.2 Signo más
 
-El símbolo `+` coincide con una o más repeticiones del carácter anterior. Por ejemplo, la expresión regular `c.+T` significa: letra  en minúscula `c`, seguida por al menos uno del mismo carácter, luego el carácter en minúscula `t`.
+El 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`.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -166,9 +167,9 @@ El símbolo `+` coincide con una o más repeticiones del carácter anterior. Por
 
 [Prueba la expresión regular](https://regex101.com/r/Dzf9Aa/1)
 
-### 2.3.3 Signo de pregunta
+### 2.3.3 Signo de interrogación
 
-En expresiones regulares el meta-caracter `?` hace que el caracter precedente sea opcional. Este símnbolo coincide con cero o una instancia del caracter precedente. Por ejemplo, la expresión regular  `[T]?he` significa: El caracteropcional predecesor `T` seguido por la letra en minúscula `h`, seguido del caracter en minúscula `e`.
+En 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`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -184,7 +185,7 @@ En expresiones regulares el meta-caracter `?` hace que el caracter precedente se
 
 ## 2.4 Llaves
 
-En la expresión regular, las llaves que también se denominan cuantificadores se utilizan 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 del rango de 0 a 9).
+En 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).
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -208,7 +209,7 @@ Podemos dejar fuera el segundo número. Por ejemplo, la expresión regular `[0-9
 
 ## 2.5 Grupos de caracteres
 
-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 caracter, repetiremos el caracter anterior. Pero si ponemos 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 caracter de alternancia `|` meta dentro del grupo de caracteres. Por ejemplo, la expresión regular `(c|g|p)ar` significa: caracter en minúscula `c`, `g` o `p`, seguido del caracter `a`, seguido del caracter `r`.
+Un 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`.
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
@@ -217,7 +218,7 @@ Grupo de caracteres es un grupo de sub-patrones que se escribe dentro de parént
 
 ## 2.6 Alternancia
 
-En la expresión regular se usa la barra vertical `|` 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. Pero la gran diferencia entre el conjunto de caracteres y la alternancia es que el conjunto de caracteres funciona a nivel de caracter pero la alternancia funciona a nivel de expresión. Por ejemplo, la expresión regular `(T|t)he|car` significa: el carcter en mayúscula `T` o en minúscula `t`, seguido del caracter en minúscula `h`, seguido del caracter en minúscula `e` o del caracter en minúscula `c`, seguido de un caracter en minúscula `a`, seguido del carácter en minúscula `r`.
+En 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`.
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -227,7 +228,9 @@ En la expresión regular se usa la barra vertical `|` para definir la alternanci
 
 ## 2.7 Caracteres especiales de escape
 
-La barra invertida `\` se utiliza en la expresión regular para escapar del carácter siguiente. Esto permite especificar un símbolo como un caracter coincidente incluyendo caracteres reservados `{}[]/\+*.^|?`. Por ejemplo, la expresión regular `.` se utiliza para coincidir con cualquier caracter, excepto la nueva línea. Ahora, para emparejar `.` en una cadena de entrada, la expresión regular `(f|c|m)at\.?` significa: la letra minúscula `f`, `c` o `m`, seguida del caracter en minúscula `a`, seguido de la letra minúscula `t`, seguida del caracter opcional `.`.
+La 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.
+
+Por 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 `.`.
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -237,11 +240,11 @@ La barra invertida `\` se utiliza en la expresión regular para escapar del car
 
 ## 2.8 Anclas
 
-En expresiones regulares, usamos anclas para comprobar si el símbolo de coincidencia 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 `^` que comprueba si el caracter coincidente es el caracter inicial de la entrada y el segundo tipo es Dollar `$` que comprueba si el caracter coincidente es el último caracter de la cadena de entrada.
+En 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.
 
-### 2.8.1 Simbolo de intercalación
+### 2.8.1 Símbolo de intercalación
 
-El símbolo de intercalación `^` se usa para verificar si el caracter coincidente es el primer caracter 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 otra expresión regular `^(T|t)he`, significa: mayúsculas `T` o la letra minúscula `t` es el símbolo inicial de la cadena de entrada, seguido del caracter minúscula `h` y seguido del caracter en minúscula `e`.
+El 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`.
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -255,9 +258,9 @@ El símbolo de intercalación `^` se usa para verificar si el caracter coinciden
 
 [Prueba la expresión regular](https://regex101.com/r/jXrKne/1)
 
-### 2.8.2 Símbolo dolar
+### 2.8.2 Símbolo del dólar
 
-El símbolo de dólar `$` se utiliza para comprobar si el caracter coincidente es el último carácter de la cadena de entrada. Por ejemplo, la expresión regular `(at\.)$` significa: un caracter en minúscula `a`, seguido del caracter en minúscula `t` seguido de un carácter `.` y el marcador debe ser el final de la cadena.
+El 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.
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -277,9 +280,9 @@ La expresión regular proporciona abreviaturas para los conjuntos de caracteres
 comúnmente utilizados, que ofrecen abreviaturas convenientes para expresiones
 regulares de uso común. Los conjuntos de caracteres abreviados son los siguientes:
 
-|Shorthand|Description|
+|Abreviatura|Descripción|
 |:----:|----|
-|.|Cualquier caracter excepto la nueva línea|
+|.|Cualquier carácter excepto nueva línea|
 |\w|Coincide con los caracteres alfanuméricos: `[a-zA-Z0-9_]`|
 |\W|Coincide con los caracteres no alfanuméricos: `[^\w]`|
 |\d|Coincide con dígitos: `[0-9]`|
@@ -289,9 +292,9 @@ regulares de uso común. Los conjuntos de caracteres abreviados son los siguient
 
 ## 4. Mirar alrededor
 
-Mirar hacia delante (lookaheds) y mirar hacia atrás (Lookbehind) a veces conocidos
-como lookaround son tipo específico de ***grupo que no captura*** (Utilice para
-coincidir con el patrón pero no se incluye en la lista correspondiente). Los
+Mirar hacia delante (lookahead) y mirar hacia atrás (lookbehind), a veces conocidos
+como lookaround, son tipo específico de **grupo que no captura** (Utilizados para
+coincidir con el patrón pero no se incluyen en la lista correspondiente). Los
 lookaheads se usan cuando tenemos la condición de que este patrón es precedido o
 seguido por otro patrón determinado. Por ejemplo, queremos obtener todos los números
 que están precedidos por el carácter `$` de la siguiente cadena de entrada
@@ -300,25 +303,25 @@ esto significa: obtener todos los números que contienen el carácter `.` y
 están precedidos del carácter `$`. A continuación se muestran los lookarounds
 que se utilizan en expresiones regulares:
 
-|Symbol|Description|
+|Símbolo|Descripción|
 |:----:|----|
-|?=|Positive Lookahead|
-|?!|Negative Lookahead|
-|?<=|Positive Lookbehind|
-|?<!|Negative Lookbehind|
+|?=|Lookahead Positivo|
+|?!|Lookahead Negativo|
+|?<=|Lookbehind Positivo|
+|?<\!|Lookbehind Negativo|
 
-### 4.1 Mirar hacia adelate positiva
+## 4.1 Mirar hacia adelate positiva
 
 El lookahead positivo afirma que la primera parte de la expresión debe ser
-seguida por la expresión lookahead. El matchonly devuelto contiene el texto que
+seguida por la expresión lookahead. La coincidencia devuelta sólo contiene el texto que
 coincide con la primera parte de la expresión. Para definir un lookahead positivo,
 se utilizan paréntesis. Dentro de esos paréntesis, un signo de interrogación con
 signo igual se utiliza de esta manera: `(?= ...)`. La expresión de Lookahead se
 escribe después del signo igual dentro de los paréntesis. Por ejemplo, la
-expresión regular `[T|t]he (?=\Sfat) significa: opcionalmente emparejar
-la letra minúscula `t` o la letra mayúscula `T`, seguida de la letra `h`, seguida
-de la letra `e`. Entre paréntesis definimos lookahead positivo que indica al motor
-de expresión regular que coincida con `The` o` the` seguido de la palabra `fat`.
+expresión regular `[T|t]he (?=\Sfat)` significa: opcionalmente emparejar
+el carácter en minúscula `t` o el carácter en mayúscula `T`, seguida del carácter `h`, seguida
+del carácter `e`. Entre paréntesis definimos el lookahead positivo que indica al motor
+de expresión regular que coincida con `The` o `the` seguido de la palabra `fat`.
 
 <pre>
 "[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -331,9 +334,9 @@ de expresión regular que coincida con `The` o` the` seguido de la palabra `fat`
 El lookahead negativo se usa cuando necesitamos obtener todas las coincidencias
 de la cadena de entrada que no son seguidas por un patrón. El aspecto negativo se
 define de la misma manera que definimos el aspecto positivo, pero la única diferencia
-es que en lugar del caracter igual `=` utilizamos la negción  `!` , es decir,
+es que en lugar del carácter igual `=` utilizamos carácter negación  `!` , es decir,
 `(?! ...)`. Vamos a echar un vistazo a la siguiente expresión regular `[T|t]he(?!\Sfat)`
-que significa: obtener todas las `The` o `the`  seguidos por la palabra `fat` precedido por un carácter de espacio.
+que significa: obtener todas las `The` o `the` seguidos por la palabra `fat` precedido por un carácter de espacio.
 
 
 <pre>
@@ -345,7 +348,7 @@ que significa: obtener todas las `The` o `the`  seguidos por la palabra `fat` pr
 ### 4.3 Mirar hacia atras positiva
 
 Positivo lookbehind se utiliza para obtener todos los caracteres que están precedidos
-por un patrón específico. La apariencia positiva se denomina `(?<=...)`.
+por un patrón específico. La apariencia positiva se denotar por `(?<=...)`.
 Por ejemplo, la expresión regular `(? <= [T|t]he\s)(fat|mat)` significa: obtener todas las palabras
 `fat` o `mat` de la cadena de entrada después de la palabra `The` o `the`.
 
@@ -369,26 +372,26 @@ la palabra` The` o `the`.
 
 [Prueba la expresión regular](https://regex101.com/r/8Efx5G/1)
 
-## 5. Banderas
+## 5. Indicadores
 
 Los indicadores también se llaman modificadores porque modifican la salida
 de una expresión regular. Estos indicadores se pueden utilizar en cualquier orden
 o combinación, y son una parte integral de RegExp.
 
 
-|Bandera|Descripción|
+|Indicador|Descripción|
 |:----:|----|
-|i|Insensible a mayúsculas y minúsculas: ajusta la coincidencia para que no distinga mayúsculas y minúsculas.|
-|g|Búsqueda global: busque un patrón en toda la cadena de entrada.|
-|m|Multilinea: Ancla meta caracter trabaja en cada linea.|
+|i|Insensible a mayúsculas y minúsculas: Ajusta la coincidencia para que no distinga mayúsculas y minúsculas.|
+|g|Búsqueda global: Busca un patrón en toda la cadena de entrada.|
+|m|Multilínea: Ancla meta carácter trabaja en cada línea.|
 
 ### 5.1 Mayúscula y minúscula
 
 El modificador `i` se utiliza para realizar la coincidencia entre mayúsculas y
-minúsculas. Por ejemplo, la expresión regular `/The/gi` significa: letra mayúscula
-`T`, seguido del caracter en minúscula `h`, seguido del carácter `e`. Y al final
+minúsculas. Por ejemplo, la expresión regular `/The/gi` significa: carácter en mayúscula
+`T`, seguido del carácter en minúscula `h`, seguido del carácter `e`. Y al final
 de la expresión regular, el indicador `i` indica al motor de expresiones
-regulares que ignore el caso. Como puede ver, también ofrecemos el indicador
+regulares que ignore el caso. Como puede ver, también proveimos el indicador
 `g` porque queremos buscar el patrón en toda la cadena de entrada.
 
 
@@ -409,9 +412,10 @@ regulares que ignore el caso. Como puede ver, también ofrecemos el indicador
 El modificador `g` se utiliza para realizar una coincidencia global
 (encontrar todos las coincidencias en lugar de detenerse después de la primera coincidencia).
 Por ejemplo, la expresión regular `/.(At)/g` significa: cualquier carácter,
-excepto la nueva línea, seguido del caracter minúsculo `a`, seguido del caracter
-en minúscula `t`. Debido a que siempre `g` prevee la bandera al final de la expresión
-regular ahora encontrará todas las coincidencias de toda la cadena de entrada.
+excepto la nueva línea, seguido del carácter en minúscula `a`, seguido del carácter
+en minúscula `t`. Debido a que proveimos el indicador `g` al final de la expresión
+regular, ahora encontrará todas las coincidencias de toda la cadena de entrada, no sólo la 
+primera instancia (el cual es el comportamiento normal).
 
 
 <pre>
@@ -426,15 +430,14 @@ regular ahora encontrará todas las coincidencias de toda la cadena de entrada.
 
 [Prueba la expresión regular](https://regex101.com/r/dO1nef/1)
 
-### 5.3 Multilinea
+### 5.3 Multilínea
 
 El modificador `m` se utiliza para realizar una coincidencia de varias líneas.
 Como analizamos anteriormente, las anclas `(^,$)` se utilizan para comprobar si
 el patrón es el comienzo de la entrada o el final de la cadena de entrada. Pero
-si queremos que las anclas funcionen en cada línea usamos la bandera `m`.
-Por ejemplo, la expresión regular `/at(.)?$/Gm`
-significa: caracter en minúscula` a`, seguido del caracter minúsculo `t`,
-opcionalmente cualquier cosa menos la nueva línea. Y debido a `m` bandera ahora
+si queremos que las anclas funcionen en cada línea usamos el indicador `m`.
+Por ejemplo, la expresión regular `/at(.)?$/Gm` significa: carácter en minúscula `a`, seguido del carácter en minúscula `t`,
+opcionalmente cualquier cosa menos la nueva línea. Y debido al indicador `m`, ahora
 el motor de expresión regular coincide con el patrón al final de cada línea de una cadena.
 
 <pre>
@@ -453,13 +456,13 @@ el motor de expresión regular coincide con el patrón al final de cada línea d
 
 [Prueba la expresión regular](https://regex101.com/r/E88WE2/1)
 
-## Contribution
+## Contribución
 
-* Report issues
-* Open pull request with improvements
-* Spread the word
-* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Reporta un problema
+* Abre un pull request con mejoras
+* Pasa la palabra
+* Contáctame directamente a ziishaned@gmail.com o [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
-## License
+## Licencia
 
 MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)

From 7b00db73fc8b0bdafcf129ab15428f7acb34d485 Mon Sep 17 00:00:00 2001
From: Caleb Mazalevskis <maikuolan@gmail.com>
Date: Wed, 18 Oct 2017 13:32:47 +0800
Subject: [PATCH 029/185] Patch.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Sync language list (all translations).
- Sync some punctuation (Chinese ",.:?" -> "，。：？" and Japanese "," ->
"、").
- Sync some spacing (various translations).
- One missing translation (Chinese).
- (PR is NOT a complete audit or proofreading).
---
 README-cn.md    | 233 ++++++++++++++++++++++++------------------------
 README-es.md    |   5 +-
 README-fr.md    |   3 +-
 README-gr.md    |   2 +-
 README-ja.md    |  29 +++---
 README-ko.md    |   3 +-
 README-pt_BR.md |   3 +-
 README-tr.md    |  15 ++--
 README.md       |   2 +-
 9 files changed, 151 insertions(+), 144 deletions(-)

diff --git a/README-cn.md b/README-cn.md
index add4168c..de8d14f9 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -3,36 +3,37 @@
 <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
 </p><br/>
 
-## 翻译:
+## 翻译：
 
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
-* [中文版](README-cn.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
 
-## 什么是正则表达式?
+## 什么是正则表达式？
 
-> 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子.
+> 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
 
 
-一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式.
-"Regular expression"这个词比较拗口, 我们常使用缩写的术语"regex"或"regexp".
-正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等.
+一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式。
+“Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。
+正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等。
 
-想象你正在写一个应用, 然后你想设定一个用户命名的规则, 让用户名包含字符,数字,下划线和连字符,以及限制字符的个数,好让名字看起来没那么丑.
-我们使用以下正则表达式来验证一个用户名:
+想象你正在写一个应用，然后你想设定一个用户命名的规则，让用户名包含字符，数字，下划线和连字符，以及限制字符的个数，好让名字看起来没那么丑。
+我们使用以下正则表达式来验证一个用户名：
 
 <br/><br/>
 <p align="center">
   <img src="./img/regexp-en.png" alt="Regular expression">
 </p>
 
-以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.
-但不匹配`Jo`, 因为它包含了大写的字母而且太短了.
+以上的正则表达式可以接受 `john_doe`、`jo-hn_doe`、`john12_as`。
+但不匹配`Jo`，因为它包含了大写的字母而且太短了。
 
 目录
 =================
@@ -69,8 +70,8 @@
 
 ## 1. 基本匹配
 
-正则表达式其实就是在执行搜索时的格式, 它由一些字母和数字组合而成.
-例如: 一个正则表达式 `the`, 它表示一个规则: 由字母`t`开始,接着是`h`,再接着是`e`.
+正则表达式其实就是在执行搜索时的格式，它由一些字母和数字组合而成。
+例如：一个正则表达式 `the`，它表示一个规则：由字母`t`开始,接着是`h`，再接着是`e`。
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -78,9 +79,9 @@
 
 [在线练习](https://regex101.com/r/dmRygT/1)
 
-正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较.
+正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较。
 
-正则表达式是大小写敏感的, 所以`The`不会匹配`the`.
+正则表达式是大小写敏感的，所以`The`不会匹配`the`。
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -90,29 +91,29 @@
 
 ## 2. 元字符
 
-正则表达式主要依赖于元字符.
-元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍:
+正则表达式主要依赖于元字符。
+元字符不代表他们本身的字面意思，他们都有特殊的含义。一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍：
 
 |元字符|描述|
 |:----:|----|
-|.|句号匹配任意单个字符除了换行符.|
-|[ ]|字符种类. 匹配方括号内的任意字符.|
-|[^ ]|否定的字符种类. 匹配除了方括号里的任意字符|
-|*|匹配>=0个重复的在*号之前的字符.|
-|+|匹配>=1个重复的+号前的字符.
-|?|标记?之前的字符为可选.|
-|{n,m}|匹配num个大括号之前的字符 (n <= num <= m).|
-|(xyz)|字符集, 匹配与 xyz 完全相等的字符串.|
-|||或运算符,匹配符号前或后的字符.|
-|\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|从开始行开始匹配.|
-|$|从末端开始匹配.|
+|.|句号匹配任意单个字符除了换行符。|
+|[ ]|字符种类. 匹配方括号内的任意字符。|
+|[^ ]|否定的字符种类。匹配除了方括号里的任意字符。|
+|*|匹配>=0个重复的在*号之前的字符。|
+|+|匹配>=1个重复的+号前的字符。|
+|?|标记?之前的字符为可选。|
+|{n,m}|匹配num个大括号之前的字符 (n <= num <= m)。|
+|(xyz)|字符集，匹配与 xyz 完全相等的字符串。|
+|||或运算符，匹配符号前或后的字符。|
+|\|转义字符，用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|从开始行开始匹配。|
+|$|从末端开始匹配。|
 
 ## 2.1 点运算符 `.`
 
-`.`是元字符中最简单的例子.
-`.`匹配任意单个字符, 但不匹配换行符.
-例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串.
+`.`是元字符中最简单的例子。
+`.`匹配任意单个字符，但不匹配换行符。
+例如，表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串。
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -122,11 +123,11 @@
 
 ## 2.2 字符集
 
-字符集也叫做字符类.
-方括号用来指定一个字符集.
-在方括号中使用连字符来指定字符集的范围.
-在方括号中的字符集不关心顺序.
-例如, 表达式`[Tt]he` 匹配 `the` 和 `The`.
+字符集也叫做字符类。
+方括号用来指定一个字符集。
+在方括号中使用连字符来指定字符集的范围。
+在方括号中的字符集不关心顺序。
+例如，表达式`[Tt]he` 匹配 `the` 和 `The`。
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -134,8 +135,8 @@
 
 [在线练习](https://regex101.com/r/2ITLQ4/1)
 
-方括号的句号就表示句号.
-表达式 `ar[.]` 匹配 `ar.`字符串
+方括号的句号就表示句号。
+表达式 `ar[.]` 匹配 `ar.`字符串。
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -145,8 +146,8 @@
 
 ### 2.2.1 否定字符集
 
-一般来说 `^` 表示一个字符串的开头, 但它用在一个方括号的开头的时候, 它表示这个字符集是否定的.
-例如, 表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符.
+一般来说 `^` 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的。
+例如，表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符。
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -156,13 +157,13 @@
 
 ## 2.3 重复次数
 
-后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数.
-这些元字符在不同的情况下有着不同的意思.
+后面跟着元字符 `+`，`*`或`?`的，用来指定匹配子模式的次数。
+这些元字符在不同的情况下有着不同的意思。
 
 ### 2.3.1 `*` 号
 
-`*`号匹配 在`*`之前的字符出现`大于等于0`次.
-例如, 表达式 `a*` 匹配以0或更多个a开头的字符, 因为有0个这个条件, 其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串.
+`*`号匹配 在`*`之前的字符出现`大于等于0`次。
+例如，表达式 `a*` 匹配以0或更多个a开头的字符，因为有0个这个条件，其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串。
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -170,8 +171,8 @@
 
 [在线练习](https://regex101.com/r/7m8me5/1)
 
-`*`字符和`.`字符搭配可以匹配所有的字符`.*`.
-`*`和表示匹配空格的符号`\s`连起来用, 如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串.
+`*`字符和`.`字符搭配可以匹配所有的字符`.*`。
+`*`和表示匹配空格的符号`\s`连起来用，如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串。
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
@@ -181,8 +182,8 @@
 
 ### 2.3.2 `+` 号
 
-`+`号匹配`+`号之前的字符出现 >=1 次.
-例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串.
+`+`号匹配`+`号之前的字符出现 >=1 次。
+例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾，中间跟着任意个字符的字符串。
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -192,8 +193,8 @@
 
 ### 2.3.3 `?` 号
 
-在正则表达式中元字符 `?` 标记在符号前面的字符为可选, 即出现 0 或 1 次.
-例如, 表达式 `[T]?he` 匹配字符串 `he` 和 `The`.
+在正则表达式中元字符 `?` 标记在符号前面的字符为可选，即出现 `0` 或 `1` 次。
+例如，表达式 `[T]?he` 匹配字符串 `he` 和 `The`。
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -209,8 +210,8 @@
 
 ## 2.4 `{}` 号
 
-在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数.
-例如,  表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字.
+在正则表达式中 `{}` 是一个量词，常用来一个或一组字符可以重复出现的次数。
+例如，表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -218,11 +219,11 @@
 
 [在线练习](https://regex101.com/r/juM86s/1)
 
-我们可以省略第二个参数.
-例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字.
+我们可以省略第二个参数。
+例如， `[0-9]{2,}` 匹配至少两位 0~9 的数字。
 
-如果逗号也省略掉则表示重复固定的次数.
-例如, `[0-9]{3}` 匹配3位数字
+如果逗号也省略掉则表示重复固定的次数。
+例如， `[0-9]{3}` 匹配3位数字。
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -238,9 +239,9 @@
 
 ## 2.5 `(...)` 特征标群
 
-特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.
+特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。
 
-我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
+我们还可以在 `()` 中用或字符 `|` 表示或。 例如， `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`。
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -250,9 +251,9 @@
 
 ## 2.6 `|` 或运算符
 
-或运算符就表示或, 用作判断条件.
+或运算符就表示或，用作判断条件。
 
-例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`.
+例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`。
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -262,9 +263,9 @@
 
 ## 2.7 转码特殊字符
 
-反斜线 `\` 在表达式中用于转码紧跟其后的字符. 用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`.
+反斜线 `\` 在表达式中用于转码紧跟其后的字符。用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`。
 
-例如 `.` 是用来匹配除换行符外的所有字符的. 如果想要匹配句子中的 `.` 则要写成 `\.` 以下这个例子 `\.?`是选择性匹配`.`
+例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\.` 以下这个例子 `\.?`是选择性匹配`.`。
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -274,15 +275,15 @@
 
 ## 2.8 锚点
 
-在正则表达式中, 想要匹配指定开头或结尾的字符串就要使用到锚点. `^` 指定开头, `$` 指定结尾.
+在正则表达式中，想要匹配指定开头或结尾的字符串就要使用到锚点。 `^` 指定开头， `$` 指定结尾。
 
 ### 2.8.1 `^` 号
 
-`^` 用来检查匹配的字符串是否在所匹配字符串的开头.
+`^` 用来检查匹配的字符串是否在所匹配字符串的开头。
 
-例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头.
+例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头。
 
-例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串.
+例如， `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串。
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -298,9 +299,9 @@
 
 ### 2.8.2 `$` 号
 
-同理于 `^` 号, `$` 号用来匹配字符是否是最后一个.
+同理于 `^` 号， `$` 号用来匹配字符是否是最后一个。
 
-例如, `(at\.)$` 匹配以 `at.` 结尾的字符串.
+例如， `(at\.)$` 匹配以 `at.` 结尾的字符串。
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -316,50 +317,50 @@
 
 ##  3. 简写字符集
 
-正则表达式提供一些常用的字符集简写. 如下:
+正则表达式提供一些常用的字符集简写. 如下：
 
 |简写|描述|
 |:----:|----|
-|.|除换行符外的所有字符|
-|\w|匹配所有字母数字, 等同于 `[a-zA-Z0-9_]`|
-|\W|匹配所有非字母数字, 即符号, 等同于: `[^\w]`|
-|\d|匹配数字: `[0-9]`|
-|\D|匹配非数字: `[^\d]`|
-|\s|匹配所有空格字符, 等同于: `[\t\n\f\r\p{Z}]`|
-|\S|匹配所有非空格字符: `[^\s]`|
-|\f|匹配一个换页符|
-|\n|匹配一个换行符|
-|\r|匹配一个回车符|
-|\t|匹配一个制表符|
-|\v|匹配一个垂直制表符|
-|\p|匹配 CR/LF (等同于 `\r\n`)，用来匹配 DOS 行终止符|
+|.|除换行符外的所有字符。|
+|\w|匹配所有字母数字，等同于 `[a-zA-Z0-9_]`。|
+|\W|匹配所有非字母数字，即符号，等同于: `[^\w]`。|
+|\d|匹配数字: `[0-9]`。|
+|\D|匹配非数字: `[^\d]`。|
+|\s|匹配所有空格字符，等同于: `[\t\n\f\r\p{Z}]`。|
+|\S|匹配所有非空格字符: `[^\s]`。|
+|\f|匹配一个换页符。|
+|\n|匹配一个换行符。|
+|\r|匹配一个回车符。|
+|\t|匹配一个制表符。|
+|\v|匹配一个垂直制表符。|
+|\p|匹配 CR/LF (等同于 `\r\n`)，用来匹配 DOS 行终止符。|
 
 ## 4. 前后关联约束(前后预查)
 
-前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式).
-前置约束用于判断所匹配的格式是否在另一个确定的格式之后.
+前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式)。
+前置约束用于判断所匹配的格式是否在另一个确定的格式之后。
 
-例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`.
-这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次.
+例如，我们想要获得所有跟在 `$` 符号后的数字，我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`。
+这个表达式匹配 `$` 开头，之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次。
 
-前后关联约束如下:
+前后关联约束如下：
 
 |符号|描述|
 |:----:|----|
-|?=|前置约束-存在|
-|?!|前置约束-排除|
-|?<=|后置约束-存在|
-|?<!|后置约束-排除|
+|?=|前置约束-存在。|
+|?!|前置约束-排除。|
+|?<=|后置约束-存在。|
+|?<!|后置约束-排除。|
 
 ### 4.1 `?=...` 前置约束(存在)
 
-`?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
+`?=...` 前置约束(存在)，表示第一部分表达式必须跟在 `?=...`定义的表达式之后。
 
-返回结果只满足第一部分表达式.
-定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
+返回结果只满足第一部分表达式。
+定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`。
 
-前置约束的内容写在括号中的等号后面.
-例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
+前置约束的内容写在括号中的等号后面。
+例如，表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`， 在括号中我们又定义了前置约束(存在) `(?=\sfat)`，即 `The` 和 `the` 后面紧跟着 `(空格)fat`。
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -369,10 +370,10 @@
 
 ### 4.2 `?!...` 前置约束-排除
 
-前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式
-`前置约束-排除`  定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
+前置约束-排除 `?!` 用于筛选所有匹配结果，筛选条件为 其后不跟随着定义的格式。
+`前置约束-排除`  定义和 `前置约束(存在)` 一样，区别就是 `=` 替换成 `!` 也就是 `(?!...)`。
 
-表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
+表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`，且其后不跟着 `fat`。
 
 <pre>
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -382,8 +383,8 @@
 
 ### 4.3 `?<= ...` 后置约束-存在
 
-后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式.
-例如, 表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
+后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果，筛选条件为 其前跟随着定义的格式。
+例如，表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`，且其前跟着 `The` 或 `the`。
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -393,8 +394,8 @@
 
 ### 4.4 `?<!...` 后置约束-排除
 
-后置约束-排除 记作 `(?<!...)` 用于筛选所有匹配结果, 筛选条件为 其前不跟着定义的格式.
-例如, 表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`, 且其前不跟着 `The` 或 `the`.
+后置约束-排除 记作 `(?<!...)` 用于筛选所有匹配结果，筛选条件为 其前不跟着定义的格式。
+例如，表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`，且其前不跟着 `The` 或 `the`。
 
 <pre>
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -404,19 +405,19 @@
 
 ## 5. 标志
 
-标志也叫修饰语, 因为它可以用来修改表达式的搜索结果.
-这些标志可以任意的组合使用, 它也是整个正则表达式的一部分.
+标志也叫修饰语，因为它可以用来修改表达式的搜索结果。
+这些标志可以任意的组合使用，它也是整个正则表达式的一部分。
 
 |标志|描述|
 |:----:|----|
-|i|忽略大小写.|
-|g|全局搜索.|
-|m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始.|
+|i|忽略大小写。|
+|g|全局搜索。|
+|m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始。|
 
 ### 5.1 忽略大小写 (Case Insensitive)
 
-修饰语 `i` 用于忽略大小写.
-例如, 表达式 `/The/gi` 表示在全局搜索 `The`, 在后面的 `i` 将其条件修改为忽略大小写, 则变成搜索 `the` 和 `The`, `g` 表示全局搜索.
+修饰语 `i` 用于忽略大小写。
+例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`， `g` 表示全局搜索。
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -432,8 +433,8 @@
 
 ### 5.2 全局搜索 (Global search)
 
-修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部).
-例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.
+修饰符 `g` 常用语执行一个全局搜索匹配，即(不仅仅返回第一个匹配的，而是返回全部)。
+例如，表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`，并返回全部结果。
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -449,11 +450,11 @@
 
 ### 5.3 多行修饰符 (Multiline)
 
-多行修饰符 `m` 常用语执行一个多行匹配.
+多行修饰符 `m` 常用语执行一个多行匹配。
 
-像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
+像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾。但我们如果想要它在每行的开头和结尾生效，我们需要用到多行修饰符 `m`。
 
-例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟一个或多个 `.` 的字符串, 并返回全部结果.
+例如，表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟一个或多个 `.` 的字符串，并返回全部结果。
 
 <pre>
 "/.at(.)?$/" => The fat
diff --git a/README-es.md b/README-es.md
index 48d54da2..41ec2bdf 100644
--- a/README-es.md
+++ b/README-es.md
@@ -9,13 +9,14 @@
 * [Español](README-es.md)
 * [Français](README-fr.md)
 * [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
 
 ## Qué es una expresión regular?
+
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
 
 Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para remplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
@@ -414,7 +415,7 @@ El modificador `g` se utiliza para realizar una coincidencia global
 Por ejemplo, la expresión regular `/.(At)/g` significa: cualquier carácter,
 excepto la nueva línea, seguido del carácter en minúscula `a`, seguido del carácter
 en minúscula `t`. Debido a que proveimos el indicador `g` al final de la expresión
-regular, ahora encontrará todas las coincidencias de toda la cadena de entrada, no sólo la 
+regular, ahora encontrará todas las coincidencias de toda la cadena de entrada, no sólo la
 primera instancia (el cual es el comportamiento normal).
 
 
diff --git a/README-fr.md b/README-fr.md
index 6e7c65d6..8bd28b52 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -8,7 +8,8 @@
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
-* [中文版](README-cn.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
diff --git a/README-gr.md b/README-gr.md
index 8fb7da26..1fed2295 100644
--- a/README-gr.md
+++ b/README-gr.md
@@ -9,7 +9,7 @@
 * [Español](README-es.md)
 * [Français](README-fr.md)
 * [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
diff --git a/README-ja.md b/README-ja.md
index 126cde8a..aa3693fe 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -8,7 +8,8 @@
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
-* [中文版](README-cn.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
@@ -33,7 +34,7 @@
   <img src="./img/regexp-en.png" alt="Regular expression">
 </p>
 
-この正規表現によって `john_doe, jo-hn_doe, john12_as` などは許容されることになります。
+この正規表現によって `john_doe`、`jo-hn_doe`、`john12_as` などは許容されることになります。
 一方で `Jo` は大文字を含む上に短すぎるため許容されません。
 
 ## 目次
@@ -129,7 +130,7 @@
 文字集合を指定するには角括弧でくくります。
 文字の範囲を指定するにはハイフンを使用します。
 角括弧内の文字の記述順はマッチングには関係ありません。
-例えば `[Tt]he` という正規表現は大文字 `T` または小文字 `t` の後に `h`, `e` が続く文字列を表します。
+例えば `[Tt]he` という正規表現は大文字 `T` または小文字 `t` の後に `h`、 `e` が続く文字列を表します。
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -151,7 +152,7 @@
 通常キャレットは文字列の開始を意味するメタ文字ですが、角括弧内で最初に使用されると
 文字集合を否定する意味を持つようになります。
 例えば `[^c]ar` という正規表現は `c` 以外の任意の文字列の後に
-`a`, `r` が続く文字列を表します。
+`a`、`r` が続く文字列を表します。
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -161,7 +162,7 @@
 
 ## 2.3 繰り返し
 
-`+`, `*`, `?` はパターンが何回続くのかを指定するためのメタ文字になります。
+`+`、 `*`、 `?` はパターンが何回続くのかを指定するためのメタ文字になります。
 これらのメタ文字は異なるシチュエーションで異なる振る舞いをします。
 
 ### 2.3.1 アスタリスク
@@ -181,7 +182,7 @@
 任意の文字列を表現できます。
 またスペースを表す `\s` と併用することで空白文字を表現できます。
 例えば `\s*cat\s*` という正規表現は 0 個以上のスペースの後に
-小文字の `c`, `a`, `t` が続き、その後に 0 個以上のスペースが続きます。
+小文字の `c`、 `a`、 `t` が続き、その後に 0 個以上のスペースが続きます。
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
@@ -207,7 +208,7 @@
 正規表現におけるメタ文字 `?` は直前の文字がオプションであることを意味します。
 すなわち直前の文字が 0 個または 1 個現れることを意味します。
 例えば `[T]?he` という正規表現は大文字の `T` が 0 個または 1 個出現し、
-その後に小文字の `h`, `e` が続くことを意味します。
+その後に小文字の `h`、 `e` が続くことを意味します。
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -258,7 +259,7 @@
 文字グループ全体が繰り返すことを意味します。
 例えば、 `(ab)*` という正規表現は "ab" という文字列の 0 個以上の繰り返しにマッチします。
 文字グループ内では選言 `|` も使用することができます。
-例えば、`(c|g|p)ar` という正規表現は小文字の `c`, `g`, `p` のいずれかの後に
+例えば、`(c|g|p)ar` という正規表現は小文字の `c`、 `g`、 `p` のいずれかの後に
 `a` が続き、さらに `r` が続くことを意味します。
 
 <pre>
@@ -289,7 +290,7 @@
 記号として指定できるようになります。
 例えば `.` という正規表現は改行を除く任意の文字として使用されますが、
 `(f|c|m)at\.?` という正規表現では `.` 自体にマッチします。
-この正規表現は小文字の `f`, `c` または `m` の後に小文字の `a`, `t` が続き、
+この正規表現は小文字の `f`、 `c` または `m` の後に小文字の `a`、 `t` が続き、
 さらに `.` が 0 個または 1 個続きます。
 
 <pre>
@@ -312,7 +313,7 @@
 しかし `^b` という正規表現は前の文字列に対してはどれにもマッチしません。
 "b" は `abc` という入力文字列の開始ではないからです。
 他の例を見てみます。`^(T|t)he` は大文字の `T` または小文字の `t` から始まる文字列で
-その後に小文字の `h`, `e` が続くことを意味します。
+その後に小文字の `h`、 `e` が続くことを意味します。
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -385,7 +386,7 @@
 肯定的な先読みを定義するには括弧を使用します。
 その括弧の中で疑問符と等号を合わせて `(?=...)` のようにします。
 先読みのパターンは括弧の中の等号の後に記述します。
-例えば `(T|t)he(?=\sfat)` という正規表現は小文字の `t` か大文字の `T` のどちらかの後に `h`, `e` が続きます。
+例えば `(T|t)he(?=\sfat)` という正規表現は小文字の `t` か大文字の `T` のどちらかの後に `h`、 `e` が続きます。
 括弧内で肯定的な先読みを定義していますが、これは `The` または `the` の後に
 `fat` が続くことを表しています。
 
@@ -448,7 +449,7 @@
 ### 5.1 大文字・小文字を区別しない
 
 修飾子 `i` は大文字・小文字を区別したくないときに使用します。
-例えば `/The/gi` という正規表現は大文字の `T` の後に小文字の `h`, `e` が続くという意味ですが、
+例えば `/The/gi` という正規表現は大文字の `T` の後に小文字の `h`、 `e` が続くという意味ですが、
 最後の `i` で大文字・小文字を区別しない設定にしています。
 文字列内の全マッチ列を検索したいのでフラグ `g` も渡しています。
 
@@ -469,7 +470,7 @@
 修飾子 `g` はグローバル検索（最初のマッチ列を検索する代わりに全マッチ列を検索する）を
 行うために使用します。
 例えば `/.(at)/g` という正規表現は、改行を除く任意の文字列の後に
-小文字の `a`, `t` が続きます。正規表現の最後にフラグ `g` を渡すことで、
+小文字の `a`、 `t` が続きます。正規表現の最後にフラグ `g` を渡すことで、
 最初のマッチだけではなく（これがデフォルトの動作です）、入力文字列内の全マッチ列を検索するようにしています。
 
 <pre>
@@ -489,7 +490,7 @@
 修飾子 `m` は複数行でマッチさせたいときに使用します。
 前述で `(^, $)` という入力文字列の開始と終了を示すためのアンカーについて説明しましたが、
 フラグ `m` は複数行でマッチさせるためのアンカーとして使用できます。
-例えば `/at(.)?$/gm` という正規表現は小文字の `a`, `t` に続き、改行を除く
+例えば `/at(.)?$/gm` という正規表現は小文字の `a`、 `t` に続き、改行を除く
 任意の文字が 0 個または 1 個続くという意味ですが、
 フラグ `m` を渡すことで入力文字列の各行でパターンを検索させることができます。
 
diff --git a/README-ko.md b/README-ko.md
index 7d0097ea..56d59b1b 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -8,7 +8,8 @@
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
-* [中文版](README-cn.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
diff --git a/README-pt_BR.md b/README-pt_BR.md
index de90728d..9c57b17a 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -9,9 +9,10 @@
 * [Español](README-es.md)
 * [Français](README-fr.md)
 * [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
+* [Turkish](README-tr.md)
 * [Greek](README-gr.md)
 
 ## O que é uma Expressão Regular?
diff --git a/README-tr.md b/README-tr.md
index 956e85ea..f066ba98 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -8,7 +8,8 @@
 * [English](README.md)
 * [Español](README-es.md)
 * [Français](README-fr.md)
-* [中文版](README-cn.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
@@ -113,7 +114,7 @@ Nokta `.` meta karakterin en basit örneğidir. `.` meta karakteri satır başla
 ## 2.2 Karakter Takımı
 
 Karakter takımları aryıca Karakter sınıfı olarak bilinir. Karakter takımlarını belirtmek için köşeli ayraçlar kullanılır.
-Karakterin aralığını belirtmek için bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının sıralaması önemli değildir. 
+Karakterin aralığını belirtmek için bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının sıralaması önemli değildir.
 
 Örneğin, `[Tt]he` düzenli ifadesinin anlamı: bir büyük `T` veya küçük `t` harflerinin ardından sırasıyla `h` ve `e` harfi gelir.
 
@@ -153,7 +154,7 @@ Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, am
 
 `*` sembolü, kendinden önce girilen eşlemenin sıfır veya daha fazla tekrarıyla eşleşir. Ama bir karakter seti ya da sınıf sonrasına girildiğinde, tüm karakter setinin tekrarlarını bulur.
 
-`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla tekrarı. 
+`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla tekrarı.
 `[a-z]*` düzenli ifadesinin anlamı: bir satırdaki herhangi bir sayıdaki küçük harfler.
 
 <pre>
@@ -250,7 +251,7 @@ Ayrıca karakter grubu içinde `|` meta karakterini kullanabiliriz.
 
 ## 2.6 Değişim
 
-Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için kullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an, karakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor olabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter grubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır. 
+Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için kullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an, karakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor olabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter grubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır.
 
 Örneğin, `(T|t)he|car` düzenli ifadesinin anlamı: Büyük `T` ya da küçük `t` karakteri, ardından küçük `h` karakteri, ardından küçük `e` ya da `c` karakteri, ardından küçük `a`, ardından küçük `r` karakteri gelir.
 
@@ -264,7 +265,7 @@ Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak içi
 
 `\` işareti sonraki karakteri hariç tutmak için kullanılır. Bu bir semboülü ayrılmış karakterlerde `{ } [ ] / \ + * . $ ^ | ?` dahil olmak üzere eşleşen bir karakter olarak belirtmemizi sağlar. Bir özel karakteri eşleşen bir karakter olarak kullanmak için önüne `\` işareti getirin.
 
-Örneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek için kullanılır. 
+Örneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek için kullanılır.
 Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.` ayrılmış karakterini hariç tutmamız gerekir. Bunun için nokta önüne `\` işaretini koymamız gereklidir.
 
 `(f|c|m)at\.?` düzenli ifadesinin anlamı: küçük `f`, `c`ya da `m` harfi, ardından küçük `a` harfi, ardından küçük `t` harfi, ardından opsiyonel `.` karakteri gelir.
@@ -277,7 +278,7 @@ Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.` ayrılmış k
 
 ## 2.8 Sabitleyiciler
 
-Düzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü veya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri kullanırız. 
+Düzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü veya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri kullanırız.
 Sabitleyiciler iki çeşittir: İlk çeşit eşleşen karakterin girişin ilk karakteri olup olmadığını kontrol eden şapka `^` karakteri, ve ikinci çeşit eşleşen karakterin girişin son karakteri olup olmadığını kontrol eden dolar `$` karakteridir.
 
 ### 2.8.1 Şapka İşareti
@@ -285,7 +286,7 @@ Sabitleyiciler iki çeşittir: İlk çeşit eşleşen karakterin girişin ilk ka
 Şapka `^` işareti eşleşen karakterin giriş harf öbeğinin ilk karakteri olup olmadığını kontrol etmek için kullanılır.
 Eğer `^a` düzenli ifadesini `abc` harf öbeğine uygularsak `a` ile eşleşir. Ama `^b` ifadesini uygularsak bir eşleşme bulamayız. Bunun nedeni `abc` harf öbeğinde `b` karakterinin başlangıç karakteri olmamasıdır.
 
-Bir başka örnek üzerinden ilerlersek, 
+Bir başka örnek üzerinden ilerlersek,
 
 `^(T|t)he` düzenli ifadesinin anlamı: büyük `T` ya da `t` karakteri giriş harf öbeğinin ilk karakteri olmak üzere, ardından küçük `h`, ardından küçük `e` karakteri gelir.
 
diff --git a/README.md b/README.md
index 4e1a6f32..e35e3ff9 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 * [Español](README-es.md)
 * [Français](README-fr.md)
 * [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
+* [中文（简体）版](README-cn.md)
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)

From f160d21c0c4ef42b2631708f3a8d5d53faffa4c6 Mon Sep 17 00:00:00 2001
From: Pichet Itngam <chilly.notsu@gmail.com>
Date: Fri, 20 Oct 2017 11:23:29 +0700
Subject: [PATCH 030/185] Add missing "|" (#99)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4e1a6f32..443973e3 100644
--- a/README.md
+++ b/README.md
@@ -106,7 +106,7 @@ square brackets. The meta characters are as follows:
 |[ ]|Character class. Matches any character contained between the square brackets.|
 |[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
 |*|Matches 0 or more repetitions of the preceding symbol.|
-|+|Matches 1 or more repetitions of the preceding symbol.
+|+|Matches 1 or more repetitions of the preceding symbol.|
 |?|Makes the preceding symbol optional.|
 |{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
 |(xyz)|Character group. Matches the characters xyz in that exact order.|

From f4d7416fd55b79e39e9dc4871c4058644f471db8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= <munkacsimark@gmail.com>
Date: Tue, 24 Oct 2017 22:57:59 +0200
Subject: [PATCH 031/185] hungarian file +links added

---
 README-cn.md    | 1 +
 README-es.md    | 1 +
 README-fr.md    | 1 +
 README-gr.md    | 1 +
 README-hu.md    | 0
 README-ja.md    | 1 +
 README-ko.md    | 1 +
 README-pt_BR.md | 1 +
 README-tr.md    | 1 +
 README.md       | 1 +
 10 files changed, 9 insertions(+)
 create mode 100644 README-hu.md

diff --git a/README-cn.md b/README-cn.md
index add4168c..a59cb5d5 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## 什么是正则表达式?
 
diff --git a/README-es.md b/README-es.md
index 48d54da2..16d3ab01 100644
--- a/README-es.md
+++ b/README-es.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/README-fr.md b/README-fr.md
index 6e7c65d6..c788cac5 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/README-gr.md b/README-gr.md
index 8fb7da26..59f9112d 100644
--- a/README-gr.md
+++ b/README-gr.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/README-hu.md b/README-hu.md
new file mode 100644
index 00000000..e69de29b
diff --git a/README-ja.md b/README-ja.md
index 126cde8a..bdcaaa0e 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## 正規表現とは
 
diff --git a/README-ko.md b/README-ko.md
index 7d0097ea..795299a3 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/README-pt_BR.md b/README-pt_BR.md
index de90728d..aca692d1 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -13,6 +13,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/README-tr.md b/README-tr.md
index 956e85ea..9d32f1b4 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/README.md b/README.md
index 443973e3..74693e79 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Magyar](README-hu.md)
 
 ## What is Regular Expression?
 

From b3789f2e40df944e8b74de70b029dd813d0f9f5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= <munkacsimark@gmail.com>
Date: Tue, 24 Oct 2017 23:00:12 +0200
Subject: [PATCH 032/185] hungarian translation added for proofreading

---
 README-hu.md      | 877 ++++++++++++++++++++++++++++++++++++++++++++++
 img/regexp-hu.png | Bin 0 -> 35766 bytes
 2 files changed, 877 insertions(+)
 create mode 100644 img/regexp-hu.png

diff --git a/README-hu.md b/README-hu.md
index e69de29b..a0e08a2d 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -0,0 +1,877 @@
+<br/>
+<p align="center">
+<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+</p><br/>
+
+## Translations:
+## Fordítások:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+* [Turkish](README-tr.md)
+* [Greek](README-gr.md)
+* [Magyar](README-hu.md)
+
+## What is Regular Expression?
+## Mi az a reguláris kifejezés?
+
+> Regular expression is a group of characters or symbols which is used to find a specific pattern from a text.
+> A reguláris kifejezés karakterek vagy szimbólumok egy csoportja, amelyet egy szövegből adott minták megtalálására használnak.
+
+A regular expression is a pattern that is matched against a subject string from
+left to right. The word "Regular expression" is a mouthful, you will usually
+find the term abbreviated as "regex" or "regexp". Regular expression is used for
+replacing a text within a string, validating form, extract a substring from a
+string based upon a pattern match, and so much more.
+
+A reguláris kifejezés egy olyan minta, amely illeszkedik egy adott karakterláncra
+balról jobbra. Maga a "Regular expression" kifejezést általában rövidítve lehet
+megtalálni, mint "regex" vagy "regexp". A reguláris kifejezést használják szövegrészek
+lecserélésére egy szövegben, űrlapok validálására, szövegrészek kiválasztására
+mintaegyezés alapján egy hosszabb szövegből és így tovább.
+
+Imagine you are writing an application and you want to set the rules for when a
+user chooses their username. We want to allow the username to contain letters,
+numbers, underscores and hyphens. We also want to limit the number of characters
+in username so it does not look ugly. We use the following regular expression to
+validate a username:
+
+Képzeld el, hogy egy alkalmazást írsz és szeretnél szabályokat állítani a felhasználónév
+kiválasztásához. A felhasználónév csak betűket, számokat, aláhúzásjelet és kötőjelet
+tartalmazhat. Szeretnénk limitálni a karakterek maximális számát is a felhasználónévben,
+hogy ne legyen csúnya. A felhasználónév validálására a következő reguláris kifejezést
+használjuk:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="./img/regexp-hu.png" alt="Regular expression">
+</p>
+
+Above regular expression can accept the strings `john_doe`, `jo-hn_doe` and
+`john12_as`. It does not match `Jo` because that string contains uppercase
+letter and also it is too short.
+
+A feljebbi reguláris kifejezés elfogadja a `john_doe`, `jo-hn_doe` és a
+`john12_as` karakterláncokat. Nem fog egyezni a `Jo`-ra mert ez nagybetűt
+tartalmaz és túl rövid is.
+
+## Table of Contents
+## Tartalomjegyzék
+
+- [Basic Matchers](#1-basic-matchers)
+- [Meta character](#2-meta-characters)
+  - [Full stop](#21-full-stop)
+  - [Character set](#22-character-set)
+    - [Negated character set](#221-negated-character-set)
+  - [Repetitions](#23-repetitions)
+    - [The Star](#231-the-star)
+    - [The Plus](#232-the-plus)
+    - [The Question Mark](#233-the-question-mark)
+  - [Braces](#24-braces)
+  - [Character Group](#25-character-group)
+  - [Alternation](#26-alternation)
+  - [Escaping special character](#27-escaping-special-character)
+  - [Anchors](#28-anchors)
+    - [Caret](#281-caret)
+    - [Dollar](#282-dollar)
+- [Shorthand Character Sets](#3-shorthand-character-sets)
+- [Lookaround](#4-lookaround)
+  - [Positive Lookahead](#41-positive-lookahead)
+  - [Negative Lookahead](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
+- [Flags](#5-flags)
+  - [Case Insensitive](#51-case-insensitive)
+  - [Global search](#52-global-search)
+  - [Multiline](#53-multiline)
+
+- [Bevezetés](#1-basic-matchers)
+- [Meta karakterek](#2-meta-characters)
+  - [Full stop](#21-full-stop)
+  - [Karakter osztályok](#22-character-set)
+    - [Negált karakter osztályok](#221-negated-character-set)
+  - [Ismétlések](#23-repetitions)
+    - [A csillag](#231-the-star)
+    - [A plusz](#232-the-plus)
+    - [A kérdőjel](#233-the-question-mark)
+  - [A kapcsos zárójelek](#24-braces)
+  - [Karakter csoportok](#25-character-group)
+  - [Alternálás](#26-alternation)
+  - [Speciális karakter escape-elése](#27-escaping-special-character)
+  - [Horgonyok](#28-anchors)
+    - [Kalap](#281-caret)
+    - [Dollár](#282-dollar)
+- [Shorthand Karakter osztályok](#3-shorthand-character-sets)
+- [Lookaround](#4-lookaround)
+  - [Positive Lookahead](#41-positive-lookahead)
+  - [Negative Lookahead](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
+- [Flag-ek](#5-flags)
+  - [Kis-nagybetű érzéketlen](#51-case-insensitive)
+  - [Globális keresés](#52-global-search)
+  - [Többsoros](#53-multiline)
+
+## 1. Basic Matchers
+## 1. Bevezetés
+
+A regular expression is just a pattern of characters that we use to perform
+search in a text.  For example, the regular expression `the` means: the letter
+`t`, followed by the letter `h`, followed by the letter `e`.
+
+A reguláris kifejezés egy karakterminta, amit keresésre használunk egy
+szövegben. Például a `the` reguláris kifejezés a következőt jelenti: egy `t` betű,
+amit `h` követ, amit egy `e` követ.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dmRygT/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/dmRygT/1)
+
+The regular expression `123` matches the string `123`. The regular expression is
+matched against an input string by comparing each character in the regular
+expression to each character in the input string, one after another. Regular
+expressions are normally case-sensitive so the regular expression `The` would
+not match the string `the`.
+
+Az `123` reguláris kifejezés illeszkedik a `123` karakterláncra. A reguláris kifejezés
+minden egyes karaktere össze lesz hasonlítva a bevitt karakterlánc minden elemével
+egymás után. A reguláris kifejezések alap esetben kis-nagybetű érzékenyek, tehát a
+`The` reguláris kifejezés nem fog illeszkedni a `the` karakterláncra.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/1paXsy/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta Characters
+## 2. Meta karakterek
+
+Meta characters are the building blocks of the regular expressions.  Meta
+characters do not stand for themselves but instead are interpreted in some
+special way. Some meta characters have a special meaning and are written inside
+square brackets. The meta characters are as follows:
+
+A meta karakterek a reguláris kifejezések építőkockái. A meta karakterek speciális
+módon értelmezendőek. Némelyik meta karakternek speciális jelentése van és
+szögletes zárójelek közé vannak téve. A meta karakterek a következők:
+
+|Meta character|Description|
+|:----:|----|
+|.|Period matches any single character except a line break.|
+|[ ]|Character class. Matches any character contained between the square brackets.|
+|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
+|*|Matches 0 or more repetitions of the preceding symbol.|
+|+|Matches 1 or more repetitions of the preceding symbol.|
+|?|Makes the preceding symbol optional.|
+|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
+|(xyz)|Character group. Matches the characters xyz in that exact order.|
+|||Alternation. Matches either the characters before or the characters after the symbol.|
+|\|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Matches the beginning of the input.|
+|$|Matches the end of the input.|
+
+|Meta karakter|Leírás|
+|:----:|----|
+|.|A pont illeszkedik minden egyes karakterre kivéve a sortörést.|
+|[ ]|Karakter osztály. Minden karakterre illeszkedik ami a szögletes zárójelek közt van.|
+|[^ ]|Negált karakter osztály. Minden karakterre illeszkedik ami nincs a szögletes zárójelek közt.|
+|*|Illeszkedik az őt megelőző szimbólum 0 vagy több ismétlődésére.|
+|+|Illeszkedik az őt megelőző szimbólum 1 vagy több ismétlődésére.|
+|?|Opcionálissá teszi az őt megelőző szimbólumot.|
+|{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.|
+|(xyz)|Karakter csoport. Illeszkedik az xyz karakterekre pontosan ilyen sorrendben.|
+|||Alternáció. Illeszkedik a szimbólum előtt és után álló karakterekre is.|
+|\|Escape-li a következő karaktert. A segítségével lefoglalt karakterekre is lehet illeszkedni <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|A bevitel elejére illeszkedik.|
+|$|A bevitel végére illeszkedik.|
+
+## 2.1 Full stop
+## 2.1 Full stop
+
+Full stop `.` is the simplest example of meta character. The meta character `.`
+matches any single character. It will not match return or newline characters.
+For example, the regular expression `.ar` means: any character, followed by the
+letter `a`, followed by the letter `r`.
+
+A full stop `.` a legegyszerűbb meta karakter példa. A `.` meta karakter illeszkedik
+minden egyes karakterre. Nem fog illeszkedni a kocsi vissza és a sortörés karakterekre.
+Például a `.ar` reguláris kifejezés jelentése: minden karakter, amit `a` aztán `r` követ.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Character set
+## 2.2 Karakter osztályok
+
+Character sets are also called character class. Square brackets are used to
+specify character sets. Use a hyphen inside a character set to specify the
+characters' range. The order of the character range inside square brackets
+doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
+`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+
+A szögletes zárójelekkel határozzuk meg a karakter osztályokat. A szögletes
+zárójelek közt kötőjel karakterrel határozhatunk meg karakter tartományokat.
+A karaktertartomány sorrendje nem számít. Például a `[Tt]he` reguláris kifejezés
+jelentése: nagybetűs `T` vagy kisbetűs `t` amit egy `h` majd egy `e` betű követ.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/2ITLQ4/1)
+
+A period inside a character set, however, means a literal period. The regular
+expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
+followed by a period `.` character.
+
+Egy pont a karakter osztályon belül egyébként szó szerint pont-ot jelent. A
+`ar[.]` reguláris kifejezés jelentése: kisbetűs `a` amit egy `r` aztán egy
+pont `.` karakter követ.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negated character set
+### 2.2.1 Negált karakter osztályok
+
+In general, the caret symbol represents the start of the string, but when it is
+typed after the opening square bracket it negates the character set. For
+example, the regular expression `[^c]ar` means: any character except `c`,
+followed by the character `a`, followed by the letter `r`.
+
+Általában a kalap szimbólum egy karakterlánc elejét jelenti, de ha egy nyitó
+szögletes zárójel után áll, akkor negálja a karakter osztályt. Például a 
+`[^c]ar` reguláris kifejezés jelentése: minden karakter a `c` kivételével
+ami után `a` aztán egy `r` betű áll.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Repetitions
+## 2.3 Ismétlések
+
+Following meta characters `+`, `*` or `?` are used to specify how many times a
+subpattern can occur. These meta characters act differently in different
+situations.
+
+A következő meta karaktereket `+`, `*` vagy `?` arra használjuk, hogy meghatározzuk,
+hányszor fordulhat elő az al-minta. Ezek a meta karakterek máshogy viselkednek
+adott helyzetekben.
+
+### 2.3.1 The Star
+### 2.3.1 A csillag
+
+The symbol `*` matches zero or more repetitions of the preceding matcher. The
+regular expression `a*` means: zero or more repetitions of preceding lowercase
+character `a`. But if it appears after a character set or class then it finds
+the repetitions of the whole character set. For example, the regular expression
+`[a-z]*` means: any number of lowercase letters in a row.
+
+A `*` szimbólum az őt megelőző karakter nulla vagy több ismétlődésére illeszkedik.
+A `a*` reguláris kifejezés jelentése: nulla vagy több ismétlődése az őt megelőző `a`
+karakternek. De ha egy karakter osztály után áll akkor az egész karakterosztály
+ismétlődését keresi. Például, a `[a-z]*` reguláris kifejezés jelentése: bármennyi
+kisbetűs betű egy sorban.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/7m8me5/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/7m8me5/1)
+
+The `*` symbol can be used with the meta character `.` to match any string of
+characters `.*`. The `*` symbol can be used with the whitespace character `\s`
+to match a string of whitespace characters. For example, the expression
+`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
+followed by lowercase character `a`, followed by lowercase character `t`,
+followed by zero or more spaces.
+
+A `*` szimbólum használható a `.` meta karakterrel `.*`, ez illeszkedik
+bármilyen karakterláncra. A `*` szimbólum használható a whitespace karakterrel `\s`
+együtt, hogy illeszkedjen egy whitespace-ekből álló karakterláncra. Például a
+`\s*cat\s*`kifejezés jelentése: nulla vagy több szóköz, amit egy kisbetűs `c`,
+aztán egy kisbetűs `a`, aztán egy kisbetűs `t`, amit még nulla vagy több szóköz követ.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 The Plus
+### 2.3.2 A plusz
+
+The symbol `+` matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+at least one character, followed by the lowercase character `t`. It needs to be
+clarified that `t` is the last `t` in the sentence.
+
+A `+` szimbólum illeszkedik az őt megelőző karakter egy vagy több ismétlődésére.
+Például a `c.+t` kifejezés jelentése: kisbetűs `c` betű, amit legalább egy vagy
+több `t` követ. Itt tisztázni kell hogy a `t` az utolsó `t` a mondatban.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 The Question Mark
+### 2.3.3 A kérdőjel
+
+In regular expression the meta character `?` makes the preceding character
+optional. This symbol matches zero or one instance of the preceding character.
+For example, the regular expression `[T]?he` means: Optional the uppercase
+letter `T`, followed by the lowercase character `h`, followed by the lowercase
+character `e`.
+
+A reguláris kifejezésben a `?` meta karakter opcionálissá teszi az őt
+megelőző karaktert. Ez a szimbólum az őt megelőző karakter nulla vagy egy
+példányára illeszkedik. Például a `[T]?he` kifejezés jelentése: opcionális a
+nagybetűs `T`, amit egy kisbetűs `h`, majd egy kisbetűs `e` követ.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Braces
+## 2.4 A kapcsos zárójelek
+
+In regular expression braces that are also called quantifiers are used to
+specify the number of times that a character or a group of characters can be
+repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
+2 digits but not more than 3 ( characters in the range of 0 to 9).
+
+A reguláris kifejezésben a kapcsos zárójeleket annak meghatározására használjuk,
+hogy egy karakter vagy egy karakter csoport hányszor ismétlődhet. Például a
+`[0-9]{2,3}` kifejezés jelentése: minimum 2 de nem több mint 3 karakter a `[0-9]`
+karaktertartományon belül.
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/juM86s/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/juM86s/1)
+
+We can leave out the second number. For example, the regular expression
+`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
+regular expression `[0-9]{3}` means: Match exactly 3 digits.
+
+Kihagyhatjuk a második számot. Például a `[0-9]{2,}` kifejezés jelentése:
+2 vagy több számra illeszkedik. Ha a vesszőt is kitöröljük `[0-9]{3}`: Pontosan
+3 számra illeszkedik.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Character Group
+## 2.5 Karakter csoportok
+
+Character group is a group of sub-patterns that is written inside Parentheses `(...)`.
+As we discussed before that in regular expression if we put a quantifier after a
+character then it will repeat the preceding character. But if we put quantifier
+after a character group then it repeats the whole character group. For example,
+the regular expression `(ab)*` matches zero or more repetitions of the character
+"ab". We can also use the alternation `|` meta character inside character group.
+For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+`g` or `p`, followed by character `a`, followed by character `r`.
+
+A karakter csoport al-minták csoportja amik zárójelek közé `(...)` vannak írva.
+Ahogy előbb már megbeszéltük, ha egy karakter után ismétlő karaktert rakunk, az
+ismételni fogja az előtte lévő karaktert. De ha egy ismétlő karaktert egy karakter
+csoport után rakunk, az ismételni fogja az egész csoportot. Például a `(ab)*`
+kifejezés illeszkedik nulla vagy több ismétlődésére az `ab` karaktereknek.
+Használhatunk alternáló meta karaktert `|` is a csoporton belül. Például a `(c|g|p)ar`
+kifejezés jelentése: kisbetűs `c`, `g` vagy `p` karakter, amit egy `a` aztán
+egy `r` karakter követ.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Alternation
+## 2.6 Alternálás
+
+In regular expression Vertical bar `|` is used to define alternation.
+Alternation is like a condition between multiple expressions. Now, you may be
+thinking that character set and alternation works the same way. But the big
+difference between character set and alternation is that character set works on
+character level but alternation works on expression level. For example, the
+regular expression `(T|t)he|car` means: uppercase character `T` or lowercase
+`t`, followed by lowercase character `h`, followed by lowercase character `e` or
+lowercase character `c`, followed by lowercase character `a`, followed by
+lowercase character `r`.
+
+A reguláris kifejezésben a függőleges vonalat `|` alternálásra (választásra)
+használjuk. Az alternálás olyan, mint egy feltétel több kifejezés közt. Most
+azt gondolhatod, hogy a karakter osztály és az alternáció ugyan úgy működik.
+De a fő különbség köztük, hogy a karakter osztály a karakterek szintjén működik,
+az alternáció viszont a kifejezés szintjén. Például a `(T|t)he|car` kifejezés
+jelentése: nagybetűs `T` karakter vagy kisbetűs `t` karakter, amit egy `h` és
+egy `e` követ, VAGY kisbetűs `c` aztán `a` aztán `r` karakter.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Escaping special character
+## 2.7 Speciális karakter escape-elése
+
+Backslash `\` is used in regular expression to escape the next character. This
+allows us to specify a symbol as a matching character including reserved
+characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
+character prepend `\` before it.
+
+A visszaper `\` a reguláris kifejezésekben a következő karakter escape-elésére
+való. Ez enged nekünk szimbólumokat vagy lefoglalt karaktereket `{ } [ ] / \ + * . $ ^ | ?`
+megadni. Egy speciális karakter egyező karakterként való megadásához tedd elé
+a `\` karaktert.
+
+For example, the regular expression `.` is used to match any character except
+newline. Now to match `.` in an input string the regular expression
+`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
+character `a`, followed by lowercase letter `t`, followed by optional `.`
+character.
+
+Például a `.` kifejezést az összes karakter, kivéve a sortörés illeszkedéséhez
+használjuk. A `(f|c|m)at\.?` kifejezés jelentése: kisbetűs `f`, `c` vagy `m`, amit
+egy kisbetűs `a` aztán egy kisbetűs `t`, amit egy opcionális `.` karakter követ.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)
+
+## 2.8 Anchors
+## 2.8 Horgonyok
+
+In regular expressions, we use anchors to check if the matching symbol is the
+starting symbol or ending symbol of the input string. Anchors are of two types:
+First type is Caret `^` that check if the matching character is the start
+character of the input and the second type is Dollar `$` that checks if matching
+character is the last character of the input string.
+
+A reguláris kifejezésekben horgonyokat használunk, hogy megnézzük, az illeszkedő
+szimbólum a kezdő vagy a záró szimbóluma-e a karakterláncnak. A horgonyoknak két
+fajtájuk van: Az első a Kalap `^`, ami megnézi, hogy az egyező karakter a karakterlánc
+kezdő kerektere-e és a második a Dollár `$`, ami azt vizsgálja, hogy az egyező
+karakter a karakterlánc utolsó karaktere-e.
+
+### 2.8.1 Caret
+### 2.8.1 Kalap
+
+Caret `^` symbol is used to check if matching character is the first character
+of the input string. If we apply the following regular expression `^a` (if a is
+the starting symbol) to input string `abc` it matches `a`. But if we apply
+regular expression `^b` on above input string it does not match anything.
+Because in input string `abc` "b" is not the starting symbol. Let's take a look
+at another regular expression `^(T|t)he` which means: uppercase character `T` or
+lowercase character `t` is the start symbol of the input string, followed by
+lowercase character `h`, followed by lowercase character `e`.
+
+A kalap `^` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező karakter
+a karakterlánc kezdő kerektere-e. Ha megadjuk a következő kifejezést: `^a`,
+akkor illeszkedik a `abc` karakterlánc `a` karakterére, mert az za első. De ha
+megadjuk, hogy: `^b`, ez nem fog illeszkedni az `abc` egyik részére sem, mert
+nem `b` a kezdő karakter. Nézzünk meg egy másik kifejezést. `^(T|t)he` jelentése:
+nagybetűs `T` vagy kisbetűs `t` a kezdő karaktere a karakterláncnak, amit kisbetűs
+`h`, majd kisbetűs `e` követ.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jXrKne/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dollar
+### 2.8.2 Dollár
+
+Dollar `$` symbol is used to check if matching character is the last character
+of the input string. For example, regular expression `(at\.)$` means: a
+lowercase character `a`, followed by lowercase character `t`, followed by a `.`
+character and the matcher must be end of the string.
+
+A dollár `$` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező
+karakter a karakterlánc utolsó karaktere-e. Például a `(at\.)$` kifejezés
+jelentése: egy kisbetűs `a`, amit egy kisbetűs `t`, amit egy `.` követ. És
+ennek az egésznek a karakterlánc végén kell lennie.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/t0AkOd/1)
+
+##  3. Shorthand Character Sets
+## 3. Shorthand Karakter osztályok
+
+Regular expression provides shorthands for the commonly used character sets,
+which offer convenient shorthands for commonly used regular expressions. The
+shorthand character sets are as follows:
+
+A gyakran használt karakter osztályokra a reguláris kifejezésnek vannak
+rövidítései, amikkel kényelmesebben tudunk használni általános kifejezéseket.
+A shorthand karakter osztályok a következők:
+
+|Shorthand|Description|
+|:----:|----|
+|.|Any character except new line|
+|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
+|\W|Matches non-alphanumeric characters: `[^\w]`|
+|\d|Matches digit: `[0-9]`|
+|\D|Matches non-digit: `[^\d]`|
+|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
+|\S|Matches non-whitespace character: `[^\s]`|
+
+|Rövidítés|Leírás|
+|:----:|----|
+|.|Minden karakter a sortörésen kívül.|
+|\w|Az alfanumerikus karakterekre illeszkedik: `[a-zA-Z0-9_]`|
+|\W|A nem alfanumerikus karakterekre illeszkedik: `[^\w]`|
+|\d|Számra illeszkedik: `[0-9]`|
+|\D|Nem számra illeszkedik: `[^\d]`|
+|\s|Whitespace karakterre illeszkedik: `[\t\n\f\r\p{Z}]`|
+|\S|Nem whitespace karakterre illeszkedik: `[^\s]`|
+
+## 4. Lookaround
+## 4. Lookaround
+
+Lookbehind and lookahead (also called lookaround) are specific types of
+***non-capturing groups*** (Used to match the pattern but not included in matching
+list). Lookaheads are used when we have the condition that this pattern is
+preceded or followed by another certain pattern. For example, we want to get all
+numbers that are preceded by `$` character from the following input string
+`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
+which means: get all the numbers which contain `.` character and  are preceded
+by `$` character. Following are the lookarounds that are used in regular
+expressions:
+
+A lookbehind (hátranézés) és a lookahead (előrenézés) speciális típusai a
+***nem tárolt csoport***oknak, amiket illeszkedésre használnak, de nincsenek
+benne az illeszkedési listában. Az előrenézést akkor használjuk, ha feltételezzük,
+hogy ezt a mintát egy másik minta előzi meg, vagy követi. Például kell nekünk
+az összes szám ami előtt `$` karakter áll a következő karakterláncból: `$4.44 and $10.88`.
+Ezt a mintát fogjuk használni: `(?<=\$)[0-9\.]*`, aminek a jelentése: Szedd ki az
+összes számot ami `.` karaktert tartalmaz és megelőzi egy `$` karakter. A
+következő lookaround-okat használhatjuk:
+
+|Symbol|Description|
+|:----:|----|
+|?=|Positive Lookahead|
+|?!|Negative Lookahead|
+|?<=|Positive Lookbehind|
+|?<!|Negative Lookbehind|
+
+|Szimbólum|Leírás|
+|:----:|----|
+|?=|Positive Lookahead|
+|?!|Negative Lookahead|
+|?<=|Positive Lookbehind|
+|?<!|Negative Lookbehind|
+
+### 4.1 Positive Lookahead
+### 4.1 Positive Lookahead
+
+The positive lookahead asserts that the first part of the expression must be
+followed by the lookahead expression. The returned match only contains the text
+that is matched by the first part of the expression. To define a positive
+lookahead, parentheses are used. Within those parentheses, a question mark with
+equal sign is used like this: `(?=...)`. Lookahead expression is written after
+the equal sign inside parentheses. For example, the regular expression
+`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
+letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
+define positive lookahead which tells regular expression engine to match `The`
+or `the` which are followed by the word `fat`.
+
+A pozitív előrenézés azt mondja, hogy a kifejezés első részét az előrenézés
+kifejezésnek kell követnie. Az illeszkedés csak azt a szöveget tartalmazza, amire
+a kifejezés első része illeszkedett. Pozitív előrenézést zárójelekkel definiálunk.
+A zárójelek közt van a kérdőjel egy egyenlőségjellel, így: `(?=...)`. Az előrenézés
+kifejezést az egyenlőségjel után írjuk a zárójelek közé. Például a `(T|t)he(?=\sfat)`
+jelentése: opcionális kisbetűs `t` vagy nagybetűs `T`, amit egy `h` aztán egy `e`
+követ. A zárójelek közt definiáljuk a pozitív előrenézést ami megmondja a reguláris
+kifejezés motornak, hogy illeszkedjen a `The` vagy `the` karakterláncokra, amelyeket
+a `fat` karakterlánc követ.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/IDDARt/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Negative Lookahead
+### 4.2 Negative Lookahead
+
+Negative lookahead is used when we need to get all matches from input string
+that are not followed by a pattern. Negative lookahead is defined same as we define
+positive lookahead but the only difference is instead of equal `=` character we
+use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
+from input string that are not followed by the word `fat` precedes by a space
+character.
+
+A negatív előrenézést akkor használjuk, ha az olyan illeszkedések kellenek,
+amelyeket nem követ egy bizonyos minta. A negatív előrenézést ugyanúgy
+definiáljuk mint a pozitív előrenézést, az egyetlen különbség, hogy az
+egyenlőségjel `=` helyett negálást `!` használunk: `(?!...)`. Nézzük meg
+a következő kifejezést: `(T|t)he(?!\sfat)`, jelentése: szedd ki az összes
+`The` vagy `the` szót, amelyeket nem követ a `fat` szó (amit még megelőz
+egy szóköz).
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Positive Lookbehind
+### 4.3 Positive Lookbehind
+
+Positive lookbehind is used to get all the matches that are preceded by a
+specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
+regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
+from input string that are after the word `The` or `the`.
+
+A pozitív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit
+egy megadott minta előz meg. A pozitív hátranézés így van jelölve: `(?<=...)`.
+A `(?<=(T|t)he\s)(fat|mat)` jelentése: szedd ki az összes `fat` vagy `mat` szót
+amelyek a `The` vagy a `the` szavak után vannak.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/avH165/1)
+
+### 4.4 Negative Lookbehind
+### 4.4 Negative Lookbehind
+
+Negative lookbehind is used to get all the matches that are not preceded by a
+specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
+regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
+string that are not after the word `The` or `the`.
+
+A negatív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit nem
+egy megadott minta előz meg. Jelölése: `(?<!...)`. Például a `(?<!(T|t)he\s)(cat)`
+kifejezés jelentése: szedd ki az összes olyan `cat` szót, amelyik nem a `The` vagy
+a `the` szavak után van.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flags
+## 5. Flag-ek
+
+Flags are also called modifiers because they modify the output of a regular
+expression. These flags can be used in any order or combination, and are an
+integral part of the RegExp.
+
+A flag-eket módosítónak hívják, mert módosítják a reguláris kifejezés
+kimenetét. Ezeket a flag-eket bármilyen sorban vagy kombinációban lehet
+használni, a RegExp szerves részét képezik.
+
+|Flag|Description|
+|:----:|----|
+|i|Case insensitive: Sets matching to be case-insensitive.|
+|g|Global Search: Search for a pattern throughout the input string.|
+|m|Multiline: Anchor meta character works on each line.|
+
+|Flag|Leírás|
+|:----:|----|
+|i|Kis-nagybetű érzéketlen: Beállítja, hogy az illeszkedés kis-nagybetű érzéketlen legyen.|
+|g|Globális keresés: A bemeneti szövegben mindenütt keresi az illeszkedéseket.|
+|m|Többsoros: A horgonyok az összes sorra működnek.|
+
+### 5.1 Case Insensitive
+### 5.1 Kis-nagybetű érzéketlen
+
+The `i` modifier is used to perform case-insensitive matching. For example, the
+regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
+character `h`, followed by character `e`. And at the end of regular expression
+the `i` flag tells the regular expression engine to ignore the case. As you can
+see we also provided `g` flag because we want to search for the pattern in the
+whole input string.
+
+Az `i` módosító beállítja, hogy az illeszkedés ne legyen kis-nagybetű érzékeny.
+Például a `/The/gi` kifejezés jelentése: nagybetűs `T` amit kisbetűs `h`, majd `e`
+követ. A kifejezés végén az `i` megmondja a reguláris kifejezés motornak, hogy
+hagyja figyelmen kívül a betűk méretét. Ahogy látod, megadtuk a `g` flag-et, mert
+az egész bemeneti szövegben akarjuk keresni az illeszkedéseket.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Global search
+### 5.2 Globális keresés
+
+The `g` modifier is used to perform a global match (find all matches rather than
+stopping after the first match). For example, the regular expression`/.(at)/g`
+means: any character except new line, followed by lowercase character `a`,
+followed by lowercase character `t`. Because we provided `g` flag at the end of
+the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
+
+A `g` módosítót arra használjuk, hogy globálisan keressünk illeszkedéseket.
+(Megkeresi az összes előfordulást, nem áll meg az első egyezés után). Például
+a `/.(at)/g` kifejezés jelentése: minden karakter, kivéve a sortörést, amelyet
+`a` és `t` követ. Mivel megadtuk a `g` flag-et, az összes ilyenre fog illeszkedni,
+nem csak az elsőre (ami az alapértelmezett viselkedés). 
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dO1nef/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multiline
+### 5.3 Többsoros
+
+The `m` modifier is used to perform a multi-line match. As we discussed earlier
+anchors `(^, $)` are used to check if pattern is the beginning of the input or
+end of the input string. But if we want that anchors works on each line we use
+`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
+character `a`, followed by lowercase character `t`, optionally anything except
+new line. And because of `m` flag now regular expression engine matches pattern
+at the end of each line in a string.
+
+Az `m` módosítót a többsoros illeszkedésekhez használjuk. Ahogy előzőleg beszéltük,
+a horgonyokat `(^, $)` arra használjuk, hogy megnézzük, a minta az eleje, vagy a vége-e
+a vizsgált karakterláncnak. De ha azt szeretnénk, hogy a horgonyok az összes soron
+működjenek, használjuk az `m` módosítót. Például a `/at(.)?$/gm` kifejezés jelentése:
+kisbetűs `a` karakter, amit egy kisbetűs `t` követ, amit opcionálisan bármi követhet,
+kivéve sortörés. És az `m` flag miatt a reguláris kifejezés motor az összes sor
+végéig keres illeszkedést.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/E88WE2/1)
+[Teszteld a reguláris kifejezést](https://regex101.com/r/E88WE2/1)
+
+## Contribution
+## Hozzájárulás
+
+* Report issues
+* Open pull request with improvements
+* Spread the word
+* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+* Jelents hibákat
+* Nyiss pull request-eket fejlesztésekkel
+* Hírdesd az igét
+* Érj el közvetlenül itt: ziishaned@gmail.com vagy [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+## Licenc
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/img/regexp-hu.png b/img/regexp-hu.png
new file mode 100644
index 0000000000000000000000000000000000000000..70d1f516881f7a93647beb8fb680df08c95c235f
GIT binary patch
literal 35766
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

literal 0
HcmV?d00001


From 8caf03bceb3d40687889113bed5fb2cef2fb68be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= <munkacsimark@gmail.com>
Date: Tue, 24 Oct 2017 23:10:13 +0200
Subject: [PATCH 033/185] typos

---
 README-hu.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README-hu.md b/README-hu.md
index a0e08a2d..a198a9e5 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -30,7 +30,7 @@ replacing a text within a string, validating form, extract a substring from a
 string based upon a pattern match, and so much more.
 
 A reguláris kifejezés egy olyan minta, amely illeszkedik egy adott karakterláncra
-balról jobbra. Maga a "Regular expression" kifejezést általában rövidítve lehet
+balról jobbra. Magát a "Regular expression" kifejezést általában rövidítve lehet
 megtalálni, mint "regex" vagy "regexp". A reguláris kifejezést használják szövegrészek
 lecserélésére egy szövegben, űrlapok validálására, szövegrészek kiválasztására
 mintaegyezés alapján egy hosszabb szövegből és így tovább.
@@ -193,8 +193,8 @@ szögletes zárójelek közé vannak téve. A meta karakterek a következők:
 |(xyz)|Karakter csoport. Illeszkedik az xyz karakterekre pontosan ilyen sorrendben.|
 |||Alternáció. Illeszkedik a szimbólum előtt és után álló karakterekre is.|
 |\|Escape-li a következő karaktert. A segítségével lefoglalt karakterekre is lehet illeszkedni <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|A bevitel elejére illeszkedik.|
-|$|A bevitel végére illeszkedik.|
+|^|A karakterlánc elejére illeszkedik.|
+|$|A karakterlánc végére illeszkedik.|
 
 ## 2.1 Full stop
 ## 2.1 Full stop
@@ -620,7 +620,7 @@ by `$` character. Following are the lookarounds that are used in regular
 expressions:
 
 A lookbehind (hátranézés) és a lookahead (előrenézés) speciális típusai a
-***nem tárolt csoport***oknak, amiket illeszkedésre használnak, de nincsenek
+***nem tárolt csoport*** oknak, amiket illeszkedésre használnak, de nincsenek
 benne az illeszkedési listában. Az előrenézést akkor használjuk, ha feltételezzük,
 hogy ezt a mintát egy másik minta előzi meg, vagy követi. Például kell nekünk
 az összes szám ami előtt `$` karakter áll a következő karakterláncból: `$4.44 and $10.88`.

From be9c737cdd6b9e6079a7620cab10079255db33be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= <munkacsimark@gmail.com>
Date: Tue, 24 Oct 2017 23:22:28 +0200
Subject: [PATCH 034/185] removed english text

---
 README-hu.md | 340 ---------------------------------------------------
 1 file changed, 340 deletions(-)

diff --git a/README-hu.md b/README-hu.md
index a198a9e5..44ef5590 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -3,7 +3,6 @@
 <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
 </p><br/>
 
-## Translations:
 ## Fordítások:
 
 * [English](README.md)
@@ -17,30 +16,16 @@
 * [Greek](README-gr.md)
 * [Magyar](README-hu.md)
 
-## What is Regular Expression?
 ## Mi az a reguláris kifejezés?
 
-> Regular expression is a group of characters or symbols which is used to find a specific pattern from a text.
 > A reguláris kifejezés karakterek vagy szimbólumok egy csoportja, amelyet egy szövegből adott minták megtalálására használnak.
 
-A regular expression is a pattern that is matched against a subject string from
-left to right. The word "Regular expression" is a mouthful, you will usually
-find the term abbreviated as "regex" or "regexp". Regular expression is used for
-replacing a text within a string, validating form, extract a substring from a
-string based upon a pattern match, and so much more.
-
 A reguláris kifejezés egy olyan minta, amely illeszkedik egy adott karakterláncra
 balról jobbra. Magát a "Regular expression" kifejezést általában rövidítve lehet
 megtalálni, mint "regex" vagy "regexp". A reguláris kifejezést használják szövegrészek
 lecserélésére egy szövegben, űrlapok validálására, szövegrészek kiválasztására
 mintaegyezés alapján egy hosszabb szövegből és így tovább.
 
-Imagine you are writing an application and you want to set the rules for when a
-user chooses their username. We want to allow the username to contain letters,
-numbers, underscores and hyphens. We also want to limit the number of characters
-in username so it does not look ugly. We use the following regular expression to
-validate a username:
-
 Képzeld el, hogy egy alkalmazást írsz és szeretnél szabályokat állítani a felhasználónév
 kiválasztásához. A felhasználónév csak betűket, számokat, aláhúzásjelet és kötőjelet
 tartalmazhat. Szeretnénk limitálni a karakterek maximális számát is a felhasználónévben,
@@ -49,48 +34,15 @@ használjuk:
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
   <img src="./img/regexp-hu.png" alt="Regular expression">
 </p>
 
-Above regular expression can accept the strings `john_doe`, `jo-hn_doe` and
-`john12_as`. It does not match `Jo` because that string contains uppercase
-letter and also it is too short.
-
 A feljebbi reguláris kifejezés elfogadja a `john_doe`, `jo-hn_doe` és a
 `john12_as` karakterláncokat. Nem fog egyezni a `Jo`-ra mert ez nagybetűt
 tartalmaz és túl rövid is.
 
-## Table of Contents
 ## Tartalomjegyzék
 
-- [Basic Matchers](#1-basic-matchers)
-- [Meta character](#2-meta-characters)
-  - [Full stop](#21-full-stop)
-  - [Character set](#22-character-set)
-    - [Negated character set](#221-negated-character-set)
-  - [Repetitions](#23-repetitions)
-    - [The Star](#231-the-star)
-    - [The Plus](#232-the-plus)
-    - [The Question Mark](#233-the-question-mark)
-  - [Braces](#24-braces)
-  - [Character Group](#25-character-group)
-  - [Alternation](#26-alternation)
-  - [Escaping special character](#27-escaping-special-character)
-  - [Anchors](#28-anchors)
-    - [Caret](#281-caret)
-    - [Dollar](#282-dollar)
-- [Shorthand Character Sets](#3-shorthand-character-sets)
-- [Lookaround](#4-lookaround)
-  - [Positive Lookahead](#41-positive-lookahead)
-  - [Negative Lookahead](#42-negative-lookahead)
-  - [Positive Lookbehind](#43-positive-lookbehind)
-  - [Negative Lookbehind](#44-negative-lookbehind)
-- [Flags](#5-flags)
-  - [Case Insensitive](#51-case-insensitive)
-  - [Global search](#52-global-search)
-  - [Multiline](#53-multiline)
-
 - [Bevezetés](#1-basic-matchers)
 - [Meta karakterek](#2-meta-characters)
   - [Full stop](#21-full-stop)
@@ -118,13 +70,8 @@ tartalmaz és túl rövid is.
   - [Globális keresés](#52-global-search)
   - [Többsoros](#53-multiline)
 
-## 1. Basic Matchers
 ## 1. Bevezetés
 
-A regular expression is just a pattern of characters that we use to perform
-search in a text.  For example, the regular expression `the` means: the letter
-`t`, followed by the letter `h`, followed by the letter `e`.
-
 A reguláris kifejezés egy karakterminta, amit keresésre használunk egy
 szövegben. Például a `the` reguláris kifejezés a következőt jelenti: egy `t` betű,
 amit `h` követ, amit egy `e` követ.
@@ -133,15 +80,8 @@ amit `h` követ, amit egy `e` követ.
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dmRygT/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/dmRygT/1)
 
-The regular expression `123` matches the string `123`. The regular expression is
-matched against an input string by comparing each character in the regular
-expression to each character in the input string, one after another. Regular
-expressions are normally case-sensitive so the regular expression `The` would
-not match the string `the`.
-
 Az `123` reguláris kifejezés illeszkedik a `123` karakterláncra. A reguláris kifejezés
 minden egyes karaktere össze lesz hasonlítva a bevitt karakterlánc minden elemével
 egymás után. A reguláris kifejezések alap esetben kis-nagybetű érzékenyek, tehát a
@@ -151,36 +91,14 @@ egymás után. A reguláris kifejezések alap esetben kis-nagybetű érzékenyek
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/1paXsy/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/1paXsy/1)
 
-## 2. Meta Characters
 ## 2. Meta karakterek
 
-Meta characters are the building blocks of the regular expressions.  Meta
-characters do not stand for themselves but instead are interpreted in some
-special way. Some meta characters have a special meaning and are written inside
-square brackets. The meta characters are as follows:
-
 A meta karakterek a reguláris kifejezések építőkockái. A meta karakterek speciális
 módon értelmezendőek. Némelyik meta karakternek speciális jelentése van és
 szögletes zárójelek közé vannak téve. A meta karakterek a következők:
 
-|Meta character|Description|
-|:----:|----|
-|.|Period matches any single character except a line break.|
-|[ ]|Character class. Matches any character contained between the square brackets.|
-|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
-|*|Matches 0 or more repetitions of the preceding symbol.|
-|+|Matches 1 or more repetitions of the preceding symbol.|
-|?|Makes the preceding symbol optional.|
-|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
-|(xyz)|Character group. Matches the characters xyz in that exact order.|
-|||Alternation. Matches either the characters before or the characters after the symbol.|
-|\|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Matches the beginning of the input.|
-|$|Matches the end of the input.|
-
 |Meta karakter|Leírás|
 |:----:|----|
 |.|A pont illeszkedik minden egyes karakterre kivéve a sortörést.|
@@ -197,12 +115,6 @@ szögletes zárójelek közé vannak téve. A meta karakterek a következők:
 |$|A karakterlánc végére illeszkedik.|
 
 ## 2.1 Full stop
-## 2.1 Full stop
-
-Full stop `.` is the simplest example of meta character. The meta character `.`
-matches any single character. It will not match return or newline characters.
-For example, the regular expression `.ar` means: any character, followed by the
-letter `a`, followed by the letter `r`.
 
 A full stop `.` a legegyszerűbb meta karakter példa. A `.` meta karakter illeszkedik
 minden egyes karakterre. Nem fog illeszkedni a kocsi vissza és a sortörés karakterekre.
@@ -212,18 +124,10 @@ Például a `.ar` reguláris kifejezés jelentése: minden karakter, amit `a` az
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/xc9GkU/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/xc9GkU/1)
 
-## 2.2 Character set
 ## 2.2 Karakter osztályok
 
-Character sets are also called character class. Square brackets are used to
-specify character sets. Use a hyphen inside a character set to specify the
-characters' range. The order of the character range inside square brackets
-doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
-`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
-
 A szögletes zárójelekkel határozzuk meg a karakter osztályokat. A szögletes
 zárójelek közt kötőjel karakterrel határozhatunk meg karakter tartományokat.
 A karaktertartomány sorrendje nem számít. Például a `[Tt]he` reguláris kifejezés
@@ -233,13 +137,8 @@ jelentése: nagybetűs `T` vagy kisbetűs `t` amit egy `h` majd egy `e` betű k
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/2ITLQ4/1)
 
-A period inside a character set, however, means a literal period. The regular
-expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
-followed by a period `.` character.
-
 Egy pont a karakter osztályon belül egyébként szó szerint pont-ot jelent. A
 `ar[.]` reguláris kifejezés jelentése: kisbetűs `a` amit egy `r` aztán egy
 pont `.` karakter követ.
@@ -248,17 +147,10 @@ pont `.` karakter követ.
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/wL3xtE/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Negated character set
 ### 2.2.1 Negált karakter osztályok
 
-In general, the caret symbol represents the start of the string, but when it is
-typed after the opening square bracket it negates the character set. For
-example, the regular expression `[^c]ar` means: any character except `c`,
-followed by the character `a`, followed by the letter `r`.
-
 Általában a kalap szimbólum egy karakterlánc elejét jelenti, de ha egy nyitó
 szögletes zárójel után áll, akkor negálja a karakter osztályt. Például a 
 `[^c]ar` reguláris kifejezés jelentése: minden karakter a `c` kivételével
@@ -268,29 +160,16 @@ ami után `a` aztán egy `r` betű áll.
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/nNNlq3/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/nNNlq3/1)
 
-## 2.3 Repetitions
 ## 2.3 Ismétlések
 
-Following meta characters `+`, `*` or `?` are used to specify how many times a
-subpattern can occur. These meta characters act differently in different
-situations.
-
 A következő meta karaktereket `+`, `*` vagy `?` arra használjuk, hogy meghatározzuk,
 hányszor fordulhat elő az al-minta. Ezek a meta karakterek máshogy viselkednek
 adott helyzetekben.
 
-### 2.3.1 The Star
 ### 2.3.1 A csillag
 
-The symbol `*` matches zero or more repetitions of the preceding matcher. The
-regular expression `a*` means: zero or more repetitions of preceding lowercase
-character `a`. But if it appears after a character set or class then it finds
-the repetitions of the whole character set. For example, the regular expression
-`[a-z]*` means: any number of lowercase letters in a row.
-
 A `*` szimbólum az őt megelőző karakter nulla vagy több ismétlődésére illeszkedik.
 A `a*` reguláris kifejezés jelentése: nulla vagy több ismétlődése az őt megelőző `a`
 karakternek. De ha egy karakter osztály után áll akkor az egész karakterosztály
@@ -301,16 +180,8 @@ kisbetűs betű egy sorban.
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/7m8me5/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/7m8me5/1)
 
-The `*` symbol can be used with the meta character `.` to match any string of
-characters `.*`. The `*` symbol can be used with the whitespace character `\s`
-to match a string of whitespace characters. For example, the expression
-`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
-followed by lowercase character `a`, followed by lowercase character `t`,
-followed by zero or more spaces.
-
 A `*` szimbólum használható a `.` meta karakterrel `.*`, ez illeszkedik
 bármilyen karakterláncra. A `*` szimbólum használható a whitespace karakterrel `\s`
 együtt, hogy illeszkedjen egy whitespace-ekből álló karakterláncra. Például a
@@ -321,17 +192,10 @@ aztán egy kisbetűs `a`, aztán egy kisbetűs `t`, amit még nulla vagy több s
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/gGrwuz/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/gGrwuz/1)
 
-### 2.3.2 The Plus
 ### 2.3.2 A plusz
 
-The symbol `+` matches one or more repetitions of the preceding character. For
-example, the regular expression `c.+t` means: lowercase letter `c`, followed by
-at least one character, followed by the lowercase character `t`. It needs to be
-clarified that `t` is the last `t` in the sentence.
-
 A `+` szimbólum illeszkedik az őt megelőző karakter egy vagy több ismétlődésére.
 Például a `c.+t` kifejezés jelentése: kisbetűs `c` betű, amit legalább egy vagy
 több `t` követ. Itt tisztázni kell hogy a `t` az utolsó `t` a mondatban.
@@ -340,18 +204,10 @@ több `t` követ. Itt tisztázni kell hogy a `t` az utolsó `t` a mondatban.
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/Dzf9Aa/1)
 
-### 2.3.3 The Question Mark
 ### 2.3.3 A kérdőjel
 
-In regular expression the meta character `?` makes the preceding character
-optional. This symbol matches zero or one instance of the preceding character.
-For example, the regular expression `[T]?he` means: Optional the uppercase
-letter `T`, followed by the lowercase character `h`, followed by the lowercase
-character `e`.
-
 A reguláris kifejezésben a `?` meta karakter opcionálissá teszi az őt
 megelőző karaktert. Ez a szimbólum az őt megelőző karakter nulla vagy egy
 példányára illeszkedik. Például a `[T]?he` kifejezés jelentése: opcionális a
@@ -361,24 +217,16 @@ nagybetűs `T`, amit egy kisbetűs `h`, majd egy kisbetűs `e` követ.
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/cIg9zm/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/cIg9zm/1)
 
 <pre>
 "[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/kPpO2x/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/kPpO2x/1)
 
-## 2.4 Braces
 ## 2.4 A kapcsos zárójelek
 
-In regular expression braces that are also called quantifiers are used to
-specify the number of times that a character or a group of characters can be
-repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
-2 digits but not more than 3 ( characters in the range of 0 to 9).
-
 A reguláris kifejezésben a kapcsos zárójeleket annak meghatározására használjuk,
 hogy egy karakter vagy egy karakter csoport hányszor ismétlődhet. Például a
 `[0-9]{2,3}` kifejezés jelentése: minimum 2 de nem több mint 3 karakter a `[0-9]`
@@ -388,13 +236,8 @@ karaktertartományon belül.
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/juM86s/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/juM86s/1)
 
-We can leave out the second number. For example, the regular expression
-`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
-regular expression `[0-9]{3}` means: Match exactly 3 digits.
-
 Kihagyhatjuk a második számot. Például a `[0-9]{2,}` kifejezés jelentése:
 2 vagy több számra illeszkedik. Ha a vesszőt is kitöröljük `[0-9]{3}`: Pontosan
 3 számra illeszkedik.
@@ -403,28 +246,16 @@ Kihagyhatjuk a második számot. Például a `[0-9]{2,}` kifejezés jelentése:
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/Gdy4w5/1)
 
 <pre>
 "[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Sivu30/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/Sivu30/1)
 
-## 2.5 Character Group
 ## 2.5 Karakter csoportok
 
-Character group is a group of sub-patterns that is written inside Parentheses `(...)`.
-As we discussed before that in regular expression if we put a quantifier after a
-character then it will repeat the preceding character. But if we put quantifier
-after a character group then it repeats the whole character group. For example,
-the regular expression `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside character group.
-For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
-`g` or `p`, followed by character `a`, followed by character `r`.
-
 A karakter csoport al-minták csoportja amik zárójelek közé `(...)` vannak írva.
 Ahogy előbb már megbeszéltük, ha egy karakter után ismétlő karaktert rakunk, az
 ismételni fogja az előtte lévő karaktert. De ha egy ismétlő karaktert egy karakter
@@ -438,22 +269,10 @@ egy `r` karakter követ.
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/tUxrBG/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/tUxrBG/1)
 
-## 2.6 Alternation
 ## 2.6 Alternálás
 
-In regular expression Vertical bar `|` is used to define alternation.
-Alternation is like a condition between multiple expressions. Now, you may be
-thinking that character set and alternation works the same way. But the big
-difference between character set and alternation is that character set works on
-character level but alternation works on expression level. For example, the
-regular expression `(T|t)he|car` means: uppercase character `T` or lowercase
-`t`, followed by lowercase character `h`, followed by lowercase character `e` or
-lowercase character `c`, followed by lowercase character `a`, followed by
-lowercase character `r`.
-
 A reguláris kifejezésben a függőleges vonalat `|` alternálásra (választásra)
 használjuk. Az alternálás olyan, mint egy feltétel több kifejezés közt. Most
 azt gondolhatod, hogy a karakter osztály és az alternáció ugyan úgy működik.
@@ -466,28 +285,15 @@ egy `e` követ, VAGY kisbetűs `c` aztán `a` aztán `r` karakter.
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/fBXyX0/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 Escaping special character
 ## 2.7 Speciális karakter escape-elése
 
-Backslash `\` is used in regular expression to escape the next character. This
-allows us to specify a symbol as a matching character including reserved
-characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
-character prepend `\` before it.
-
 A visszaper `\` a reguláris kifejezésekben a következő karakter escape-elésére
 való. Ez enged nekünk szimbólumokat vagy lefoglalt karaktereket `{ } [ ] / \ + * . $ ^ | ?`
 megadni. Egy speciális karakter egyező karakterként való megadásához tedd elé
 a `\` karaktert.
 
-For example, the regular expression `.` is used to match any character except
-newline. Now to match `.` in an input string the regular expression
-`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
-character `a`, followed by lowercase letter `t`, followed by optional `.`
-character.
-
 Például a `.` kifejezést az összes karakter, kivéve a sortörés illeszkedéséhez
 használjuk. A `(f|c|m)at\.?` kifejezés jelentése: kisbetűs `f`, `c` vagy `m`, amit
 egy kisbetűs `a` aztán egy kisbetűs `t`, amit egy opcionális `.` karakter követ.
@@ -496,36 +302,18 @@ egy kisbetűs `a` aztán egy kisbetűs `t`, amit egy opcionális `.` karakter k
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/fBXyX0/1)
 
-## 2.8 Anchors
 ## 2.8 Horgonyok
 
-In regular expressions, we use anchors to check if the matching symbol is the
-starting symbol or ending symbol of the input string. Anchors are of two types:
-First type is Caret `^` that check if the matching character is the start
-character of the input and the second type is Dollar `$` that checks if matching
-character is the last character of the input string.
-
 A reguláris kifejezésekben horgonyokat használunk, hogy megnézzük, az illeszkedő
 szimbólum a kezdő vagy a záró szimbóluma-e a karakterláncnak. A horgonyoknak két
 fajtájuk van: Az első a Kalap `^`, ami megnézi, hogy az egyező karakter a karakterlánc
 kezdő kerektere-e és a második a Dollár `$`, ami azt vizsgálja, hogy az egyező
 karakter a karakterlánc utolsó karaktere-e.
 
-### 2.8.1 Caret
 ### 2.8.1 Kalap
 
-Caret `^` symbol is used to check if matching character is the first character
-of the input string. If we apply the following regular expression `^a` (if a is
-the starting symbol) to input string `abc` it matches `a`. But if we apply
-regular expression `^b` on above input string it does not match anything.
-Because in input string `abc` "b" is not the starting symbol. Let's take a look
-at another regular expression `^(T|t)he` which means: uppercase character `T` or
-lowercase character `t` is the start symbol of the input string, followed by
-lowercase character `h`, followed by lowercase character `e`.
-
 A kalap `^` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező karakter
 a karakterlánc kezdő kerektere-e. Ha megadjuk a következő kifejezést: `^a`,
 akkor illeszkedik a `abc` karakterlánc `a` karakterére, mert az za első. De ha
@@ -538,24 +326,16 @@ nagybetűs `T` vagy kisbetűs `t` a kezdő karaktere a karakterláncnak, amit ki
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/5ljjgB/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/5ljjgB/1)
 
 <pre>
 "^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/jXrKne/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/jXrKne/1)
 
-### 2.8.2 Dollar
 ### 2.8.2 Dollár
 
-Dollar `$` symbol is used to check if matching character is the last character
-of the input string. For example, regular expression `(at\.)$` means: a
-lowercase character `a`, followed by lowercase character `t`, followed by a `.`
-character and the matcher must be end of the string.
-
 A dollár `$` szimbólumot arra használjuk, hogy megnézzük, hogy az egyező
 karakter a karakterlánc utolsó karaktere-e. Például a `(at\.)$` kifejezés
 jelentése: egy kisbetűs `a`, amit egy kisbetűs `t`, amit egy `.` követ. És
@@ -565,37 +345,20 @@ ennek az egésznek a karakterlánc végén kell lennie.
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/y4Au4D/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/y4Au4D/1)
 
 <pre>
 "(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/t0AkOd/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/t0AkOd/1)
 
-##  3. Shorthand Character Sets
 ## 3. Shorthand Karakter osztályok
 
-Regular expression provides shorthands for the commonly used character sets,
-which offer convenient shorthands for commonly used regular expressions. The
-shorthand character sets are as follows:
-
 A gyakran használt karakter osztályokra a reguláris kifejezésnek vannak
 rövidítései, amikkel kényelmesebben tudunk használni általános kifejezéseket.
 A shorthand karakter osztályok a következők:
 
-|Shorthand|Description|
-|:----:|----|
-|.|Any character except new line|
-|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
-|\W|Matches non-alphanumeric characters: `[^\w]`|
-|\d|Matches digit: `[0-9]`|
-|\D|Matches non-digit: `[^\d]`|
-|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
-|\S|Matches non-whitespace character: `[^\s]`|
-
 |Rövidítés|Leírás|
 |:----:|----|
 |.|Minden karakter a sortörésen kívül.|
@@ -606,19 +369,8 @@ A shorthand karakter osztályok a következők:
 |\s|Whitespace karakterre illeszkedik: `[\t\n\f\r\p{Z}]`|
 |\S|Nem whitespace karakterre illeszkedik: `[^\s]`|
 
-## 4. Lookaround
 ## 4. Lookaround
 
-Lookbehind and lookahead (also called lookaround) are specific types of
-***non-capturing groups*** (Used to match the pattern but not included in matching
-list). Lookaheads are used when we have the condition that this pattern is
-preceded or followed by another certain pattern. For example, we want to get all
-numbers that are preceded by `$` character from the following input string
-`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
-which means: get all the numbers which contain `.` character and  are preceded
-by `$` character. Following are the lookarounds that are used in regular
-expressions:
-
 A lookbehind (hátranézés) és a lookahead (előrenézés) speciális típusai a
 ***nem tárolt csoport*** oknak, amiket illeszkedésre használnak, de nincsenek
 benne az illeszkedési listában. Az előrenézést akkor használjuk, ha feltételezzük,
@@ -628,13 +380,6 @@ Ezt a mintát fogjuk használni: `(?<=\$)[0-9\.]*`, aminek a jelentése: Szedd k
 összes számot ami `.` karaktert tartalmaz és megelőzi egy `$` karakter. A
 következő lookaround-okat használhatjuk:
 
-|Symbol|Description|
-|:----:|----|
-|?=|Positive Lookahead|
-|?!|Negative Lookahead|
-|?<=|Positive Lookbehind|
-|?<!|Negative Lookbehind|
-
 |Szimbólum|Leírás|
 |:----:|----|
 |?=|Positive Lookahead|
@@ -643,18 +388,6 @@ következő lookaround-okat használhatjuk:
 |?<!|Negative Lookbehind|
 
 ### 4.1 Positive Lookahead
-### 4.1 Positive Lookahead
-
-The positive lookahead asserts that the first part of the expression must be
-followed by the lookahead expression. The returned match only contains the text
-that is matched by the first part of the expression. To define a positive
-lookahead, parentheses are used. Within those parentheses, a question mark with
-equal sign is used like this: `(?=...)`. Lookahead expression is written after
-the equal sign inside parentheses. For example, the regular expression
-`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
-letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
-define positive lookahead which tells regular expression engine to match `The`
-or `the` which are followed by the word `fat`.
 
 A pozitív előrenézés azt mondja, hogy a kifejezés első részét az előrenézés
 kifejezésnek kell követnie. Az illeszkedés csak azt a szöveget tartalmazza, amire
@@ -670,19 +403,9 @@ a `fat` karakterlánc követ.
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/IDDARt/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/IDDARt/1)
 
 ### 4.2 Negative Lookahead
-### 4.2 Negative Lookahead
-
-Negative lookahead is used when we need to get all matches from input string
-that are not followed by a pattern. Negative lookahead is defined same as we define
-positive lookahead but the only difference is instead of equal `=` character we
-use negation `!` character i.e. `(?!...)`. Let's take a look at the following
-regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
-from input string that are not followed by the word `fat` precedes by a space
-character.
 
 A negatív előrenézést akkor használjuk, ha az olyan illeszkedések kellenek,
 amelyeket nem követ egy bizonyos minta. A negatív előrenézést ugyanúgy
@@ -696,16 +419,9 @@ egy szóköz).
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/V32Npg/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/V32Npg/1)
 
 ### 4.3 Positive Lookbehind
-### 4.3 Positive Lookbehind
-
-Positive lookbehind is used to get all the matches that are preceded by a
-specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
-regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
-from input string that are after the word `The` or `the`.
 
 A pozitív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit
 egy megadott minta előz meg. A pozitív hátranézés így van jelölve: `(?<=...)`.
@@ -716,16 +432,9 @@ amelyek a `The` vagy a `the` szavak után vannak.
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/avH165/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/avH165/1)
 
 ### 4.4 Negative Lookbehind
-### 4.4 Negative Lookbehind
-
-Negative lookbehind is used to get all the matches that are not preceded by a
-specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
-regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
-string that are not after the word `The` or `the`.
 
 A negatív hátranézést akkor használjuk, ha kell az összes illeszkedés, amit nem
 egy megadott minta előz meg. Jelölése: `(?<!...)`. Például a `(?<!(T|t)he\s)(cat)`
@@ -736,42 +445,22 @@ a `the` szavak után van.
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/8Efx5G/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/8Efx5G/1)
 
-## 5. Flags
 ## 5. Flag-ek
 
-Flags are also called modifiers because they modify the output of a regular
-expression. These flags can be used in any order or combination, and are an
-integral part of the RegExp.
-
 A flag-eket módosítónak hívják, mert módosítják a reguláris kifejezés
 kimenetét. Ezeket a flag-eket bármilyen sorban vagy kombinációban lehet
 használni, a RegExp szerves részét képezik.
 
-|Flag|Description|
-|:----:|----|
-|i|Case insensitive: Sets matching to be case-insensitive.|
-|g|Global Search: Search for a pattern throughout the input string.|
-|m|Multiline: Anchor meta character works on each line.|
-
 |Flag|Leírás|
 |:----:|----|
 |i|Kis-nagybetű érzéketlen: Beállítja, hogy az illeszkedés kis-nagybetű érzéketlen legyen.|
 |g|Globális keresés: A bemeneti szövegben mindenütt keresi az illeszkedéseket.|
 |m|Többsoros: A horgonyok az összes sorra működnek.|
 
-### 5.1 Case Insensitive
 ### 5.1 Kis-nagybetű érzéketlen
 
-The `i` modifier is used to perform case-insensitive matching. For example, the
-regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
-character `h`, followed by character `e`. And at the end of regular expression
-the `i` flag tells the regular expression engine to ignore the case. As you can
-see we also provided `g` flag because we want to search for the pattern in the
-whole input string.
-
 Az `i` módosító beállítja, hogy az illeszkedés ne legyen kis-nagybetű érzékeny.
 Például a `/The/gi` kifejezés jelentése: nagybetűs `T` amit kisbetűs `h`, majd `e`
 követ. A kifejezés végén az `i` megmondja a reguláris kifejezés motornak, hogy
@@ -782,25 +471,16 @@ az egész bemeneti szövegben akarjuk keresni az illeszkedéseket.
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dpQyf9/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/dpQyf9/1)
 
 <pre>
 "/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/ahfiuh/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 Global search
 ### 5.2 Globális keresés
 
-The `g` modifier is used to perform a global match (find all matches rather than
-stopping after the first match). For example, the regular expression`/.(at)/g`
-means: any character except new line, followed by lowercase character `a`,
-followed by lowercase character `t`. Because we provided `g` flag at the end of
-the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
-
 A `g` módosítót arra használjuk, hogy globálisan keressünk illeszkedéseket.
 (Megkeresi az összes előfordulást, nem áll meg az első egyezés után). Például
 a `/.(at)/g` kifejezés jelentése: minden karakter, kivéve a sortörést, amelyet
@@ -811,27 +491,16 @@ nem csak az elsőre (ami az alapértelmezett viselkedés).
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/jnk6gM/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/jnk6gM/1)
 
 <pre>
 "/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dO1nef/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/dO1nef/1)
 
-### 5.3 Multiline
 ### 5.3 Többsoros
 
-The `m` modifier is used to perform a multi-line match. As we discussed earlier
-anchors `(^, $)` are used to check if pattern is the beginning of the input or
-end of the input string. But if we want that anchors works on each line we use
-`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
-character `a`, followed by lowercase character `t`, optionally anything except
-new line. And because of `m` flag now regular expression engine matches pattern
-at the end of each line in a string.
-
 Az `m` módosítót a többsoros illeszkedésekhez használjuk. Ahogy előzőleg beszéltük,
 a horgonyokat `(^, $)` arra használjuk, hogy megnézzük, a minta az eleje, vagy a vége-e
 a vizsgált karakterláncnak. De ha azt szeretnénk, hogy a horgonyok az összes soron
@@ -846,7 +515,6 @@ végéig keres illeszkedést.
                 on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/hoGMkP/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/hoGMkP/1)
 
 <pre>
@@ -855,23 +523,15 @@ végéig keres illeszkedést.
                   on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/E88WE2/1)
 [Teszteld a reguláris kifejezést](https://regex101.com/r/E88WE2/1)
 
-## Contribution
 ## Hozzájárulás
 
-* Report issues
-* Open pull request with improvements
-* Spread the word
-* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
-
 * Jelents hibákat
 * Nyiss pull request-eket fejlesztésekkel
 * Hírdesd az igét
 * Érj el közvetlenül itt: ziishaned@gmail.com vagy [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
-## License
 ## Licenc
 
 MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)

From ec60f531e5a831f070cab059b6ea36e88f7f33df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= <munkacsimark@gmail.com>
Date: Tue, 24 Oct 2017 23:33:17 +0200
Subject: [PATCH 035/185] hungarian table of contents fixed

---
 README-hu.md | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/README-hu.md b/README-hu.md
index 44ef5590..92a57fb9 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -43,32 +43,32 @@ tartalmaz és túl rövid is.
 
 ## Tartalomjegyzék
 
-- [Bevezetés](#1-basic-matchers)
-- [Meta karakterek](#2-meta-characters)
+- [Bevezetés](#1-bevezetés)
+- [Meta karakterek](#2-meta-karakterek)
   - [Full stop](#21-full-stop)
-  - [Karakter osztályok](#22-character-set)
-    - [Negált karakter osztályok](#221-negated-character-set)
-  - [Ismétlések](#23-repetitions)
-    - [A csillag](#231-the-star)
-    - [A plusz](#232-the-plus)
-    - [A kérdőjel](#233-the-question-mark)
-  - [A kapcsos zárójelek](#24-braces)
-  - [Karakter csoportok](#25-character-group)
-  - [Alternálás](#26-alternation)
-  - [Speciális karakter escape-elése](#27-escaping-special-character)
-  - [Horgonyok](#28-anchors)
-    - [Kalap](#281-caret)
-    - [Dollár](#282-dollar)
-- [Shorthand Karakter osztályok](#3-shorthand-character-sets)
+  - [Karakter osztályok](#22-karakter-osztályok)
+    - [Negált karakter osztályok](#221-negált-karakter-osztályok)
+  - [Ismétlések](#23-ismétlések)
+    - [A csillag](#231-a-csillag)
+    - [A plusz](#232-a-plusz)
+    - [A kérdőjel](#233-a-kérdőjel)
+  - [A kapcsos zárójelek](#24-a-kapcsos-zárójelek)
+  - [Karakter csoportok](#25-karakter-csoportok)
+  - [Alternálás](#26-alternálás)
+  - [Speciális karakter escape-elése](#27-speciális-karakter-escape-elése)
+  - [Horgonyok](#28-horgonyok)
+    - [Kalap](#281-kalap)
+    - [Dollár](#282-dollár)
+- [Shorthand Karakter osztályok](#3-shorthand-karakter-osztályok)
 - [Lookaround](#4-lookaround)
   - [Positive Lookahead](#41-positive-lookahead)
   - [Negative Lookahead](#42-negative-lookahead)
   - [Positive Lookbehind](#43-positive-lookbehind)
   - [Negative Lookbehind](#44-negative-lookbehind)
-- [Flag-ek](#5-flags)
-  - [Kis-nagybetű érzéketlen](#51-case-insensitive)
-  - [Globális keresés](#52-global-search)
-  - [Többsoros](#53-multiline)
+- [Flag-ek](#5-flag-ek)
+  - [Kis-nagybetű érzéketlen](#51-kis-nagybetű-érzéketlen)
+  - [Globális keresés](#52-globális-keresés)
+  - [Többsoros](#53-többsoros)
 
 ## 1. Bevezetés
 

From 86e51f7baad389ddf34bf62e31fbcb8e085c9160 Mon Sep 17 00:00:00 2001
From: donpepe0 <mruq80@gmail.com>
Date: Wed, 20 Dec 2017 17:27:14 +0100
Subject: [PATCH 036/185] Polish translation (#105)

* introdution and p.1 translated

* introdution and p.1 translated

* 2.3 translated

* 2.8.1 translated

* 3. translated

* all text translated

* image translated, and replaced

* fixed link in context tabe
---
 README-cn.md      |   1 +
 README-es.md      |   1 +
 README-fr.md      |   1 +
 README-gr.md      |   1 +
 README-ja.md      |   1 +
 README-ko.md      |   1 +
 README-pl.md      | 533 ++++++++++++++++++++++++++++++++++++++++++++++
 README-pt_BR.md   |   1 +
 README-tr.md      |   1 +
 README.md         |   1 +
 img/regexp-pl.png | Bin 0 -> 20204 bytes
 11 files changed, 542 insertions(+)
 create mode 100644 README-pl.md
 create mode 100644 img/regexp-pl.png

diff --git a/README-cn.md b/README-cn.md
index add4168c..0f7e9b81 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## 什么是正则表达式?
 
diff --git a/README-es.md b/README-es.md
index 48d54da2..3f59d662 100644
--- a/README-es.md
+++ b/README-es.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/README-fr.md b/README-fr.md
index 6e7c65d6..8216394d 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/README-gr.md b/README-gr.md
index 8fb7da26..935f0827 100644
--- a/README-gr.md
+++ b/README-gr.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/README-ja.md b/README-ja.md
index 126cde8a..af9d8b3a 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## 正規表現とは
 
diff --git a/README-ko.md b/README-ko.md
index 7d0097ea..e3029d0f 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/README-pl.md b/README-pl.md
new file mode 100644
index 00000000..28622c42
--- /dev/null
+++ b/README-pl.md
@@ -0,0 +1,533 @@
+<br/>
+<p align="center">
+<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+</p><br/>
+
+## Tłumaczenia:
+
+* [English](README.md)
+* [Español](README-es.md)
+* [Français](README-fr.md)
+* [Português do Brasil](README-pt_BR.md)
+* [中文版](README-cn.md)
+* [日本語](README-ja.md)
+* [한국어](README-ko.md)
+* [Turkish](README-tr.md)
+* [Greek](README-gr.md)
+* [Polish](README-pl.md)
+
+## Co to jest wyrażenie regularne?
+
+> Wyrażenie regularne to grupa znaków lub symboli, które służą do odnalezienia określonego wzoru w tekście.
+
+Wyrażenie regularne to wzorzec, który jest dopasowywany do tekstu od lewej
+do prawej strony. Termin "wyrażenie regularne" (ang. "regular expression")
+jest dość długie, więc zazwyczaj używa się skróconej formy "regex" lub "regexp".
+Wyrażenie regularne jest używane do zastępowania tekstu w łańcuchu znaków
+(ang. string), walidacji formularzy, wyodrębniania wycinka z łańcucha
+(ang. substring) według podanego wzorca, i wielu innych.
+
+Wyobraź sobie, że piszesz aplikację i chcesz ustawić reguły dotyczące tego,
+jak użytkownik wybiera swoją nazwę. Chcemy, aby nazwa użytkownika zawierała litery,
+liczby, podkreślenia i myślniki. Chcemy również ograniczyć liczbę znaków w nazwie
+użytkownika, aby nie wyglądała za brzydko. Stosujemy następujące wyrażenie
+regularne, aby sprawdzić poprawność nazwy:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-pl.png" alt="Wyrażenie regularne">
+</p>
+
+Powyższe wyrażenie akceptuje łańcuchy `john_doe`, `jo-hn_doe`
+i `john12_as`. Odrzuca `Jo` ponieważ łańcuch zawiera dużą literę
+i jest za krótki.
+
+## Spis treści
+
+- [Najprostsze wyrażenie](#1-najprostsze-wyrażenie)
+- [Metaznaki](#2-metaznaki)
+  - [Kropka](#21-kropka)
+  - [Zestaw znaków](#22-zestaw-znaków)
+    - [Odwrócony zestaw znaków](#221-odwrócony-zestaw-znaków)
+  - [Powtórzenia](#23-powtórzenia)
+    - [Gwiazdka](#231-gwiazdka)
+    - [Plus](#232-plus)
+    - [Znak zapytania](#233-znak-zapytania)
+  - [Klamry](#24-klamry)
+  - [Grupa znaków](#25-grupa-znaków)
+  - [Alternatywa](#26-alternatywa)
+  - [Znak ucieczki](#27-znak-ucieczki)
+  - [Kotwice](#28-kotwice)
+    - [Kareta](#281-kareta)
+    - [Dolar](#282-dolar)
+- [Skróty](#3-skróty)
+- [Lookaround](#4-lookaround)
+  - [Lookahead](#41-lookahead)
+  - [Odwrócony lookahead](#42-odwrócony-lookahead)
+  - [Lookbehind](#43-lookbehind)
+  - [Odwrócony lookbehind](#44-odwrócony-lookbehind)
+- [Flagi](#5-flagi)
+  - [Wielkość znaków](#51-wielkość-znaków)
+  - [Przeszukiwanie globalne](#52-przeszukiwanie-globalne)
+  - [Multilinia](#53-multilinia)
+
+## 1. Najprostsze wyrażenie
+
+Wyrażenie regularne to ciąg znaków, których używamy do przeszukania tekstu.
+Na przykład, wyrażenie `the` oznacza: literę `t`, następującą
+po niej literę `h`, następującą po niej literę `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/dmRygT/1)
+
+Wyrażenie regularne `123` pasuje do łańcucha `123`. Wyrażenie regularne
+jest dopasowywane do danego łańcucha poprzez porównanie każdego znaku,
+jeden po drugim, w wyrażeniu i łańcuchu. Wyrażenia są zwykle wrażliwe
+na wielkość znaków, więc wyrażenie `The` nie pasuje do łańcucha `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/1paXsy/1)
+
+## 2. Metaznaki
+
+Metaznaki to składowe elementy wyrażeń regularnych. Znaki te, nie oznaczają
+siebie samych, są natomiast interpretowane w specjalny sposób.
+Niektóre znaki mają specjalne znaczenie i są zapisywane w kwadratowych nawiasach.
+Metaznaki to:
+
+|Metaznaki|Opis|
+|:----:|----|
+|.|Dowolny znak z wyjątkiem nowej linii.|
+|[ ]|Zakres. Każdy znak zapisany w kwadratowym nawiasie.|
+|[^ ]|Odwrócony zakres. Każdy znak, który nie znajduje się w kwadratowym nawiasie.|
+|*|0 lub więcej poprzedzających znaków.|
+|+|1 lub więcej poprzedzających znaków.|
+|?|0 lub 1 poprzedzających znaków.|
+|{n,m}|Minimum "n" ale nie więcej niż "m" poprzedzających znaków.|
+|(xyz)|Grupowanie znaków. Znaki xyz dokładnie w tej kolejności.|
+|||Alternatywa. Znaki przed symbolem lub za symbolem.|
+|\|Znak ucieczki. Umożliwia używanie zarezerwowanych znaków <code>[ ] ( ) { } . * + ? ^ $ \ |</code>.|
+|^|Oznacza początek wzorca.|
+|$|Oznacza koniec wzorca.|
+
+## 2.1 Kropka
+
+Kropka `.` jest najprostszym przykładem metaznaku. Oznacza dowolny znak z wyłączeniem entera
+i znaków nowej linii. Na przykład, wyrażenie regularne `.ar` oznacza: dowolny znak, następującą
+po niej literę `a`, następującą po niej literę `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Zestaw znaków
+
+Zestawy znaków nazywane też klasami znaków. Nawiasy kwadratowe służą do określenia zestawów znaków.
+Użycie myślnika wewnątrz zestawu, określa jego zakres. Kolejność znaków w nawiasach kwadratowych
+nie ma znaczenia. Na przykład wyrażenie `[Tt]he` oznacza: dużą literę `T` lub małą `t`,
+następującą po niej literę `h`, następującą po niej literę `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/2ITLQ4/1)
+
+Jednak kropka w zestawie znaków, oznacza dosłownie kropkę. Wyrażenie regularne
+`ar[.]` oznacza: małą literę `a`, następującą po niej literę `r`,
+następującą po niej `.` kropkę.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Odwrócony zestaw znaków
+
+Generalnie znak karety oznacza początek wyrażenia, ale gdy zostanie użyty zaraz
+za otwierającym nawiasem kwadratowym, odwraca zestaw znaków. Na przykład
+wyrażenie `[^c]ar` oznacza: każdy znak z wyjątkiem `c`,
+następującą po niej literę `a`, następującą po niej literę `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Powtórzenia
+
+Następujące metaznaki `+`, `*` czy `?` określają ile razy wzorzec może się powtórzyć.
+Te metaznaki zachowują się różnie, w zależności od sytuacji.
+
+### 2.3.1 Gwiazdka
+
+Symbol `*` oznacza zero lub więcej powtórzeń poprzedzających znaków. Wyrażenie
+regularne `a*` oznacza: zero lub więcej powtórzeń poprzedzającej małej
+litery `a`. Ale jeśli występuje po zestawie znaków lub klasie, to oznacza
+powtórzenia całego zestawu lub klasy. Na przykład, wyrażenie regularne
+`[a-z]*` oznacza: każdy ciąg znaków pisany małymi literami.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/7m8me5/1)
+
+Symbol `*` może być użyty z metaznakiem `.` by oznaczyć każdy łańcuch
+znaków `.*`. Symbol `*` może być użyty ze znakiem `\s`
+by znaleźć łańcuch zawierający spacje. Na przykład, wyrażenie
+`\s*cat\s*` oznacza: zero lub więcej spacji, następującą po niej małą literę `c`,
+następującą po niej małą literę `a`, następującą po niej małą literę `t`,
+następujące po niej zero lub więcej spacji.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Plus
+
+Symbol `+` oznacza jeden lub więcej powtórzeń poprzedzających znaków. Na przykład,
+wyrażenie `c.+t` oznacza: małą literę `c`, następujący po niej przynajmniej jeden
+dowolny znak, następującą po nim małą literę `t`. W tym wypadku `t` jest ostatnim
+`t` w zdaniu.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Znak zapytania
+
+W wyrażeniach regularnych znak `?` sprawia, że poprzedzający znak jest opcjonalny.
+Ten symbol oznacza zero lub jedno wystąpienie poprzedzającego znaku. Na przykład,
+wyrażenie regularne `[T]?he` oznacza: opcjonalną dużą literę `T`, następującą
+po niej małą literę `h`, następującą po niej małą literę `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Klamry
+
+W wyrażeniach regularnych, klamry zwane również kwantyfikatorami, używane są
+do określenia, ile razy znak lub grupa znaków może się powtórzyć.
+Na przykład wyrażenie regularne `[0-9]{2,3}` oznacza: przynajmniej
+2 znaki, ale nie więcej niż 3 (znaki z zakresu od 0 do 9).
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/juM86s/1)
+
+Możemy opuścić drugą liczbę. Na przykład regularne wyrażenie `[0-9]{2,}`
+oznacza: 2 lub więcej znaków. Jeżeli dodatkowo usuniemy przecinek,
+to wyrażenie `[0-9]{3}` oznacza: dokładnie 3 znaki z zakresu 0 do 9.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Grupa znaków
+
+Grupa znaków to grupa podwzorców, które zapisywane są w nawiasach `(...)`.
+Jak wspominaliśmy wyżej, jeśli w wyrażeniu regularnym wstawimy kwantyfikator po
+znaku, wtedy powtórzy on ten znak. Ale gdy wstawimy kwantyfikator po grupie znaków,
+wtedy cała grupa zostanie powtórzona. Na przykład wyrażenie regularne `(ab)*`
+oznacza zero lub więcej powtórzeń grupy "ab". Możemy także użyć metaznaku
+alternatywy `|` wewnątrz grupy. Na przykład wyrażenie `(c|g|p)ar` oznacza: małą literę `c`,
+`g` lub `p`, następującą po niej literę `a`, następującą po niej literę `r`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/tUxrBG/1)
+
+## 2.6 Alternatywa
+
+W wyrażeniach regularnych pionowa kreska `|` oznacza alternatywę.
+Działa jak warunek pomiędzy różnymi wyrażeniami. Teraz możesz pomyśleć, że
+to działa tak samo jak zestaw znaków. Różnica polega na tym, że zestaw znaków
+działa na poziomie znaków, natomiast alternatywa na poziomie wyrażenia. Na przykład
+wyrażenie regularne `(T|t)he|car` oznacza: dużą literę `T` lub małą `t`,
+następującą po niej literę `h`, następującą po niej literę `e` lub `c`, następującą
+po niej literę `a`, następującą po niej literę `r`.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Znak ucieczki
+
+Ukośnik `\` w wyrażeniach regularnych jest znakiem ucieczki. Pozwala on
+używać w wyrażeniu zarezerwowanych znaków takich jak `{ } [ ] / \ + * . $ ^ | ?`.
+Aby użyć znaku specjalnego w wyrażeniu, postaw `\` przed nim.
+
+Na przykład wyrażenie `.` dopasowuje każdy znak z wyjątkiem nowej linii.
+Żeby dopasować kropkę `.` w wyrażeniu regularnym, trzeba wstawić przed nią ukośnik.
+Wyrażenie `(f|c|m)at\.?` oznacza: małe litery `f` lub `c` lub `m`, następującą po niej
+literę `a`, następującą po niej literę `t`, następującą kropkę `.`, która jest opcjonalna.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Kotwice
+
+W wyrażeniach regularnych używamy kotwic aby sprawdzić czy dopasowywany symbol
+jest pierwszym lub ostatnim symbolem w łańcuchu. Są dwa typy: pierwszy to
+kareta `^`, która sprawdza czy znak jest początkiem łańcucha, drugi to dolar `$`,
+który sprawdza czy znak jest ostatnim elementem łańcucha.
+
+### 2.8.1 Kareta
+
+Kareta `^` sprawdza czy znak jest początkiem łańcucha. Jeżeli użyjemy takiego
+wyrażenia `^a` (jeśli a jest pierwszym znakiem) na łańcuchu `abc` to dopasuje
+nam `a`. Ale jeśli użyjemy takiego wyrażenia `^b` na tym samym łańcuchu, to nie
+zwróci nam nic. Ponieważ w łańcuchu `abc` "b" nie jest pierwszym symbolem.
+Spójrzmy teraz na wyrażenie `^(T|t)he` które oznacza: dużą literę `T` lub małą
+`t`, która jest początkiem łańcucha, następującą po niej literę `h`, następującą
+po niej literę `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dolar
+
+Symbol dolara `$` używany jest do sprawdzenia czy dopasowywany znak jest ostatni
+w łańcuchu. Na przykład, wyrażenie regularne `(at\.)$` oznacza: małą literę `a`,
+następującą po niej literę `t`, następującą po niej kropkę `.` i na dodatek
+dopasowanie musi być końcem łańcucha.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/t0AkOd/1)
+
+##  3. Skróty
+
+W wyrażeniach regularnych znajdziemy także skróty dla popularnych zestawów znaków,
+które ułatwiają pracę z wyrażeniami regularnymi. Skróty wyglądają następująco:
+
+|Skrót|Opis|
+|:----:|----|
+|.|Każdy znak z wyjątkiem nowej linii|
+|\w|Znaki alfanumeryczne: `[a-zA-Z0-9_]`|
+|\W|Znaki nie alfanumeryczne: `[^\w]`|
+|\d|Cyfry: `[0-9]`|
+|\D|Nie cyfry: `[^\d]`|
+|\s|Dowolny biały znak: `[\t\n\f\r\p{Z}]`|
+|\S|Każdy znak oprócz białych: `[^\s]`|
+
+## 4. Lookaround
+
+Lookbehind i lookahead (nazywane również lookaround) to specyficzne typy
+***niezwracających grup*** (dopasowują wzorzec, ale nie zwracają wartości).
+Lookaround używane są w sytuacji, gdy mamy wzorzec i jest on poprzedzony innym wzorcem,
+lub następuje po nim kolejny wzorzec. Na przykład, chcemy mieć wszystkie
+numery, które są poprzedzone znakiem `$` w takim łańcuchu `$4.44 and $10.88`.
+Użyjemy takiego wyrażenia regularnego `(?<=\$)[0-9\.]*` które oznacza: znajdź
+wszystkie liczby ze znakiem `.` poprzedzone znakiem `$`. W wyrażeniach regularnych
+wyróżniamy:
+
+|Symbol|Opis|
+|:----:|----|
+|?=|Lookahead|
+|?!|Odwrócony lookahead|
+|?<=|Lookbehind|
+|?<!|Odwrócony lookbehind|
+
+### 4.1 Lookahead
+
+Lookahead stwierdza, że po pierwszej części wyrażenia musi następować
+następne wyrażenie. Zwracane dopasowanie zawiera tylko tekst, który został
+dopasowany przez pierwszą część wyrażenia. Stosuje się je w nawiasach wraz
+ze znakami zapytania i równości: `(?=...)`. Wyrażenie lookahead
+wpisuje się po znaku równości. Na przykład wyrażenie `(T|t)he(?=\sfat)`
+oznacza: opcjonalną małą literę `t` lub dużą `T`, następującą po niej
+literę `h`, następującą po niej literę `e`. W nawiasach definiujemy
+wyrażenie lookahead, które mówi aby dopasować `The` lub `the` i następujące
+po nich `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Odwrócony lookahead
+
+Używany jest, gdy potrzebujemy dopasowania z łańcucha, po których nie następują
+żadne wzorce. Odwrócony lookahead definiujemy w nawiasach, stosując znak negacji
+`!` po znaku zapytania, na przykład: `(?!...)`. Popatrzmy na następujące wyrażenie
+`(T|t)he(?!\sfat)` które oznacza: znajdź wszystkie słowa `The` lub `the` w łańcuchu,
+po których nie następuje słowo `fat`, poprzedzone spacją.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Lookbehind
+
+Lookbehind używany jest do odnalezienia wszystkich dopasowań poprzedzonych konkretnym
+wzorcem. Wyrażenie lookbehind zapisujemy tak: `(?<=...)`. Na przykład, wyrażenie
+`(?<=(T|t)he\s)(fat|mat)` oznacza: znajdź wszystkie słowa `fat` lub `mat` w łańcuchu,
+które znajdują się po słowach `The` lub `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/avH165/1)
+
+### 4.4 Odwrócony lookbehind
+
+Odwrócony używany jest do odnalezienia wszystkich dopasowań niepoprzedzonych konkretnym
+wzorcem. Odwrócony lookbehind zapisujemy tak: `(?<!...)`. Na przykład, wyrażenie
+`(?<!(T|t)he\s)(cat)` oznacza: znajdź wszystkie słowa `cat` w stringu, które nie następują
+po słowach `The` lub `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flagi
+
+Flagi nazywane są także modyfikatorami, ponieważ zmieniają wynik wyrażenia regularnego.
+Flagi mogą być używane w każdej kombinacji i są integralną częścią wyrażeń regularnych.
+
+|Flaga|Opis|
+|:----:|----|
+|i|Wielkość znaków: Sprawia, że dopasowanie nie jest wrażliwe na wielkość znaków.|
+|g|Przeszukanie globalne: Wyszukiwanie wzorca w całym łańcuchu.|
+|m|Multilinia: Sprawia, że kotwice działają na każdej linii.|
+
+### 5.1 Wielkość znaków
+
+Modyfikator `i` używany jest, gdy wielkość liter nie ma znaczenia. Na przykład
+wyrażenie `/The/gi` oznacza: dużą literę `T`, następującą po niej literę `h`,
+następującą po niej literę `e`. A na końcu wyrażenia, flaga `i` żeby ignorować
+wielkość znaków. Jak widać, została też użyta flaga `g` ponieważ chcemy przeszukać
+cały łańcuch.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Przeszukiwanie globalne
+
+Modyfikator `g` używany jest do przeszukiwania całego łańcucha (znajdź wszystko,
+a nie tylko zatrzymuj się na pierwszym). Na przykład wyrażenie `/.(at)/g`
+oznacza: każdy znak z wyjątkiem nowej linii, następującą po nim literę `a`,
+następującą po niej literę `t`. Ponieważ użyliśmy na końcu wyrażenia flagi `g`,
+wyszukane zostaną wszystkie dopasowania w łańcuchu, a nie tylko pierwszy (domyślne zachowanie).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multilinia
+
+Modyfikator `m` używany jest do dopasowywania w wielu liniach. Jak wspominaliśmy
+wcześniej, kotwice `(^, $)` używane są do sprawdzania czy wzorzec jest początkiem
+lub końcem łańcucha. Jeśli chcemy, żeby kotwice zadziałały w każdej linii, używamy
+wtedy flagi `m`. Na przykład wyrażenie `/at(.)?$/gm` oznacza: małą literę `a`,
+następującą po niej małą literę `t`, opcjonalnie dowolny znak z wyjątkiem nowej linii.
+I ponieważ użyliśmy flagi `m` dopasowywane będą wzorce na końcu każdej linii w łańcuchu.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Przetestuj wyrażenie](https://regex101.com/r/E88WE2/1)
+
+## Kontrybucja
+
+* Zgłaszanie błędów
+* Otwieranie pull request z poprawkami
+* Dzielenie się poradnikiem
+* Skontaktuj się ze mną ziishaned@gmail.com lub [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## Licencja
+
+MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
diff --git a/README-pt_BR.md b/README-pt_BR.md
index de90728d..791c48c2 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -13,6 +13,7 @@
 * [日本語](README-ja.md)
 * [한국어](README-ko.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/README-tr.md b/README-tr.md
index 956e85ea..718849bd 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -13,6 +13,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/README.md b/README.md
index 443973e3..29f1d4cd 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@
 * [한국어](README-ko.md)
 * [Turkish](README-tr.md)
 * [Greek](README-gr.md)
+* [Polish](README-pl.md)
 
 ## What is Regular Expression?
 
diff --git a/img/regexp-pl.png b/img/regexp-pl.png
new file mode 100644
index 0000000000000000000000000000000000000000..5da2cd423c715a7ca33f218c5918d70345868398
GIT binary patch
literal 20204
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

literal 0
HcmV?d00001


From 1fa0fa7786f815cf2d11e9f6bfee615e85fcaefb Mon Sep 17 00:00:00 2001
From: Amey Joshi <amey589@users.noreply.github.com>
Date: Mon, 25 Dec 2017 00:19:53 -0500
Subject: [PATCH 037/185] #103 Add greedy vs lazy matching (#104)

---
 README.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/README.md b/README.md
index 29f1d4cd..82add6e0 100644
--- a/README.md
+++ b/README.md
@@ -540,6 +540,23 @@ at the end of each line in a string.
 
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
+## 6. Greedy vs lazy matching
+By default regex will do greedy matching , means it will match as long as
+possible. we can use `?` to match in lazy way means as short as possible
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat.</strong></a> </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+
+
 ## Contribution
 
 * Report issues

From f489ee2cc0fc224394c3945be74176c16017e237 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 25 Dec 2017 10:22:36 +0500
Subject: [PATCH 038/185] Update table of contents

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 82add6e0..de9ac4ff 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,7 @@ letter and also it is too short.
   - [Case Insensitive](#51-case-insensitive)
   - [Global search](#52-global-search)
   - [Multiline](#53-multiline)
+- [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
 
 ## 1. Basic Matchers
 

From aeecdc154a834948e23566cffe4175f3de13ab47 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 13 Jan 2018 22:13:55 +0400
Subject: [PATCH 039/185] Fix typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index de9ac4ff..f89d1cc1 100644
--- a/README.md
+++ b/README.md
@@ -195,7 +195,7 @@ followed by lowercase character `a`, followed by lowercase character `t`,
 followed by zero or more spaces.
 
 <pre>
-"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
 </pre>
 
 [Test the regular expression](https://regex101.com/r/gGrwuz/1)

From ef6abcb2cfdcb724ad10a7d41d1007210767f351 Mon Sep 17 00:00:00 2001
From: Hello World <tanguang2017@gmail.com>
Date: Fri, 19 Jan 2018 16:00:05 +0800
Subject: [PATCH 040/185] Fix Chinese translation error (#107)

---
 README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README-cn.md b/README-cn.md
index 0f7e9b81..5899a10a 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -454,7 +454,7 @@
 
 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
 
-例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟一个或多个 `.` 的字符串, 并返回全部结果.
+例如, 表达式 `/at(.)?$/gm` 表示小写字符 `a` 后跟小写字符 `t` , 末尾可选除换行符外任意字符. 根据 `m` 修饰符, 现在表达式匹配每行的结尾.
 
 <pre>
 "/.at(.)?$/" => The fat

From 755ae62bff06891ad2f0764f45e9cb852926ad96 Mon Sep 17 00:00:00 2001
From: EdgarAllanzp <edgarallan@qq.com>
Date: Tue, 30 Jan 2018 12:30:10 +0800
Subject: [PATCH 041/185] fix example error at section Greedy vs lazy matching.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f89d1cc1..d49c725e 100644
--- a/README.md
+++ b/README.md
@@ -546,7 +546,7 @@ By default regex will do greedy matching , means it will match as long as
 possible. we can use `?` to match in lazy way means as short as possible
 
 <pre>
-"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat.</strong></a> </pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
 
 
 [Test the regular expression](https://regex101.com/r/AyAdgJ/1)

From 6d5c34d90678b168af9b0b33fcc6ca2415974fbe Mon Sep 17 00:00:00 2001
From: Edgarli <edgarallan@qq.com>
Date: Tue, 30 Jan 2018 14:03:26 +0800
Subject: [PATCH 042/185] fix example error at section Greedy vs lazy matching.
 (#109)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f89d1cc1..d49c725e 100644
--- a/README.md
+++ b/README.md
@@ -546,7 +546,7 @@ By default regex will do greedy matching , means it will match as long as
 possible. we can use `?` to match in lazy way means as short as possible
 
 <pre>
-"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat.</strong></a> </pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
 
 
 [Test the regular expression](https://regex101.com/r/AyAdgJ/1)

From 30d0fa33ef4bc14abeda92c0230092e569bf069d Mon Sep 17 00:00:00 2001
From: EdgarAllanzp <edgarallan@qq.com>
Date: Tue, 30 Jan 2018 18:02:12 +0800
Subject: [PATCH 043/185] Chinese translation at section 'Greedy vs lazy
 matching'.

---
 README-cn.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/README-cn.md b/README-cn.md
index 5899a10a..f31fdf7c 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -472,6 +472,21 @@
 
 [在线练习](https://regex101.com/r/E88WE2/1)
 
+### 6. 贪婪匹配与惰性匹配 (Greedy vs lazy matching)
+
+正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 `?` 将贪婪匹配模式转化为惰性匹配模式。
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+[在线练习](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[在线练习](https://regex101.com/r/AyAdgJ/2)
+
 ## 贡献
 
 * 报告问题

From 9ed1a20b215c7621b54018c1e4e589dc35980805 Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" <opid911@gmail.com>
Date: Fri, 16 Mar 2018 15:30:41 +0900
Subject: [PATCH 044/185]  Translate 'Greedy vs lazy matching' into korean

---
 README-ko.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/README-ko.md b/README-ko.md
index e3029d0f..413c5a0b 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -59,6 +59,7 @@
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
   - [멀티 라인](#53-멀티-라인)
+ - [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
 
 ## 1. 기본 매쳐
 
@@ -401,6 +402,22 @@
 
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
+## 6. 탐욕적 vs 게으른 매칭
+기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 
+우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. 
+</pre>
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. 
+</pre>
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+
 ## 기여 방법
 
 * 이슈 리포팅

From eed5d788230e8b9eaff92d3c5eb08e8cf40517e5 Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" <opid911@gmail.com>
Date: Fri, 16 Mar 2018 17:08:22 +0900
Subject: [PATCH 045/185] Fix toc link

- fix incorrectly link in toc
- modify sentence in section 6
---
 README-ko.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README-ko.md b/README-ko.md
index 413c5a0b..02678b22 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -59,7 +59,7 @@
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
   - [멀티 라인](#53-멀티-라인)
- - [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
+- [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른-매칭)
 
 ## 1. 기본 매쳐
 
@@ -404,7 +404,7 @@
 
 ## 6. 탐욕적 vs 게으른 매칭
 기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 
-우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
+우리는 `?`를 사용하여 게으른(lazy) 방법으로 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. 

From 0d20c325e5f0b907b8ca32330664914ac15edebf Mon Sep 17 00:00:00 2001
From: webber <webber.nl@gmail.com>
Date: Tue, 27 Mar 2018 19:30:57 +0200
Subject: [PATCH 046/185] Add more context to (non) capturing groups

Changed 2.5 to reflect the following changes:

- Character group is now named capturing group
- Capturing group is given proper context of its usage (initial text)
- Non-capturing group is now described as per #16.
---
 README.md | 33 +++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index ffd6e9c4..9b36ad19 100644
--- a/README.md
+++ b/README.md
@@ -263,14 +263,14 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 [Test the regular expression](https://regex101.com/r/Sivu30/1)
 
-## 2.5 Character Group
+## 2.5 Capturing Group
 
-Character group is a group of sub-patterns that is written inside Parentheses `(...)`.
-As we discussed before that in regular expression if we put a quantifier after a
-character then it will repeat the preceding character. But if we put quantifier
-after a character group then it repeats the whole character group. For example,
+A capturing group is a group of sub-patterns that is written inside Parentheses 
+`(...)`. Like As we discussed before that in regular expression if we put a quantifier 
+after a character then it will repeat the preceding character. But if we put quantifier
+after a capturing group then it repeats the whole capturing group. For example,
 the regular expression `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside character group.
+"ab". We can also use the alternation `|` meta character inside capturing group.
 For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
 `g` or `p`, followed by character `a`, followed by character `r`.
 
@@ -280,6 +280,27 @@ For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
 
 [Test the regular expression](https://regex101.com/r/tUxrBG/1)
 
+Note that capturing groups do not only match but also capture the characters for use in 
+the parent language. The parent language could be python or javascript or virtually any
+language that implements regular expressions in a function definition.
+
+### 2.5.1 Non-capturing group
+
+A non-capturing group is a capturing group that only matches the characters, but 
+does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
+within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+Non-capturing groups can come in handy when used in find-and-replace functionality or 
+when mixed with capturing groups to keep the overview when producing any other kind of output. 
+See also [4. Lookaround](# 4. Lookaround).
+
 ## 2.6 Alternation
 
 In regular expression Vertical bar `|` is used to define alternation.

From 3142822931c86ee8fa68e639399353d6d3492bb2 Mon Sep 17 00:00:00 2001
From: Josh Byster <8664074+josh-byster@users.noreply.github.com>
Date: Sat, 23 Jun 2018 00:03:22 -0500
Subject: [PATCH 047/185] Clarified alternation

---
 README.md | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 9b36ad19..e4d3561b 100644
--- a/README.md
+++ b/README.md
@@ -303,15 +303,16 @@ See also [4. Lookaround](# 4. Lookaround).
 
 ## 2.6 Alternation
 
-In regular expression Vertical bar `|` is used to define alternation.
-Alternation is like a condition between multiple expressions. Now, you may be
+In a regular expression, the vertical bar `|` is used to define alternation.
+Alternation is like an OR statement between multiple expressions. Now, you may be
 thinking that character set and alternation works the same way. But the big
 difference between character set and alternation is that character set works on
 character level but alternation works on expression level. For example, the
-regular expression `(T|t)he|car` means: uppercase character `T` or lowercase
-`t`, followed by lowercase character `h`, followed by lowercase character `e` or
-lowercase character `c`, followed by lowercase character `a`, followed by
-lowercase character `r`.
+regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
+`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
+(lowercase character `c`, followed by lowercase character `a`, followed by
+lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
+in parentheses can be met and it will match.
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.

From da41a9d2970d7b7e57fd2c923f5ffa2721205f76 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 16 Jul 2018 17:29:33 +0400
Subject: [PATCH 048/185] Revert "Fix toc link"

---
 README-ko.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README-ko.md b/README-ko.md
index c5016322..a740acfd 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -60,7 +60,7 @@
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
   - [멀티 라인](#53-멀티-라인)
-- [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른-매칭)
+ - [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
 
 ## 1. 기본 매쳐
 
@@ -405,7 +405,7 @@
 
 ## 6. 탐욕적 vs 게으른 매칭
 기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 
-우리는 `?`를 사용하여 게으른(lazy) 방법으로 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
+우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. 

From e11b2c9134403f5a77a348df06f4e658c4f17769 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 28 Sep 2018 23:31:05 +0400
Subject: [PATCH 049/185] Fix typos

---
 .gitignore          | 1 +
 LICENSE             | 2 +-
 README-cn.md        | 2 +-
 README-es.md        | 2 +-
 README-fr.md        | 2 +-
 README-gr.md        | 2 +-
 README-hu.md        | 2 +-
 README-ja.md        | 2 +-
 README-ko.md        | 2 +-
 README-pl.md        | 2 +-
 README-pt_BR.md     | 2 +-
 README-tr.md        | 2 +-
 README-zh-simple.md | 2 +-
 README.md           | 2 +-
 14 files changed, 14 insertions(+), 13 deletions(-)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..600d2d33
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.vscode
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
index 78bf0689..de523bdf 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Zeeshan Ahmed
+Copyright (c) 2017 Zeeshan Ahmad
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README-cn.md b/README-cn.md
index 2d996cb1..e1e4eb5e 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -497,4 +497,4 @@
 
 ## 许可证
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-es.md b/README-es.md
index 19d5e5a8..8026ee5d 100644
--- a/README-es.md
+++ b/README-es.md
@@ -467,4 +467,4 @@ el motor de expresión regular coincide con el patrón al final de cada línea d
 
 ## Licencia
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-fr.md b/README-fr.md
index 2af7fe25..e0354beb 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -468,4 +468,4 @@ Grâce au drapeau `m` maintenant le moteur d'expression régulière trouve le sc
 
 ## License
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-gr.md b/README-gr.md
index 30da6a4b..b480e9a3 100644
--- a/README-gr.md
+++ b/README-gr.md
@@ -551,4 +551,4 @@ string με βάση κάποιου μοτίβου αναζήτησης και 
 
 ## License
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-hu.md b/README-hu.md
index 92a57fb9..770a61f3 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -534,4 +534,4 @@ végéig keres illeszkedést.
 
 ## Licenc
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-ja.md b/README-ja.md
index bdfec3a4..b5ed321a 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -520,4 +520,4 @@
 
 ## ライセンス
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-ko.md b/README-ko.md
index a740acfd..777c76d6 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -428,4 +428,4 @@
 
 ## 라이센스
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-pl.md b/README-pl.md
index 28622c42..a5ef17c0 100644
--- a/README-pl.md
+++ b/README-pl.md
@@ -530,4 +530,4 @@ I ponieważ użyliśmy flagi `m` dopasowywane będą wzorce na końcu każdej li
 
 ## Licencja
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-pt_BR.md b/README-pt_BR.md
index e1f6df7a..0942e5c3 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -410,4 +410,4 @@ O modificador `m` é usado para realizar uma busca em várias linhas. Como falam
 
 ## Licença
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-tr.md b/README-tr.md
index 1dfbf7c6..fe40116b 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -478,4 +478,4 @@ Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak içi
 
 ## License
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README-zh-simple.md b/README-zh-simple.md
index 2ae80013..83de5b82 100644
--- a/README-zh-simple.md
+++ b/README-zh-simple.md
@@ -485,4 +485,4 @@
 
 ## 许可证
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/README.md b/README.md
index e4d3561b..6f52a703 100644
--- a/README.md
+++ b/README.md
@@ -590,4 +590,4 @@ possible. we can use `?` to match in lazy way means as short as possible
 
 ## License
 
-MIT © [Zeeshan Ahmed](mailto:ziishaned@gmail.com)
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From 6909472cd391d8add49f7e7db8759ac0fb29a803 Mon Sep 17 00:00:00 2001
From: BigBadJohn562 <44328380+BigBadJohn562@users.noreply.github.com>
Date: Mon, 22 Oct 2018 11:03:20 -0700
Subject: [PATCH 050/185] Wording and Sentence Structure Changes

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 6f52a703..89844ef4 100644
--- a/README.md
+++ b/README.md
@@ -22,10 +22,10 @@
 > Regular expression is a group of characters or symbols which is used to find a specific pattern from a text.
 
 A regular expression is a pattern that is matched against a subject string from
-left to right. The word "Regular expression" is a mouthful, you will usually
-find the term abbreviated as "regex" or "regexp". Regular expression is used for
-replacing a text within a string, validating form, extract a substring from a
-string based upon a pattern match, and so much more.
+left to right. Regular expression is used for replacing a text within a string, 
+validating form, extract a substring from a string based upon a pattern match, 
+and so much more. The word "Regular expression" is a mouthful, so you will usually
+find the term abbreviated as "regex" or "regexp". 
 
 Imagine you are writing an application and you want to set the rules for when a
 user chooses their username. We want to allow the username to contain letters,

From 780ab9bd69bd36676cc501da503e414a3cd5c10f Mon Sep 17 00:00:00 2001
From: Lucky Ozoka <me@orobolucky.com>
Date: Mon, 26 Nov 2018 21:30:35 +0100
Subject: [PATCH 051/185] Replace lookaheads with lookarounds in definition of
 lookarounds

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6f52a703..5daf25dc 100644
--- a/README.md
+++ b/README.md
@@ -409,7 +409,7 @@ shorthand character sets are as follows:
 
 Lookbehind and lookahead (also called lookaround) are specific types of
 ***non-capturing groups*** (Used to match the pattern but not included in matching
-list). Lookaheads are used when we have the condition that this pattern is
+list). Lookarounds are used when we have the condition that this pattern is
 preceded or followed by another certain pattern. For example, we want to get all
 numbers that are preceded by `$` character from the following input string
 `$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`

From 38354692cfddae7540686542c47c7e331ccf4307 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:24:11 +0400
Subject: [PATCH 052/185] Put links inside header

---
 README-cn.md        | 18 +++++++++++++++---
 README-es.md        | 18 +++++++++++++++---
 README-fr.md        | 18 +++++++++++++++---
 README-gr.md        | 18 +++++++++++++++---
 README-hu.md        | 18 +++++++++++++++---
 README-ja.md        | 18 +++++++++++++++---
 README-ko.md        | 18 +++++++++++++++---
 README-pl.md        | 18 +++++++++++++++---
 README-pt_BR.md     | 18 +++++++++++++++---
 README-tr.md        | 18 +++++++++++++++---
 README-zh-simple.md | 18 +++++++++++++++---
 README.md           | 17 ++++++++++++++---
 12 files changed, 179 insertions(+), 36 deletions(-)

diff --git a/README-cn.md b/README-cn.md
index e1e4eb5e..c710fc61 100644
--- a/README-cn.md
+++ b/README-cn.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## 翻译:
 
diff --git a/README-es.md b/README-es.md
index 8026ee5d..d9eb4260 100644
--- a/README-es.md
+++ b/README-es.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Traducciones:
 
diff --git a/README-fr.md b/README-fr.md
index e0354beb..f102e8f5 100644
--- a/README-fr.md
+++ b/README-fr.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Traductions:
 
diff --git a/README-gr.md b/README-gr.md
index b480e9a3..b8dd12fa 100644
--- a/README-gr.md
+++ b/README-gr.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Μεταφράσεις:
 
diff --git a/README-hu.md b/README-hu.md
index 770a61f3..ff9e09f2 100644
--- a/README-hu.md
+++ b/README-hu.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Fordítások:
 
diff --git a/README-ja.md b/README-ja.md
index b5ed321a..81ac7324 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## 翻訳
 
diff --git a/README-ko.md b/README-ko.md
index 777c76d6..448f8d1b 100644
--- a/README-ko.md
+++ b/README-ko.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## 번역:
 
diff --git a/README-pl.md b/README-pl.md
index a5ef17c0..f4064b43 100644
--- a/README-pl.md
+++ b/README-pl.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Tłumaczenia:
 
diff --git a/README-pt_BR.md b/README-pt_BR.md
index 0942e5c3..eff3549a 100644
--- a/README-pt_BR.md
+++ b/README-pt_BR.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Traduções:
 
diff --git a/README-tr.md b/README-tr.md
index fe40116b..308e41fd 100644
--- a/README-tr.md
+++ b/README-tr.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## Çeviriler:
 
diff --git a/README-zh-simple.md b/README-zh-simple.md
index 83de5b82..e88116a3 100644
--- a/README-zh-simple.md
+++ b/README-zh-simple.md
@@ -1,7 +1,19 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
+
 
 ## 什么是正则表达式?
  
diff --git a/README.md b/README.md
index 5daf25dc..e7590922 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,18 @@
-<br/>
 <p align="center">
-<img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
-</p><br/>
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+        </a>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+        </a>
+    </p>
+</p>
 
 ## Translations:
 

From 19170f71fad77eab5db74b72bd6876ec06526ef2 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:27:58 +0400
Subject: [PATCH 053/185] Update year inside LICENSE.md

---
 LICENSE.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 LICENSE.md

diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 00000000..5171fedf
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Zeeshan Ahmad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

From a2bf72bfb8376e6a98c78393d1720041a6fafd59 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:28:40 +0400
Subject: [PATCH 054/185] Put .DS_Store inside .gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 600d2d33..0f971a30 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
-.vscode
\ No newline at end of file
+.vscode
+.DS_STORE
\ No newline at end of file

From 9e2ac646bba0ea3bb128a34a284303ec0812d08d Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:29:02 +0400
Subject: [PATCH 055/185] Move translations md files to translations directory

---
 LICENSE                                       | 21 -------------------
 README-cn.md => translations/README-cn.md     |  0
 README-es.md => translations/README-es.md     |  0
 README-fr.md => translations/README-fr.md     |  0
 README-gr.md => translations/README-gr.md     |  0
 README-hu.md => translations/README-hu.md     |  0
 README-ja.md => translations/README-ja.md     |  0
 README-ko.md => translations/README-ko.md     |  0
 README-pl.md => translations/README-pl.md     |  0
 .../README-pt_BR.md                           |  0
 README-tr.md => translations/README-tr.md     |  0
 .../README-zh-simple.md                       |  0
 12 files changed, 21 deletions(-)
 delete mode 100644 LICENSE
 rename README-cn.md => translations/README-cn.md (100%)
 rename README-es.md => translations/README-es.md (100%)
 rename README-fr.md => translations/README-fr.md (100%)
 rename README-gr.md => translations/README-gr.md (100%)
 rename README-hu.md => translations/README-hu.md (100%)
 rename README-ja.md => translations/README-ja.md (100%)
 rename README-ko.md => translations/README-ko.md (100%)
 rename README-pl.md => translations/README-pl.md (100%)
 rename README-pt_BR.md => translations/README-pt_BR.md (100%)
 rename README-tr.md => translations/README-tr.md (100%)
 rename README-zh-simple.md => translations/README-zh-simple.md (100%)

diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index de523bdf..00000000
--- a/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Zeeshan Ahmad
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/README-cn.md b/translations/README-cn.md
similarity index 100%
rename from README-cn.md
rename to translations/README-cn.md
diff --git a/README-es.md b/translations/README-es.md
similarity index 100%
rename from README-es.md
rename to translations/README-es.md
diff --git a/README-fr.md b/translations/README-fr.md
similarity index 100%
rename from README-fr.md
rename to translations/README-fr.md
diff --git a/README-gr.md b/translations/README-gr.md
similarity index 100%
rename from README-gr.md
rename to translations/README-gr.md
diff --git a/README-hu.md b/translations/README-hu.md
similarity index 100%
rename from README-hu.md
rename to translations/README-hu.md
diff --git a/README-ja.md b/translations/README-ja.md
similarity index 100%
rename from README-ja.md
rename to translations/README-ja.md
diff --git a/README-ko.md b/translations/README-ko.md
similarity index 100%
rename from README-ko.md
rename to translations/README-ko.md
diff --git a/README-pl.md b/translations/README-pl.md
similarity index 100%
rename from README-pl.md
rename to translations/README-pl.md
diff --git a/README-pt_BR.md b/translations/README-pt_BR.md
similarity index 100%
rename from README-pt_BR.md
rename to translations/README-pt_BR.md
diff --git a/README-tr.md b/translations/README-tr.md
similarity index 100%
rename from README-tr.md
rename to translations/README-tr.md
diff --git a/README-zh-simple.md b/translations/README-zh-simple.md
similarity index 100%
rename from README-zh-simple.md
rename to translations/README-zh-simple.md

From 26a602c535afd7cd820733deabe0ac9619de6b53 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:48:59 +0400
Subject: [PATCH 056/185] Update readme links

---
 README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index e7590922..7fea7021 100644
--- a/README.md
+++ b/README.md
@@ -16,17 +16,17 @@
 
 ## Translations:
 
-* [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [English](translations/README.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## What is Regular Expression?
 

From 89a8d7ed0536c761361eedf193f84ce7ef6c9f04 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:50:04 +0400
Subject: [PATCH 057/185] Update readme link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7fea7021..368ea626 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 
 ## Translations:
 
-* [English](translations/README.md)
+* [English](README.md)
 * [Español](translations/README-es.md)
 * [Français](translations/README-fr.md)
 * [Português do Brasil](translations/README-pt_BR.md)

From 082750a4fe7b22b9a2869929254f9c8ca77e25b5 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:52:43 +0400
Subject: [PATCH 058/185] Update readme links

---
 translations/README-cn.md        | 19 ++++++++++---------
 translations/README-es.md        | 20 ++++++++++----------
 translations/README-fr.md        | 19 ++++++++++---------
 translations/README-gr.md        | 20 ++++++++++----------
 translations/README-hu.md        | 19 ++++++++++---------
 translations/README-ja.md        | 19 ++++++++++---------
 translations/README-ko.md        | 19 ++++++++++---------
 translations/README-pl.md        | 19 ++++++++++---------
 translations/README-pt_BR.md     | 19 ++++++++++---------
 translations/README-tr.md        | 19 ++++++++++---------
 translations/README-zh-simple.md | 13 +++++++++++++
 11 files changed, 113 insertions(+), 92 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index c710fc61..c765fc54 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -18,15 +18,16 @@
 ## 翻译:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## 什么是正则表达式?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index d9eb4260..ff25d406 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -18,16 +18,16 @@
 ## Traducciones:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index f102e8f5..271a1326 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -18,15 +18,16 @@
 ## Traductions:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index b8dd12fa..3a906d0d 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -18,16 +18,16 @@
 ## Μεταφράσεις:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index ff9e09f2..ee1e552f 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -18,15 +18,16 @@
 ## Fordítások:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 81ac7324..3269fea5 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -18,15 +18,16 @@
 ## 翻訳
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index 448f8d1b..a13eeb43 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -18,15 +18,16 @@
 ## 번역:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index f4064b43..2a7d387b 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -18,15 +18,16 @@
 ## Tłumaczenia:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index eff3549a..2a7ed8f4 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -18,15 +18,16 @@
 ## Traduções:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [Português do Brasil](README-pt_BR.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 308e41fd..b935359f 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -18,15 +18,16 @@
 ## Çeviriler:
 
 * [English](README.md)
-* [Español](README-es.md)
-* [Français](README-fr.md)
-* [中文版](README-cn.md)
-* [日本語](README-ja.md)
-* [한국어](README-ko.md)
-* [Turkish](README-tr.md)
-* [Greek](README-gr.md)
-* [Magyar](README-hu.md)
-* [Polish](README-pl.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index e88116a3..708371d2 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -14,6 +14,19 @@
     </p>
 </p>
 
+## Translations:
+
+* [English](README.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
 
 ## 什么是正则表达式?
  

From 3ad593b82aaba9274b28adff169cc2669ef51a5f Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:56:24 +0400
Subject: [PATCH 059/185] Add how-to.md file

---
 translations/how-to.md | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 translations/how-to.md

diff --git a/translations/how-to.md b/translations/how-to.md
new file mode 100644
index 00000000..91b6081d
--- /dev/null
+++ b/translations/how-to.md
@@ -0,0 +1,9 @@
+Please put new translation README files here.
+
+To start a new translation, please:
+
+1. Make an issue (for collaboration with other translators)
+2. Make a pull request to collaborate and commit to.
+3. Let me know when it's ready to pull.
+
+Thank you!
\ No newline at end of file

From 99e40a2bdd777c1b4d5957666fa12d6682e69762 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 21:57:58 +0400
Subject: [PATCH 060/185] Add regex svg file

---
 img/regexp.svg | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/img/regexp.svg b/img/regexp.svg
index 50ea7c7a..46d9f188 100644
--- a/img/regexp.svg
+++ b/img/regexp.svg
@@ -55,7 +55,7 @@
         <dc:type
            rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
         <dc:title>regexp</dc:title>
-        <dc:source>https://github.com/zeeshanu/learn-regex</dc:source>
+        <dc:source>https://github.com/ziishaned/learn-regex</dc:source>
         <dc:creator>
           <cc:Agent>
             <dc:title>ponsfrilus</dc:title>

From b00833c815d903cc4b5e1be7a47e21c67f8cfb18 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 12 Jan 2019 22:02:51 +0400
Subject: [PATCH 061/185] Update contribution section

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 368ea626..d0712bbe 100644
--- a/README.md
+++ b/README.md
@@ -594,10 +594,10 @@ possible. we can use `?` to match in lazy way means as short as possible
 
 ## Contribution
 
-* Report issues
 * Open pull request with improvements
+* Discuss ideas in issues
 * Spread the word
-* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
 ## License
 

From a43006b5624c0bd361dde7169e727dd4cc1e209a Mon Sep 17 00:00:00 2001
From: "Yeongjun.Kim" <yeongjun.kim@worksmobile.com>
Date: Mon, 28 Jan 2019 11:59:43 +0900
Subject: [PATCH 062/185] Update README-ko

---
 translations/README-ko.md | 116 +++++++++++++++++++++-----------------
 1 file changed, 65 insertions(+), 51 deletions(-)

diff --git a/translations/README-ko.md b/translations/README-ko.md
index a13eeb43..ee7abdcf 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -57,7 +57,8 @@
     - [덧셈 부호](#232-덧셈-부호)
     - [물음표](#233-물음표)
   - [중괄호](#24-중괄호)
-  - [문자 그룹](#25-문자-그룹)
+  - [캡쳐링 그룹](#25-캡쳐-그룹)
+    - [논-캡쳐링 그룹](#251-논-캡쳐링-그룹)
   - [대안 부호](#26-대안-부호)
   - [특수 문자 이스케이핑](#27-특수-문자-이스케이핑)
   - [앵커 부호](#28-앵커-부호)
@@ -73,7 +74,7 @@
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
   - [멀티 라인](#53-멀티-라인)
- - [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
+- [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
 
 ## 1. 기본 매쳐
 
@@ -95,23 +96,22 @@
 
 ## 2. 메타 문자
 
-메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다.
-아래는 이러한 메타 문자열들이다:
-
-|메타 문자|설명|
-|:----:|----|
-|.|온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|
-|[ ]|문자 클래스. 대괄호 사이에 있는 문자들로 매치.|
-|[^ ]|부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|
-|*|이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|
-|+|이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|
-|?|이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|
-|{n,m}|중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|
-|(xyz)|문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|
-|||대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|
-|\|다음 문자 이스케이프(Escape). 예약된 문자열들 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
-|^|입력의 시작과 매치.|
-|$|입력의 끝과 매치.|
+메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 아래는 이러한 메타 문자열들이다:
+
+| 메타 문자 | 설명 |
+|:----:| ----|
+| . | 온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|
+| [ ] | 문자 클래스. 대괄호 사이에 있는 문자들로 매치.|
+| [^ ] | 부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|
+| \* | 이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|
+| + | 이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|
+| ? | 이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|
+| {n,m} | 중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|
+| (xyz) | 문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|
+| | | 대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|
+| \| 다음 문자 이스케이프(Escape). 예약된 문자열들 <code>[ ] ( ) { } . \* + ? ^ \$ \ |</code>을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
+| ^ | 입력의 시작과 매치.|
+| \$ | 입력의 끝과 매치.|
 
 ## 2.1 마침표
 
@@ -176,7 +176,7 @@
 ### 2.3.2 덧셈 부호
 
 `+` 부호는 부호 앞에 위치한 문자가 한번 이상 반복되는 패턴을 만드는데 사용된다. 예를 들어, 정규 표현식 `c.+t`는 소문자 `c`가 나오고, 그 뒤에 한개 이상의 문자가 나온 후, 소문자 `t`가 나오는 패턴을 의미한다. 여기서 문자 `t`는 해당 문장의 제일 마지막 글자 `t`라는것을 명확히할 필요가 있다.
-  w
+
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
 </pre>
@@ -201,7 +201,7 @@
 
 ## 2.4 중괄호
 
-정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.
+정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -223,9 +223,9 @@
 
 [Test the regular expression](https://regex101.com/r/Sivu30/1)
 
-## 2.5 문자 그룹
+## 2.5 캡쳐링 그룹
 
-문자 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자 뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 문자 그룹 뒤에 정량자를 넣는 경우에는 문자 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
+캡쳐링 그룹은 괄호 `(...)` 안에 쓰여진 하위 패턴들의 그룹이다. 위에서 논의했듯이, 정규 표현식에서 하나의 문자 뒤에 정량자(quantifier)를 넣는 경우에는 해당 문자의 반복을 나타낸다. 하지만, 만약 하나의 캡쳐링 그룹 뒤에 정량자를 넣는 경우에는 캡쳐링 그룹 전체의 반복을 나타내게 된다. 예를 들어, 정규 표현식 `(ab)*`는 문자 "ab"가 0번 이상 반복되는 패턴을 의미한다. 대안 부호인 `|` 또한 문자 그룹 내부에서 사용할 수 있다. 예를 들어, 정규 표현식 `(c|g|p)ar`은 소문자 `c`, `g` 혹은 `p`가 나온 이후에 문자 `a`가 나오고 그 뒤에 문자 `r`이 나오는 패턴을 의미한다.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -233,6 +233,20 @@
 
 [Test the regular expression](https://regex101.com/r/tUxrBG/1)
 
+캡처링 그룹은 부모 언어에서 사용하기 위해 문자를 일치시킬뿐만 아니라 문자를 캡처한다는 점에 유의해야 한다. 부모 언어는 파이썬이나 자바 스크립트 또는 함수 정의에서 정규 표현식을 구현하는 거의 모든 언어가 될 수 있다.
+
+### 2.5.1 논-캡쳐링 그룹
+
+논-캡쳐링 그룹은 오직 문자열에 매칭되지만, 그룹을 캡쳐하지 않는 캡쳐링 그룹이다. 논-캡쳐링 그룹은 `(...)` 괄호안에 `?:` 로 표시된다. 예를 들어 정규식 `(?:c|g|p)ar` 는 `(c|g|p)ar`와 같은 문자열을 매칭하는 것에서 유사하지만, 캡쳐링 그룹을 만들지 않는다.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+논-캡처링 그룹은 찾기 및 변경 기능에서 사용하거나 캡처 그룹 함께 사용하여 다른 종류의 출력 생성시 overview를 유지할 때 유용하다. 또한 [4. 전후방탐색](#4-전후방탐색)를 보아라.
+
 ## 2.6 대안 부호
 
 정규 표현식에서 수직 막대 부호 `|`는 대안을 정의하는데 사용된다. 대안 부호는 여러개의 표현식들 사이의 조건과도 같다. 지금쯤 당신은 문자 집합(Character set)과 대안 부호가 동일하게 동작한다고 생각하고 있을 것이다. 하지만, 문자 집합과 대안 부호 사이의 가장 큰 차이점은 문자 집합은 문자 수준에서 동작하는 반면, 대안 부호는 표현식 수준에서 동작한다는 것이다. 예를 들어, 정규 표현식 `(T|t)he|car`는 대문자 `T` 혹은 소문자 `t`가 나오고 문자 `h`, 문자 `e`가 차례로 나오거나 문자 `c`, 문자 `a`, 문자 `r`이 차례로 나오는 패턴을 의미한다.
@@ -293,26 +307,26 @@
 
 정규 표현식은 일반적으로 사용되는 문자열 집합들을 간편하게 사용할 수 있도록 여러 단축형들을 제공한다. 단축형 문자열 집합은 아래와 같다.
 
-|단축형|설명|
-|:----:|----|
-|.|개행을 제외한 모든 문자|
-|\w|영숫자 문자와 매치: `[a-zA-Z0-9_]`|
-|\W|영숫자 문자가 아닌 문자와 매치: `[^\w]`|
-|\d|숫자와 매치: `[0-9]`|
-|\D|숫자가 아닌 문자와 매치: `[^\d]`|
-|\s|공백 문자와 매치: `[\t\n\f\r\p{Z}]`|
-|\S|공백 문자가 아닌 문자와 매치: `[^\s]`|
+| 단축형 | 설명                                    |
+| :----: | --------------------------------------- |
+|   .    | 개행을 제외한 모든 문자                 |
+|   \w   | 영숫자 문자와 매치: `[a-zA-Z0-9_]`      |
+|   \W   | 영숫자 문자가 아닌 문자와 매치: `[^\w]` |
+|   \d   | 숫자와 매치: `[0-9]`                    |
+|   \D   | 숫자가 아닌 문자와 매치: `[^\d]`        |
+|   \s   | 공백 문자와 매치: `[\t\n\f\r\p{Z}]`     |
+|   \S   | 공백 문자가 아닌 문자와 매치: `[^\s]`   |
 
 ## 4. 전후방탐색
 
-때때로 전후방탐색<sub>Lookaround</sub>이라고 알려진 후방탐색<sub>Lookbehind</sub>과 전방탐색<sub>Lookahead</sub>은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) ***넌-캡쳐링 그룹*** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$)[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
+때때로 전후방탐색<sub>Lookaround</sub>이라고 알려진 후방탐색<sub>Lookbehind</sub>과 전방탐색<sub>Lookahead</sub>은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) **_넌-캡쳐링 그룹_** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$)[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
 
-|부호|설명|
-|:----:|----|
-|?=|긍정형 전방탐색|
-|?!|부정형 전방탐색|
-|?<=|긍정형 후방탐색|
-|?<!|부정형 후방탐색|
+| 부호 | 설명            |
+| :--: | --------------- |
+|  ?=  | 긍정형 전방탐색 |
+|  ?!  | 부정형 전방탐색 |
+| ?<=  | 긍정형 후방탐색 |
+| ?<!  | 부정형 후방탐색 |
 
 ### 4.1 긍정형 전방탐색
 
@@ -346,7 +360,7 @@
 
 ### 4.4 부정형 후방탐색
 
-부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(?<!...)`로 표시된다. 예를 들어, 정규 표현식 `(?<!(T|t)he\s)(cat)`은 앞에 `The ` 혹은 `the `가 위치하지 않는 모든 `cat` 문자열을 의미한다.
+부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(?<!...)`로 표시된다. 예를 들어, 정규 표현식 `(?<!(T|t)he\s)(cat)`은 앞에 `The` 혹은 `the`가 위치하지 않는 모든 `cat` 문자열을 의미한다.
 
 <pre>
 "(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -358,11 +372,11 @@
 
 플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용 가능하며 정규 표현식의 일부분이다.
 
-|플래그|설명|
-|:----:|----|
-|i|대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정.|
-|g|전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.|
-|m|멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.|
+| 플래그 | 설명                                                       |
+| :----: | ---------------------------------------------------------- |
+|   i    | 대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정. |
+|   g    | 전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.        |
+|   m    | 멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.     |
 
 ### 5.1 대소문자 구분없음
 
@@ -417,8 +431,8 @@
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
 ## 6. 탐욕적 vs 게으른 매칭
-기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 
-우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
+
+기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. 
@@ -434,10 +448,10 @@
 
 ## 기여 방법
 
-* 이슈 리포팅
-* 코드 개선해서 풀 리퀘스트 열기
-* 소문내기
-* ziishaned@gmail.com 메일로 직접 연락하기 또는 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+- 이슈 리포팅
+- 코드 개선해서 풀 리퀘스트 열기
+- 소문내기
+- ziishaned@gmail.com 메일로 직접 연락하기 또는 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
 ## 라이센스
 

From 3a30006de007a1adc318371ceb026578b57fd9d7 Mon Sep 17 00:00:00 2001
From: "Yeongjun.Kim" <yeongjun.kim@worksmobile.com>
Date: Mon, 28 Jan 2019 12:02:08 +0900
Subject: [PATCH 063/185] Update README-ko

---
 translations/README-ko.md | 52 +++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/translations/README-ko.md b/translations/README-ko.md
index ee7abdcf..5061101a 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -201,7 +201,7 @@
 
 ## 2.4 중괄호
 
-정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.
+정규 표현식에서 정량자(quantifier)라고도 불리는 중괄호는 하나의 문자 혹은 문자 집합으로 표시된 문자가 몇번 반복되는지 명시하는데 사용된다. 예를 들어, 정규 표현식 `[0-9]{2,3}`은 숫자 문자(0부터 9사이의 문자)가 최소 2번, 최대 3번 연속해서 나오는 문자열 패턴을 의미한다.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -307,26 +307,26 @@
 
 정규 표현식은 일반적으로 사용되는 문자열 집합들을 간편하게 사용할 수 있도록 여러 단축형들을 제공한다. 단축형 문자열 집합은 아래와 같다.
 
-| 단축형 | 설명                                    |
-| :----: | --------------------------------------- |
-|   .    | 개행을 제외한 모든 문자                 |
-|   \w   | 영숫자 문자와 매치: `[a-zA-Z0-9_]`      |
-|   \W   | 영숫자 문자가 아닌 문자와 매치: `[^\w]` |
-|   \d   | 숫자와 매치: `[0-9]`                    |
-|   \D   | 숫자가 아닌 문자와 매치: `[^\d]`        |
-|   \s   | 공백 문자와 매치: `[\t\n\f\r\p{Z}]`     |
-|   \S   | 공백 문자가 아닌 문자와 매치: `[^\s]`   |
+|단축형|설명|
+|:----:|----|
+|.|개행을 제외한 모든 문자|
+|\w|영숫자 문자와 매치: `[a-zA-Z0-9_]`|
+|\W|영숫자 문자가 아닌 문자와 매치: `[^\w]`|
+|\d|숫자와 매치: `[0-9]`|
+|\D|숫자가 아닌 문자와 매치: `[^\d]`|
+|\s|공백 문자와 매치: `[\t\n\f\r\p{Z}]`|
+|\S|공백 문자가 아닌 문자와 매치: `[^\s]`|
 
 ## 4. 전후방탐색
 
 때때로 전후방탐색<sub>Lookaround</sub>이라고 알려진 후방탐색<sub>Lookbehind</sub>과 전방탐색<sub>Lookahead</sub>은 (패턴 매칭을 위해서 사용되지만 매칭된 리스트에는 포함되지 않는) **_넌-캡쳐링 그룹_** 의 특정 종류들이다. 전후방탐색은 하나의 패턴이 다른 특정 패턴 전이나 후에 나타나는 조건을 가지고 있을때 사용한다. 예를 들어, 우리가 입력 문자열 `$4.44 and $10.88`에 대해서 달러 부호 `$`이후에 나오는 모든 숫자를 매칭시키고 싶다고 하자. 이때 정규 표현식 `(?<=\$)[0-9\.]*`를 사용할 수 있다. 이 정규 표현식은 `$` 문자 뒤에 나오는 문자 `.`을 포함한 모든 숫자 문자를 의미한다. 다음은 정규 표현식에서 사용되는 전후방탐색들이다.
 
-| 부호 | 설명            |
-| :--: | --------------- |
-|  ?=  | 긍정형 전방탐색 |
-|  ?!  | 부정형 전방탐색 |
-| ?<=  | 긍정형 후방탐색 |
-| ?<!  | 부정형 후방탐색 |
+|부호|설명|
+|:----:|----|
+|?=|긍정형 전방탐색|
+|?!|부정형 전방탐색|
+|?<=|긍정형 후방탐색|
+|?<!|부정형 후방탐색|
 
 ### 4.1 긍정형 전방탐색
 
@@ -360,7 +360,7 @@
 
 ### 4.4 부정형 후방탐색
 
-부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(?<!...)`로 표시된다. 예를 들어, 정규 표현식 `(?<!(T|t)he\s)(cat)`은 앞에 `The` 혹은 `the`가 위치하지 않는 모든 `cat` 문자열을 의미한다.
+부정형 후방탐색는 특정 패턴이 뒤에 나오지 않기를 바라는 상황에서 사용된다. 부정형 후방탐색는 `(?<!...)`로 표시된다. 예를 들어, 정규 표현식 `(?<!(T|t)he\s)(cat)`은 앞에 `The` 혹은 `the` 가 위치하지 않는 모든 `cat` 문자열을 의미한다.
 
 <pre>
 "(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -372,11 +372,11 @@
 
 플래그는 정규표현식의 출력값을 수정하기 때문에 수정자(modifier)라고도 불린다. 이러한 플래그들은 어떤 순서 혹은 조합으로 사용 가능하며 정규 표현식의 일부분이다.
 
-| 플래그 | 설명                                                       |
-| :----: | ---------------------------------------------------------- |
-|   i    | 대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정. |
-|   g    | 전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.        |
-|   m    | 멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.     |
+|플래그|설명|
+|:----:|----|
+|i|대소문자 구분없음: 매칭이 대소문자를 구분하지 않도록 설정.|
+|g|전체 검색: 입력 문자열 전체를 대상으로 패턴을 검색.|
+|m|멀티 라인: 앵터 메타 문자가 각 줄마다 동작하도록 설정.|
 
 ### 5.1 대소문자 구분없음
 
@@ -448,10 +448,10 @@
 
 ## 기여 방법
 
-- 이슈 리포팅
-- 코드 개선해서 풀 리퀘스트 열기
-- 소문내기
-- ziishaned@gmail.com 메일로 직접 연락하기 또는 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* 이슈 리포팅
+* 코드 개선해서 풀 리퀘스트 열기
+* 소문내기
+* ziishaned@gmail.com 메일로 직접 연락하기 또는 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
 ## 라이센스
 

From 4ae12d88057e2988c17573aaa032bee64fd04cc6 Mon Sep 17 00:00:00 2001
From: "Yeongjun.Kim" <yeongjun.kim@worksmobile.com>
Date: Mon, 28 Jan 2019 12:04:01 +0900
Subject: [PATCH 064/185] Update README-ko

---
 translations/README-ko.md | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/translations/README-ko.md b/translations/README-ko.md
index 5061101a..6a962ed8 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -98,20 +98,20 @@
 
 메타 문자들은 정규 표현식의 빌딩 블락들이다. 메타 문자들은 자체적인 의미를 가지지 않고 특별한 방식으로 해석되어진다. 어떤 메타 문자열들은 특별한 의미를 가지며 대괄호안에서 쓰인다. 아래는 이러한 메타 문자열들이다:
 
-| 메타 문자 | 설명 |
+|메타 문자|설명|
 |:----:| ----|
-| . | 온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|
-| [ ] | 문자 클래스. 대괄호 사이에 있는 문자들로 매치.|
-| [^ ] | 부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|
-| \* | 이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|
-| + | 이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|
-| ? | 이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|
-| {n,m} | 중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|
-| (xyz) | 문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|
-| | | 대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|
-| \| 다음 문자 이스케이프(Escape). 예약된 문자열들 <code>[ ] ( ) { } . \* + ? ^ \$ \ |</code>을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
-| ^ | 입력의 시작과 매치.|
-| \$ | 입력의 끝과 매치.|
+|.|온점(Period)는 줄바꿈을 제외한 어떤 종류의 단일 문자와 매치.|
+|[ ]|문자 클래스. 대괄호 사이에 있는 문자들로 매치.|
+|[^ ]|부정 문자 클래스. 대괄호 안에 포함되지 않은 모든 문자들로 매치.|
+|\*|이 메타 문자의 바로 앞에 있는 심볼이 0번 이상 반복된 문자들과 매치.|
+|+|이 메타 문자의 바로 앞에 있는 심볼이 한번 이상 반복된 문자들과 매치.|
+|?|이 메타 문자의 바로 앞에 있는 심볼을 선택적(optional)으로 만듬.|
+|{n,m}|중괄호. 이 메타 문자의 바로 앞에 위치한 심볼이 최소 n번 최대 m번의 반복된 문자들과 매치.|
+|(xyz)|문자 그룹. 문자열 xyz와 정확히 같은 순서를 가진 문자들과 매치.|
+|||대안. 문자가 이 메타 문자의 앞에 있는 심볼이거나 뒤에 있는 심볼이면 매치.|
+|\|다음 문자 이스케이프(Escape). 예약된 문자열들 <code>[ ] ( ) { } . \* + ? ^ \$ \ |</code>을 이스케이핑함으로써 그 자체와 매칭되는 것을 허용.|
+|^|입력의 시작과 매치.|
+|\$|입력의 끝과 매치.|
 
 ## 2.1 마침표
 
@@ -431,7 +431,6 @@
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
 ## 6. 탐욕적 vs 게으른 매칭
-
 기본적으로 정규 표현식은 탐욕적(greedy) 매칭을 수행하는데, 이는 가능한 한 길게 매칭하는 것을 의미한다. 우리는 `?`를 사용하여 게으른(lazy) 방법 매칭할 수 있으며, 가능한 한 짧게 매칭하는 것을 의미한다.
 
 <pre>

From 89f4503bc02fc8b8afb801fe51e1acba8ddbf24b Mon Sep 17 00:00:00 2001
From: Enis OEZGEN <mail@enisozgen.com>
Date: Sun, 3 Feb 2019 14:46:49 +0100
Subject: [PATCH 065/185] Fix-Translation-Links

---
 translations/README-cn.md        | 22 +++++++++++-----------
 translations/README-es.md        | 22 +++++++++++-----------
 translations/README-fr.md        | 22 +++++++++++-----------
 translations/README-gr.md        | 22 +++++++++++-----------
 translations/README-hu.md        | 22 +++++++++++-----------
 translations/README-ja.md        | 22 +++++++++++-----------
 translations/README-ko.md        | 22 +++++++++++-----------
 translations/README-pl.md        | 22 +++++++++++-----------
 translations/README-pt_BR.md     | 22 +++++++++++-----------
 translations/README-tr.md        | 22 +++++++++++-----------
 translations/README-zh-simple.md | 22 +++++++++++-----------
 11 files changed, 121 insertions(+), 121 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index c765fc54..3d256c44 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -17,17 +17,17 @@
 
 ## 翻译:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## 什么是正则表达式?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index ff25d406..233e39ae 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -17,17 +17,17 @@
 
 ## Traducciones:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index 271a1326..46f62391 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -17,17 +17,17 @@
 
 ## Traductions:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 3a906d0d..00411898 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -17,17 +17,17 @@
 
 ## Μεταφράσεις:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index ee1e552f..48253c44 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -17,17 +17,17 @@
 
 ## Fordítások:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 3269fea5..5657daba 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -17,17 +17,17 @@
 
 ## 翻訳
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index a13eeb43..19527422 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -17,17 +17,17 @@
 
 ## 번역:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index 2a7d387b..5a0ebda1 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -17,17 +17,17 @@
 
 ## Tłumaczenia:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 2a7ed8f4..7fecb53f 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -17,17 +17,17 @@
 
 ## Traduções:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index b935359f..ec918cfa 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -17,17 +17,17 @@
 
 ## Çeviriler:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 708371d2..60652cef 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -16,17 +16,17 @@
 
 ## Translations:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
 
 ## 什么是正则表达式?
  

From 1a84cd502bb208086b0761d4d507401c24cf4e21 Mon Sep 17 00:00:00 2001
From: Enis OEZGEN <mail@enisozgen.com>
Date: Sun, 3 Feb 2019 15:52:17 +0100
Subject: [PATCH 066/185] Improve Turkish language

---
 translations/README-tr.md | 243 +++++++++++++++++++++++++++-----------
 1 file changed, 174 insertions(+), 69 deletions(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index b935359f..6add9c61 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -33,9 +33,19 @@
 
 > Düzenli ifade, bir metinden belirli bir deseni bulmak için kullanılan bir karakter veya sembol grubudur.
 
-Bir düzenli ifade soldan sağa söz konusu harf öbekleriyle eşleşen bir desendir. "Regular expression" söylemesi zor bir tabirdir, genellikle "regex" ya da "regexp" olarak kısaltılmış terimler olarak bulacaksınız. Düzenli ifade bir harf öbeğinde ki bir metin değiştirmek, form doğrulamak, bir desen eşleşmesine dayalı harf öbeğinden bir alt harf öbeği ayıklamak ve çok daha fazlası için kullanılır.
-
-Bir uygulama yazdığınızı hayal edin ve bir kullanıcı kullanıcı adını seçtiğinde kullanıcı adı için kurallar belirlemek istiyorsunuz. Kullanıcı adının harfler, sayılar, altçizgiler ve tireler içermesine izin vermek istiyoruz. Ayrıca, Kullanıcı adındaki karakter sayısını sınırlamak istiyoruz böylece çirkin görünmeyecek. Bir kullanıcı adını doğrulamak için aşağıdaki düzenli ifadeyi kullanıyoruz:
+Bir düzenli ifade soldan sağa söz konusu harf öbekleriyle eşleşen bir desendir.
+"Regular expression" söylemesi zor bir tabir olduğundan dolayı, genellikle
+"regex" ya da "regexp" olarak kısaltılmış olarak bulacaksınız. Düzenli ifade bir
+harf öbeğinde ki bir metin değiştirmek, form doğrulamak, bir desen eşleşmesine
+dayalı harf öbeğinden bir alt harf öbeği ayıklamak ve çok daha fazlası için
+kullanılır.
+
+Bir uygulama yazdığınızı hayal edin ve bir kullanıcı adını seçtiğinde, bu
+kullanıcı adı için kurallar belirlemek istiyorsunuz. Kullanıcı adının harfler,
+sayılar, altçizgiler ve tireler içermesine izin vermek, ayrıca, kullanıcı
+adındaki karakter sayısını sınırlamak istiyorsunuz, böylece çirkin görünmeyecek.
+Böyle durumlarda kullanıcı adını doğrulamak için aşağıdaki düzenli ifadeyi
+kullanıyoruz:
 
 <br/><br/>
 <p align="center">
@@ -85,7 +95,10 @@ Bir düzenli ifade bir metin içinde arama yapabilmek için kullandığımız bi
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/dmRygT/1)
 
-`123` düzenli ifadesi `123` harf öbeğiyle eşleşir. Düzenli ifade birbiri ardına, girilen harf öbeğindeki her karakter düzenli ifadenin içindeki her karakterle karşılaştırılarak eşleştirilir. Düzenli ifadeler normal olarak büyük/küçük harfe duyarlıdırlar, yani `The` düzenli ifadesi `the` harf öbeğiyle eşleşmez.
+`123` düzenli ifadesi `123` harf öbeğiyle eşleşir. Düzenli ifade birbiri ardına,
+girilen harf öbeğindeki her karakter düzenli ifadenin içindeki her karakterle
+karşılaştırılarak eşleştirilir. Düzenli ifadeler normal olarak büyük/küçük harfe
+duyarlıdırlar, yani `The` düzenli ifadesi `the` harf öbeğiyle eşleşmez.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -95,29 +108,33 @@ Bir düzenli ifade bir metin içinde arama yapabilmek için kullandığımız bi
 
 ## 2. Meta Karakterler
 
-Meta karakterler düzenli ifadelerin yapı taşlarıdırlar. Meta karakterler kendileri için değil bunun yerine bazı özel yollarla yorumlanırlar. Bazı meta karakterler özel anlamları vardır ve bunlar köşeli parantez içinde yazılırlar.
+Meta karakterler düzenli ifadelerin yapı taşlarıdırlar. Meta karakterler
+kendileri için değil bunun yerine bazı özel yollarla yorumlanırlar. Bazı meta
+karakterler özel anlamları vardır ve bunlar köşeli parantez içinde yazılırlar.
 
 Meta karakterler aşağıdaki gibidir:
 
 |Meta karakter|Açıklama|
 |:----:|----|
-|.|Satır sonuc hariç herhangi bir karakterle eşleşir.|
+|.|Satır sonuç hariç herhangi bir karakterle eşleşir.|
 |[ ]|Köşeli parantezler arasında bulunan herhangi bir karakterle eşleşir.|
 |[^ ]|Köşeli parantez içerisinde yer alan `^` işaretinden sonra girilen karakterler haricindeki karakterlerle eşleşir.|
 |*|Kendisinden önce yazılan karakterin sıfır veya daha fazla tekrarı ile eşleşir.|
-|+|Kendisinden önce yazılan karakterin bir veya daha fazla tekrarı ile eşleşir.|
+|+|Kendisinden önce yazılan karakterin bir veya daha fazla olan tekrarı ile eşleşir.|
 |?|Kendisinden önce yazılan karakterin varlık durumunu opsiyonel kılar.|
 |{n,m}|Kendisinden önce yazılan karakterin en az `n` en fazla `m` değeri kadar olmasını ifade eder.|
 |(xyz)|Verilen sırayla `xyz` karakterleriyle eşleşir.|
-|||`|` karakterinden önce veya sonra verilen ifadelerin herhangi biriyle eşleşir. Or anlamı verir.|
-|\|Sonraki karakteri kaçırır. Bu, ayrılmış karakterleri eşleştirmenizi sağlar <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+||| Karakterden önce veya sonra verilen ifadelerin herhangi biriyle eşleşebilir. İfadeye Yada anlamı katar.|
+|\|<code>[ ] ( ) { } . * + ? ^ $ \ |</code> özel karakterin aranmasını sağlar.|
 |^|Girilen verinin başlangıcını ifade eder.|
-|$|Girilen veririnin sonunu ifade eder.|
+|$|Girilen verinin sonunu ifade eder.|
 
 ## 2.1 Nokta
 
-Nokta `.` meta karakterin en basit örneğidir. `.` meta karakteri satır başlangıcı hariç herhangi bir karakterle eşleşir.
-Örneğin, `.ar` düzenli ifadesinin anlamı: herhangi bir karakterin ardından `a` harfi ve `r` harfi gelir.
+Nokta `.` meta karakterlerin en basit örneğidir. `.` meta karakteri satır
+başlangıcı hariç herhangi bir karakterle eşleşir. Örneğin, `.ar` düzenli
+ifadesinin anlamı: herhangi bir karakterin ardından `a` harfi ve `r` harfi
+gelir.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -127,10 +144,13 @@ Nokta `.` meta karakterin en basit örneğidir. `.` meta karakteri satır başla
 
 ## 2.2 Karakter Takımı
 
-Karakter takımları aryıca Karakter sınıfı olarak bilinir. Karakter takımlarını belirtmek için köşeli ayraçlar kullanılır.
-Karakterin aralığını belirtmek için bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının sıralaması önemli değildir. 
+Karakter takımları aryıca Karakter sınıfı olarak bilinir. Karakter takımlarını
+belirtmek için köşeli ayraçlar kullanılır. Karakterin aralığını belirtmek için
+bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının
+sıralaması önemli değildir.
 
-Örneğin, `[Tt]he` düzenli ifadesinin anlamı: bir büyük `T` veya küçük `t` harflerinin ardından sırasıyla `h` ve `e` harfi gelir.
+Örneğin, `[Tt]he` düzenli ifadesinin anlamı: bir büyük `T` veya küçük `t`
+harflerinin ardından sırasıyla `h` ve `e` harfi gelir.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -138,9 +158,11 @@ Karakterin aralığını belirtmek için bir karakter takımında tire kullanın
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/2ITLQ4/1)
 
-Bununla birlikte, bir karakter takımı içerisindeki bir periyot bir tam periyot demektir.
+Bununla birlikte, bir karakter takımı içerisindeki bir periyot bir tam periyot
+demektir.
 
-`ar[.]` düzenli ifadesinin anlamı: Küçük `a` karakteri ardından `r` harfi gelir, ardından bir `.` karakteri gelir.
+`ar[.]` düzenli ifadesinin anlamı: Küçük `a` karakteri ardından `r` harfi gelir,
+ardından bir `.` karakteri gelir.
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -150,9 +172,11 @@ Bununla birlikte, bir karakter takımı içerisindeki bir periyot bir tam periyo
 
 ### 2.2.1 Negatiflenmiş karakter seti
 
-Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, ama köşeli parantez içinde kullanıldığında verilen karakter takımını hariç tutar.
+Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, ama köşeli
+parantez içinde kullanıldığında verilen karakter takımını hariç tutar.
 
-Örneğin, `[^c]ar` ifadesinin anlamı: `c` harfinden hariç herhangi bir harfin ardından `a`, ardından `r` gelir.
+Örneğin, `[^c]ar` ifadesinin anlamı: `c` harfinden hariç herhangi bir harfin
+ardından `a`, ardından `r` gelir.
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -162,14 +186,19 @@ Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, am
 
 ## 2.3 Tekrarlar
 
-`+`, `*` ya da `?` meta karakterlerinden sonra bir alt desenin kaç defa tekrar edebileceğini belirtmek için kullanılır. Bu meta karakterler farklı durumlarda farklı davranırlar.
+`+`, `*` ya da `?` meta karakterlerinden sonra bir alt desenin kaç defa tekrar
+edebileceğini belirtmek için kullanılır. Bu meta karakterler farklı durumlarda
+farklı davranırlar.
 
 ### 2.3.1 Yıldız İşareti
 
-`*` sembolü, kendinden önce girilen eşlemenin sıfır veya daha fazla tekrarıyla eşleşir. Ama bir karakter seti ya da sınıf sonrasına girildiğinde, tüm karakter setinin tekrarlarını bulur.
+`*` sembolü, kendinden önce girilen eşlemenin sıfır veya daha fazla tekrarıyla
+eşleşir. Ama bir karakter seti ya da sınıf sonrasına girildiğinde, tüm karakter
+setinin tekrarlarını bulur.
 
-`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla tekrarı. 
-`[a-z]*` düzenli ifadesinin anlamı: bir satırdaki herhangi bir sayıdaki küçük harfler.
+`a*` düzenli ifadesinin anlamı: `a` karakterinin sıfır veya daha fazla
+tekrarları, `[a-z]*` düzenli ifadesinin anlamı ise bir satırdaki herhangi bir
+sayıdaki küçük harfler anlamına gelir.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -177,9 +206,13 @@ Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, am
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/7m8me5/1)
 
-`*` sembolü `.` meta karakteri ile `.*` karakterinin herhangi harf öbeğine eşleştirmek için kullanılabilir. `*` sembolü boşluk karakteriyle `\s` bir harf öbeğinde boşluk karakterlerini eşleştirmek için kullanılabilir.
+`*` sembolü `.` meta karakteri ile `.*` karakterinin herhangi harf öbeğine
+eşleştirmek için kullanılabilir. `*` sembolü boşluk karakteriyle `\s` bir harf
+öbeğinde boşluk karakterlerini eşleştirmek için kullanılabilir.
 
-Örneğin, `\s*cat\s*` düzenli ifadesinin anlamı: sıfır veya daha fazla boşluk ardından küçük `c` karakteri gelir, ardından küçük `a` karakteri gelir, ardından küçük `t` karakteri gelir, ardından sıfır veya daha fazla boşluk gelir.
+Örneğin, `\s*cat\s*` düzenli ifadesinin anlamı: sıfır veya daha fazla boşluk
+ardından küçük `c` karakteri gelir, ardından küçük `a` karakteri gelir, ardından
+küçük `t` karakteri gelir, ardından sıfır veya daha fazla boşluk gelir.
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
@@ -189,10 +222,13 @@ Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, am
 
 ### 2.3.2 Artı İşareti
 
-`+` sembolü, kendinden önce girilen eşlemenin bir veya daha fazla tekrarıyla eşleşir.
+`+` sembolü, kendinden önce girilen eşlemenin bir veya daha fazla tekrarıyla
+eşleşir.
 
-Örneğin, `c.+t` ifadesinin anlamı: küçük `c` harfi, ardından en az bir karakter gelir, ardından küçük `t` karakteri gelir.
-Örnekte açıklamak gereken önemli nokta: `t` harfi cümledeki son `t` harfi olacaktır. `c` ve `t` harfi arasında en az bir karakter vardır.
+Örneğin, `c.+t` ifadesinin anlamı: küçük `c` harfi, ardından en az bir karakter
+gelir, ardından küçük `t` karakteri gelir. Örnekte açıklamak gereken önemli
+nokta: `t` harfi cümledeki son `t` harfi olacaktır. `c` ve `t` harfi arasında en
+az bir karakter vardır.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -202,9 +238,12 @@ Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, am
 
 ### 2.3.3 Soru İşareti
 
-Düzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel olarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örbeğiyle eşleşir.
+Düzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel
+olarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örbeğiyle
+eşleşir.
 
-Örneğin, `[T]?he` ifadesinin anlamı: opsiyonel büyük `T` harfi, ardından küçük `h` karakteri gelir, ardından küçük `e` karakteri gelir.
+Örneğin, `[T]?he` ifadesinin anlamı: opsiyonel büyük `T` harfi, ardından küçük
+`h` karakteri gelir, ardından küçük `e` karakteri gelir.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -220,9 +259,12 @@ Düzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel ola
 
 ## 2.4 Süslü Parantez
 
-Düzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler, bir karakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için kullanılırlar.
+Düzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler, bir
+karakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için
+kullanılırlar.
 
-Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 0 aralığındaki karakterlerden, en az 2 en fazla 3 defa ile eşleş.
+Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 0 aralığındaki karakterlerden, en
+az 2 en fazla 3 defa ile eşleş.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -249,13 +291,18 @@ Düzenli ifadeden virgülü kaldırırsak `[0-9]{3}`: doğrudan 3 defa eşleşir
 
 ## 2.5 Karakter Grubu
 
-Karakter grubu parantezler içine yazılmış alt desenler grubudur. Daha önce tasarım deseninde değindiğimiz gibi, bir karakterden önce bir miktar belirleyici koyarsak önceki karakteri tekrar eder. Fakat miktar belirleyiciyi bir karakter grubundan sonra koyarsak tüm karakter grubunu tekrarlar.
+Karakter grubu parantezler içine yazılmış alt desenler grubudur. Daha önce
+tasarım deseninde değindiğimiz gibi, bir karakterden önce bir miktar belirleyici
+koyarsak önceki karakteri tekrar eder. Fakat miktar belirleyiciyi bir karakter
+grubundan sonra koyarsak tüm karakter grubunu tekrarlar.
 
-Örneğin: `(ab)*` düzenli ifadesi "ab" karakterinin sıfır veya daha fazla tekrarıyla eşleşir.
+Örneğin: `(ab)*` düzenli ifadesi "ab" karakterinin sıfır veya daha fazla
+tekrarıyla eşleşir.
 
 Ayrıca karakter grubu içinde `|` meta karakterini kullanabiliriz.
 
-Örneğin, `(c|g|p)ar` düzenli ifadesinin anlamı: küçük `c`, `g` veya `p` karakteri, ardından `a` karakteri, ardından `r` karakteri gelir.
+Örneğin, `(c|g|p)ar` düzenli ifadesinin anlamı: küçük `c`, `g` veya `p`
+karakteri, ardından `a` karakteri, ardından `r` karakteri gelir.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -265,9 +312,15 @@ Ayrıca karakter grubu içinde `|` meta karakterini kullanabiliriz.
 
 ## 2.6 Değişim
 
-Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için kullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an, karakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor olabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter grubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır. 
+Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için
+kullanılır. Alternasyon birden fazla ifade arasındaki bir koşul gibidir. Şu an,
+karakter grubu ve alternasyonun aynı şekilde çalıştığını düşünüyor
+olabilirsiniz. Ama, Karakter grubu ve alternasyon arasındaki büyük fark karakter
+grubu karakter düzeyinde çalışır ama alternasyon ifade düzeyinde çalışır.
 
-Örneğin, `(T|t)he|car` düzenli ifadesinin anlamı: Büyük `T` ya da küçük `t` karakteri, ardından küçük `h` karakteri, ardından küçük `e` ya da `c` karakteri, ardından küçük `a`, ardından küçük `r` karakteri gelir.
+Örneğin, `(T|t)he|car` düzenli ifadesinin anlamı: Büyük `T` ya da küçük `t`
+karakteri, ardından küçük `h` karakteri, ardından küçük `e` ya da `c` karakteri,
+ardından küçük `a`, ardından küçük `r` karakteri gelir.
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -277,12 +330,19 @@ Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak içi
 
 ## 2.7 Özel Karakter Hariç Tutma
 
-`\` işareti sonraki karakteri hariç tutmak için kullanılır. Bu bir semboülü ayrılmış karakterlerde `{ } [ ] / \ + * . $ ^ | ?` dahil olmak üzere eşleşen bir karakter olarak belirtmemizi sağlar. Bir özel karakteri eşleşen bir karakter olarak kullanmak için önüne `\` işareti getirin.
+`\` işareti sonraki karakteri hariç tutmak için kullanılır. Bu bir semboülü
+ayrılmış karakterlerde `{ } [ ] / \ + * . $ ^ | ?` dahil olmak üzere eşleşen bir
+karakter olarak belirtmemizi sağlar. Bir özel karakteri eşleşen bir karakter
+olarak kullanmak için önüne `\` işareti getirin.
 
-Örneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek için kullanılır. 
-Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.` ayrılmış karakterini hariç tutmamız gerekir. Bunun için nokta önüne `\` işaretini koymamız gereklidir.
+Örneğin, `.` düzenli ifadesi yeni satır hariç herhangi bir karakteri eşleştirmek
+için kullanılır. Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.`
+ayrılmış karakterini hariç tutmamız gerekir. Bunun için nokta önüne `\`
+işaretini koymamız gereklidir.
 
-`(f|c|m)at\.?` düzenli ifadesinin anlamı: küçük `f`, `c`ya da `m` harfi, ardından küçük `a` harfi, ardından küçük `t` harfi, ardından opsiyonel `.` karakteri gelir.
+`(f|c|m)at\.?` düzenli ifadesinin anlamı: küçük `f`, `c`ya da `m` harfi,
+ardından küçük `a` harfi, ardından küçük `t` harfi, ardından opsiyonel `.`
+karakteri gelir.
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -292,17 +352,26 @@ Bir harf öbeği içinde nokta `.` karakterini yakalamak için `.` ayrılmış k
 
 ## 2.8 Sabitleyiciler
 
-Düzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü veya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri kullanırız. 
-Sabitleyiciler iki çeşittir: İlk çeşit eşleşen karakterin girişin ilk karakteri olup olmadığını kontrol eden şapka `^` karakteri, ve ikinci çeşit eşleşen karakterin girişin son karakteri olup olmadığını kontrol eden dolar `$` karakteridir.
+Düzenli ifadelerde, eşleşen sembolün girilen harf öbeğinin başlangıç sembolü
+veya bitiş sembolü olup olmadığını kontrol etmek için sabitleyicileri
+kullanırız. Sabitleyiciler iki çeşittir: İlk çeşit, eşleşen karakterin girişin
+ilk karakteri olup olmadığını kontrol eden şapka `^` karakteri, ikinci çeşit ise
+eşleşen karakterin girişin son karakteri olup olmadığını kontrol eden dolar `$`
+karakteridir.
 
 ### 2.8.1 Şapka İşareti
 
-Şapka `^` işareti eşleşen karakterin giriş harf öbeğinin ilk karakteri olup olmadığını kontrol etmek için kullanılır.
-Eğer `^a` düzenli ifadesini `abc` harf öbeğine uygularsak `a` ile eşleşir. Ama `^b` ifadesini uygularsak bir eşleşme bulamayız. Bunun nedeni `abc` harf öbeğinde `b` karakterinin başlangıç karakteri olmamasıdır.
+Şapka `^` işareti eşleşen karakterin giriş harf öbeğinin ilk karakteri olup
+olmadığını kontrol etmek için kullanılır. Eğer `^a` düzenli ifadesini `abc` harf
+öbeğine uygularsak `a` ile eşleşir. Ama `^b` ifadesini uygularsak bir eşleşme
+bulamayız. Bunun nedeni `abc` harf öbeğinde `b` karakterinin başlangıç karakteri
+olmamasıdır.
 
-Bir başka örnek üzerinden ilerlersek, 
+Bir başka örnek üzerinden ilerlersek,
 
-`^(T|t)he` düzenli ifadesinin anlamı: büyük `T` ya da `t` karakteri giriş harf öbeğinin ilk karakteri olmak üzere, ardından küçük `h`, ardından küçük `e` karakteri gelir.
+`^(T|t)he` düzenli ifadesinin anlamı: büyük `T` ya da `t` karakteri giriş harf
+öbeğinin ilk karakteri olmak üzere, ardından küçük `h`, ardından küçük `e`
+karakteri gelir.
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -318,9 +387,12 @@ Bir başka örnek üzerinden ilerlersek,
 
 ### 2.8.2 Dolar İşareti
 
-Dolar `$` işareti eşleşen karakterin giriş harf öbeğinin son karakteri olup olmadığını kontrol etmek için kullanılır.
+Dolar `$` işareti eşleşen karakterin giriş harf öbeğinin son karakteri olup
+olmadığını kontrol etmek için kullanılır.
 
-Örneğin, `(at\.)$` ifadesinin anlamı: küçük bir `a` karakteri, ardından küçük bir `t` karakteri, ardıdan nokta `.` karakteri gelir ve bu eşleşme harf öbeğinin sonunda olmalıdır.
+Örneğin, `(at\.)$` ifadesinin anlamı: küçük bir `a` karakteri, ardından küçük
+bir `t` karakteri, ardıdan nokta `.` karakteri gelir ve bu eşleşme harf öbeğinin
+sonunda olmalıdır.
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -336,9 +408,10 @@ Dolar `$` işareti eşleşen karakterin giriş harf öbeğinin son karakteri olu
 
 ##  3. Kısaltma Karakter Takımları
 
-Regex, yaygın olarak kullanılan düzenli ifadeler için uygun kısaltmalar sunan sık kullanılan karakter setleri için kısaltmalar sağlar.
+Regex, sık olarak kullanılan düzenli ifadeler için özel karakter setleri ve
+kısaltmalar sağlar.
 
-Kullanılan karakter setleri kısaltmaları aşağıdaki gibidir:
+Kullanılan karakter setlerinin kısaltmaları aşağıdaki gibidir:
 
 |Kısaltma|Açıklama|
 |:----:|----|
@@ -352,13 +425,16 @@ Kullanılan karakter setleri kısaltmaları aşağıdaki gibidir:
 
 ## 4. Bakınmak
 
-Bakınma sembolleri, bir ifade öncesinde veya sonrasında başka bir ifademiz olduğunda kullanılırlar.
+Bakınma sembolleri, bir ifade öncesinde veya sonrasında başka bir ifademiz
+olduğunda kullanılırlar.
 
-Örneğin, `$4.44 ve $10.88` girişlerinden `$` karakteri önündeki tüm sayıları almak istiyoruz, bu durumda `(?<=\$)[0-9\.]*` ifadesini kullanırız.
+Örneğin, `$4.44 ve $10.88` girişlerinden `$` karakteri önündeki tüm sayıları
+almak istiyoruz, bu durumda `(?<=\$)[0-9\.]*` ifadesini kullanırız.
 
-`(?<=\$)[0-9\.]*` ifadesinin anlamı: `.` karakterini içeren ve `$` karakteriyle devam eden tüm sayıları al.
+`(?<=\$)[0-9\.]*` ifadesinin anlamı: `.` karakterini içeren ve `$` karakteriyle
+devam eden tüm sayıları al demektir.
 
-Düzenli ifadelerde kullanılan bakınma sembolleri aşağıdadır:
+Düzenli ifadelerde kullanılan bakınma sembolleri aşadaki gibidir:
 
 |Sembol|Açıklama|
 |:----:|----|
@@ -369,9 +445,16 @@ Düzenli ifadelerde kullanılan bakınma sembolleri aşağıdadır:
 
 ### 4.1 Positive Lookahead
 
-Positive Lookahead, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi gerektiğini savunur. Bulunan eşleşme yalnızca ifadenin ilk bölümüyle eşleşen metin içerir. Olumlu bir bakınma tanımlamak için, içinde eşittir işareti yer alan parantezler `(?=...)` şeklinde kullanılır. Bakınma ifadesi parantezler içinde eşittir işaretinden sonra yazılır.
+Positive Lookahead, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi
+gerektiğini savunur. Bulunan eşleşme yalnızca ifadenin ilk bölümüyle eşleşen
+metin içerir. Olumlu bir bakınma tanımlamak için, içinde eşittir işareti yer
+alan parantezler `(?=...)` şeklinde kullanılır. Bakınma ifadesi parantezler
+içinde eşittir işaretinden sonra yazılır.
 
-Örneğin, `[T|t]he(?=\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T` harfi, ardından `h` harfi gelir, ardından `e` harfi gelir. Parantez içinde ise bu dizilimin bir boşluk karakterinden sonra `fat` öbeğiyle devam edeceğini tanımlıyoruz.
+Örneğin, `[T|t]he(?=\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da
+büyük `T` harfi, ardından `h` harfi gelir, ardından `e` harfi gelir. Parantez
+içinde ise bu dizilimin bir boşluk karakterinden sonra `fat` öbeğiyle devam
+edeceğini tanımlıyoruz.
 
 <pre>
 "[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -381,9 +464,13 @@ Positive Lookahead, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi gere
 
 ### 4.2 Negative Lookahead
 
-Negative Lookahead sembolü positive lookahead tersine, verdiğimiz desenle devam etmemesi durumunda eşleşir. Bu sembol positive lookahead gibi tanımlanır ama `=` işareti yerine `!` kullanılır.
+Negative Lookahead sembolü positive lookahead tersine, verdiğimiz desenle devam
+etmemesi durumunda eşleşir. Bu sembol positive lookahead gibi tanımlanır ama `=`
+işareti yerine `!` kullanılır.
 
-`[T|t]he(?!\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T` harfi, ardından `h` harfi gelir, ardından `e` harfi gelir, ardından öncesinde boşluk olan bir `fat` öbeği olmamalıdır.
+`[T|t]he(?!\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T`
+harfi, ardından `h` harfi gelir, ardından `e` harfi gelir, ardından öncesinde
+boşluk olan bir `fat` öbeği olmamalıdır.
 
 
 <pre>
@@ -394,9 +481,11 @@ Negative Lookahead sembolü positive lookahead tersine, verdiğimiz desenle deva
 
 ### 4.3 Positive Lookbehind
 
-Positive Lookbehind, belirli bir desenden önceki eşleşmeleri almak için kullanılır. `(?<=...)` ile gösterilir.
+Positive Lookbehind, belirli bir desenden önceki eşleşmeleri almak için
+kullanılır. `(?<=...)` ile gösterilir.
 
-Örneğin, `(?<=[T|t]he\s)(fat|mat)` ifadesinin anlamı: Öncesinde `The` veya `the` öbekleri olan tüm `fat` veya `mat` öbeklerini getir.
+Örneğin, `(?<=[T|t]he\s)(fat|mat)` ifadesinin anlamı: Öncesinde `The` veya `the`
+öbekleri olan tüm `fat` veya `mat` öbeklerini getir.
 
 <pre>
 "(?<=[T|t]he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -406,9 +495,11 @@ Positive Lookbehind, belirli bir desenden önceki eşleşmeleri almak için kull
 
 ### 4.4 Negative Lookbehind
 
-Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak için kullanılır. `(?<=!..)` ile gösterilir.
+Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak için
+kullanılır. `(?<=!..)` ile gösterilir.
 
-Örneğin, `(?<!(T|t)he\s)(cat)` ifadesinin anlamı: Öncesinde `The` veya `the` öbekleri yer almayan tüm `cat` öbeklerini getir.
+Örneğin, `(?<!(T|t)he\s)(cat)` ifadesinin anlamı: Öncesinde `The` veya `the`
+öbekleri yer almayan tüm `cat` öbeklerini getir.
 
 <pre>
 "(?<![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -418,7 +509,10 @@ Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak içi
 
 ## 5. İşaretler
 
-İşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü onlar bir düzenli ifadenin çıktısını düzenlerler. Bu işaretler herhangi bir sırada veya kombinasyonda kullanılabilirler, ve bunlar Düzenli İfadelerin ayrılmaz bir parçasıdırlar.
+İşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü onlar bir düzenli
+ifadenin çıktısını düzenlerler. Bu işaretler herhangi bir sırada veya
+kombinasyonda kullanılabilirler, ve bunlar Düzenli İfadelerin ayrılmaz bir
+parçasıdırlar.
 
 |İşaret|Açıklama|
 |:----:|----|
@@ -428,9 +522,13 @@ Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak içi
 
 ### 5.1 Büyük/Küçük harf duyarlılığı
 
-`ì` işaretleyicisi büyük/küçük harfe duyarsız eşleştirme yapmak için kullanılır.
+`i` işaretleyicisi büyük/küçük harfe duyarsız eşleştirme yapmak için kullanılır.
 
-Örneğin, `/The/gi` ifadesi: büyük `T` harfi, ardından küçük `h` harfi, ardından küçük `e` harfi gelir. ifadenin sonunda yer alan `i` işareti büyük-küçük harfe karşı duyarsız olması gerektiğini belirtir. Ayrıca `g` işaretinide kullandığımızı görebilirsiniz, tüm text içinde bu aramayı yapmak istediğimiz için `g` işaretini ayrıca belirtiyoruz.
+Örneğin, `/The/gi` ifadesi: büyük `T` harfi, ardından küçük `h` harfi, ardından
+küçük `e` harfi gelir. ifadenin sonunda yer alan `i` işareti büyük-küçük harfe
+karşı duyarsız olması gerektiğini belirtir. Ayrıca `g` işaretinide
+kullandığımızı görebilirsiniz, tüm text içinde bu aramayı yapmak istediğimiz
+için `g` işaretini ayrıca belirtiyoruz.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -446,7 +544,8 @@ Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak içi
 
 ### 5.2 Genel Arama
 
-`g` işareti bir giriş içinde eşleşen tüm varsayonları bulmak için kullanılır. `g` işareti kullanılmazsa ilk eşleşme bulunduktan sonra arama sona erer.
+`g` işareti bir giriş içinde eşleşen tüm varsayonları bulmak için kullanılır.
+`g` işareti kullanılmazsa ilk eşleşme bulunduktan sonra arama sona erer.
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -462,9 +561,15 @@ Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak içi
 
 ### 5.3 Çok Satırlı
 
-`m` işareti çok satırlı bir eşleşme sağlamak için kullanılır. Daha önce sabitleyicilerde gördüğümüz gibi `(^, $)` sembolleri aradığımız desenin harf öbeğinin başında veya sonunda olup olmadığını kontrol etmemiz için kullanılır. Bu sabitleyicilerin tüm satırlarda çalışması için `m` işaretini kullanırız.
+`m` işareti çok satırlı bir eşleşme bulmak için kullanılır. Daha önce
+sabitleyicilerde gördüğümüz gibi `(^, $)` sembolleri aradığımız desenin harf
+öbeğinin başında veya sonunda olup olmadığını kontrol etmemiz için kullanılır.
+Bu sabitleyicilerin tüm satırlarda çalışması için `m` işaretini kullanırız.
 
-Örneğin, `/at(.)?$/gm` ifadesinin anlamı: küçük `a` harfi, ardından küçük `t` harfi gelir, ardından opsiyonel olarak yeni satır hariç herhangi birşey gelebilir. `m` işaretini kullandığımız için bir girişin her satırının sonunda eşleştirir.
+Örneğin, `/at(.)?$/gm` ifadesinin anlamı: küçük `a` harfi, ardından küçük `t`
+harfi gelir, ardından opsiyonel olarak yeni satır hariç herhangi birşey
+gelebilir. `m` işaretini kullandığımız için bir girişin her satırının sonunda
+eşleştirir.
 
 <pre>
 "/.at(.)?$/" => The fat

From 0435c394dccd8dbd230559f9ea2443781ab73b4a Mon Sep 17 00:00:00 2001
From: guiemi <guiemi.teixeira@gmail.com>
Date: Fri, 8 Feb 2019 16:22:00 -0200
Subject: [PATCH 067/185] =?UTF-8?q?Corrige=20a=20ocorr=C3=AAncia=20de=20cr?=
 =?UTF-8?q?ases=20no=20texto.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

(EN) Fixes some grammar mistakes related to the crase.
---
 translations/README-pt_BR.md | 41 ++++++++++++++++++------------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 7fecb53f..a8e2f61d 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -33,11 +33,12 @@
 
 > Expressão Regular é um grupo de caracteres ou símbolos utilizado para encontrar um padrão específico a partir de um texto.
 
-Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. A expressão "Expressão regular" é longa e difícil de falar, você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
+Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. A expressão "Expressão regular" é longa e difícil de falar; você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
 
 Imagine que você está escrevendo uma aplicação e quer colocar regras para quando um usuário escolher seu username. Nós queremos permitir que o username contenha letras, números, underlines e hífens. Nós também queremos limitar o número de caracteres para não ficar muito feio. Então usamos a seguinte expressão regular para validar o username:
 
 <br/><br/>
+
 <p align="center">
 <img src="http://i.imgur.com/8UaOzpq.png" alt="Regular expression">
 </p>
@@ -83,7 +84,7 @@ Uma expressão regular é apenas um padrão de caracteres que usamos para fazer
 
 [Teste a RegExp](https://regex101.com/r/dmRygT/1)
 
-A expressão regular `123` corresponde a 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 à maiúsculas), então a expressão regular `The` não vai bater com a string `the`.
+A expressão regular `123` corresponde à string `123`. A expressão regular é comparada com uma string de entrada, comparando cada caractere da expressão regular para cada caractere da string de entrada, um após o outro. Expressões regulares são normalmente case-sensitive (sensíveis a maiúsculas), então a expressão regular `The` não vai bater com a string `the`.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -101,19 +102,19 @@ Os metacaracteres são os seguintes:
 |.|Corresponde a qualquer caractere, exceto uma quebra de linha|
 |[ ]|Classe de caracteres. Corresponde a qualquer caractere contido dentro dos colchetes.|
 |[^ ]|Classe de caracteres negada. Corresponde a qualquer caractere que não está contido dentro dos colchetes.|
-|*|Corresponde à 0 ou mais repetições do símbolo anterior.|
-|+|Corresponde à 1 ou mais repetições do símbolo anterior.|
+|*|Corresponde a 0 ou mais repetições do símbolo anterior.|
+|+|Corresponde a 1 ou mais repetições do símbolo anterior.|
 |?|Faz com que o símbolo anterior seja opcional.|
-|{n,m}|Chaves. Corresponde à no mínimo "n" mas não mais que "m" repetições do símbolo anterior.|
+|{n,m}|Chaves. Corresponde a no mínimo "n" mas não mais que "m" repetições do símbolo anterior.|
 |(xyz)|Grupo de caracteres. Corresponde aos caracteres xyz nesta exata ordem.|
-|||Alternância. Corresponde os caracteres antes ou os caracteres depois do símbolo|
+|||Alternância. Corresponde aos caracteres antes ou os caracteres depois do símbolo|
 |\|Escapa o próximo caractere. Isso permite você utilizar os caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
 |^|Corresponde ao início da entrada.|
 |$|Corresponde ao final da entrada.|
 
 ## 2.1 Ponto final
 
-O ponto final `.` é um simples exemplo de metacaracteres. O metacaractere `.` corresponde à 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`.
+O ponto final `.` é um simples exemplo de metacaracteres. O metacaractere `.` corresponde a qualquer caractere sozinho. Ele não se iguala ao Enter e à quebra de linha. Por exemplo, a expressão regular `.ar` significa: qualquer caractere, seguido da letra `a`, seguida da letra `r`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -155,7 +156,7 @@ Seguindo os metacaracteres `+`, `*` ou `?` são utilizados para especificar quan
 
 ### 2.3.1 O Asterisco
 
-O símbolo `*` corresponde à 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.
+O símbolo `*` corresponde a zero ou mais repetições do padrão antecedente. A expressão regular `a*` significa: zero ou mais repetições do caractere minúsculo precedente `a`. Mas se o asterisco aparecer depois de um conjunto de caracteres, ou classe de caracteres, ele irá procurar as repetições de todo o conjunto. Por exemplo, a expressão regular `[a-z]*` significa: qualquer quantidade de letras minúsculas numa linha.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -173,7 +174,7 @@ O símbolo `*` pode ser usado junto do metacaractere `.` para encontrar qualquer
 
 ### 2.3.2 O Sinal de Adição
 
-O símbolo `+` corresponde à 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`.
+O símbolo `+` corresponde a uma ou mais repetições do caractere anterior. Por exemplo, a expressão regular `c.+t` significa: a letra minúscula `c`, seguida por pelo menos um caractere, seguido do caractere minúsculo `t`.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -183,7 +184,7 @@ O símbolo `+` corresponde à uma ou mais repetições do caractere anterior. Po
 
 ### 2.3.3 O Ponto de Interrogação
 
-Em expressões regulares, o metacaractere `?` faz o caractere anterior ser opcional. Esse símbolo corresponde à 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`.
+Em expressões regulares, o metacaractere `?` faz o caractere anterior ser opcional. Esse símbolo corresponde a zero ou uma ocorrência do caractere anterior. Por exemplo, a expressão regular `[T]?he` significa: A letra maiúsculo `T` opcional, seguida do caractere minúsculo `h`, seguido do caractere minúsculo `e`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -199,7 +200,7 @@ Em expressões regulares, o metacaractere `?` faz o caractere anterior ser opcio
 
 ## 2.4 Chaves
 
-Em expressões regulares, chaves, que também são chamadas de quantificadores, são utilizadas para especificar o número de vezes que o caractere, ou um grupo de caracteres, pode se repetir. Por exemplo, a expressão regular `[0-9]{2,3}` significa: Encontre no mínimo 2 dígitos, mas não mais que 3 (caracteres no intervalo de 0 à 9).
+Em expressões regulares, chaves, que também são chamadas de quantificadores, são utilizadas para especificar o número de vezes que o caractere, ou um grupo de caracteres, pode se repetir. Por exemplo, a expressão regular `[0-9]{2,3}` significa: Encontre no mínimo 2 dígitos, mas não mais que 3 (caracteres no intervalo de 0 a 9).
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -223,7 +224,7 @@ Nós podemos retirar o segundo número. Por exemplo, a expressão regular `[0-9]
 
 ## 2.5 Grupo de Caracteres
 
-Grupo de caracteres é um grupo de sub-padrão que é escrito dentro de parênteses `(...)`. Como falamos antes, se colocaramos um quantificador depois de um caractere, ele irá repetir o caractere anterior. Mas se colocarmos um quantificador depois de um grupo de caracteres, ele irá repetir todo o conjunto. Por exemplo, a expressão regular `(ab)*` corresponde à 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`.
+Grupo de caracteres é um grupo de sub-padrão que é escrito dentro de parênteses `(...)`. Como falamos antes, se colocaramos um quantificador depois de um caractere, ele irá repetir o caractere anterior. Mas se colocarmos um quantificador depois de um grupo de caracteres, ele irá repetir todo o conjunto. Por exemplo, a expressão regular `(ab)*` corresponde a zero ou mais repetições dos caracteres "ab". Nós também podemos usar o metacaractere de alternância `|` dentro de um grupo de caracteres. Por exemplo, a expressão regular `(c|g|p)ar` significa: caractere minúsculo `c`, `g` ou `p`, seguido do caractere `a`, seguido do caractere `r`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -294,16 +295,16 @@ As expressões regulares fornecem abreviações para conjuntos de caracteres com
 |Abreviação|Descrição|
 |:----:|----|
 |.|Qualquer caractere, exceto nova linha|
-|\w|Corresponde à caracteres alfanuméricos: `[a-zA-Z0-9_]`|
-|\W|Corresponde à caracteres não alfanuméricos: `[^\w]`|
-|\d|Corresponde à dígitos: `[0-9]`|
-|\D|Corresponde à não dígitos: `[^\d]`|
-|\s|Corresponde à caracteres de espaços em branco: `[\t\n\f\r\p{Z}]`|
-|\S|Corresponde à caracteres de espaços não em branco: `[^\s]`|
+|\w|Corresponde a caracteres alfanuméricos: `[a-zA-Z0-9_]`|
+|\W|Corresponde a caracteres não alfanuméricos: `[^\w]`|
+|\d|Corresponde a dígitos: `[0-9]`|
+|\D|Corresponde a não dígitos: `[^\d]`|
+|\s|Corresponde a caracteres de espaços em branco: `[\t\n\f\r\p{Z}]`|
+|\S|Corresponde a caracteres de espaços não em branco: `[^\s]`|
 
 ## 4. Olhar ao Redor
 
-Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrêncoas). 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 `$`. À seguir estão os lookarounds que são utilizados em expressões regulares:
+Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrêncoas). 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:
 
 |Símbolo|Descrição|
 |:----:|----|
@@ -362,7 +363,7 @@ Flags (sinalizadores) também são chamados de modificadores, porque eles modifi
 |g|Busca global: Procura o padrão em toda a string de entrada.|
 |m|Multilinhas: Os metacaracteres de âncora funcionam em cada linha.|
 
-### 5.1 Indiferente à Maiúsculas
+### 5.1 Indiferente a Maiúsculas
 
 O modificador `i` é usado para tornar o padrão case-insensitive. Por exemplo, a expressão regular `/The/gi` significa: a letra maiúscula `T`, seguida do caractere minúsculo `h`, seguido do caractere `e`. E ao final da expressão regular, a flag `i` diz ao motor de expressões regulares para ignorar maiúsculas e minúsculas. Como você pode ver, nós também determinamos a flag `g` porque queremos procurar o padrão em toda a string de entrada.
 

From 780edf731801af3c1520c8d8fd0bf8b66041b2cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=8A=B1=E8=A3=A4=E8=A1=A9?= <panfree23@gmail.com>
Date: Wed, 20 Mar 2019 21:59:01 +0800
Subject: [PATCH 068/185] fix CN

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 3d256c44..447f0c68 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -189,7 +189,7 @@
 `*`和表示匹配空格的符号`\s`连起来用, 如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串.
 
 <pre>
-"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
 </pre>
 
 [在线练习](https://regex101.com/r/gGrwuz/1)

From 45a211d191d7ec107dfa974794e3106bef84e836 Mon Sep 17 00:00:00 2001
From: ivothgle <ivothgle@gmail.com>
Date: Fri, 22 Mar 2019 17:32:07 +0800
Subject: [PATCH 069/185] Fix image link error

---
 translations/README-cn.md        | 2 +-
 translations/README-es.md        | 2 +-
 translations/README-fr.md        | 2 +-
 translations/README-gr.md        | 2 +-
 translations/README-hu.md        | 2 +-
 translations/README-ja.md        | 2 +-
 translations/README-ko.md        | 2 +-
 translations/README-pl.md        | 2 +-
 translations/README-tr.md        | 2 +-
 translations/README-zh-simple.md | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 447f0c68..fd0b9137 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -43,7 +43,7 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-cn.png" alt="Regular expression">
+  <img src="../img/regexp-cn.png" alt="Regular expression">
 </p>
 
 以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.
diff --git a/translations/README-es.md b/translations/README-es.md
index 233e39ae..f059dc62 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -39,7 +39,7 @@ Imagina que estás escribiendo una aplicación y quieres agregar reglas para cua
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-es.png" alt="Expresión regular">
+  <img src="../img/regexp-es.png" alt="Expresión regular">
 </p>
 
 La expresión regular anterior puede aceptar las cadenas `john_doe`, `jo-hn_doe` y `john12_as`. Sin embargo, la expresión no coincide con el nombre de usuario `Jo` porque es una cadena de caracteres que contiene letras mayúsculas y es demasiado corta.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index 46f62391..66caacc8 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -42,7 +42,7 @@ le pseudonyme à contenir des lettres, des nombres, des underscores et des trait
 de caractères dans le pseudonyme pour qu'il n'ait pas l'air moche. Nous utilisons l'expression régulière suivante pour valider un pseudonyme:
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-fr.png" alt="Expressions régulières">
+  <img src="../img/regexp-fr.png" alt="Expressions régulières">
 </p>
 
 L'expression régulière ci-dessus peut accepter les chaines de caractères (string) `john_doe`, `jo-hn_doe` et `john12_as`. Ça ne fonctionne pas avec `Jo` car cette chaine de caractères (string) contient une lettre majuscule et elle est trop courte.
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 00411898..42c133bc 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -47,7 +47,7 @@ string με βάση κάποιου μοτίβου αναζήτησης και 
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
 Η παραπάνω κανονική έκφραση θα δεχτεί ως σωστά τα ονόματα χρήστη `john_doe`, `jo-hn_doe` και
diff --git a/translations/README-hu.md b/translations/README-hu.md
index 48253c44..cc433678 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -47,7 +47,7 @@ használjuk:
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-hu.png" alt="Regular expression">
+  <img src="../img/regexp-hu.png" alt="Regular expression">
 </p>
 
 A feljebbi reguláris kifejezés elfogadja a `john_doe`, `jo-hn_doe` és a
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 5657daba..4675635d 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -45,7 +45,7 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
 この正規表現によって `john_doe, jo-hn_doe, john12_as` などは許容されることになります。
diff --git a/translations/README-ko.md b/translations/README-ko.md
index 19527422..d75a5c5f 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -39,7 +39,7 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
 위의 정규 표현식은 `john_doe`, `jo-hn_doe`, 그리고 `john12_as` 문자열을 받아들일 수 있다. `Jo`는 대문자를 포함하고 있고 길이가 너무 짧기 때문에 위의 정규표현식과 매칭되지 않는다.
diff --git a/translations/README-pl.md b/translations/README-pl.md
index 5a0ebda1..f9104d55 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -48,7 +48,7 @@ regularne, aby sprawdzić poprawność nazwy:
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-pl.png" alt="Wyrażenie regularne">
+  <img src="../img/regexp-pl.png" alt="Wyrażenie regularne">
 </p>
 
 Powyższe wyrażenie akceptuje łańcuchy `john_doe`, `jo-hn_doe`
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 47472e6e..cc218776 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -49,7 +49,7 @@ kullanıyoruz:
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-tr.png" alt="Regular expression">
+  <img src="../img/regexp-tr.png" alt="Regular expression">
 </p>
 
 Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri kabul edebilir.
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 60652cef..4f60eccc 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -42,7 +42,7 @@
 
 <br/><br/>
 <p align="center">
-<img src="01.png" alt="Regular expression">
+  <img src="../img/regexp-cn.png" alt="Regular expression">
 </p>
 
 以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.

From 7c06620b6369439570c7fae88ef6156773f6aa0d Mon Sep 17 00:00:00 2001
From: ParadoxZW <964730078@qq.com>
Date: Sun, 7 Apr 2019 15:36:13 +0800
Subject: [PATCH 070/185] fix some improper statement in cn-translation

---
 translations/README-cn.md | 60 +++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index fd0b9137..0513841f 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -59,7 +59,7 @@
 		* [2.2.1 否定字符集](#221-否定字符集)
 	* [2.3 重复次数](#23-重复次数)
 		* [2.3.1 * 号](#231--号)
-		* [2.3.2   号](#232--号)
+		* [2.3.2 + 号](#232--号)
 		* [2.3.3 ? 号](#233--号)
 	* [2.4 {} 号](#24--号)
 	* [2.5 (...) 特征标群](#25--特征标群)
@@ -69,11 +69,11 @@
 		* [2.8.1 ^ 号](#281--号)
 		* [2.8.2 $ 号](#282--号)
 * [3. 简写字符集](#3-简写字符集)
-* [4. 前后关联约束(前后预查)](#4-前后关联约束前后预查)
-	* [4.1 ?=... 前置约束(存在)](#41--前置约束存在)
-	* [4.2 ?!... 前置约束-排除](#42--前置约束-排除)
-	* [4.3 ?<= ... 后置约束-存在](#43---后置约束-存在)
-	* [4.4 ?<!... 后置约束-排除](#44--后置约束-排除)
+* [4. 零宽度断言(前后预查)](#4-零宽度断言前后预查)
+	* [4.1 ?=... 正先行断言](#41--正先行断言)
+	* [4.2 ?!... 负先行断言](#42--负先行断言)
+	* [4.3 ?<= ... 正后发断言](#43---正后发断言)
+	* [4.4 ?<!... 负后发断言](#44--负后发断言)
 * [5. 标志](#5-标志)
 	* [5.1 忽略大小写 (Case Insensitive)](#51-忽略大小写-case-insensitive)
 	* [5.2 全局搜索 (Global search)](#52-全局搜索-global-search)
@@ -349,32 +349,32 @@
 |\v|匹配一个垂直制表符|
 |\p|匹配 CR/LF (等同于 `\r\n`)，用来匹配 DOS 行终止符|
 
-## 4. 前后关联约束(前后预查)
+## 4. 零宽度断言(前后预查)
 
-前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式).
-前置约束用于判断所匹配的格式是否在另一个确定的格式之后.
+先行断言和后发断言都属于**非捕获簇**(不捕获文本 ，也不针对组合计进行计数).
+先行断言用于判断所匹配的格式是否在另一个确定的格式之前, 匹配结果不包含该确定格式(仅作为约束).
 
-例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`.
+例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正后发断言 `(?<=\$)[0-9\.]*`.
 这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次.
 
-前后关联约束如下:
+零宽度断言如下:
 
 |符号|描述|
 |:----:|----|
-|?=|前置约束-存在|
-|?!|前置约束-排除|
-|?<=|后置约束-存在|
-|?<!|后置约束-排除|
+|?=|正先行断言-存在|
+|?!|负先行断言-排除|
+|?<=|正后发断言-存在|
+|?<!|负后发断言-排除|
 
-### 4.1 `?=...` 前置约束(存在)
+### 4.1 `?=...` 正先行断言
 
-`?=...` 前置约束(存在), 表示第一部分表达式必须跟在 `?=...`定义的表达式之后.
+`?=...` 正先行断言, 表示第一部分表达式之后必须跟着 `?=...`定义的表达式.
 
-返回结果只满足第一部分表达式.
-定义一个前置约束(存在)要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
+返回结果只包含满足匹配条件的第一部分表达式.
+定义一个正先行断言要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
 
-前置约束的内容写在括号中的等号后面.
-例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了前置约束(存在) `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
+正先行断言的内容写在括号中的等号后面.
+例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了正先行断言 `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -382,10 +382,10 @@
 
 [在线练习](https://regex101.com/r/IDDARt/1)
 
-### 4.2 `?!...` 前置约束-排除
+### 4.2 `?!...` 负先行断言
 
-前置约束-排除 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着定义的格式
-`前置约束-排除`  定义和 `前置约束(存在)` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
+负先行断言 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着断言中定义的格式.
+`正先行断言`  定义和 `负先行断言` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
 
 表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
 
@@ -395,9 +395,9 @@
 
 [在线练习](https://regex101.com/r/V32Npg/1)
 
-### 4.3 `?<= ...` 后置约束-存在
+### 4.3 `?<= ...` 正后发断言
 
-后置约束-存在 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着定义的格式.
+正后发断言 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着断言中定义的格式.
 例如, 表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
 
 <pre>
@@ -406,9 +406,9 @@
 
 [在线练习](https://regex101.com/r/avH165/1)
 
-### 4.4 `?<!...` 后置约束-排除
+### 4.4 `?<!...` 负后发断言
 
-后置约束-排除 记作 `(?<!...)` 用于筛选所有匹配结果, 筛选条件为 其前不跟着定义的格式.
+负后发断言 记作 `(?<!...)` 用于筛选所有匹配结果, 筛选条件为 其前不跟随着断言中定义的格式.
 例如, 表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`, 且其前不跟着 `The` 或 `the`.
 
 <pre>
@@ -419,7 +419,7 @@
 
 ## 5. 标志
 
-标志也叫修饰语, 因为它可以用来修改表达式的搜索结果.
+标志也叫模式修正符, 因为它可以用来修改表达式的搜索结果.
 这些标志可以任意的组合使用, 它也是整个正则表达式的一部分.
 
 |标志|描述|
@@ -447,7 +447,7 @@
 
 ### 5.2 全局搜索 (Global search)
 
-修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部).
+修饰符 `g` 常用于执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部).
 例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.
 
 <pre>

From d2ddc4d5ba8bc293d08225fcdad338bc19e2d96a Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 27 May 2019 11:10:18 +0400
Subject: [PATCH 071/185] Add funding yml file

---
 .github/FUNDING.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..b994b54a
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+open_collective: learn-regex

From 897be2d07c1c1e2970813b14a6e298198345d135 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 27 May 2019 11:36:31 +0400
Subject: [PATCH 072/185] Update FUNDING.yml

---
 .github/FUNDING.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index b994b54a..42e653b6 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1 +1,2 @@
 open_collective: learn-regex
+patreon: ziishaned

From 9392a3df39e4351abd55112eee5045cb82a7bed3 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Wed, 3 Jul 2019 10:12:18 +0400
Subject: [PATCH 073/185] Add github badge

---
 README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d0712bbe..15f1c262 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,13 @@
     <br /><br />
     <p>
         <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
-            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg?style=flat-square"/>
+            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg" />
         </a>
         <a href="https://twitter.com/ziishaned">
-            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg?style=flat-square" />
+            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg" />
+        </a>
+        <a href="https://github.com/ziishaned">
+            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
         </a>
     </p>
 </p>

From 7c6353325b0e431d87d2df4823e0f0382ec54227 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Wed, 3 Jul 2019 10:14:25 +0400
Subject: [PATCH 074/185] Add twitter badge inside readme

---
 README.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 15f1c262..60e5dff8 100644
--- a/README.md
+++ b/README.md
@@ -5,11 +5,8 @@
     </a>
     <br /><br />
     <p>
-        <a href="https://twitter.com/home?status=Learn%20regex%20the%20easy%20way%20by%20%40ziishaned%20http%3A//github.com/ziishaned/learn-regex">
-            <img src="https://img.shields.io/badge/twitter-tweet-blue.svg" />
-        </a>
         <a href="https://twitter.com/ziishaned">
-            <img src="https://img.shields.io/badge/feedback-@ziishaned-blue.svg" />
+            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
         </a>
         <a href="https://github.com/ziishaned">
             <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />

From c5738a7c63db0c3de43c28bc9a7707e3e1f7e3d9 Mon Sep 17 00:00:00 2001
From: Veikko Lehmuskorpi <veikko.lehmuskorpi@student.lamk.fi>
Date: Thu, 4 Jul 2019 11:05:02 +0300
Subject: [PATCH 075/185] Fix 2.5.1. header anchor link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 60e5dff8..b83683fc 100644
--- a/README.md
+++ b/README.md
@@ -310,7 +310,7 @@ within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is
 
 Non-capturing groups can come in handy when used in find-and-replace functionality or 
 when mixed with capturing groups to keep the overview when producing any other kind of output. 
-See also [4. Lookaround](# 4. Lookaround).
+See also [4. Lookaround](#4-lookaround).
 
 ## 2.6 Alternation
 

From 982462b60165b370bf864bc416455276dc2668b2 Mon Sep 17 00:00:00 2001
From: mrtheyann <darklodr@gmail.com>
Date: Sun, 7 Jul 2019 21:21:11 +0500
Subject: [PATCH 076/185] Translate to Russian (#142)

---
 img/regexp-ru.png         | Bin 0 -> 17905 bytes
 translations/README-ru.md | 565 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 565 insertions(+)
 create mode 100644 img/regexp-ru.png
 create mode 100644 translations/README-ru.md

diff --git a/img/regexp-ru.png b/img/regexp-ru.png
new file mode 100644
index 0000000000000000000000000000000000000000..a28870ccdda15091fc187f8a181d1f0a9a8e828e
GIT binary patch
literal 17905
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
O3~!s>s?>FU`riPA9i(ai

literal 0
HcmV?d00001

diff --git a/translations/README-ru.md b/translations/README-ru.md
new file mode 100644
index 00000000..78288300
--- /dev/null
+++ b/translations/README-ru.md
@@ -0,0 +1,565 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
+        </a>
+        <a href="https://github.com/ziishaned">
+            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
+        </a>
+    </p>
+</p>
+
+## Translations:
+
+* [English](README.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
+
+## Что такое Регулярное выражение?
+
+> Регулярное выражение - это группа букв или символов, которая используется для поиска определенного шаблона в тексте.
+
+Регулярное выражение - это шаблон, сопоставляемый с искомой строкой слева направо. 
+Термин «Регулярное выражение» сложно произносить каждый раз, поэтому, обычно, вы будете сталкиваться с сокращениями "регэкспы" или "регулярки". 
+Регулярные выражения используются для замен текста внутри строк, валидации форм,
+извлечений подстрок по определенным шаблонам и множества других вещей.
+
+Представьте, что вы пишете приложение и хотите установить правила, по которым пользователь выбирает свой юзернейм.  Мы хотим, чтобы имя пользователя содержало буквы, цифры, подчеркивания и дефисы.  Мы также хотим ограничить количество символов в имени пользователя, чтобы оно не выглядело безобразно. 
+Для этого, используем следующее регулярное выражение:
+
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-ru.png" alt="Regular expression">
+</p>
+
+Регулярное выражения выше может принимать строки `john_doe`,` jo-hn_doe` и `john12_as`. 
+Оно не валидирует `Jo`, поскольку эта строка содержит заглавные буквы, а также она слишком короткая.
+
+## Содержание
+
+- [Совпадения](#1-совпадения)
+- [Метасимволы](#2-метасимволы)
+  - [Точка](#21-точка)
+  - [Набор символов](#22-набор-символов)
+    - [Отрицание набора символов](#221-отрицание-набора-символов)
+  - [Повторения](#23-повторения)
+    - [Звёздочка](#231-звёздочка)
+    - [Плюс](#232-плюс)
+    - [Знак вопроса](#233-знак-вопроса)
+  - [Фигурные скобки](#24-фигурные-скобки)
+  - [Скобочные группы](#25-скобочные-группы)
+  - [Альтернация](#26-альтернация)
+  - [Экранирование](#27-экранирование)
+  - [Якоря](#28-якоря)
+    - [Каретка](#281-каретка)
+    - [Доллар](#282-доллар)
+- [Наборы сокращений и диапазоны](#3-наборы-сокращений-и-диапазоны)
+- [Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки)
+  - [Положительное опережающее условие](#41-положительное-опережающее-условие)
+  - [Отрицательное опережающее условие](#42-отрицательное-опережающее-условие)
+  - [Положительное ретроспективное условие](#43-положительное-ретроспективное-условие)
+  - [Отрицательное ретроспективное условие](#44-отрицательное-ретроспективное-условие)
+- [Флаги](#5-флаги)
+  - [Поиск без учета регистра](#51-поиск-без-учета-регистра)
+  - [Глобальный поиск](#52-глобальный-поиск)
+  - [Мультистроковый поиск](#53-мультистроковый-поиск)
+- [Жадные vs ленивые квантификаторы](#6-жадные-vs-ленивые-квантификаторы)
+
+## 1. Совпадения.
+
+В сущности, регулярное выражение - это просто набор символов, который мы используем для поиска в тексте. 
+Например, регулярное выражение `the` состоит из буквы` t`, за которой следует буква `h`, за которой следует буква `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/dmRygT/1)
+
+Регулярное выражение `123` соответствует строке` 123`. Регулярное выражение сопоставляется с входной строкой, сравнивая 
+каждый символ в регулярном выражении с каждым символом во входной строке по одному символу за другим. Регулярные выражения 
+обычно чувствительны к регистру, поэтому регулярное выражение `The` не будет соответствовать строке` the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/1paXsy/1)
+
+## 2. Метасимволы
+
+Метасимволы это блоки, из которых строятся регулярные выражения. Метасимволы не означают что-то сами по себе,
+вместо этого они интерпретируются для распознавания специальных групп символов. Некоторые метасимволы имеют 
+особые обозначения и пишутся в квадратных скобках. Существуют следующие метасимволы:
+
+|Метасимволы|Описание|
+|:----:|----|
+|.|Точка соответствует любому отдельному символу, кроме разрыва строки.|
+|[ ]|Класс символов. Находить любые символы заключенные в квадратных скобках.|
+|[^ ]|Отрицание класа символов. Находить любые символы не заключенные в квадратных скобках.|
+|*|Находить 0 или более повторений предыдущего символа.|
+|+|Находить 1 или более повторений предыдущего символа.|
+|?|Сделать предыдущий символ необязательным.|
+|{n,m}|Скобки. Находить по крайней мере "n" но не более чем "m" повторений предыдущего символа.|
+|(xyz)|Группа символов. Находить только символы xyz в указанном порядке.|
+|||Чередование. Находить либо буквы до, либо буквы после символа.|
+|\|Экранирование. Позволяет находить зарезервированные символы: <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Обозначает начало пользовательского ввода.| 
+|$|Обозначает конец пользовательского ввода.|
+
+## 2.1 Точка
+
+Точка `.` это простейший пример метасимвола. Метасимвол `.`
+находит любой отдельный символ. Точка не будет находить символы перехода или перевода строки.
+For example, the regular expression `.ar` means: any character, followed by the
+letter `a`, followed by the letter `r`. Например, регулярное выражение '.ar' обозначает: любой символ, за которым следуют буквы ` a` и `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Набор символов.
+
+Набор символов также называется классом символов. Квадратные скобки используются
+для определения набора символов. Дефис используется для указания диапазона символов. 
+Порядок следования символов, заданный в квадратных скобках, не важен. Например, 
+регулярное выражение  `[Tt]he` обозначает заглавную 'T' или строчную 't', за которой следуют буквы 'h' и 'e'.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/2ITLQ4/1)
+
+Точка внутри набора символов, однако, обозначает непосредственно точку, как символ. 
+Регулярное выражение `ar[.]` обозначает строчную 'a', за которой следует 'r', за которой следует '.' (символ точки).
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Отрицание набора символов
+
+Знак вставки '^' обозначает начало строки, однако, когда вы вписываете его после открытия квадратных скобок, он отрицает набор символов. 
+Например, регулярное выражение `[^c]ar` обозначает любой символ, кроме 'c', за которым следуют буквы 'a' и 'r'.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Повторения
+
+Символы `+`, `*` or `?` используются для обозначения того, как сколько раз появляется какой-либо подшаблон. 
+Данные метасимволы могут вести себя по-разному, в зависимости от ситуации.
+
+### 2.3.1 Звёздочка
+
+Символ `*` обозначает ноль или более повторений предыдущего совпадения. 
+Регулярное выражение `a *` означает ноль или более повторений предыдущего
+строчного символа `a`. Если же символ появляется после набора или класса символов,
+он находит повторения всего набора символов. Например, регулярное выражение `[a-z] *`
+означает любое количество строчных букв в строке.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/7m8me5/1)
+
+Символы можно комбинировать, так, например, символ `*` может использоваться с метасимволом `.` 
+для поиска одной строки с произвольным содержанием `. * `. Символ `*` может использоваться
+с символом пробела `\ s`, чтобы находить строки с символами пробела. Например, выражение 
+`\ s * cat \ s *` означает: ноль или более пробелов, за которыми следует слово  `cat`,
+за которым следует ноль или более символов пробела.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Плюс
+
+Символ `+` соответствует одному или более повторению предыдущего символа. Например, 
+регулярное выражение `c.+t` означает строчную `c`, за которой следует по крайней мере один символ, 
+следом за которым идёт символ `t`. Стоит уточнить, что в данном шаблоне, `t` является последним` t` в предложении.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Знак вопроса
+
+В регулярном выражении метасимвол `?` делает предыдущий символ необязательным. 
+Этот символ соответствует нулю или одному экземпляру предыдущего символа.
+Например, регулярное выражение `[T]?he` означает  необязательную заглавную букву `T`, за которой следуют символы 'h' и 'e'.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Фигурные скобки
+
+В фигурных скобках, которые также называются квантификаторами, указывается, 
+сколько раз символ или группа символов могут повторяться. Например, регулярное выражение 
+`[0-9] {2,3}` означает совпадение не менее 2 но не более 3 цифр в диапазоне от 0 до 9.
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/juM86s/1)
+
+Уберём второй номер (цифру 3), тогда,  регулярное выражение `[0-9] {2,}` будет означать 
+совпадение 2 или более цифр. Если мы также удалим запятую, то регулярное выражение
+`[0-9] {3}` будет означать  совпадение точно с 3 цифрами.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Скобочные группы
+
+Скобочные группы это группы подшаблонов, которые написаны в круглых скобках
+`(...)`. Как мы уже говорили ранее в регулярном выражении, если мы поставим квантификатор
+после символа, он будет повторять предыдущий символ. Но если мы поставим квантификатор после 
+скобочной группы, он будет искать всю группу. Например, регулярное выражение `(ab) *` соответствует
+нулю или более повторений символа "ab". Мы также можем использовать метасимвол чередования `|`
+внутри скобочной группы. Например, регулярное выражение `(c|g|p)ar` означает поиск одной из строчных букв `c`,
+`g` или `p`, за которыми следуют буквы 'a' и 'r'.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/tUxrBG/1)
+
+Обратите внимание, что скобочные группы не только находят, но и захватывают символы для использования на родительском языке. 
+Родительским языком может быть python, javascript или практически любой язык, который реализует использование регулярных выражений как параметров функций.
+
+### 2.5.1 Не запоминающие скобочные группы
+
+Бывает так, что группу определить нужно, а вот запоминать их содержимое в массиве не требуется.
+Подобный трюк осуществляется при помощи зарезервированной комбинации `?:` 
+в круглых скобках `(...)`. Например, регулярное выражение `(?:c|g|p)ar` будет находить такие же шаблоны как и 
+`(c|g|p)ar`, однако скобочная группа при этом создана не будет. 
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/Rm7Me8/1)
+
+Не запоминающиеся группы пригодиться, когда они используются в функциях поиска и замены
+или в сочетании со скобочными группами, например, для предпросмотра при создании скобочной группы или другого вида выходных данных, 
+смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).
+
+## 2.6 Альтернация
+
+В регулярных выражениях, вертикальная черта `|` используется для определения альтернации (чередования).
+Альтернация по своей сути похожа на оператор ИЛИ между логическими выражениями. Может создаться впечатление, что
+чередование это то же самое, что и определение набора символов. Однако, большая разница между ними в том, что 
+набор символов работает на уровне конкретных символов, в то время как альтернация работает на уровне выражений.
+Например, регулярное выражение `(T|t)he|car` объединяет два шаблона (заглавная `T` ИЛИ строчная `t`, с продолжением из 'h' и 'e') и шаблон
+(строчная `c`, затем строчная `a`, за которой следует строчная `r`). Таким образом, в поиске будет участвовать любой из данных шаблонов,
+по аналогии с логической операцией ИЛИ в программировании и алгебре выражений.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Экранирование спецсимволов
+
+Обратный слэш `\` используется в регулярных выражениях для экранирования следующего символа. 
+Это позволяет формировать шаблоны с поиском зарезервированных символамов, таких как `{ } [ ] / \ + * . $ ^ | ?`. 
+Для использования спецсимвола в шаблоне необходимо указать символ '\' перед ним.
+
+Как упомянуто выше, символ `.` является зарезервированным и соответствует любому значению, кроме символа новой строки. 
+Бывают ситуации, когда необходимо найти точку в предложении, для таких случаев применимо экранирование. Рассмотрим выражение
+`(f|c|m)at\.?`, что соответствует следующему шаблону: стройчный символ `f`, `c` или `m`,  за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Якоря
+
+Понятие якорей в регулярных выражениях используется для обозначения проверок, является ли 
+соответствующий символ начальным или конечным символом входной строки. Якоря бывают двух типов:
+Первый тип - Каретка `^`, проверяет, является ли соответствующий символ начальным символом в тексте.
+Второй тип - Доллар `$`, проверяет, является ли соответствующий символ последним символом входной строки.
+
+### 2.8.1 Каретка
+
+Символ каретки `^` используется для проверки, является ли соответствующий символ первым символом входной строки. 
+Если мы применяем следующее регулярное выражение `^a` (если a является начальным символом) для строки `abc`,
+совпадение будет соответствовать букве `a`. Если же мы используем регулярное выражение `^b` на той же строке,
+мы не получим совпадения, поскольку во входящей строке  `abc` "b"  не является первым символом. Рассмотрим другое
+регулярное выражение: `^(T|t)he`, обозначающее заглавную `T` или строчную `t` как первый символ, за которым следуют
+символы букв 'h' и 'e'. Cоответственно:
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Доллар
+
+Символ доллара `$` используется для проверки, является ли соответствующий символ
+последним символом входной строки. Например, регулярное выражение `(at\.)$` последовательность из
+строчной `a`, строчной `t`, и точки `.`, ключевой момент в том, что благодаря доллару этот шаблон будет
+находить совпадения только в том случае, если будет наблюдаться в конце строки. Например:
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/t0AkOd/1)
+
+##  3. Наборы сокращений и диапазоны
+
+Регулярные выражения предоставляют сокращения для часто используемых наборов символов,
+которые предлагают удобные сокращения для часто используемых регулярных выражений. 
+Наборы сокращенных символов следующие:
+
+|Сокращение|Описание|
+|:----:|----|
+|.|Любой символ кроме символа новой строки|
+|\w|Поиск буквенно-цифрового диапазона символов: `[a-zA-Z0-9_]`|
+|\W|Поиск не буквенно-цифрового диапазона символов: `[^\w]`|
+|\d|Поиск цифр: `[0-9]`|
+|\D|Поиск всего, что не является цифрой: `[^\d]`|
+|\s|Поиск пробелов и символов начала строки: `[\t\n\f\r\p{Z}]`|
+|\S|Поиск всего кроме пробелов и символов начала строки: `[^\s]`|
+
+## 4. Опережающие и ретроспективные проверки
+
+Опережающие и ретроспективные проверки (в английской литературе lookbehind, lookahead) это особый вид 
+***не запоминающих скобочных групп*** (находящих совпадения, но не добавляющих в массив). 
+Данные проверки используются, мы знаем, что шаблон предшествует или сопровождается другим шаблоном.
+Например, мы хотим получить получить цену в долларах `$`, из следующей входной строки
+`$4.44 and $10.88`. Для этого используем следующее регулярное выражение `(?<=\$)[0-9\.]*`, означающее
+получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара `$`. Существуют 
+следующие виды проверок:
+
+|Символ|Описание|
+|:----:|----|
+|?=|Положительное опережающее условие|
+|?!|Отрицательное опережающее условие|
+|?<=|Положительное ретроспективное условие|
+|?<!|Отрицательное ретроспективное условие|
+
+### 4.1 Положительное опережающее условие
+
+Положительное опережающее утверждение (assert) означает, что за первой частью выражения должно следовать
+опережающее выражение (lookahead expression). (по аналогии с условиями, if (..) then (..)). 
+Возвращенное совпадение содержит только текст, который соответствует первой части выражения. 
+Для определения положительного опережающего условия используются круглые скобки. В этих скобках используется
+знак вопроса со знаком равенства: `(?=...)`. Опережающее выражение, записывается в скобках после знака равенства. 
+Рассмотрим пример регулярного выражения:  `(T|t)he(?=\sfat)`, обозначающее опциональное наличие строчной `t` или заглавной `T`, 
+следом буквы `h` и `e`. В скобках, мы определяем положительное опережающее условие, которое сообщает движку регулярных выражений
+информацию о том, что после шаблона `The` или `the` будет следовать слово `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Отрицательное опережающее условие
+
+Отрицательное опережающее условие работает по обратному принципу: используется, когда нам нужно получить 
+все совпадения из входной строки, за которыми НЕ следует определенный шаблон. Отрицательное опережающее условие
+определяется таким же образом, как и позитивное, с той лишь разницей, что вместо равенства `=` мы ставим
+восклицательный знак `!` (отрицание) например: `(?!...)`. Рассмотрим выражение `(T|t)he(?!\sfat)`, в котором мы
+находим все `The` или `the` слова из входной строки, за которыми не следует слово `fat`.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Положительное ретроспективное условие
+
+Положительное ретроспективное условие используется чтобы найти все совпадения, которым предшествует
+определенный шаблон. Условие определяется как `(?<=...)`. Например, выражение `(?<=(T|t)he\s)(fat|mat)` означает, 
+найти все слова `fat` или `mat` из входной строки, которым предшествует слово `The` or `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/avH165/1)
+
+### 4.4 Отрицательное ретроспективное условие
+
+Отрицательное ретроспективное условие используется чтобы найти все совпадения, которым НЕ предшествует
+определенный шаблон. Условие определяется как `(?<!...)`. Например, выражение `(?<!(T|t)he\s)(cat)` означает
+найти все слова `cat` из входной строки, которым не предшествует определенный артикль `The` или `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/8Efx5G/1)
+
+## 5. Флаги
+
+Флаги, также называемые модификаторами, изменяют вывод регулярного выражения. 
+Эти флаги могут быть использованы в любом порядке или комбинации, и являются
+неотъемлемой частью регулярных выражений.
+
+|Флаг|Описание|
+|:----:|----|
+|i|Поиск без учета регистра|
+|g|Глобальный поиск: поиск шаблона во всем входном тексте|
+|m|Мультистроковый поиск: Якоря применяются к каждой строке.|
+
+### 5.1 Поиск без учета регистра
+
+Модификатор `i` используется для поиска без учета регистра. Например, регулярное выражение
+`/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце регулярного выражения флаг `i`, 
+указывающий движку регулярных выражений игнорировать регистр. Помимо  `i`, для поиска шаблона во
+всем входном тексте, использован флаг `g`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Глобальный поиск
+
+Модификатор `g` используется для выполнения глобального сопоставления (найти все совпадения, а не останавливаться после первого).
+Например, регулярное выражение `/.(at)/g` означает любой символ кроме символа новой строки, следом строчная `a`, далее строчная `t`. 
+Из-за использования флага `g` в конце регулярного выражения, теперь оно найдет все совпадения во входной строке, а не остановится на первом 
+(что является поведением по умолчанию).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Мультистроковый поиск
+
+Модификатор `m` используется для многострочного поиска. Как мы обсуждали ранее,
+якоря `(^, $)` используются для проверки, является ли шаблон началом или концом входной строки.
+Но если мы хотим, чтобы якоря работали в каждой строке, мы используем флаг `m`.  Например, 
+регулярное выражение `/at(.)?$/gm` означает строчную  `a`, следом строчная `t` и любой
+символ кроме начала новой строки, идущий опционально (не обязательно). Из-за флага `m` механизм 
+регулярных выражений будет искать данный шаблон в конце каждой строки в тексте.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Запустить регулярное выражение](https://regex101.com/r/E88WE2/1)
+
+## 6. Жадные vs ленивые квантификаторы
+По умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно будет 
+искать совпадения как можно дольше. Мы можем использовать `?` для ленивого поиска, который
+будет стремиться быть как можно более коротким по времени.
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/2)
+
+
+## Содействие
+
+* Вы можете открыть пулл реквест с улучшением
+* Обсуждать идеи в issues
+* Распространять ссылку на репозиторий
+* Получить обратную связь через [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## Лицензия
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
\ No newline at end of file

From 65938c0533eb9b2b84cc8c62d2279e7004918084 Mon Sep 17 00:00:00 2001
From: mrtheyann <darklodr@gmail.com>
Date: Sun, 7 Jul 2019 21:25:17 +0500
Subject: [PATCH 077/185] Update translations list

---
 README.md                        | 1 +
 translations/README-cn.md        | 1 +
 translations/README-es.md        | 1 +
 translations/README-fr.md        | 1 +
 translations/README-gr.md        | 1 +
 translations/README-hu.md        | 1 +
 translations/README-ja.md        | 1 +
 translations/README-ko.md        | 1 +
 translations/README-pl.md        | 1 +
 translations/README-pt_BR.md     | 1 +
 translations/README-tr.md        | 1 +
 translations/README-zh-simple.md | 1 +
 12 files changed, 12 insertions(+)

diff --git a/README.md b/README.md
index b83683fc..94b44d06 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@
 * [Greek](translations/README-gr.md)
 * [Magyar](translations/README-hu.md)
 * [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## What is Regular Expression?
 
diff --git a/translations/README-cn.md b/translations/README-cn.md
index 0513841f..ac375044 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## 什么是正则表达式?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index f059dc62..d12f2343 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index 66caacc8..ab245d9d 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 42c133bc..a59eec5c 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index cc433678..ffed4dbb 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 4675635d..e59a73b7 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index d75a5c5f..80e3a049 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index f9104d55..a0cc5a70 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index a8e2f61d..1aaf7a4a 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index cc218776..094456d0 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -28,6 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 4f60eccc..ee33936d 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -27,6 +27,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
+* [Русский](translations/README-ru.md)
 
 ## 什么是正则表达式?
  

From db9cf88153ad1474853e7bf8fbfd52718166fb6a Mon Sep 17 00:00:00 2001
From: mrtheyann <darklodr@gmail.com>
Date: Sun, 7 Jul 2019 21:33:00 +0500
Subject: [PATCH 078/185] Fix regexp-ru.png display

---
 translations/README-ru.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index 78288300..eea55aab 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -44,7 +44,7 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-ru.png" alt="Regular expression">
+  <img src="../img/regexp-ru.png" alt="Regular expression">
 </p>
 
 Регулярное выражения выше может принимать строки `john_doe`,` jo-hn_doe` и `john12_as`. 

From 0e046dd0582d3eb1c56efefc4c88d4eecd22676e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=88=91=E6=98=AF=E6=B4=97=E8=A1=A3=E6=9C=BA?=
 <womeimingzi11@users.noreply.github.com>
Date: Mon, 8 Jul 2019 15:51:38 +0800
Subject: [PATCH 079/185] Fix content's order

---
 translations/README-cn.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 0513841f..8883baa8 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -236,15 +236,15 @@
 我们可以省略第二个参数.
 例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字.
 
-如果逗号也省略掉则表示重复固定的次数.
-例如, `[0-9]{3}` 匹配3位数字
-
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
 </pre>
 
 [在线练习](https://regex101.com/r/Gdy4w5/1)
 
+如果逗号也省略掉则表示重复固定的次数.
+例如, `[0-9]{3}` 匹配3位数字
+
 <pre>
 "[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
 </pre>

From cfe3850d8ed6afbb825d84e44254189e0dfef994 Mon Sep 17 00:00:00 2001
From: Andrey Ponomarenko <myxobek@gmail.com>
Date: Wed, 10 Jul 2019 13:49:08 +0100
Subject: [PATCH 080/185] Removed wrong english sentence

---
 translations/README-ru.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index eea55aab..df194261 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -126,8 +126,7 @@
 
 Точка `.` это простейший пример метасимвола. Метасимвол `.`
 находит любой отдельный символ. Точка не будет находить символы перехода или перевода строки.
-For example, the regular expression `.ar` means: any character, followed by the
-letter `a`, followed by the letter `r`. Например, регулярное выражение '.ar' обозначает: любой символ, за которым следуют буквы ` a` и `r`.
+Например, регулярное выражение '.ar' обозначает: любой символ, за которым следуют буквы ` a` и `r`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -562,4 +561,4 @@ letter `a`, followed by the letter `r`. Например, регулярное 
 
 ## Лицензия
 
-MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
\ No newline at end of file
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From 57a7df38aa54a8741c32aa5d60c42687b35b4a93 Mon Sep 17 00:00:00 2001
From: pravdakotchestno <pravdakotchestno@protonmail.ch>
Date: Wed, 10 Jul 2019 16:56:40 +0300
Subject: [PATCH 081/185] Links fix

---
 translations/README-ru.md | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index df194261..ad6e9a68 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -16,18 +16,18 @@
 
 ## Translations:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
+* [Русский](../translations/README-ru.md)
 
 ## Что такое Регулярное выражение?
 

From ba0298dc7813a5c8ab73d20ed719b947d8c89d6f Mon Sep 17 00:00:00 2001
From: pravdakotchestno <pravdakotchestno@protonmail.ch>
Date: Wed, 10 Jul 2019 16:57:18 +0300
Subject: [PATCH 082/185] Links fix

---
 translations/README-es.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-es.md b/translations/README-es.md
index d12f2343..a65a5fed 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -28,7 +28,7 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.

From 48dc9be5ef9924f4b46c7dc2c4a5893d3307bcdd Mon Sep 17 00:00:00 2001
From: Oleg Ermakov <ol.ermakov@phystech.edu>
Date: Thu, 11 Jul 2019 17:51:20 +0300
Subject: [PATCH 083/185] Fixed translation

Fixed spelling of some words
---
 translations/README-ru.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index ad6e9a68..e00c2280 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -311,12 +311,12 @@
 ## 2.7 Экранирование спецсимволов
 
 Обратный слэш `\` используется в регулярных выражениях для экранирования следующего символа. 
-Это позволяет формировать шаблоны с поиском зарезервированных символамов, таких как `{ } [ ] / \ + * . $ ^ | ?`. 
+Это позволяет формировать шаблоны с поиском зарезервированных символов, таких как `{ } [ ] / \ + * . $ ^ | ?`. 
 Для использования спецсимвола в шаблоне необходимо указать символ '\' перед ним.
 
 Как упомянуто выше, символ `.` является зарезервированным и соответствует любому значению, кроме символа новой строки. 
 Бывают ситуации, когда необходимо найти точку в предложении, для таких случаев применимо экранирование. Рассмотрим выражение
-`(f|c|m)at\.?`, что соответствует следующему шаблону: стройчный символ `f`, `c` или `m`,  за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
+`(f|c|m)at\.?`, что соответствует следующему шаблону: строчный символ `f`, `c` или `m`,  за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>

From eb62537b48ceb8379b4c0ec39238006a63718214 Mon Sep 17 00:00:00 2001
From: Seasle <seasle98@gmail.com>
Date: Fri, 2 Aug 2019 21:11:43 +0600
Subject: [PATCH 084/185] Fixes

Fixed translation;
Fixed whitespaces;
Fixed inline code blocks.
---
 translations/README-ru.md | 154 +++++++++++++++++++-------------------
 1 file changed, 77 insertions(+), 77 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index e00c2280..f1d10605 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -33,12 +33,12 @@
 
 > Регулярное выражение - это группа букв или символов, которая используется для поиска определенного шаблона в тексте.
 
-Регулярное выражение - это шаблон, сопоставляемый с искомой строкой слева направо. 
-Термин «Регулярное выражение» сложно произносить каждый раз, поэтому, обычно, вы будете сталкиваться с сокращениями "регэкспы" или "регулярки". 
+Регулярное выражение - это шаблон, сопоставляемый с искомой строкой слева направо.
+Термин «Регулярное выражение» сложно произносить каждый раз, поэтому, обычно, вы будете сталкиваться с сокращениями "регэкспы" или "регулярки".
 Регулярные выражения используются для замен текста внутри строк, валидации форм,
 извлечений подстрок по определенным шаблонам и множества других вещей.
 
-Представьте, что вы пишете приложение и хотите установить правила, по которым пользователь выбирает свой юзернейм.  Мы хотим, чтобы имя пользователя содержало буквы, цифры, подчеркивания и дефисы.  Мы также хотим ограничить количество символов в имени пользователя, чтобы оно не выглядело безобразно. 
+Представьте, что вы пишете приложение и хотите установить правила, по которым пользователь выбирает свой юзернейм. Мы хотим, чтобы имя пользователя содержало буквы, цифры, подчеркивания и дефисы. Мы также хотим ограничить количество символов в имени пользователя, чтобы оно не выглядело безобразно.
 Для этого, используем следующее регулярное выражение:
 
 
@@ -47,7 +47,7 @@
   <img src="../img/regexp-ru.png" alt="Regular expression">
 </p>
 
-Регулярное выражения выше может принимать строки `john_doe`,` jo-hn_doe` и `john12_as`. 
+Регулярное выражения выше может принимать строки `john_doe`,`jo-hn_doe` и `john12_as`.
 Оно не валидирует `Jo`, поскольку эта строка содержит заглавные буквы, а также она слишком короткая.
 
 ## Содержание
@@ -82,8 +82,8 @@
 
 ## 1. Совпадения.
 
-В сущности, регулярное выражение - это просто набор символов, который мы используем для поиска в тексте. 
-Например, регулярное выражение `the` состоит из буквы` t`, за которой следует буква `h`, за которой следует буква `e`.
+В сущности, регулярное выражение - это просто набор символов, который мы используем для поиска в тексте.
+Например, регулярное выражение `the` состоит из буквы `t`, за которой следует буква `h`, за которой следует буква `e`.
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -91,9 +91,9 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/dmRygT/1)
 
-Регулярное выражение `123` соответствует строке` 123`. Регулярное выражение сопоставляется с входной строкой, сравнивая 
-каждый символ в регулярном выражении с каждым символом во входной строке по одному символу за другим. Регулярные выражения 
-обычно чувствительны к регистру, поэтому регулярное выражение `The` не будет соответствовать строке` the`.
+Регулярное выражение `123` соответствует строке `123`. Регулярное выражение сопоставляется с входной строкой, сравнивая
+каждый символ в регулярном выражении с каждым символом во входной строке по одному символу за другим. Регулярные выражения
+обычно чувствительны к регистру, поэтому регулярное выражение `The` не будет соответствовать строке `the`.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -104,7 +104,7 @@
 ## 2. Метасимволы
 
 Метасимволы это блоки, из которых строятся регулярные выражения. Метасимволы не означают что-то сами по себе,
-вместо этого они интерпретируются для распознавания специальных групп символов. Некоторые метасимволы имеют 
+вместо этого они интерпретируются для распознавания специальных групп символов. Некоторые метасимволы имеют
 особые обозначения и пишутся в квадратных скобках. Существуют следующие метасимволы:
 
 |Метасимволы|Описание|
@@ -119,14 +119,14 @@
 |(xyz)|Группа символов. Находить только символы xyz в указанном порядке.|
 |||Чередование. Находить либо буквы до, либо буквы после символа.|
 |\|Экранирование. Позволяет находить зарезервированные символы: <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Обозначает начало пользовательского ввода.| 
+|^|Обозначает начало пользовательского ввода.|
 |$|Обозначает конец пользовательского ввода.|
 
 ## 2.1 Точка
 
 Точка `.` это простейший пример метасимвола. Метасимвол `.`
 находит любой отдельный символ. Точка не будет находить символы перехода или перевода строки.
-Например, регулярное выражение '.ar' обозначает: любой символ, за которым следуют буквы ` a` и `r`.
+Например, регулярное выражение `.ar` обозначает: любой символ, за которым следуют буквы `a` и `r`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -137,9 +137,9 @@
 ## 2.2 Набор символов.
 
 Набор символов также называется классом символов. Квадратные скобки используются
-для определения набора символов. Дефис используется для указания диапазона символов. 
-Порядок следования символов, заданный в квадратных скобках, не важен. Например, 
-регулярное выражение  `[Tt]he` обозначает заглавную 'T' или строчную 't', за которой следуют буквы 'h' и 'e'.
+для определения набора символов. Дефис используется для указания диапазона символов.
+Порядок следования символов, заданный в квадратных скобках, не важен. Например,
+регулярное выражение `[Tt]he` обозначает заглавную `T` или строчную `t`, за которой следуют буквы `h` и `e`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -147,8 +147,8 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/2ITLQ4/1)
 
-Точка внутри набора символов, однако, обозначает непосредственно точку, как символ. 
-Регулярное выражение `ar[.]` обозначает строчную 'a', за которой следует 'r', за которой следует '.' (символ точки).
+Точка внутри набора символов, однако, обозначает непосредственно точку, как символ.
+Регулярное выражение `ar[.]` обозначает строчную `a`, за которой следует `r`, за которой следует `.` (символ точки).
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -158,8 +158,8 @@
 
 ### 2.2.1 Отрицание набора символов
 
-Знак вставки '^' обозначает начало строки, однако, когда вы вписываете его после открытия квадратных скобок, он отрицает набор символов. 
-Например, регулярное выражение `[^c]ar` обозначает любой символ, кроме 'c', за которым следуют буквы 'a' и 'r'.
+Знак вставки `^` обозначает начало строки, однако, когда вы вписываете его после открытия квадратных скобок, он отрицает набор символов.
+Например, регулярное выражение `[^c]ar` обозначает любой символ, кроме `c`, за которым следуют буквы `a` и `r`.
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -169,15 +169,15 @@
 
 ## 2.3 Повторения
 
-Символы `+`, `*` or `?` используются для обозначения того, как сколько раз появляется какой-либо подшаблон. 
+Символы `+`, `*` или `?` используются для обозначения того, как сколько раз появляется какой-либо подшаблон.
 Данные метасимволы могут вести себя по-разному, в зависимости от ситуации.
 
 ### 2.3.1 Звёздочка
 
-Символ `*` обозначает ноль или более повторений предыдущего совпадения. 
-Регулярное выражение `a *` означает ноль или более повторений предыдущего
+Символ `*` обозначает ноль или более повторений предыдущего совпадения.
+Регулярное выражение `a*` означает ноль или более повторений предыдущего
 строчного символа `a`. Если же символ появляется после набора или класса символов,
-он находит повторения всего набора символов. Например, регулярное выражение `[a-z] *`
+он находит повторения всего набора символов. Например, регулярное выражение `[a-z]*`
 означает любое количество строчных букв в строке.
 
 <pre>
@@ -186,10 +186,10 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/7m8me5/1)
 
-Символы можно комбинировать, так, например, символ `*` может использоваться с метасимволом `.` 
-для поиска одной строки с произвольным содержанием `. * `. Символ `*` может использоваться
-с символом пробела `\ s`, чтобы находить строки с символами пробела. Например, выражение 
-`\ s * cat \ s *` означает: ноль или более пробелов, за которыми следует слово  `cat`,
+Символы можно комбинировать, так, например, символ `*` может использоваться с метасимволом `.`
+для поиска одной строки с произвольным содержанием `.*`. Символ `*` может использоваться
+с символом пробела `\s`, чтобы находить строки с символами пробела. Например, выражение
+`\s*cat\s*` означает: ноль или более пробелов, за которыми следует слово `cat`,
 за которым следует ноль или более символов пробела.
 
 <pre>
@@ -200,9 +200,9 @@
 
 ### 2.3.2 Плюс
 
-Символ `+` соответствует одному или более повторению предыдущего символа. Например, 
-регулярное выражение `c.+t` означает строчную `c`, за которой следует по крайней мере один символ, 
-следом за которым идёт символ `t`. Стоит уточнить, что в данном шаблоне, `t` является последним` t` в предложении.
+Символ `+` соответствует одному или более повторению предыдущего символа. Например,
+регулярное выражение `c.+t` означает строчную `c`, за которой следует по крайней мере один символ,
+следом за которым идёт символ `t`. Стоит уточнить, что в данном шаблоне, `t` является последним `t` в предложении.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -212,9 +212,9 @@
 
 ### 2.3.3 Знак вопроса
 
-В регулярном выражении метасимвол `?` делает предыдущий символ необязательным. 
+В регулярном выражении метасимвол `?` делает предыдущий символ необязательным.
 Этот символ соответствует нулю или одному экземпляру предыдущего символа.
-Например, регулярное выражение `[T]?he` означает  необязательную заглавную букву `T`, за которой следуют символы 'h' и 'e'.
+Например, регулярное выражение `[T]?he` означает необязательную заглавную букву `T`, за которой следуют символы `h` и `e`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -230,9 +230,9 @@
 
 ## 2.4 Фигурные скобки
 
-В фигурных скобках, которые также называются квантификаторами, указывается, 
-сколько раз символ или группа символов могут повторяться. Например, регулярное выражение 
-`[0-9] {2,3}` означает совпадение не менее 2 но не более 3 цифр в диапазоне от 0 до 9.
+В фигурных скобках, которые также называются квантификаторами, указывается,
+сколько раз символ или группа символов могут повторяться. Например, регулярное выражение
+`[0-9]{2,3}` означает совпадение не менее 2 но не более 3 цифр в диапазоне от 0 до 9.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -240,9 +240,9 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/juM86s/1)
 
-Уберём второй номер (цифру 3), тогда,  регулярное выражение `[0-9] {2,}` будет означать 
+Уберём второй номер (цифру 3), тогда, регулярное выражение `[0-9]{2,}` будет означать
 совпадение 2 или более цифр. Если мы также удалим запятую, то регулярное выражение
-`[0-9] {3}` будет означать  совпадение точно с 3 цифрами.
+`[0-9]{3}` будет означать совпадение точно с 3 цифрами.
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -260,11 +260,11 @@
 
 Скобочные группы это группы подшаблонов, которые написаны в круглых скобках
 `(...)`. Как мы уже говорили ранее в регулярном выражении, если мы поставим квантификатор
-после символа, он будет повторять предыдущий символ. Но если мы поставим квантификатор после 
-скобочной группы, он будет искать всю группу. Например, регулярное выражение `(ab) *` соответствует
+после символа, он будет повторять предыдущий символ. Но если мы поставим квантификатор после
+скобочной группы, он будет искать всю группу. Например, регулярное выражение `(ab)*` соответствует
 нулю или более повторений символа "ab". Мы также можем использовать метасимвол чередования `|`
 внутри скобочной группы. Например, регулярное выражение `(c|g|p)ar` означает поиск одной из строчных букв `c`,
-`g` или `p`, за которыми следуют буквы 'a' и 'r'.
+`g` или `p`, за которыми следуют буквы `a` и `r`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -272,15 +272,15 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/tUxrBG/1)
 
-Обратите внимание, что скобочные группы не только находят, но и захватывают символы для использования на родительском языке. 
+Обратите внимание, что скобочные группы не только находят, но и захватывают символы для использования на родительском языке.
 Родительским языком может быть python, javascript или практически любой язык, который реализует использование регулярных выражений как параметров функций.
 
 ### 2.5.1 Не запоминающие скобочные группы
 
 Бывает так, что группу определить нужно, а вот запоминать их содержимое в массиве не требуется.
-Подобный трюк осуществляется при помощи зарезервированной комбинации `?:` 
-в круглых скобках `(...)`. Например, регулярное выражение `(?:c|g|p)ar` будет находить такие же шаблоны как и 
-`(c|g|p)ar`, однако скобочная группа при этом создана не будет. 
+Подобный трюк осуществляется при помощи зарезервированной комбинации `?:`
+в круглых скобках `(...)`. Например, регулярное выражение `(?:c|g|p)ar` будет находить такие же шаблоны как и
+`(c|g|p)ar`, однако скобочная группа при этом создана не будет.
 
 <pre>
 "(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -289,16 +289,16 @@
 [Запустить регулярное выражение](https://regex101.com/r/Rm7Me8/1)
 
 Не запоминающиеся группы пригодиться, когда они используются в функциях поиска и замены
-или в сочетании со скобочными группами, например, для предпросмотра при создании скобочной группы или другого вида выходных данных, 
+или в сочетании со скобочными группами, например, для предпросмотра при создании скобочной группы или другого вида выходных данных,
 смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).
 
 ## 2.6 Альтернация
 
 В регулярных выражениях, вертикальная черта `|` используется для определения альтернации (чередования).
 Альтернация по своей сути похожа на оператор ИЛИ между логическими выражениями. Может создаться впечатление, что
-чередование это то же самое, что и определение набора символов. Однако, большая разница между ними в том, что 
+чередование это то же самое, что и определение набора символов. Однако, большая разница между ними в том, что
 набор символов работает на уровне конкретных символов, в то время как альтернация работает на уровне выражений.
-Например, регулярное выражение `(T|t)he|car` объединяет два шаблона (заглавная `T` ИЛИ строчная `t`, с продолжением из 'h' и 'e') и шаблон
+Например, регулярное выражение `(T|t)he|car` объединяет два шаблона (заглавная `T` ИЛИ строчная `t`, с продолжением из `h` и `e`) и шаблон
 (строчная `c`, затем строчная `a`, за которой следует строчная `r`). Таким образом, в поиске будет участвовать любой из данных шаблонов,
 по аналогии с логической операцией ИЛИ в программировании и алгебре выражений.
 
@@ -310,13 +310,13 @@
 
 ## 2.7 Экранирование спецсимволов
 
-Обратный слэш `\` используется в регулярных выражениях для экранирования следующего символа. 
-Это позволяет формировать шаблоны с поиском зарезервированных символов, таких как `{ } [ ] / \ + * . $ ^ | ?`. 
-Для использования спецсимвола в шаблоне необходимо указать символ '\' перед ним.
+Обратный слэш `\` используется в регулярных выражениях для экранирования следующего символа.
+Это позволяет формировать шаблоны с поиском зарезервированных символов, таких как `{ } [ ] / \ + * . $ ^ | ?`.
+Для использования спецсимвола в шаблоне необходимо указать символ `\` перед ним.
 
-Как упомянуто выше, символ `.` является зарезервированным и соответствует любому значению, кроме символа новой строки. 
+Как упомянуто выше, символ `.` является зарезервированным и соответствует любому значению, кроме символа новой строки.
 Бывают ситуации, когда необходимо найти точку в предложении, для таких случаев применимо экранирование. Рассмотрим выражение
-`(f|c|m)at\.?`, что соответствует следующему шаблону: строчный символ `f`, `c` или `m`,  за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
+`(f|c|m)at\.?`, что соответствует следующему шаблону: строчный символ `f`, `c` или `m`, за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -326,19 +326,19 @@
 
 ## 2.8 Якоря
 
-Понятие якорей в регулярных выражениях используется для обозначения проверок, является ли 
+Понятие якорей в регулярных выражениях используется для обозначения проверок, является ли
 соответствующий символ начальным или конечным символом входной строки. Якоря бывают двух типов:
 Первый тип - Каретка `^`, проверяет, является ли соответствующий символ начальным символом в тексте.
 Второй тип - Доллар `$`, проверяет, является ли соответствующий символ последним символом входной строки.
 
 ### 2.8.1 Каретка
 
-Символ каретки `^` используется для проверки, является ли соответствующий символ первым символом входной строки. 
+Символ каретки `^` используется для проверки, является ли соответствующий символ первым символом входной строки.
 Если мы применяем следующее регулярное выражение `^a` (если a является начальным символом) для строки `abc`,
 совпадение будет соответствовать букве `a`. Если же мы используем регулярное выражение `^b` на той же строке,
-мы не получим совпадения, поскольку во входящей строке  `abc` "b"  не является первым символом. Рассмотрим другое
+мы не получим совпадения, поскольку во входящей строке `abc` "b" не является первым символом. Рассмотрим другое
 регулярное выражение: `^(T|t)he`, обозначающее заглавную `T` или строчную `t` как первый символ, за которым следуют
-символы букв 'h' и 'e'. Cоответственно:
+символы букв `h` и `e`. Cоответственно:
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -371,10 +371,10 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/t0AkOd/1)
 
-##  3. Наборы сокращений и диапазоны
+## 3. Наборы сокращений и диапазоны
 
 Регулярные выражения предоставляют сокращения для часто используемых наборов символов,
-которые предлагают удобные сокращения для часто используемых регулярных выражений. 
+которые предлагают удобные сокращения для часто используемых регулярных выражений.
 Наборы сокращенных символов следующие:
 
 |Сокращение|Описание|
@@ -389,12 +389,12 @@
 
 ## 4. Опережающие и ретроспективные проверки
 
-Опережающие и ретроспективные проверки (в английской литературе lookbehind, lookahead) это особый вид 
-***не запоминающих скобочных групп*** (находящих совпадения, но не добавляющих в массив). 
+Опережающие и ретроспективные проверки (в английской литературе lookbehind, lookahead) это особый вид
+***не запоминающих скобочных групп*** (находящих совпадения, но не добавляющих в массив).
 Данные проверки используются, мы знаем, что шаблон предшествует или сопровождается другим шаблоном.
 Например, мы хотим получить получить цену в долларах `$`, из следующей входной строки
 `$4.44 and $10.88`. Для этого используем следующее регулярное выражение `(?<=\$)[0-9\.]*`, означающее
-получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара `$`. Существуют 
+получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара `$`. Существуют
 следующие виды проверок:
 
 |Символ|Описание|
@@ -407,11 +407,11 @@
 ### 4.1 Положительное опережающее условие
 
 Положительное опережающее утверждение (assert) означает, что за первой частью выражения должно следовать
-опережающее выражение (lookahead expression). (по аналогии с условиями, if (..) then (..)). 
-Возвращенное совпадение содержит только текст, который соответствует первой части выражения. 
+опережающее выражение (lookahead expression). (по аналогии с условиями, if (..) then (..)).
+Возвращенное совпадение содержит только текст, который соответствует первой части выражения.
 Для определения положительного опережающего условия используются круглые скобки. В этих скобках используется
-знак вопроса со знаком равенства: `(?=...)`. Опережающее выражение, записывается в скобках после знака равенства. 
-Рассмотрим пример регулярного выражения:  `(T|t)he(?=\sfat)`, обозначающее опциональное наличие строчной `t` или заглавной `T`, 
+знак вопроса со знаком равенства: `(?=...)`. Опережающее выражение, записывается в скобках после знака равенства.
+Рассмотрим пример регулярного выражения: `(T|t)he(?=\sfat)`, обозначающее опциональное наличие строчной `t` или заглавной `T`,
 следом буквы `h` и `e`. В скобках, мы определяем положительное опережающее условие, которое сообщает движку регулярных выражений
 информацию о том, что после шаблона `The` или `the` будет следовать слово `fat`.
 
@@ -423,7 +423,7 @@
 
 ### 4.2 Отрицательное опережающее условие
 
-Отрицательное опережающее условие работает по обратному принципу: используется, когда нам нужно получить 
+Отрицательное опережающее условие работает по обратному принципу: используется, когда нам нужно получить
 все совпадения из входной строки, за которыми НЕ следует определенный шаблон. Отрицательное опережающее условие
 определяется таким же образом, как и позитивное, с той лишь разницей, что вместо равенства `=` мы ставим
 восклицательный знак `!` (отрицание) например: `(?!...)`. Рассмотрим выражение `(T|t)he(?!\sfat)`, в котором мы
@@ -438,8 +438,8 @@
 ### 4.3 Положительное ретроспективное условие
 
 Положительное ретроспективное условие используется чтобы найти все совпадения, которым предшествует
-определенный шаблон. Условие определяется как `(?<=...)`. Например, выражение `(?<=(T|t)he\s)(fat|mat)` означает, 
-найти все слова `fat` или `mat` из входной строки, которым предшествует слово `The` or `the`.
+определенный шаблон. Условие определяется как `(?<=...)`. Например, выражение `(?<=(T|t)he\s)(fat|mat)` означает,
+найти все слова `fat` или `mat` из входной строки, которым предшествует слово `The` или `the`.
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -461,7 +461,7 @@
 
 ## 5. Флаги
 
-Флаги, также называемые модификаторами, изменяют вывод регулярного выражения. 
+Флаги, также называемые модификаторами, изменяют вывод регулярного выражения.
 Эти флаги могут быть использованы в любом порядке или комбинации, и являются
 неотъемлемой частью регулярных выражений.
 
@@ -474,8 +474,8 @@
 ### 5.1 Поиск без учета регистра
 
 Модификатор `i` используется для поиска без учета регистра. Например, регулярное выражение
-`/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце регулярного выражения флаг `i`, 
-указывающий движку регулярных выражений игнорировать регистр. Помимо  `i`, для поиска шаблона во
+`/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце регулярного выражения флаг `i`,
+указывающий движку регулярных выражений игнорировать регистр. Помимо `i`, для поиска шаблона во
 всем входном тексте, использован флаг `g`.
 
 <pre>
@@ -493,8 +493,8 @@
 ### 5.2 Глобальный поиск
 
 Модификатор `g` используется для выполнения глобального сопоставления (найти все совпадения, а не останавливаться после первого).
-Например, регулярное выражение `/.(at)/g` означает любой символ кроме символа новой строки, следом строчная `a`, далее строчная `t`. 
-Из-за использования флага `g` в конце регулярного выражения, теперь оно найдет все совпадения во входной строке, а не остановится на первом 
+Например, регулярное выражение `/.(at)/g` означает любой символ кроме символа новой строки, следом строчная `a`, далее строчная `t`.
+Из-за использования флага `g` в конце регулярного выражения, теперь оно найдет все совпадения во входной строке, а не остановится на первом
 (что является поведением по умолчанию).
 
 <pre>
@@ -513,9 +513,9 @@
 
 Модификатор `m` используется для многострочного поиска. Как мы обсуждали ранее,
 якоря `(^, $)` используются для проверки, является ли шаблон началом или концом входной строки.
-Но если мы хотим, чтобы якоря работали в каждой строке, мы используем флаг `m`.  Например, 
-регулярное выражение `/at(.)?$/gm` означает строчную  `a`, следом строчная `t` и любой
-символ кроме начала новой строки, идущий опционально (не обязательно). Из-за флага `m` механизм 
+Но если мы хотим, чтобы якоря работали в каждой строке, мы используем флаг `m`. Например,
+регулярное выражение `/at(.)?$/gm` означает строчную `a`, следом строчная `t` и любой
+символ кроме начала новой строки, идущий опционально (не обязательно). Из-за флага `m` механизм
 регулярных выражений будет искать данный шаблон в конце каждой строки в тексте.
 
 <pre>
@@ -535,7 +535,7 @@
 [Запустить регулярное выражение](https://regex101.com/r/E88WE2/1)
 
 ## 6. Жадные vs ленивые квантификаторы
-По умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно будет 
+По умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно будет
 искать совпадения как можно дольше. Мы можем использовать `?` для ленивого поиска, который
 будет стремиться быть как можно более коротким по времени.
 

From 1cde7e2d775e83462ff1b86097c579f6fc57d146 Mon Sep 17 00:00:00 2001
From: Gordon Bai <gdbaifdu@gmail.com>
Date: Mon, 5 Aug 2019 16:54:13 +0100
Subject: [PATCH 085/185] Correct a typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2dee7bc2..dd140b7f 100644
--- a/README.md
+++ b/README.md
@@ -278,7 +278,7 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 ## 2.5 Capturing Group
 
 A capturing group is a group of sub-patterns that is written inside Parentheses 
-`(...)`. Like As we discussed before that in regular expression if we put a quantifier 
+`(...)`. Like as we discussed before that in regular expression if we put a quantifier 
 after a character then it will repeat the preceding character. But if we put quantifier
 after a capturing group then it repeats the whole capturing group. For example,
 the regular expression `(ab)*` matches zero or more repetitions of the character

From 8dc654ae1ffafcdad9abd9c020019cac786d7771 Mon Sep 17 00:00:00 2001
From: liuyonghui <1359158019@qq.com>
Date: Tue, 6 Aug 2019 02:02:47 +0800
Subject: [PATCH 086/185] fix: correct a typo

---
 translations/README-zh-simple.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index ee33936d..43f55ef5 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -442,7 +442,7 @@
 
 ### 5.2 全局搜索 (Global search)
 
-修饰符 `g` 常用语执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). 
+修饰符 `g` 常用于执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部). 
 例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.
 
 <pre>

From 3538d4353494d9d7db6e6d694c4f82e61b0849c8 Mon Sep 17 00:00:00 2001
From: imyhui <1359158019@qq.com>
Date: Tue, 6 Aug 2019 09:34:20 +0800
Subject: [PATCH 087/185] fix: correct two typo errs

---
 translations/README-cn.md        | 2 +-
 translations/README-zh-simple.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 205efc35..0ae81134 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -465,7 +465,7 @@
 
 ### 5.3 多行修饰符 (Multiline)
 
-多行修饰符 `m` 常用语执行一个多行匹配.
+多行修饰符 `m` 常用于执行一个多行匹配.
 
 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
 
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 43f55ef5..1a1736e2 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -459,7 +459,7 @@
 
 ### 5.3 多行修饰符 (Multiline)
 
-多行修饰符 `m` 常用语执行一个多行匹配. 
+多行修饰符 `m` 常用于执行一个多行匹配.
 
 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
 

From 8a486acafcc6963eb07f03558726090c5af03751 Mon Sep 17 00:00:00 2001
From: ImKifu <somebodyisdaydreamer@gmail.com>
Date: Tue, 6 Aug 2019 08:58:03 +0700
Subject: [PATCH 088/185] add vietnamese

---
 translations/README-vn.md | 619 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 619 insertions(+)
 create mode 100644 translations/README-vn.md

diff --git a/translations/README-vn.md b/translations/README-vn.md
new file mode 100644
index 00000000..e2e3918c
--- /dev/null
+++ b/translations/README-vn.md
@@ -0,0 +1,619 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
+        </a>
+        <a href="https://github.com/ziishaned">
+            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
+        </a>
+    </p>
+</p>
+
+
+
+## Translations:
+
+* [English](README.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
+* [Vietnamese](translations/README-vn.md)
+
+
+## Biểu thức chính quy là gì?
+
+> Biểu thức chính quy là một nhóm các ký tự hoặc ký hiệu được sử dụng để tìm một mẫu cụ thể từ một văn bản.
+
+Biểu thức chính quy là một khuôn mẫu được khớp với chuỗi các từ, từ trái sang phải. Từ "Biểu thức chính quy" là một câu cửa miệng, bạn thường sẽ tìm thấy thuật ngữ viết tắt là "regex" hoặc "regexp". Biểu thức chính quy được sử dụng để thay thế một văn bản trong một chuỗi, xác thực mẫu, trích xuất một chuỗi con từ một chuỗi dựa trên khớp mẫu và hơn thế nữa.
+
+Hãy tưởng tượng bạn đang viết một ứng dụng và bạn muốn đặt quy tắc khi người dùng chọn tên người dùng của họ. Chúng tôi muốn cho phép tên người dùng chứa các chữ cái, số, dấu gạch dưới và dấu gạch nối. Chúng tôi cũng muốn giới hạn số lượng ký tự trong tên người dùng để nó trông không xấu. Chúng tôi sử dụng biểu thức chính quy sau để xác thực tên người dùng:
+
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+Trên biểu thức chính quy có thể chấp nhận các chuỗi `john_doe`, `jo-hn_doe` và `john12_as`. Nó không khớp với `Jo` vì chuỗi đó chứa chữ hoa và nó quá ngắn.
+
+## Table of Contents
+
+- [Basic Matchers](#1-basic-matchers)
+- [Meta character](#2-meta-characters)
+  - [Full stop](#21-full-stop)
+  - [Character set](#22-character-set)
+    - [Negated character set](#221-negated-character-set)
+  - [Repetitions](#23-repetitions)
+    - [The Star](#231-the-star)
+    - [The Plus](#232-the-plus)
+    - [The Question Mark](#233-the-question-mark)
+  - [Braces](#24-braces)
+  - [Character Group](#25-character-group)
+  - [Alternation](#26-alternation)
+  - [Escaping special character](#27-escaping-special-character)
+  - [Anchors](#28-anchors)
+    - [Caret](#281-caret)
+    - [Dollar](#282-dollar)
+- [Shorthand Character Sets](#3-shorthand-character-sets)
+- [Lookaround](#4-lookaround)
+  - [Positive Lookahead](#41-positive-lookahead)
+  - [Negative Lookahead](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
+- [Flags](#5-flags)
+  - [Case Insensitive](#51-case-insensitive)
+  - [Global search](#52-global-search)
+  - [Multiline](#53-multiline)
+- [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
+
+
+## 1. Basic Matchers
+
+A regular expression is just a pattern of characters that we use to perform
+search in a text.  For example, the regular expression `the` means: the letter
+`t`, followed by the letter `h`, followed by the letter `e`.
+
+
+Biểu thức chính quy chỉ là một mẫu các ký tự mà chúng ta sử dụng để thực hiện tìm kiếm trong văn bản. Ví dụ, biểu thức chính quy `the` có nghĩa là: chữ `t`, tiếp theo là chữ `h`, tiếp theo là chữ `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dmRygT/1)
+
+Biể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`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta Characters
+
+Cá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:
+
+|Meta character|Description|
+|:----:|----|
+|.|Khớp với tất cả các kí tự trừ dấu xuống dòng.|
+|[ ]|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.|
+|[^ ]|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.|
+|*|Khớp 0 hoặc nhiều lần lặp lại của kí tự trước.|
+|+|Khớp 1 hoặc nhiều lần lặp lại của kí tự trước.|
+|?|Làm cho kí tự trước tùy chọ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.|
+|(xyz)|Nhóm kí tự. Khớp các ký tự xyz theo thứ tự chính xác đó.|
+|||Thay thế. Khớp các ký tự trước hoặc ký tự sau ký hiệu.|
+|\|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 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Khớp với sự bắt đầu của đầu vào.|
+|$|Khớp với kết thúc đầu vào.|
+
+## 2.1 Full stop
+
+
+Full stop `.`  là ví dụ đơn giản nhất về ký tự meta. Kí tự meta `.`
+khớ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)
+
+Ví 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`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Character set
+
+Bộ 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. 
+
+Ví 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`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+
+
+Tuy 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ự `.` .
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negated character set
+
+Nó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`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+
+
+
+
+## 2.3 Repetitions
+
+Theo 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.
+
+
+### 2.3.1 The Star
+
+Biể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.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/7m8me5/1)
+
+Biể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. 
+
+Ví 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.
+
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+
+
+
+
+### 2.3.2 The Plus
+
+The symbol `+` matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+at least one character, followed by the lowercase character `t`. It needs to be
+clarified that `t` is the last `t` in the sentence.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 The Question Mark
+
+Trong 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`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+
+
+## 2.4 Braces
+
+
+Trong 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).
+
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/juM86s/1)
+
+
+Chú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ố.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+
+
+## 2.5 Capturing Group
+
+A capturing group is a group of sub-patterns that is written inside Parentheses 
+`(...)`. Like As we discussed before that in regular expression if we put a quantifier 
+after a character then it will repeat the preceding character. But if we put quantifier
+after a capturing group then it repeats the whole capturing group. For example,
+the regular expression `(ab)*` matches zero or more repetitions of the character
+"ab". We can also use the alternation `|` meta character inside capturing group.
+For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+`g` or `p`, followed by character `a`, followed by character `r`.
+
+
+Mộ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`.
+
+
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+
+Note that capturing groups do not only match but also capture the characters for use in 
+the parent language. The parent language could be python or javascript or virtually any
+language that implements regular expressions in a function definition.
+
+
+Lư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.
+
+
+### 2.5.1 Non-capturing group
+
+A non-capturing group is a capturing group that only matches the characters, but 
+does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
+within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+
+
+
+Nhó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 `(...)`. 
+
+Ví 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.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+Cá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). 
+
+
+## 2.6 Alternation
+
+Trong 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. 
+
+Ví 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.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Escaping special character
+
+Backslash `\` is used in regular expression to escape the next character. This
+allows us to specify a symbol as a matching character including reserved
+characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
+character prepend `\` before it.
+
+For example, the regular expression `.` is used to match any character except
+newline. Now to match `.` in an input string the regular expression
+`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
+character `a`, followed by lowercase letter `t`, followed by optional `.`
+character.
+
+
+Dấ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.
+
+Ví 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.
+
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+
+
+## 2.8 Anchors
+
+
+Trong 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.
+
+
+
+
+### 2.8.1 Caret
+
+
+Biể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`.
+
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dollar
+
+
+Biể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.
+
+
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+
+##  3. Shorthand Character Sets
+
+
+
+Biể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:
+
+
+|Shorthand|Description|
+|:----:|----|
+|.| Bất kỳ kí tự nào ngoại trừ dòng mới|
+|\w|Khớp các ký tự chữ và số: `[a-zA-Z0-9_]`|
+|\W|Khớp các ký tự không phải chữ và số: `[^\w]`|
+|\d|khớp với số trong khoảng: `[0-9]`|
+|\D|Khớp không có chữ số: `[^\d]`|
+|\s|Khớp các ký tự khoảng trắng: `[\t\n\f\r\p{Z}]`|
+|\S|Khớp với ký tự không phải khoảng trắng: `[^\s]`|
+
+## 4. Lookaround
+
+Lookbehind 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. 
+
+Ví 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:
+
+|Kí hiệu|Mô tả|
+|:----:|----|
+|?=|Positive Lookahead|
+|?!|Negative Lookahead|
+|?<=|Positive Lookbehind|
+|?<!|Negative Lookbehind|
+
+### 4.1 Positive Lookahead
+
+
+`Positive lookahead` khẳng định rằng phần đầu tiên của biểu thức phải được theo sau bởi biểu thức `lookahead expression`. Phần khớp trả về (The returned match) chỉ chứa văn bản được khớp bởi phần đầu tiên của biểu thức. Để xác định một `positive lookahead`, dấu ngoặc đơn được sử dụng. Trong các dấu ngoặc đơn đó, một dấu hỏi có dấu bằng được sử dụng như thế này: `(?=...)`. Biểu thức `Lookahead` được viết sau dấu bằng trong ngoặc đơn. 
+
+Ví dụ: biểu thức chính quy `(T|t)he(?=\Sfat)` có nghĩa là: tùy ý khớp chữ thường chữ `t` hoặc chữ hoa chữ `T`, theo sau là chữ `h`, tiếp theo là chữ `e`. Trong ngoặc đơn, chúng tôi xác định `positive lookahead` cho biết công cụ (engine) biểu thức chính quy khớp với `The` hoặc `the` cái mà được đứng trước bởi từ `fat`.
+
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Negative Lookahead
+
+Negative lookahead is used when we need to get all matches from input string
+that are not followed by a pattern. Negative lookahead is defined same as we define
+positive lookahead but the only difference is instead of equal `=` character we
+use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
+from input string that are not followed by the word `fat` precedes by a space
+character.
+
+
+
+
+
+
+`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à `(?! ...)`. 
+
+Chú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.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Positive Lookbehind
+
+`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 `(?<=...)`. 
+
+Ví 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`.
+
+
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+
+### 4.4 Negative Lookbehind
+
+
+`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à `(?<!...)`. 
+
+Ví dụ: biểu thức chính quy `(?<!(T|t)he\s)(cat)` có nghĩa là: lấy tất cả các từ `cat` từ chuỗi đầu vào, không nằm sau từ `The` hoặc `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flags
+
+Flags are also called modifiers because they modify the output of a regular
+expression. These flags can be used in any order or combination, and are an
+integral part of the RegExp.
+
+
+Cờ (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.
+
+
+
+|Cờ|Mô tả|
+|:------:|----|
+|i|Case insensitive: Đặt khớp với mẫu không phân biệt chữ hoa chữ thường.|
+|g|Global Search: Tìm kiếm một mẫu trong suốt chuỗi đầu vào.|
+|m|Multiline: ký tự Anchor meta hoạt động trên mỗi dòng.|
+
+### 5.1 Case Insensitive
+
+The `i` modifier is used to perform case-insensitive matching. For example, the
+regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
+character `h`, followed by character `e`. And at the end of regular expression
+the `i` flag tells the regular expression engine to ignore the case. As you can
+see we also provided `g` flag because we want to search for the pattern in the
+whole input string.
+
+
+
+Cô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. 
+
+Ví 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.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Global search
+
+
+Cô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). 
+
+Ví 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).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multiline
+
+
+Cô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`. 
+
+Ví 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.
+
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/E88WE2/1)
+
+
+
+
+## 6. Greedy vs lazy matching
+By default regex will do greedy matching , means it will match as long as
+possible. we can use `?` to match in lazy way means as short as possible
+
+
+Theo 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
+
+
+
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+
+
+## Contribution
+
+* Open pull request with improvements
+* Discuss ideas in issues
+* Spread the word
+* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
+
+
+
+
+
+

From 182e2afbbeed976e2d5622314c24ff465013fa1d Mon Sep 17 00:00:00 2001
From: ImKifu <somebodyisdaydreamer@gmail.com>
Date: Tue, 6 Aug 2019 09:00:14 +0700
Subject: [PATCH 089/185] add vietnamese

---
 translations/README-vn.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/translations/README-vn.md b/translations/README-vn.md
index e2e3918c..86cf6326 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -42,11 +42,14 @@ Biểu thức chính quy là một khuôn mẫu được khớp với chuỗi c
 Hãy tưởng tượng bạn đang viết một ứng dụng và bạn muốn đặt quy tắc khi người dùng chọn tên người dùng của họ. Chúng tôi muốn cho phép tên người dùng chứa các chữ cái, số, dấu gạch dưới và dấu gạch nối. Chúng tôi cũng muốn giới hạn số lượng ký tự trong tên người dùng để nó trông không xấu. Chúng tôi sử dụng biểu thức chính quy sau để xác thực tên người dùng:
 
 
+
 <br/><br/>
 <p align="center">
   <img src="./img/regexp-en.png" alt="Regular expression">
 </p>
 
+
+
 Trên biểu thức chính quy có thể chấp nhận các chuỗi `john_doe`, `jo-hn_doe` và `john12_as`. Nó không khớp với `Jo` vì chuỗi đó chứa chữ hoa và nó quá ngắn.
 
 ## Table of Contents

From e7498c48de52e8f22c666523b2bca0b5df9d8fba Mon Sep 17 00:00:00 2001
From: ImKifu <somebodyisdaydreamer@gmail.com>
Date: Tue, 6 Aug 2019 09:01:39 +0700
Subject: [PATCH 090/185] add vietnamese

---
 translations/README-vn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-vn.md b/translations/README-vn.md
index 86cf6326..7b0b43c4 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -45,7 +45,7 @@ Hãy tưởng tượng bạn đang viết một ứng dụng và bạn muốn đ
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
 

From bfb63e9b75cd6e2761e9464a3882e02fdecfcf6d Mon Sep 17 00:00:00 2001
From: ImKifu <somebodyisdaydreamer@gmail.com>
Date: Tue, 6 Aug 2019 09:07:10 +0700
Subject: [PATCH 091/185] add vietnamese

---
 translations/README-vn.md | 71 +++------------------------------------
 1 file changed, 5 insertions(+), 66 deletions(-)

diff --git a/translations/README-vn.md b/translations/README-vn.md
index 7b0b43c4..6ca8470d 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -85,10 +85,6 @@ Trên biểu thức chính quy có thể chấp nhận các chuỗi `john_doe`,
 
 ## 1. Basic Matchers
 
-A regular expression is just a pattern of characters that we use to perform
-search in a text.  For example, the regular expression `the` means: the letter
-`t`, followed by the letter `h`, followed by the letter `e`.
-
 
 Biểu thức chính quy chỉ là một mẫu các ký tự mà chúng ta sử dụng để thực hiện tìm kiếm trong văn bản. Ví dụ, biểu thức chính quy `the` có nghĩa là: chữ `t`, tiếp theo là chữ `h`, tiếp theo là chữ `e`.
 
@@ -204,10 +200,11 @@ Ví dụ: biểu thức `\s*cat\s*` có nghĩa là: không hoặc nhiều khoả
 
 ### 2.3.2 The Plus
 
-The symbol `+` matches one or more repetitions of the preceding character. For
-example, the regular expression `c.+t` means: lowercase letter `c`, followed by
-at least one character, followed by the lowercase character `t`. It needs to be
-clarified that `t` is the last `t` in the sentence.
+
+Biể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. 
+
+Ví 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.
+
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -262,16 +259,6 @@ Chúng ta có thể bỏ qua số thứ hai. Ví dụ: biểu thức chính quy
 
 ## 2.5 Capturing Group
 
-A capturing group is a group of sub-patterns that is written inside Parentheses 
-`(...)`. Like As we discussed before that in regular expression if we put a quantifier 
-after a character then it will repeat the preceding character. But if we put quantifier
-after a capturing group then it repeats the whole capturing group. For example,
-the regular expression `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside capturing group.
-For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
-`g` or `p`, followed by character `a`, followed by character `r`.
-
-
 Mộ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`.
 
 
@@ -282,23 +269,12 @@ Một nhóm capturing là một nhóm các mẫu con được viết bên trong
 
 [Test the regular expression](https://regex101.com/r/tUxrBG/1)
 
-Note that capturing groups do not only match but also capture the characters for use in 
-the parent language. The parent language could be python or javascript or virtually any
-language that implements regular expressions in a function definition.
-
 
 Lư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.
 
 
 ### 2.5.1 Non-capturing group
 
-A non-capturing group is a capturing group that only matches the characters, but 
-does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
-within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
-`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
-
-
-
 Nhó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 `(...)`. 
 
 Ví 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.
@@ -326,17 +302,6 @@ Ví dụ: biểu thức chính quy `(T|t)he|car` có nghĩa là: hoặc (ký t
 
 ## 2.7 Escaping special character
 
-Backslash `\` is used in regular expression to escape the next character. This
-allows us to specify a symbol as a matching character including reserved
-characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
-character prepend `\` before it.
-
-For example, the regular expression `.` is used to match any character except
-newline. Now to match `.` in an input string the regular expression
-`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
-character `a`, followed by lowercase letter `t`, followed by optional `.`
-character.
-
 
 Dấ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.
 
@@ -441,18 +406,6 @@ Ví dụ: biểu thức chính quy `(T|t)he(?=\Sfat)` có nghĩa là: tùy ý kh
 
 ### 4.2 Negative Lookahead
 
-Negative lookahead is used when we need to get all matches from input string
-that are not followed by a pattern. Negative lookahead is defined same as we define
-positive lookahead but the only difference is instead of equal `=` character we
-use negation `!` character i.e. `(?!...)`. Let's take a look at the following
-regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
-from input string that are not followed by the word `fat` precedes by a space
-character.
-
-
-
-
-
 
 `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à `(?! ...)`. 
 
@@ -493,10 +446,6 @@ Ví dụ: biểu thức chính quy `(?<!(T|t)he\s)(cat)` có nghĩa là: lấy t
 
 ## 5. Flags
 
-Flags are also called modifiers because they modify the output of a regular
-expression. These flags can be used in any order or combination, and are an
-integral part of the RegExp.
-
 
 Cờ (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.
 
@@ -510,14 +459,6 @@ Cờ (flags) cũng được gọi là bổ nghĩa (modifiers) vì chúng sửa 
 
 ### 5.1 Case Insensitive
 
-The `i` modifier is used to perform case-insensitive matching. For example, the
-regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
-character `h`, followed by character `e`. And at the end of regular expression
-the `i` flag tells the regular expression engine to ignore the case. As you can
-see we also provided `g` flag because we want to search for the pattern in the
-whole input string.
-
-
 
 Cô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. 
 
@@ -582,8 +523,6 @@ Ví dụ: biểu thức chính quy `/at(.)?$/gm` có nghĩa là: ký tự chữ
 
 
 ## 6. Greedy vs lazy matching
-By default regex will do greedy matching , means it will match as long as
-possible. we can use `?` to match in lazy way means as short as possible
 
 
 Theo 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

From e91303d770c259eaca41c91772b3429fce2d2f61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Og=C3=BCn=20Karaku=C5=9F?= <kirk5bucuk@gmail.com>
Date: Wed, 7 Aug 2019 12:37:06 +0300
Subject: [PATCH 092/185] Update Turkish Translations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Ogün Karakuş <kirk5bucuk@gmail.com>
---
 translations/README-tr.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index 094456d0..0195d255 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -552,7 +552,7 @@ için `g` işaretini ayrıca belirtiyoruz.
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+[Düzenli ifadeyi test edin](https://regex101.com/r/jnk6gM/1)
 
 <pre>
 "/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.

From 7907bf7a879ea43015a9d81cd7ef4e0c7ae5e57e Mon Sep 17 00:00:00 2001
From: Kevin Pallikunnel <oapallikunnel@gmail.com>
Date: Fri, 9 Aug 2019 09:34:13 -0500
Subject: [PATCH 093/185] fixed image with spelling error

---
 img/regexp-en.png | Bin 32399 -> 26931 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/img/regexp-en.png b/img/regexp-en.png
index c38c90fb009dd72770ec7c32f5323ed968b5b07e..46b1a0b93ca7c036b10a4f2a7fd9a2a5a591fdea 100644
GIT binary patch
literal 26931
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
ZjtDY56v1G_i;jM?JZ5WFYT|P9e*o(lYz_bb

literal 32399
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
KpE1FA{eJ-|l+%p>


From fec4133b862c4fa3dd9c0dbf412157befee7526c Mon Sep 17 00:00:00 2001
From: Johnny <johnny.m.bui@jpl.nasa.gov>
Date: Fri, 9 Aug 2019 10:33:19 -0700
Subject: [PATCH 094/185] Add vietnamese link and fix relative links

---
 README.md                        |  1 +
 translations/README-cn.md        |  3 ++-
 translations/README-es.md        |  1 +
 translations/README-fr.md        |  3 ++-
 translations/README-gr.md        |  3 ++-
 translations/README-hu.md        |  3 ++-
 translations/README-ja.md        |  3 ++-
 translations/README-ko.md        |  3 ++-
 translations/README-pl.md        |  3 ++-
 translations/README-pt_BR.md     |  3 ++-
 translations/README-ru.md        |  1 +
 translations/README-tr.md        |  3 ++-
 translations/README-vn.md        | 26 +++++++++++++-------------
 translations/README-zh-simple.md |  3 ++-
 14 files changed, 36 insertions(+), 23 deletions(-)

diff --git a/README.md b/README.md
index dd140b7f..3a5c0557 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@
 * [Magyar](translations/README-hu.md)
 * [Polish](translations/README-pl.md)
 * [Русский](translations/README-ru.md)
+* [Tiếng Việt](translations/README-vn.md)
 
 ## What is Regular Expression?
 
diff --git a/translations/README-cn.md b/translations/README-cn.md
index 0ae81134..6cce5dee 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## 什么是正则表达式?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index a65a5fed..dbb8f29a 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -29,6 +29,7 @@
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index ab245d9d..4d495e97 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index a59eec5c..7d62a6e6 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index ffed4dbb..1017260f 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index e59a73b7..cb8df84a 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index c88b8fa6..05ae2977 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index a0cc5a70..c5213f51 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 1aaf7a4a..90170f48 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-ru.md b/translations/README-ru.md
index f1d10605..8e7ccdea 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -28,6 +28,7 @@
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Что такое Регулярное выражение?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 0195d255..8e601187 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -28,7 +28,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-vn.md b/translations/README-vn.md
index 6ca8470d..60c51e8d 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -18,19 +18,19 @@
 
 ## Translations:
 
-* [English](README.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
-* [Русский](translations/README-ru.md)
-* [Vietnamese](translations/README-vn.md)
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 
 ## Biểu thức chính quy là gì?
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 1a1736e2..8ee4847d 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -27,7 +27,8 @@
 * [Greek](../translations/README-gr.md)
 * [Magyar](../translations/README-hu.md)
 * [Polish](../translations/README-pl.md)
-* [Русский](translations/README-ru.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
 
 ## 什么是正则表达式?
  

From 88c778f971d04bf70a11bdeb03ebbcab36a9ead2 Mon Sep 17 00:00:00 2001
From: Jovibor <jovibor@users.noreply.github.com>
Date: Sun, 11 Aug 2019 20:36:53 +1000
Subject: [PATCH 095/185] Fixed typos

---
 translations/README-ru.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index 8e7ccdea..8f3ad116 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -170,7 +170,7 @@
 
 ## 2.3 Повторения
 
-Символы `+`, `*` или `?` используются для обозначения того, как сколько раз появляется какой-либо подшаблон.
+Символы `+`, `*` или `?` используются для обозначения того сколько раз появляется какой-либо подшаблон.
 Данные метасимволы могут вести себя по-разному, в зависимости от ситуации.
 
 ### 2.3.1 Звёздочка
@@ -289,7 +289,7 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/Rm7Me8/1)
 
-Не запоминающиеся группы пригодиться, когда они используются в функциях поиска и замены
+Незапоминающиеся группы могут пригодиться, когда они используются в функциях поиска и замены,
 или в сочетании со скобочными группами, например, для предпросмотра при создании скобочной группы или другого вида выходных данных,
 смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).
 
@@ -392,8 +392,8 @@
 
 Опережающие и ретроспективные проверки (в английской литературе lookbehind, lookahead) это особый вид
 ***не запоминающих скобочных групп*** (находящих совпадения, но не добавляющих в массив).
-Данные проверки используются, мы знаем, что шаблон предшествует или сопровождается другим шаблоном.
-Например, мы хотим получить получить цену в долларах `$`, из следующей входной строки
+Данные проверки используются когда мы знаем, что шаблон предшествует или сопровождается другим шаблоном.
+Например, мы хотим получить цену в долларах `$` из следующей входной строки
 `$4.44 and $10.88`. Для этого используем следующее регулярное выражение `(?<=\$)[0-9\.]*`, означающее
 получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара `$`. Существуют
 следующие виды проверок:

From 816b7384cfcc0e2b3c02001e638f6c7be1206324 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Thu, 29 Aug 2019 12:13:54 +0200
Subject: [PATCH 096/185] Start of Translation in German language.

---
 translations/README-de.md | 593 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 593 insertions(+)
 create mode 100644 translations/README-de.md

diff --git a/translations/README-de.md b/translations/README-de.md
new file mode 100644
index 00000000..f4e7e145
--- /dev/null
+++ b/translations/README-de.md
@@ -0,0 +1,593 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+</p>
+
+## Translations:
+
+* [English](../README.md)
+* [German](../translations/Readme-de.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
+
+## Was sind reguläre Ausdrücke
+
+> Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein spezifisches Muster in einem Text zu finden
+Ein regulärer Ausdruch ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
+"Regulärer Ausdruck" ist in der Praxis unüblich und stattdessen wird häufig die Englische Abkürzung "Regex" verwendet. Reguläre
+Ausdrücke werden verwendet um Fragemente eines Textes zu ersetzen, Formulare zu validieren, Segmente eines Textes anhand eines
+Musters zu extrahieren und für vieles mehr.
+
+Angenommen Du schreibst eine Applikation und möchtest die Regeln definieren, nach denen ein Benutzer seinen Benutzernamen auswählen
+kann. Wir möchten festlegen, dass der Benutzernamen Buchstaben, Ziffern, Unter- und Bindestriche beinhalten darf. Außerdem wollen
+wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu verwenden wir den folgenden regulären Ausdruck um
+den Benutzernamen zu überprüfen:
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird
+nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
+
+## Table of Contents
+
+- [Basis Vergleiche](#1-basic-matchers)
+- [Sonderzeichen](#2-meta-characters)
+  - [Punkt](#21-full-stop)
+  - [Character set](#22-character-set)
+    - [Invertierter Zeichensatz](#221-negated-character-set)
+  - [Wiederholungen](#23-repetitions)
+    - [Stern *](#231-the-star)
+    - [Plus +](#232-the-plus)
+    - [Fragezeichen ?](#233-the-question-mark)
+  - [Klammern](#24-braces)
+  - [Zeichengruppen](#25-character-group)
+  - [Alternation](#26-alternation)
+  - [Auswertung von Sonderzeichen](#27-escaping-special-character)
+  - [Anker](#28-anchors)
+    - [Caret ^](#281-caret)
+    - [Dollar $](#282-dollar)
+- [Kurzschreibweisen](#3-shorthand-character-sets)
+- [Umschauen](#4-lookaround)
+  - [Positives Vorrausschauen](#41-positive-lookahead)
+  - [Negatives Vorrausschauen](#42-negative-lookahead)
+  - [Positives Zurückschauen](#43-positive-lookbehind)
+  - [Negatives Zurückschauen](#44-negative-lookbehind)
+- [Steuerparameter](#5-flags)
+  - [Groß-/kleinschreibung](#51-case-insensitive)
+  - [Globale Suche](#52-global-search)
+  - [Mehrzeilig](#53-multiline)
+- [Gierige oder faule Übereinstimmung](#6-greedy-vs-lazy-matching)
+
+## 1. Basis Vergleiche
+
+A regular expression is just a pattern of characters that we use to perform
+search in a text.  For example, the regular expression `the` means: the letter
+`t`, followed by the letter `h`, followed by the letter `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dmRygT/1)
+
+The regular expression `123` matches the string `123`. The regular expression is
+matched against an input string by comparing each character in the regular
+expression to each character in the input string, one after another. Regular
+expressions are normally case-sensitive so the regular expression `The` would
+not match the string `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta Characters
+
+Meta characters are the building blocks of the regular expressions.  Meta
+characters do not stand for themselves but instead are interpreted in some
+special way. Some meta characters have a special meaning and are written inside
+square brackets. The meta characters are as follows:
+
+|Meta character|Description|
+|:----:|----|
+|.|Period matches any single character except a line break.|
+|[ ]|Character class. Matches any character contained between the square brackets.|
+|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
+|*|Matches 0 or more repetitions of the preceding symbol.|
+|+|Matches 1 or more repetitions of the preceding symbol.|
+|?|Makes the preceding symbol optional.|
+|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
+|(xyz)|Character group. Matches the characters xyz in that exact order.|
+|||Alternation. Matches either the characters before or the characters after the symbol.|
+|\|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Matches the beginning of the input.|
+|$|Matches the end of the input.|
+
+## 2.1 Full stop
+
+Full stop `.` is the simplest example of meta character. The meta character `.`
+matches any single character. It will not match return or newline characters.
+For example, the regular expression `.ar` means: any character, followed by the
+letter `a`, followed by the letter `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Character set
+
+Character sets are also called character class. Square brackets are used to
+specify character sets. Use a hyphen inside a character set to specify the
+characters' range. The order of the character range inside square brackets
+doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
+`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+
+A period inside a character set, however, means a literal period. The regular
+expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
+followed by a period `.` character.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negated character set
+
+In general, the caret symbol represents the start of the string, but when it is
+typed after the opening square bracket it negates the character set. For
+example, the regular expression `[^c]ar` means: any character except `c`,
+followed by the character `a`, followed by the letter `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Repetitions
+
+Following meta characters `+`, `*` or `?` are used to specify how many times a
+subpattern can occur. These meta characters act differently in different
+situations.
+
+### 2.3.1 The Star
+
+The symbol `*` matches zero or more repetitions of the preceding matcher. The
+regular expression `a*` means: zero or more repetitions of preceding lowercase
+character `a`. But if it appears after a character set or class then it finds
+the repetitions of the whole character set. For example, the regular expression
+`[a-z]*` means: any number of lowercase letters in a row.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/7m8me5/1)
+
+The `*` symbol can be used with the meta character `.` to match any string of
+characters `.*`. The `*` symbol can be used with the whitespace character `\s`
+to match a string of whitespace characters. For example, the expression
+`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
+followed by lowercase character `a`, followed by lowercase character `t`,
+followed by zero or more spaces.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 The Plus
+
+The symbol `+` matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+at least one character, followed by the lowercase character `t`. It needs to be
+clarified that `t` is the last `t` in the sentence.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 The Question Mark
+
+In regular expression the meta character `?` makes the preceding character
+optional. This symbol matches zero or one instance of the preceding character.
+For example, the regular expression `[T]?he` means: Optional the uppercase
+letter `T`, followed by the lowercase character `h`, followed by the lowercase
+character `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Braces
+
+In regular expression braces that are also called quantifiers are used to
+specify the number of times that a character or a group of characters can be
+repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
+2 digits but not more than 3 ( characters in the range of 0 to 9).
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/juM86s/1)
+
+We can leave out the second number. For example, the regular expression
+`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
+regular expression `[0-9]{3}` means: Match exactly 3 digits.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Capturing Group
+
+A capturing group is a group of sub-patterns that is written inside Parentheses 
+`(...)`. Like as we discussed before that in regular expression if we put a quantifier 
+after a character then it will repeat the preceding character. But if we put quantifier
+after a capturing group then it repeats the whole capturing group. For example,
+the regular expression `(ab)*` matches zero or more repetitions of the character
+"ab". We can also use the alternation `|` meta character inside capturing group.
+For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+`g` or `p`, followed by character `a`, followed by character `r`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+
+Note that capturing groups do not only match but also capture the characters for use in 
+the parent language. The parent language could be python or javascript or virtually any
+language that implements regular expressions in a function definition.
+
+### 2.5.1 Non-capturing group
+
+A non-capturing group is a capturing group that only matches the characters, but 
+does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
+within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+Non-capturing groups can come in handy when used in find-and-replace functionality or 
+when mixed with capturing groups to keep the overview when producing any other kind of output. 
+See also [4. Lookaround](#4-lookaround).
+
+## 2.6 Alternation
+
+In a regular expression, the vertical bar `|` is used to define alternation.
+Alternation is like an OR statement between multiple expressions. Now, you may be
+thinking that character set and alternation works the same way. But the big
+difference between character set and alternation is that character set works on
+character level but alternation works on expression level. For example, the
+regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
+`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
+(lowercase character `c`, followed by lowercase character `a`, followed by
+lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
+in parentheses can be met and it will match.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Escaping special character
+
+Backslash `\` is used in regular expression to escape the next character. This
+allows us to specify a symbol as a matching character including reserved
+characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
+character prepend `\` before it.
+
+For example, the regular expression `.` is used to match any character except
+newline. Now to match `.` in an input string the regular expression
+`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
+character `a`, followed by lowercase letter `t`, followed by optional `.`
+character.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Anchors
+
+In regular expressions, we use anchors to check if the matching symbol is the
+starting symbol or ending symbol of the input string. Anchors are of two types:
+First type is Caret `^` that check if the matching character is the start
+character of the input and the second type is Dollar `$` that checks if matching
+character is the last character of the input string.
+
+### 2.8.1 Caret
+
+Caret `^` symbol is used to check if matching character is the first character
+of the input string. If we apply the following regular expression `^a` (if a is
+the starting symbol) to input string `abc` it matches `a`. But if we apply
+regular expression `^b` on above input string it does not match anything.
+Because in input string `abc` "b" is not the starting symbol. Let's take a look
+at another regular expression `^(T|t)he` which means: uppercase character `T` or
+lowercase character `t` is the start symbol of the input string, followed by
+lowercase character `h`, followed by lowercase character `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dollar
+
+Dollar `$` symbol is used to check if matching character is the last character
+of the input string. For example, regular expression `(at\.)$` means: a
+lowercase character `a`, followed by lowercase character `t`, followed by a `.`
+character and the matcher must be end of the string.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+
+##  3. Shorthand Character Sets
+
+Regular expression provides shorthands for the commonly used character sets,
+which offer convenient shorthands for commonly used regular expressions. The
+shorthand character sets are as follows:
+
+|Shorthand|Description|
+|:----:|----|
+|.|Any character except new line|
+|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
+|\W|Matches non-alphanumeric characters: `[^\w]`|
+|\d|Matches digit: `[0-9]`|
+|\D|Matches non-digit: `[^\d]`|
+|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
+|\S|Matches non-whitespace character: `[^\s]`|
+
+## 4. Lookaround
+
+Lookbehind and lookahead (also called lookaround) are specific types of
+***non-capturing groups*** (Used to match the pattern but not included in matching
+list). Lookarounds are used when we have the condition that this pattern is
+preceded or followed by another certain pattern. For example, we want to get all
+numbers that are preceded by `$` character from the following input string
+`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
+which means: get all the numbers which contain `.` character and  are preceded
+by `$` character. Following are the lookarounds that are used in regular
+expressions:
+
+|Symbol|Description|
+|:----:|----|
+|?=|Positive Lookahead|
+|?!|Negative Lookahead|
+|?<=|Positive Lookbehind|
+|?<!|Negative Lookbehind|
+
+### 4.1 Positive Lookahead
+
+The positive lookahead asserts that the first part of the expression must be
+followed by the lookahead expression. The returned match only contains the text
+that is matched by the first part of the expression. To define a positive
+lookahead, parentheses are used. Within those parentheses, a question mark with
+equal sign is used like this: `(?=...)`. Lookahead expression is written after
+the equal sign inside parentheses. For example, the regular expression
+`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
+letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
+define positive lookahead which tells regular expression engine to match `The`
+or `the` which are followed by the word `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Negative Lookahead
+
+Negative lookahead is used when we need to get all matches from input string
+that are not followed by a pattern. Negative lookahead is defined same as we define
+positive lookahead but the only difference is instead of equal `=` character we
+use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
+from input string that are not followed by the word `fat` precedes by a space
+character.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Positive Lookbehind
+
+Positive lookbehind is used to get all the matches that are preceded by a
+specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
+regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
+from input string that are after the word `The` or `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+
+### 4.4 Negative Lookbehind
+
+Negative lookbehind is used to get all the matches that are not preceded by a
+specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
+regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
+string that are not after the word `The` or `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flags
+
+Flags are also called modifiers because they modify the output of a regular
+expression. These flags can be used in any order or combination, and are an
+integral part of the RegExp.
+
+|Flag|Description|
+|:----:|----|
+|i|Case insensitive: Sets matching to be case-insensitive.|
+|g|Global Search: Search for a pattern throughout the input string.|
+|m|Multiline: Anchor meta character works on each line.|
+
+### 5.1 Case Insensitive
+
+The `i` modifier is used to perform case-insensitive matching. For example, the
+regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
+character `h`, followed by character `e`. And at the end of regular expression
+the `i` flag tells the regular expression engine to ignore the case. As you can
+see we also provided `g` flag because we want to search for the pattern in the
+whole input string.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Global search
+
+The `g` modifier is used to perform a global match (find all matches rather than
+stopping after the first match). For example, the regular expression`/.(at)/g`
+means: any character except new line, followed by lowercase character `a`,
+followed by lowercase character `t`. Because we provided `g` flag at the end of
+the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multiline
+
+The `m` modifier is used to perform a multi-line match. As we discussed earlier
+anchors `(^, $)` are used to check if pattern is the beginning of the input or
+end of the input string. But if we want that anchors works on each line we use
+`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
+character `a`, followed by lowercase character `t`, optionally anything except
+new line. And because of `m` flag now regular expression engine matches pattern
+at the end of each line in a string.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/E88WE2/1)
+
+## 6. Greedy vs lazy matching
+By default regex will do greedy matching , means it will match as long as
+possible. we can use `?` to match in lazy way means as short as possible
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+
+
+## Contribution
+
+* Open pull request with improvements
+* Discuss ideas in issues
+* Spread the word
+* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From e3a1744640c2eef8c4e3d3606c33f6a883366eb7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Thu, 29 Aug 2019 12:21:24 +0200
Subject: [PATCH 097/185] Update path to self file and image

---
 translations/README-de.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index f4e7e145..b503af40 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -8,7 +8,7 @@
 ## Translations:
 
 * [English](../README.md)
-* [German](../translations/Readme-de.md)
+* [German](Readme-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -36,7 +36,7 @@ wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu
 den Benutzernamen zu überprüfen:
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
 Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird

From b0f6cf611b805fed710edc270d126cec7e7d098e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Thu, 29 Aug 2019 12:22:19 +0200
Subject: [PATCH 098/185] Remove Link we are on the file

---
 translations/README-de.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index b503af40..22463f61 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -8,7 +8,7 @@
 ## Translations:
 
 * [English](../README.md)
-* [German](Readme-de.md)
+* German
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)

From 21cf6aefe58165b14079ccedaf8714af6b02b6d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Thu, 29 Aug 2019 12:23:14 +0200
Subject: [PATCH 099/185] Add link to German translation.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 3a5c0557..63c8a7ed 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@
 ## Translations:
 
 * [English](README.md)
+* [German](translations/README-de.md)
 * [Español](translations/README-es.md)
 * [Français](translations/README-fr.md)
 * [Português do Brasil](translations/README-pt_BR.md)

From 81660715a4cb5ffb2a1de8b953b800f735d877e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Thu, 29 Aug 2019 15:01:28 +0200
Subject: [PATCH 100/185] Add more translations

---
 translations/README-de.md | 32 +++++++++++---------------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 22463f61..ff2ebd4a 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -39,8 +39,7 @@ den Benutzernamen zu überprüfen:
   <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
-Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird
-nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
+Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
 
 ## Table of Contents
 
@@ -53,9 +52,9 @@ nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
     - [Stern *](#231-the-star)
     - [Plus +](#232-the-plus)
     - [Fragezeichen ?](#233-the-question-mark)
-  - [Klammern](#24-braces)
+  - [Klammern {}](#24-braces)
   - [Zeichengruppen](#25-character-group)
-  - [Alternation](#26-alternation)
+  - [Alternation |](#26-alternation)
   - [Auswertung von Sonderzeichen](#27-escaping-special-character)
   - [Anker](#28-anchors)
     - [Caret ^](#281-caret)
@@ -67,43 +66,34 @@ nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
   - [Positives Zurückschauen](#43-positive-lookbehind)
   - [Negatives Zurückschauen](#44-negative-lookbehind)
 - [Steuerparameter](#5-flags)
-  - [Groß-/kleinschreibung](#51-case-insensitive)
+  - [Groß-/Kleinschreibung](#51-case-insensitive)
   - [Globale Suche](#52-global-search)
   - [Mehrzeilig](#53-multiline)
 - [Gierige oder faule Übereinstimmung](#6-greedy-vs-lazy-matching)
 
 ## 1. Basis Vergleiche
 
-A regular expression is just a pattern of characters that we use to perform
-search in a text.  For example, the regular expression `the` means: the letter
-`t`, followed by the letter `h`, followed by the letter `e`.
+Ein regulärer Ausdruck ist ein einfaches Muster von Zeichen, welches für eine Suche in Text genutzt wird. Zum Beispiel, der reguläre Ausdruck `the` meint: der Buchstabe `t`, gefolgt durch den Buchstaben `h`, gefolgt durch den Buchstaben `e`.
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dmRygT/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1)
 
-The regular expression `123` matches the string `123`. The regular expression is
-matched against an input string by comparing each character in the regular
-expression to each character in the input string, one after another. Regular
-expressions are normally case-sensitive so the regular expression `The` would
-not match the string `the`.
+Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre Ausdruck kann mit einer Zeichenkette verglichen werden, in dem jedes Zeichen in dem regulären Ausdruck nacheinander verglichen wird. Reguläre Ausdrücke sind normalerweise case sensitiv, Beachtung von Groß-/Kleinschreibung, so dass der Ausdruck `The` nicht mit der Zeichenkette  `the` überein stimmen würde. 
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/1paXsy/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/1paXsy/1)
 
-## 2. Meta Characters
+## 2. Sonderzeichen
 
-Meta characters are the building blocks of the regular expressions.  Meta
-characters do not stand for themselves but instead are interpreted in some
-special way. Some meta characters have a special meaning and are written inside
-square brackets. The meta characters are as follows:
+Sonderzeichen sind Bausteine von regulären Ausdrücken. Sonderzeichen stehen nicht für sich selbst, sondern werden in speziellen Fällen interpretiert. Einige Sonderzeichen haben eine besondere Bedeutung und sind innerhalb eckiger Klammern `[]`. Folgende Sonderzeichen sind möglich:
 
-|Meta character|Description|
+|Sonderzeichen|Beschreibung|
 |:----:|----|
 |.|Period matches any single character except a line break.|
 |[ ]|Character class. Matches any character contained between the square brackets.|

From 807c7071aaee4cb4ed084b9afd5cb5ba7b1c0717 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B0=AD=E4=B9=9D=E9=BC=8E?= <109224573@qq.com>
Date: Mon, 7 Oct 2019 11:17:00 +0800
Subject: [PATCH 101/185] Update zh-CN

---
 translations/README-cn.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 6cce5dee..c885630c 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -179,7 +179,7 @@
 ### 2.3.1 `*` 号
 
 `*`号匹配 在`*`之前的字符出现`大于等于0`次.
-例如, 表达式 `a*` 匹配以0或更多个a开头的字符, 因为有0个这个条件, 其实也就匹配了所有的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串.
+例如, 表达式 `a*` 匹配0或更多个以a开头的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -199,7 +199,7 @@
 ### 2.3.2 `+` 号
 
 `+`号匹配`+`号之前的字符出现 >=1 次.
-例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着任意个字符的字符串.
+例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着至少一个字符的字符串.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.

From 73403e6fdfa9748ddfae845372ee78fa2f051afc Mon Sep 17 00:00:00 2001
From: Caleb Mazalevskis <maikuolan@gmail.com>
Date: Sun, 13 Oct 2019 21:04:51 +0800
Subject: [PATCH 102/185] Fix typo.

(See: https://www.diccionariodedudas.com/remplazar-o-reemplazar/)
---
 translations/README-es.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-es.md b/translations/README-es.md
index dbb8f29a..da6d3e15 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -34,7 +34,7 @@
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
 
-Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para remplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
+Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para reemplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
 
 Imagina que estás escribiendo una aplicación y quieres agregar reglas para cuando el usuario elija su nombre de usuario. Nosotros queremos permitir que el nombre de usuario contenga letras, números, guión bajo (raya), y guión medio. También queremos limitar el número de caracteres en el nombre de usuario para que no se vea feo. Para ello usamos la siguiente expresión regular para validar el nombre de usuario.
 

From 65c7e3ee7e81c20c804955723c343c0218cb3575 Mon Sep 17 00:00:00 2001
From: Roberto Ruccia <roberto.ruccia@gmail.com>
Date: Tue, 8 Oct 2019 15:52:51 +0200
Subject: [PATCH 103/185] Fix typos

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 3a5c0557..23a2b86e 100644
--- a/README.md
+++ b/README.md
@@ -252,7 +252,7 @@ character `e`.
 In regular expression braces that are also called quantifiers are used to
 specify the number of times that a character or a group of characters can be
 repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
-2 digits but not more than 3 ( characters in the range of 0 to 9).
+2 digits but not more than 3 (characters in the range of 0 to 9).
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -421,7 +421,7 @@ shorthand character sets are as follows:
 ## 4. Lookaround
 
 Lookbehind and lookahead (also called lookaround) are specific types of
-***non-capturing groups*** (Used to match the pattern but not included in matching
+***non-capturing groups*** (used to match the pattern but not included in matching
 list). Lookarounds are used when we have the condition that this pattern is
 preceded or followed by another certain pattern. For example, we want to get all
 numbers that are preceded by `$` character from the following input string
@@ -578,8 +578,8 @@ at the end of each line in a string.
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
 ## 6. Greedy vs lazy matching
-By default regex will do greedy matching , means it will match as long as
-possible. we can use `?` to match in lazy way means as short as possible
+By default regex will do greedy matching which means it will match as long as
+possible. We can use `?` to match in lazy way which means as short as possible.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>

From 5e624ad0fe3dde51e9350da814e4d779575bbd2a Mon Sep 17 00:00:00 2001
From: chenyuheng <pass@chenyuheng.cn>
Date: Fri, 18 Oct 2019 00:41:44 +0800
Subject: [PATCH 104/185] update the Chinese text punctuations to fullwidth
 marks

reference: https://en.wikipedia.org/wiki/Chinese_punctuation#Marks_similar_to_European_punctuation
---
 translations/README-cn.md | 217 +++++++++++++++++++-------------------
 1 file changed, 108 insertions(+), 109 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index c885630c..06c2a367 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -15,7 +15,7 @@
 </p>
 
 
-## 翻译:
+## 翻译：
 
 * [English](../README.md)
 * [Español](../translations/README-es.md)
@@ -31,25 +31,25 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 
-## 什么是正则表达式?
+## 什么是正则表达式？
 
-> 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子.
+> 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
 
+一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式。
+“Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。
+正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等。
 
-一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式.
-"Regular expression"这个词比较拗口, 我们常使用缩写的术语"regex"或"regexp".
-正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等.
-
-想象你正在写一个应用, 然后你想设定一个用户命名的规则, 让用户名包含字符,数字,下划线和连字符,以及限制字符的个数,好让名字看起来没那么丑.
-我们使用以下正则表达式来验证一个用户名:
+想象你正在写一个应用，然后你想设定一个用户命名的规则，让用户名包含字符、数字、下划线和连字符，以及限制字符的个数，好让名字看起来没那么丑。
+我们使用以下正则表达式来验证一个用户名：
 
 <br/><br/>
+
 <p align="center">
   <img src="../img/regexp-cn.png" alt="Regular expression">
 </p>
 
-以上的正则表达式可以接受 `john_doe`, `jo-hn_doe`, `john12_as`.
-但不匹配`Jo`, 因为它包含了大写的字母而且太短了.
+以上的正则表达式可以接受 `john_doe`、`jo-hn_doe`、`john12_as`。
+但不匹配`Jo`，因为它包含了大写的字母而且太短了。
 
 目录
 =================
@@ -77,17 +77,17 @@
 	* [4.3 ?<= ... 正后发断言](#43---正后发断言)
 	* [4.4 ?<!... 负后发断言](#44--负后发断言)
 * [5. 标志](#5-标志)
-	* [5.1 忽略大小写 (Case Insensitive)](#51-忽略大小写-case-insensitive)
-	* [5.2 全局搜索 (Global search)](#52-全局搜索-global-search)
-	* [5.3 多行修饰符 (Multiline)](#53-多行修饰符-multiline)
+	* [5.1 忽略大小写（Case Insensitive）](#51-忽略大小写-case-insensitive)
+	* [5.2 全局搜索（Global search）](#52-全局搜索-global-search)
+	* [5.3 多行修饰符（Multiline）](#53-多行修饰符-multiline)
 * [额外补充](#额外补充)
 * [贡献](#贡献)
 * [许可证](#许可证)
 
 ## 1. 基本匹配
 
-正则表达式其实就是在执行搜索时的格式, 它由一些字母和数字组合而成.
-例如: 一个正则表达式 `the`, 它表示一个规则: 由字母`t`开始,接着是`h`,再接着是`e`.
+正则表达式其实就是在执行搜索时的格式，它由一些字母和数字组合而成。
+例如：一个正则表达式 `the`，它表示一个规则：由字母`t`开始，接着是`h`，再接着是`e`。
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -95,9 +95,9 @@
 
 [在线练习](https://regex101.com/r/dmRygT/1)
 
-正则表达式`123`匹配字符串`123`. 它逐个字符的与输入的正则表达式做比较.
+正则表达式`123`匹配字符串`123`。它逐个字符的与输入的正则表达式做比较。
 
-正则表达式是大小写敏感的, 所以`The`不会匹配`the`.
+正则表达式是大小写敏感的，所以`The`不会匹配`the`。
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -107,29 +107,29 @@
 
 ## 2. 元字符
 
-正则表达式主要依赖于元字符.
-元字符不代表他们本身的字面意思, 他们都有特殊的含义. 一些元字符写在方括号中的时候有一些特殊的意思. 以下是一些元字符的介绍:
+正则表达式主要依赖于元字符。
+元字符不代表他们本身的字面意思，他们都有特殊的含义。一些元字符写在方括号中的时候有一些特殊的意思。以下是一些元字符的介绍：
 
 |元字符|描述|
 |:----:|----|
-|.|句号匹配任意单个字符除了换行符.|
-|[ ]|字符种类. 匹配方括号内的任意字符.|
-|[^ ]|否定的字符种类. 匹配除了方括号里的任意字符|
-|*|匹配>=0个重复的在*号之前的字符.|
-|+|匹配>=1个重复的+号前的字符.
+|.|句号匹配任意单个字符除了换行符。|
+|[ ]|字符种类。匹配方括号内的任意字符。|
+|[^ ]|否定的字符种类。匹配除了方括号里的任意字符|
+|*|匹配>=0个重复的在*号之前的字符。|
+|+|匹配>=1个重复的+号前的字符。
 |?|标记?之前的字符为可选.|
 |{n,m}|匹配num个大括号之前的字符 (n <= num <= m).|
-|(xyz)|字符集, 匹配与 xyz 完全相等的字符串.|
-|||或运算符,匹配符号前或后的字符.|
+|(xyz)|字符集，匹配与 xyz 完全相等的字符串.|
+|||或运算符，匹配符号前或后的字符.|
 |\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
 |^|从开始行开始匹配.|
 |$|从末端开始匹配.|
 
 ## 2.1 点运算符 `.`
 
-`.`是元字符中最简单的例子.
-`.`匹配任意单个字符, 但不匹配换行符.
-例如, 表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串.
+`.`是元字符中最简单的例子。
+`.`匹配任意单个字符，但不匹配换行符。
+例如，表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串。
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -139,11 +139,11 @@
 
 ## 2.2 字符集
 
-字符集也叫做字符类.
-方括号用来指定一个字符集.
-在方括号中使用连字符来指定字符集的范围.
-在方括号中的字符集不关心顺序.
-例如, 表达式`[Tt]he` 匹配 `the` 和 `The`.
+字符集也叫做字符类。
+方括号用来指定一个字符集。
+在方括号中使用连字符来指定字符集的范围。
+在方括号中的字符集不关心顺序。
+例如，表达式`[Tt]he` 匹配 `the` 和 `The`。
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -151,7 +151,7 @@
 
 [在线练习](https://regex101.com/r/2ITLQ4/1)
 
-方括号的句号就表示句号.
+方括号的句号就表示句号。
 表达式 `ar[.]` 匹配 `ar.`字符串
 
 <pre>
@@ -162,8 +162,8 @@
 
 ### 2.2.1 否定字符集
 
-一般来说 `^` 表示一个字符串的开头, 但它用在一个方括号的开头的时候, 它表示这个字符集是否定的.
-例如, 表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符.
+一般来说 `^` 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的。
+例如，表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符。
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -173,13 +173,13 @@
 
 ## 2.3 重复次数
 
-后面跟着元字符 `+`, `*` or `?` 的, 用来指定匹配子模式的次数.
-这些元字符在不同的情况下有着不同的意思.
+后面跟着元字符 `+`，`*` or `?` 的，用来指定匹配子模式的次数。
+这些元字符在不同的情况下有着不同的意思。
 
 ### 2.3.1 `*` 号
 
-`*`号匹配 在`*`之前的字符出现`大于等于0`次.
-例如, 表达式 `a*` 匹配0或更多个以a开头的字符. 表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串.
+`*`号匹配 在`*`之前的字符出现`大于等于0`次。
+例如，表达式 `a*` 匹配0或更多个以a开头的字符。表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串。
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -187,8 +187,8 @@
 
 [在线练习](https://regex101.com/r/7m8me5/1)
 
-`*`字符和`.`字符搭配可以匹配所有的字符`.*`.
-`*`和表示匹配空格的符号`\s`连起来用, 如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串.
+`*`字符和`.`字符搭配可以匹配所有的字符`.*`。
+`*`和表示匹配空格的符号`\s`连起来用，如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串。
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
@@ -198,8 +198,8 @@
 
 ### 2.3.2 `+` 号
 
-`+`号匹配`+`号之前的字符出现 >=1 次.
-例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾,中间跟着至少一个字符的字符串.
+`+`号匹配`+`号之前的字符出现 >=1 次。
+例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾，中间跟着至少一个字符的字符串。
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -209,8 +209,8 @@
 
 ### 2.3.3 `?` 号
 
-在正则表达式中元字符 `?` 标记在符号前面的字符为可选, 即出现 0 或 1 次.
-例如, 表达式 `[T]?he` 匹配字符串 `he` 和 `The`.
+在正则表达式中元字符 `?` 标记在符号前面的字符为可选，即出现 0 或 1 次。
+例如，表达式 `[T]?he` 匹配字符串 `he` 和 `The`。
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -226,8 +226,8 @@
 
 ## 2.4 `{}` 号
 
-在正则表达式中 `{}` 是一个量词, 常用来一个或一组字符可以重复出现的次数.
-例如,  表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字.
+在正则表达式中 `{}` 是一个量词，常用来一个或一组字符可以重复出现的次数。
+例如， 表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -235,8 +235,8 @@
 
 [在线练习](https://regex101.com/r/juM86s/1)
 
-我们可以省略第二个参数.
-例如, `[0-9]{2,}` 匹配至少两位 0~9 的数字.
+我们可以省略第二个参数。
+例如，`[0-9]{2,}` 匹配至少两位 0~9 的数字。
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -244,8 +244,8 @@
 
 [在线练习](https://regex101.com/r/Gdy4w5/1)
 
-如果逗号也省略掉则表示重复固定的次数.
-例如, `[0-9]{3}` 匹配3位数字
+如果逗号也省略掉则表示重复固定的次数。
+例如，`[0-9]{3}` 匹配3位数字
 
 <pre>
 "[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
@@ -255,9 +255,9 @@
 
 ## 2.5 `(...)` 特征标群
 
-特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.
+特征标群是一组写在 `(...)` 中的子模式。例如之前说的 `{}` 是用来表示前面一个字符出现指定次数。但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次。例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。
 
-我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
+我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -267,9 +267,9 @@
 
 ## 2.6 `|` 或运算符
 
-或运算符就表示或, 用作判断条件.
+或运算符就表示或，用作判断条件。
 
-例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`.
+例如 `(T|t)he|car` 匹配 `(T|t)he` 或 `car`。
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -279,9 +279,9 @@
 
 ## 2.7 转码特殊字符
 
-反斜线 `\` 在表达式中用于转码紧跟其后的字符. 用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符. 如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`.
+反斜线 `\` 在表达式中用于转码紧跟其后的字符。用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符。如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`。
 
-例如 `.` 是用来匹配除换行符外的所有字符的. 如果想要匹配句子中的 `.` 则要写成 `\.` 以下这个例子 `\.?`是选择性匹配`.`
+例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\.` 以下这个例子 `\.?`是选择性匹配`.`
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -291,15 +291,15 @@
 
 ## 2.8 锚点
 
-在正则表达式中, 想要匹配指定开头或结尾的字符串就要使用到锚点. `^` 指定开头, `$` 指定结尾.
+在正则表达式中，想要匹配指定开头或结尾的字符串就要使用到锚点。`^` 指定开头，`$` 指定结尾。
 
 ### 2.8.1 `^` 号
 
-`^` 用来检查匹配的字符串是否在所匹配字符串的开头.
+`^` 用来检查匹配的字符串是否在所匹配字符串的开头。
 
-例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头.
+例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。但如果使用 `^b` 将匹配不到任何结果。因为在字符串 `abc` 中并不是以 `b` 开头。
 
-例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串.
+例如，`^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串。
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -315,9 +315,9 @@
 
 ### 2.8.2 `$` 号
 
-同理于 `^` 号, `$` 号用来匹配字符是否是最后一个.
+同理于 `^` 号，`$` 号用来匹配字符是否是最后一个。
 
-例如, `(at\.)$` 匹配以 `at.` 结尾的字符串.
+例如，`(at\.)$` 匹配以 `at.` 结尾的字符串。
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -333,33 +333,33 @@
 
 ##  3. 简写字符集
 
-正则表达式提供一些常用的字符集简写. 如下:
+正则表达式提供一些常用的字符集简写。如下:
 
 |简写|描述|
 |:----:|----|
 |.|除换行符外的所有字符|
-|\w|匹配所有字母数字, 等同于 `[a-zA-Z0-9_]`|
-|\W|匹配所有非字母数字, 即符号, 等同于: `[^\w]`|
-|\d|匹配数字: `[0-9]`|
-|\D|匹配非数字: `[^\d]`|
-|\s|匹配所有空格字符, 等同于: `[\t\n\f\r\p{Z}]`|
-|\S|匹配所有非空格字符: `[^\s]`|
+|\w|匹配所有字母数字，等同于 `[a-zA-Z0-9_]`|
+|\W|匹配所有非字母数字，即符号，等同于： `[^\w]`|
+|\d|匹配数字： `[0-9]`|
+|\D|匹配非数字： `[^\d]`|
+|\s|匹配所有空格字符，等同于： `[\t\n\f\r\p{Z}]`|
+|\S|匹配所有非空格字符： `[^\s]`|
 |\f|匹配一个换页符|
 |\n|匹配一个换行符|
 |\r|匹配一个回车符|
 |\t|匹配一个制表符|
 |\v|匹配一个垂直制表符|
-|\p|匹配 CR/LF (等同于 `\r\n`)，用来匹配 DOS 行终止符|
+|\p|匹配 CR/LF（等同于 `\r\n`），用来匹配 DOS 行终止符|
 
-## 4. 零宽度断言(前后预查)
+## 4. 零宽度断言（前后预查）
 
-先行断言和后发断言都属于**非捕获簇**(不捕获文本 ，也不针对组合计进行计数).
-先行断言用于判断所匹配的格式是否在另一个确定的格式之前, 匹配结果不包含该确定格式(仅作为约束).
+先行断言和后发断言都属于**非捕获簇**（不捕获文本 ，也不针对组合计进行计数）。
+先行断言用于判断所匹配的格式是否在另一个确定的格式之前，匹配结果不包含该确定格式（仅作为约束）。
 
-例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正后发断言 `(?<=\$)[0-9\.]*`.
-这个表达式匹配 `$` 开头, 之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次.
+例如，我们想要获得所有跟在 `$` 符号后的数字，我们可以使用正后发断言 `(?<=\$)[0-9\.]*`。
+这个表达式匹配 `$` 开头，之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次。
 
-零宽度断言如下:
+零宽度断言如下：
 
 |符号|描述|
 |:----:|----|
@@ -370,13 +370,13 @@
 
 ### 4.1 `?=...` 正先行断言
 
-`?=...` 正先行断言, 表示第一部分表达式之后必须跟着 `?=...`定义的表达式.
+`?=...` 正先行断言，表示第一部分表达式之后必须跟着 `?=...`定义的表达式。
 
-返回结果只包含满足匹配条件的第一部分表达式.
-定义一个正先行断言要使用 `()`. 在括号内部使用一个问号和等号: `(?=...)`. 
+返回结果只包含满足匹配条件的第一部分表达式。
+定义一个正先行断言要使用 `()`。在括号内部使用一个问号和等号： `(?=...)`。
 
-正先行断言的内容写在括号中的等号后面.
-例如, 表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`, 在括号中我们又定义了正先行断言 `(?=\sfat)` ,即 `The` 和 `the` 后面紧跟着 `(空格)fat`.
+正先行断言的内容写在括号中的等号后面。
+例如，表达式 `(T|t)he(?=\sfat)` 匹配 `The` 和 `the`，在括号中我们又定义了正先行断言 `(?=\sfat)` ，即 `The` 和 `the` 后面紧跟着 `(空格)fat`。
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -386,10 +386,10 @@
 
 ### 4.2 `?!...` 负先行断言
 
-负先行断言 `?!` 用于筛选所有匹配结果, 筛选条件为 其后不跟随着断言中定义的格式.
-`正先行断言`  定义和 `负先行断言` 一样, 区别就是 `=` 替换成 `!` 也就是 `(?!...)`.
+负先行断言 `?!` 用于筛选所有匹配结果，筛选条件为 其后不跟随着断言中定义的格式。
+`正先行断言`  定义和 `负先行断言` 一样，区别就是 `=` 替换成 `!` 也就是 `(?!...)`。
 
-表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`, 且其后不跟着 `(空格)fat`.
+表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`，且其后不跟着 `(空格)fat`。
 
 <pre>
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -399,8 +399,8 @@
 
 ### 4.3 `?<= ...` 正后发断言
 
-正后发断言 记作`(?<=...)` 用于筛选所有匹配结果, 筛选条件为 其前跟随着断言中定义的格式.
-例如, 表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`, 且其前跟着 `The` 或 `the`.
+正后发断言 记作`(?<=...)` 用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。
+例如，表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`，且其前跟着 `The` 或 `the`。
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -410,8 +410,8 @@
 
 ### 4.4 `?<!...` 负后发断言
 
-负后发断言 记作 `(?<!...)` 用于筛选所有匹配结果, 筛选条件为 其前不跟随着断言中定义的格式.
-例如, 表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`, 且其前不跟着 `The` 或 `the`.
+负后发断言 记作 `(?<!...)` 用于筛选所有匹配结果，筛选条件为 其前不跟随着断言中定义的格式。
+例如，表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`，且其前不跟着 `The` 或 `the`。
 
 <pre>
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -421,19 +421,19 @@
 
 ## 5. 标志
 
-标志也叫模式修正符, 因为它可以用来修改表达式的搜索结果.
-这些标志可以任意的组合使用, 它也是整个正则表达式的一部分.
+标志也叫模式修正符，因为它可以用来修改表达式的搜索结果。
+这些标志可以任意的组合使用，它也是整个正则表达式的一部分。
 
 |标志|描述|
 |:----:|----|
-|i|忽略大小写.|
-|g|全局搜索.|
-|m|多行的: 锚点元字符 `^` `$` 工作范围在每行的起始.|
+|i|忽略大小写。|
+|g|全局搜索。|
+|m|多行修饰符：锚点元字符 `^` `$` 工作范围在每行的起始。|
 
-### 5.1 忽略大小写 (Case Insensitive)
+### 5.1 忽略大小写（Case Insensitive）
 
-修饰语 `i` 用于忽略大小写.
-例如, 表达式 `/The/gi` 表示在全局搜索 `The`, 在后面的 `i` 将其条件修改为忽略大小写, 则变成搜索 `the` 和 `The`, `g` 表示全局搜索.
+修饰语 `i` 用于忽略大小写。
+例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`，`g` 表示全局搜索。
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -447,10 +447,10 @@
 
 [在线练习](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 全局搜索 (Global search)
+### 5.2 全局搜索（Global search）
 
-修饰符 `g` 常用于执行一个全局搜索匹配, 即(不仅仅返回第一个匹配的, 而是返回全部).
-例如, 表达式 `/.(at)/g` 表示搜索 任意字符(除了换行) + `at`, 并返回全部结果.
+修饰符 `g` 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。
+例如，表达式 `/.(at)/g` 表示搜索 任意字符（除了换行）+ `at`，并返回全部结果。
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -464,13 +464,13 @@
 
 [在线练习](https://regex101.com/r/dO1nef/1)
 
-### 5.3 多行修饰符 (Multiline)
+### 5.3 多行修饰符（Multiline）
 
-多行修饰符 `m` 常用于执行一个多行匹配.
+多行修饰符 `m` 常用于执行一个多行匹配。
 
-像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
+像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾。但我们如果想要它在每行的开头和结尾生效，我们需要用到多行修饰符 `m`。
 
-例如, 表达式 `/at(.)?$/gm` 表示小写字符 `a` 后跟小写字符 `t` , 末尾可选除换行符外任意字符. 根据 `m` 修饰符, 现在表达式匹配每行的结尾.
+例如，表达式 `/at(.)?$/gm` 表示小写字符 `a` 后跟小写字符 `t` ，末尾可选除换行符外任意字符。根据 `m` 修饰符，现在表达式匹配每行的结尾。
 
 <pre>
 "/.at(.)?$/" => The fat
@@ -488,7 +488,7 @@
 
 [在线练习](https://regex101.com/r/E88WE2/1)
 
-### 6. 贪婪匹配与惰性匹配 (Greedy vs lazy matching)
+### 6. 贪婪匹配与惰性匹配（Greedy vs lazy matching）
 
 正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 `?` 将贪婪匹配模式转化为惰性匹配模式。
 
@@ -500,7 +500,6 @@
 <pre>
 "/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
 
-
 [在线练习](https://regex101.com/r/AyAdgJ/2)
 
 ## 贡献

From fbc008255920613f55ac6d80e36c6f0ec30eeb53 Mon Sep 17 00:00:00 2001
From: Yang Jin <kingyouge@gmail.com>
Date: Mon, 21 Oct 2019 15:33:41 +0800
Subject: [PATCH 105/185] update part of Chinese translation

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 06c2a367..eac7056a 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -35,7 +35,7 @@
 
 > 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
 
-一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式。
+一个正则表达式是一种从左到右匹配主体字符串的模式。
 “Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。
 正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等。
 

From 7e5a3f43ace034ace31beb743340bf0e09432153 Mon Sep 17 00:00:00 2001
From: Hamzeh Javadi <hjavadish@users.noreply.github.com>
Date: Sun, 27 Oct 2019 08:47:47 +0330
Subject: [PATCH 106/185] =?UTF-8?q?=D8=AF=D9=88=20=D9=BE=D8=A7=D8=B1=D8=A7?=
 =?UTF-8?q?=DA=AF=D8=B1=D8=A7=D9=81=20=D8=A2=D8=BA=D8=A7=D8=B2=20=DA=A9?=
 =?UTF-8?q?=D8=A7=D8=B1=DB=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

به همراه لینک برگردان فارسی از تمام زبانهای موجود
---
 README.md                    |   1 +
 translations/README-cn.md    |   1 +
 translations/README-es.md    |   1 +
 translations/README-fa.md    | 598 +++++++++++++++++++++++++++++++++++
 translations/README-fr.md    |   1 +
 translations/README-gr.md    |   1 +
 translations/README-hu.md    |   1 +
 translations/README-ja.md    |   1 +
 translations/README-ko.md    |   1 +
 translations/README-pl.md    |   1 +
 translations/README-pt_BR.md |   1 +
 translations/README-ru.md    |   1 +
 translations/README-tr.md    |   1 +
 translations/README-vn.md    |   1 +
 14 files changed, 611 insertions(+)
 create mode 100644 translations/README-fa.md

diff --git a/README.md b/README.md
index 3a5c0557..f6b409bd 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,7 @@
 * [Polish](translations/README-pl.md)
 * [Русский](translations/README-ru.md)
 * [Tiếng Việt](translations/README-vn.md)
+* [قارسی](translations/README-fa.md)
 
 ## What is Regular Expression?
 
diff --git a/translations/README-cn.md b/translations/README-cn.md
index eac7056a..f0d89ccb 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## 什么是正则表达式？
 
diff --git a/translations/README-es.md b/translations/README-es.md
index da6d3e15..782d94e3 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fa.md b/translations/README-fa.md
new file mode 100644
index 00000000..8a7a98cf
--- /dev/null
+++ b/translations/README-fa.md
@@ -0,0 +1,598 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+    <br /><br />
+    <p>
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
+        </a>
+        <a href="https://github.com/ziishaned">
+            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
+        </a>
+    </p>
+</p>
+
+## برگردان ها:
+
+* [English](../README.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
+
+<div rtl="ltr">
+## عبارت منظم چیست؟
+</div>
+> عبارت منظم یک گروه از کارکترها یا نمادهاست که برای پیدا کردن یک الگوی مشخص در یک متن به کار گرفته می شود.
+
+یک عبارت منظم یک الگو است که با رشته ای حاص مطابقت دارد. عبارت منظم در اعتبار سنجی داده های ورودی فرم ها، پیدا کردن یک زیر متن در یک متن بزرگتر بر اساس یک الگوی ویژ] و مواردی از این دست به کار گرفته می شود. عبارت "Regular expression" کمی ثقیل است، پس معمولا بیشتر مخفف آن  - "regex" یا "regexp" - را به کار می برند.
+
+فرض کنید یه برنامه نوشته اید و می خواهید قوانینی برای گزینش نام کاربری برا کاربران بگزارید.  می خواهیم اجازه دهی که نام کاربری شامل حروف، اعداد، خط زیر و خط فاصله باشد. همچنین می خواهیم تعداد مشخصه ها یا همان کارکترها در نام کاربری محدود کنیم . ما از چنین عبارت منظمی برای اعتبار سنجی نام کاربری استفاده می کنیم:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+عبارت منظم به کار رفته در اینجا رشته `john_doe` و `jo-hn_doe` و `john12_as` می پذیرد ولی `Jo` را به دلیل کوتاه بودن بیش از حد و همچنین به کار بردن حروف بزرگ نمی پذیرد.
+
+## Table of Contents
+
+- [Basic Matchers](#1-basic-matchers)
+- [Meta character](#2-meta-characters)
+  - [Full stop](#21-full-stop)
+  - [Character set](#22-character-set)
+    - [Negated character set](#221-negated-character-set)
+  - [Repetitions](#23-repetitions)
+    - [The Star](#231-the-star)
+    - [The Plus](#232-the-plus)
+    - [The Question Mark](#233-the-question-mark)
+  - [Braces](#24-braces)
+  - [Character Group](#25-character-group)
+  - [Alternation](#26-alternation)
+  - [Escaping special character](#27-escaping-special-character)
+  - [Anchors](#28-anchors)
+    - [Caret](#281-caret)
+    - [Dollar](#282-dollar)
+- [Shorthand Character Sets](#3-shorthand-character-sets)
+- [Lookaround](#4-lookaround)
+  - [Positive Lookahead](#41-positive-lookahead)
+  - [Negative Lookahead](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
+- [Flags](#5-flags)
+  - [Case Insensitive](#51-case-insensitive)
+  - [Global search](#52-global-search)
+  - [Multiline](#53-multiline)
+- [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
+
+## 1. Basic Matchers
+
+A regular expression is just a pattern of characters that we use to perform
+search in a text.  For example, the regular expression `the` means: the letter
+`t`, followed by the letter `h`, followed by the letter `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dmRygT/1)
+
+The regular expression `123` matches the string `123`. The regular expression is
+matched against an input string by comparing each character in the regular
+expression to each character in the input string, one after another. Regular
+expressions are normally case-sensitive so the regular expression `The` would
+not match the string `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/1paXsy/1)
+
+## 2. Meta Characters
+
+Meta characters are the building blocks of the regular expressions.  Meta
+characters do not stand for themselves but instead are interpreted in some
+special way. Some meta characters have a special meaning and are written inside
+square brackets. The meta characters are as follows:
+
+|Meta character|Description|
+|:----:|----|
+|.|Period matches any single character except a line break.|
+|[ ]|Character class. Matches any character contained between the square brackets.|
+|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
+|*|Matches 0 or more repetitions of the preceding symbol.|
+|+|Matches 1 or more repetitions of the preceding symbol.|
+|?|Makes the preceding symbol optional.|
+|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
+|(xyz)|Character group. Matches the characters xyz in that exact order.|
+|||Alternation. Matches either the characters before or the characters after the symbol.|
+|\|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Matches the beginning of the input.|
+|$|Matches the end of the input.|
+
+## 2.1 Full stop
+
+Full stop `.` is the simplest example of meta character. The meta character `.`
+matches any single character. It will not match return or newline characters.
+For example, the regular expression `.ar` means: any character, followed by the
+letter `a`, followed by the letter `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Character set
+
+Character sets are also called character class. Square brackets are used to
+specify character sets. Use a hyphen inside a character set to specify the
+characters' range. The order of the character range inside square brackets
+doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
+`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+
+A period inside a character set, however, means a literal period. The regular
+expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
+followed by a period `.` character.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negated character set
+
+In general, the caret symbol represents the start of the string, but when it is
+typed after the opening square bracket it negates the character set. For
+example, the regular expression `[^c]ar` means: any character except `c`,
+followed by the character `a`, followed by the letter `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Repetitions
+
+Following meta characters `+`, `*` or `?` are used to specify how many times a
+subpattern can occur. These meta characters act differently in different
+situations.
+
+### 2.3.1 The Star
+
+The symbol `*` matches zero or more repetitions of the preceding matcher. The
+regular expression `a*` means: zero or more repetitions of preceding lowercase
+character `a`. But if it appears after a character set or class then it finds
+the repetitions of the whole character set. For example, the regular expression
+`[a-z]*` means: any number of lowercase letters in a row.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/7m8me5/1)
+
+The `*` symbol can be used with the meta character `.` to match any string of
+characters `.*`. The `*` symbol can be used with the whitespace character `\s`
+to match a string of whitespace characters. For example, the expression
+`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
+followed by lowercase character `a`, followed by lowercase character `t`,
+followed by zero or more spaces.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 The Plus
+
+The symbol `+` matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+at least one character, followed by the lowercase character `t`. It needs to be
+clarified that `t` is the last `t` in the sentence.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 The Question Mark
+
+In regular expression the meta character `?` makes the preceding character
+optional. This symbol matches zero or one instance of the preceding character.
+For example, the regular expression `[T]?he` means: Optional the uppercase
+letter `T`, followed by the lowercase character `h`, followed by the lowercase
+character `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Braces
+
+In regular expression braces that are also called quantifiers are used to
+specify the number of times that a character or a group of characters can be
+repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
+2 digits but not more than 3 ( characters in the range of 0 to 9).
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/juM86s/1)
+
+We can leave out the second number. For example, the regular expression
+`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
+regular expression `[0-9]{3}` means: Match exactly 3 digits.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Capturing Group
+
+A capturing group is a group of sub-patterns that is written inside Parentheses 
+`(...)`. Like as we discussed before that in regular expression if we put a quantifier 
+after a character then it will repeat the preceding character. But if we put quantifier
+after a capturing group then it repeats the whole capturing group. For example,
+the regular expression `(ab)*` matches zero or more repetitions of the character
+"ab". We can also use the alternation `|` meta character inside capturing group.
+For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+`g` or `p`, followed by character `a`, followed by character `r`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+
+Note that capturing groups do not only match but also capture the characters for use in 
+the parent language. The parent language could be python or javascript or virtually any
+language that implements regular expressions in a function definition.
+
+### 2.5.1 Non-capturing group
+
+A non-capturing group is a capturing group that only matches the characters, but 
+does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
+within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+Non-capturing groups can come in handy when used in find-and-replace functionality or 
+when mixed with capturing groups to keep the overview when producing any other kind of output. 
+See also [4. Lookaround](#4-lookaround).
+
+## 2.6 Alternation
+
+In a regular expression, the vertical bar `|` is used to define alternation.
+Alternation is like an OR statement between multiple expressions. Now, you may be
+thinking that character set and alternation works the same way. But the big
+difference between character set and alternation is that character set works on
+character level but alternation works on expression level. For example, the
+regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
+`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
+(lowercase character `c`, followed by lowercase character `a`, followed by
+lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
+in parentheses can be met and it will match.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Escaping special character
+
+Backslash `\` is used in regular expression to escape the next character. This
+allows us to specify a symbol as a matching character including reserved
+characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
+character prepend `\` before it.
+
+For example, the regular expression `.` is used to match any character except
+newline. Now to match `.` in an input string the regular expression
+`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
+character `a`, followed by lowercase letter `t`, followed by optional `.`
+character.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Anchors
+
+In regular expressions, we use anchors to check if the matching symbol is the
+starting symbol or ending symbol of the input string. Anchors are of two types:
+First type is Caret `^` that check if the matching character is the start
+character of the input and the second type is Dollar `$` that checks if matching
+character is the last character of the input string.
+
+### 2.8.1 Caret
+
+Caret `^` symbol is used to check if matching character is the first character
+of the input string. If we apply the following regular expression `^a` (if a is
+the starting symbol) to input string `abc` it matches `a`. But if we apply
+regular expression `^b` on above input string it does not match anything.
+Because in input string `abc` "b" is not the starting symbol. Let's take a look
+at another regular expression `^(T|t)he` which means: uppercase character `T` or
+lowercase character `t` is the start symbol of the input string, followed by
+lowercase character `h`, followed by lowercase character `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Dollar
+
+Dollar `$` symbol is used to check if matching character is the last character
+of the input string. For example, regular expression `(at\.)$` means: a
+lowercase character `a`, followed by lowercase character `t`, followed by a `.`
+character and the matcher must be end of the string.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+
+##  3. Shorthand Character Sets
+
+Regular expression provides shorthands for the commonly used character sets,
+which offer convenient shorthands for commonly used regular expressions. The
+shorthand character sets are as follows:
+
+|Shorthand|Description|
+|:----:|----|
+|.|Any character except new line|
+|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
+|\W|Matches non-alphanumeric characters: `[^\w]`|
+|\d|Matches digit: `[0-9]`|
+|\D|Matches non-digit: `[^\d]`|
+|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
+|\S|Matches non-whitespace character: `[^\s]`|
+
+## 4. Lookaround
+
+Lookbehind and lookahead (also called lookaround) are specific types of
+***non-capturing groups*** (Used to match the pattern but not included in matching
+list). Lookarounds are used when we have the condition that this pattern is
+preceded or followed by another certain pattern. For example, we want to get all
+numbers that are preceded by `$` character from the following input string
+`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
+which means: get all the numbers which contain `.` character and  are preceded
+by `$` character. Following are the lookarounds that are used in regular
+expressions:
+
+|Symbol|Description|
+|:----:|----|
+|?=|Positive Lookahead|
+|?!|Negative Lookahead|
+|?<=|Positive Lookbehind|
+|?<!|Negative Lookbehind|
+
+### 4.1 Positive Lookahead
+
+The positive lookahead asserts that the first part of the expression must be
+followed by the lookahead expression. The returned match only contains the text
+that is matched by the first part of the expression. To define a positive
+lookahead, parentheses are used. Within those parentheses, a question mark with
+equal sign is used like this: `(?=...)`. Lookahead expression is written after
+the equal sign inside parentheses. For example, the regular expression
+`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
+letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
+define positive lookahead which tells regular expression engine to match `The`
+or `the` which are followed by the word `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Negative Lookahead
+
+Negative lookahead is used when we need to get all matches from input string
+that are not followed by a pattern. Negative lookahead is defined same as we define
+positive lookahead but the only difference is instead of equal `=` character we
+use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
+from input string that are not followed by the word `fat` precedes by a space
+character.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Positive Lookbehind
+
+Positive lookbehind is used to get all the matches that are preceded by a
+specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
+regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
+from input string that are after the word `The` or `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+
+### 4.4 Negative Lookbehind
+
+Negative lookbehind is used to get all the matches that are not preceded by a
+specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
+regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
+string that are not after the word `The` or `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+
+## 5. Flags
+
+Flags are also called modifiers because they modify the output of a regular
+expression. These flags can be used in any order or combination, and are an
+integral part of the RegExp.
+
+|Flag|Description|
+|:----:|----|
+|i|Case insensitive: Sets matching to be case-insensitive.|
+|g|Global Search: Search for a pattern throughout the input string.|
+|m|Multiline: Anchor meta character works on each line.|
+
+### 5.1 Case Insensitive
+
+The `i` modifier is used to perform case-insensitive matching. For example, the
+regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
+character `h`, followed by character `e`. And at the end of regular expression
+the `i` flag tells the regular expression engine to ignore the case. As you can
+see we also provided `g` flag because we want to search for the pattern in the
+whole input string.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Global search
+
+The `g` modifier is used to perform a global match (find all matches rather than
+stopping after the first match). For example, the regular expression`/.(at)/g`
+means: any character except new line, followed by lowercase character `a`,
+followed by lowercase character `t`. Because we provided `g` flag at the end of
+the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multiline
+
+The `m` modifier is used to perform a multi-line match. As we discussed earlier
+anchors `(^, $)` are used to check if pattern is the beginning of the input or
+end of the input string. But if we want that anchors works on each line we use
+`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
+character `a`, followed by lowercase character `t`, optionally anything except
+new line. And because of `m` flag now regular expression engine matches pattern
+at the end of each line in a string.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/E88WE2/1)
+
+## 6. Greedy vs lazy matching
+By default regex will do greedy matching , means it will match as long as
+possible. we can use `?` to match in lazy way means as short as possible
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+
+
+## Contribution
+
+* Open pull request with improvements
+* Discuss ideas in issues
+* Spread the word
+* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## License
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
diff --git a/translations/README-fr.md b/translations/README-fr.md
index 4d495e97..db28f7b6 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 7d62a6e6..2e2141c1 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index 1017260f..e0c5ab02 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index cb8df84a..18ed0f13 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index 05ae2977..577bbfbb 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index c5213f51..84c50ef8 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 90170f48..d20b67b0 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-ru.md b/translations/README-ru.md
index 8e7ccdea..0dc6c677 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -29,6 +29,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Что такое Регулярное выражение?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 8e601187..d4713378 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -30,6 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-vn.md b/translations/README-vn.md
index 60c51e8d..a2920559 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -31,6 +31,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [قارسی](../translations/README-fa.md)
 
 
 ## Biểu thức chính quy là gì?

From 3faa6199f48138f3f5f8ac8cd8844cc027099bfd Mon Sep 17 00:00:00 2001
From: Hamzeh Javadi <hjavadish@users.noreply.github.com>
Date: Sun, 27 Oct 2019 08:52:54 +0330
Subject: [PATCH 107/185] Update README-fa.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

راست به چپ کردن و اصلاح تصویر
---
 translations/README-fa.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/translations/README-fa.md b/translations/README-fa.md
index 8a7a98cf..7cdee38a 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -31,10 +31,12 @@
 * [Tiếng Việt](../translations/README-vn.md)
 * [قارسی](../translations/README-fa.md)
 
-<div rtl="ltr">
+<div dir="rtl">
 ## عبارت منظم چیست؟
 </div>
+<div dir="rtl">
 > عبارت منظم یک گروه از کارکترها یا نمادهاست که برای پیدا کردن یک الگوی مشخص در یک متن به کار گرفته می شود.
+</div>
 
 یک عبارت منظم یک الگو است که با رشته ای حاص مطابقت دارد. عبارت منظم در اعتبار سنجی داده های ورودی فرم ها، پیدا کردن یک زیر متن در یک متن بزرگتر بر اساس یک الگوی ویژ] و مواردی از این دست به کار گرفته می شود. عبارت "Regular expression" کمی ثقیل است، پس معمولا بیشتر مخفف آن  - "regex" یا "regexp" - را به کار می برند.
 
@@ -42,11 +44,11 @@
 
 <br/><br/>
 <p align="center">
-  <img src="./img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
-
+<div dir="rtl">
 عبارت منظم به کار رفته در اینجا رشته `john_doe` و `jo-hn_doe` و `john12_as` می پذیرد ولی `Jo` را به دلیل کوتاه بودن بیش از حد و همچنین به کار بردن حروف بزرگ نمی پذیرد.
-
+</div>
 ## Table of Contents
 
 - [Basic Matchers](#1-basic-matchers)

From f8088499c869b37922edc86201bcab2a1b40af49 Mon Sep 17 00:00:00 2001
From: Hamzeh Javadi <hjavadish@users.noreply.github.com>
Date: Sun, 27 Oct 2019 09:06:43 +0330
Subject: [PATCH 108/185] Update README-fa.md

some rtl test
---
 translations/README-fa.md | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/translations/README-fa.md b/translations/README-fa.md
index 7cdee38a..02a76be1 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -32,16 +32,19 @@
 * [قارسی](../translations/README-fa.md)
 
 <div dir="rtl">
+
 ## عبارت منظم چیست؟
 </div>
 <div dir="rtl">
+
 > عبارت منظم یک گروه از کارکترها یا نمادهاست که برای پیدا کردن یک الگوی مشخص در یک متن به کار گرفته می شود.
 </div>
 
+<div dir="rtl">
 یک عبارت منظم یک الگو است که با رشته ای حاص مطابقت دارد. عبارت منظم در اعتبار سنجی داده های ورودی فرم ها، پیدا کردن یک زیر متن در یک متن بزرگتر بر اساس یک الگوی ویژ] و مواردی از این دست به کار گرفته می شود. عبارت "Regular expression" کمی ثقیل است، پس معمولا بیشتر مخفف آن  - "regex" یا "regexp" - را به کار می برند.
 
 فرض کنید یه برنامه نوشته اید و می خواهید قوانینی برای گزینش نام کاربری برا کاربران بگزارید.  می خواهیم اجازه دهی که نام کاربری شامل حروف، اعداد، خط زیر و خط فاصله باشد. همچنین می خواهیم تعداد مشخصه ها یا همان کارکترها در نام کاربری محدود کنیم . ما از چنین عبارت منظمی برای اعتبار سنجی نام کاربری استفاده می کنیم:
-
+</div>
 <br/><br/>
 <p align="center">
   <img src="../img/regexp-en.png" alt="Regular expression">
@@ -49,7 +52,9 @@
 <div dir="rtl">
 عبارت منظم به کار رفته در اینجا رشته `john_doe` و `jo-hn_doe` و `john12_as` می پذیرد ولی `Jo` را به دلیل کوتاه بودن بیش از حد و همچنین به کار بردن حروف بزرگ نمی پذیرد.
 </div>
-## Table of Contents
+<div dir="rtl">
+
+## فهرست
 
 - [Basic Matchers](#1-basic-matchers)
 - [Meta character](#2-meta-characters)
@@ -78,6 +83,7 @@
   - [Global search](#52-global-search)
   - [Multiline](#53-multiline)
 - [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
+</div>
 
 ## 1. Basic Matchers
 

From a817604833c338b71b956d8537b56f1169f4a175 Mon Sep 17 00:00:00 2001
From: Hamzeh Javadi <hjavadish@users.noreply.github.com>
Date: Sun, 27 Oct 2019 09:18:20 +0330
Subject: [PATCH 109/185] paragraph #1

---
 translations/README-fa.md | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/translations/README-fa.md b/translations/README-fa.md
index 02a76be1..e17f3bfa 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -84,24 +84,23 @@
   - [Multiline](#53-multiline)
 - [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
 </div>
+<div dir="rtl">
 
-## 1. Basic Matchers
-
-A regular expression is just a pattern of characters that we use to perform
-search in a text.  For example, the regular expression `the` means: the letter
-`t`, followed by the letter `h`, followed by the letter `e`.
+## 1. پایه ای ترین همخوانی
 
+یک عبارت منظم در واقع یک الگو برای جست و جو در یک متن است. برای مثال عبارت منظم  `the` به معنی : حرف
+`t`, پس از آن حرف `h`, پس از آن حرف  `e` است.
+</div>
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dmRygT/1)
 
-The regular expression `123` matches the string `123`. The regular expression is
-matched against an input string by comparing each character in the regular
-expression to each character in the input string, one after another. Regular
-expressions are normally case-sensitive so the regular expression `The` would
-not match the string `the`.
+<div dir="rtl">
+[عبارت منظم را در عمل ببینید](https://regex101.com/r/dmRygT/1)
+
+عبارت منظم `123` با رشته `123` مطابقت دارد. عبارت منظم با مقایسه حرف به حرف و کارکتر به کارکترش با متن مورد نظر تطابق را می یابد. همچنین عبارت منظم حساس به اندازه (بزرگی یا کوچکی حروف) هستند. بنابر این واژه ی `The` با  `the` همخوان نیست.
+</div>
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.

From fa254f2de75b566c8f08415bfe55d732c95158bb Mon Sep 17 00:00:00 2001
From: Hamzeh Javadi <hjavadish@users.noreply.github.com>
Date: Sun, 27 Oct 2019 09:26:46 +0330
Subject: [PATCH 110/185] =?UTF-8?q?=D8=A7=D8=B5=D9=84=D8=A7=D8=AD=20=D9=84?=
 =?UTF-8?q?=DB=8C=D9=86=DA=A9=20=D8=A8=D9=87=20=D8=A8=D8=B1=DA=AF=D8=B1?=
 =?UTF-8?q?=D8=AF=D8=A7=D9=86=20=D9=81=D8=A7=D8=B1=D8=B3=DB=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                        |  2 +-
 translations/README-cn.md        |  2 +-
 translations/README-es.md        |  2 +-
 translations/README-fa.md        | 11 +++++++----
 translations/README-fr.md        |  2 +-
 translations/README-gr.md        |  2 +-
 translations/README-hu.md        |  2 +-
 translations/README-ja.md        |  2 +-
 translations/README-ko.md        |  2 +-
 translations/README-pl.md        |  2 +-
 translations/README-pt_BR.md     |  2 +-
 translations/README-ru.md        |  2 +-
 translations/README-tr.md        |  2 +-
 translations/README-vn.md        |  2 +-
 translations/README-zh-simple.md |  1 +
 15 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index f6b409bd..3c50e7cc 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@
 * [Polish](translations/README-pl.md)
 * [Русский](translations/README-ru.md)
 * [Tiếng Việt](translations/README-vn.md)
-* [قارسی](translations/README-fa.md)
+* [فارسی](translations/README-fa.md)
 
 ## What is Regular Expression?
 
diff --git a/translations/README-cn.md b/translations/README-cn.md
index f0d89ccb..a16a71db 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## 什么是正则表达式？
 
diff --git a/translations/README-es.md b/translations/README-es.md
index 782d94e3..51d54a7e 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Qué es una expresión regular?
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
diff --git a/translations/README-fa.md b/translations/README-fa.md
index e17f3bfa..c95869a8 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -29,7 +29,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 <div dir="rtl">
 
@@ -56,7 +56,7 @@
 
 ## فهرست
 
-- [Basic Matchers](#1-basic-matchers)
+- [پایه ای ترین همخوانی](#1-basic-matchers)
 - [Meta character](#2-meta-characters)
   - [Full stop](#21-full-stop)
   - [Character set](#22-character-set)
@@ -95,8 +95,8 @@
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-
 <div dir="rtl">
+
 [عبارت منظم را در عمل ببینید](https://regex101.com/r/dmRygT/1)
 
 عبارت منظم `123` با رشته `123` مطابقت دارد. عبارت منظم با مقایسه حرف به حرف و کارکتر به کارکترش با متن مورد نظر تطابق را می یابد. همچنین عبارت منظم حساس به اندازه (بزرگی یا کوچکی حروف) هستند. بنابر این واژه ی `The` با  `the` همخوان نیست.
@@ -106,7 +106,10 @@
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/1paXsy/1)
+<div dir="rtl">
+
+[این عبارت منظم را در عمل ببنیند](https://regex101.com/r/1paXsy/1)
+</div>
 
 ## 2. Meta Characters
 
diff --git a/translations/README-fr.md b/translations/README-fr.md
index db28f7b6..c51668cc 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 2e2141c1..2e6dd9d9 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index e0c5ab02..e8c52394 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 18ed0f13..6acf9ae4 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index 577bbfbb..d4c9c0bb 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index 84c50ef8..fd1d04ca 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index d20b67b0..774cd219 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-ru.md b/translations/README-ru.md
index 0dc6c677..ed2e668d 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -29,7 +29,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Что такое Регулярное выражение?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index d4713378..41be9dd9 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -30,7 +30,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-vn.md b/translations/README-vn.md
index a2920559..0c38faa2 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -31,7 +31,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [قارسی](../translations/README-fa.md)
+* [فارسی](../translations/README-fa.md)
 
 
 ## Biểu thức chính quy là gì?
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 8ee4847d..292e8778 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -29,6 +29,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [فارسی](../translations/README-fa.md)
 
 ## 什么是正则表达式?
  

From 3fc465e0dd6f3e287ccbb538272cb00c13888917 Mon Sep 17 00:00:00 2001
From: hanhan9449 <1481220484@qq.com>
Date: Wed, 30 Oct 2019 09:03:21 +0800
Subject: [PATCH 111/185] Fix a translation error

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index eac7056a..77cb90ea 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -118,7 +118,7 @@
 |*|匹配>=0个重复的在*号之前的字符。|
 |+|匹配>=1个重复的+号前的字符。
 |?|标记?之前的字符为可选.|
-|{n,m}|匹配num个大括号之前的字符 (n <= num <= m).|
+|{n,m}|匹配num个大括号之间的字符 (n <= num <= m).|
 |(xyz)|字符集，匹配与 xyz 完全相等的字符串.|
 |||或运算符，匹配符号前或后的字符.|
 |\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|

From ac30dce43841e031e77b8589c6bb17acf24b734a Mon Sep 17 00:00:00 2001
From: yangjin <kingyouge@gmail.com>
Date: Wed, 30 Oct 2019 23:19:16 +0800
Subject: [PATCH 112/185] Update Chinese translation at section Lookaround

---
 translations/README-cn.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index eac7056a..5b545380 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -353,11 +353,9 @@
 
 ## 4. 零宽度断言（前后预查）
 
-先行断言和后发断言都属于**非捕获簇**（不捕获文本 ，也不针对组合计进行计数）。
-先行断言用于判断所匹配的格式是否在另一个确定的格式之前，匹配结果不包含该确定格式（仅作为约束）。
+先行断言和后发断言（合称 lookaround）都属于**非捕获组**（用于匹配模式，但不包括在匹配列表中）。当我们需要一个模式的前面或后面有另一个特定的模式时，就可以使用它们。
 
-例如，我们想要获得所有跟在 `$` 符号后的数字，我们可以使用正后发断言 `(?<=\$)[0-9\.]*`。
-这个表达式匹配 `$` 开头，之后跟着 `0,1,2,3,4,5,6,7,8,9,.` 这些字符可以出现大于等于 0 次。
+例如，我们希望从下面的输入字符串 `$4.44` 和 `$10.88` 中获得所有以 `$` 字符开头的数字，我们将使用以下的正则表达式 `(?<=\$)[0-9\.]*`。意思是：获取所有包含 `.` 并且前面是 `$` 的数字。
 
 零宽度断言如下：
 

From 366bc0da08c98485aebf6515c6c738ebef996c07 Mon Sep 17 00:00:00 2001
From: Jigao Luo_X1 <luojigao@outlook.com>
Date: Mon, 6 Jan 2020 17:28:43 +0100
Subject: [PATCH 113/185] new ch translation for word capturing group

---
 translations/README-zh-simple.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 292e8778..29a51933 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -64,7 +64,7 @@
 		* [2.3.2   号](#232--号)
 		* [2.3.3 ? 号](#233--号)
 	* [2.4 {} 号](#24--号)
-	* [2.5 (...) 特征标群](#25--特征标群)
+	* [2.5 (...) 捕获组](#25--捕获组)
 	* [2.6 | 或运算符](#26--或运算符)
 	* [2.7 转码特殊字符](#27-转码特殊字符)
 	* [2.8 锚点](#28-锚点)
@@ -254,9 +254,9 @@
 
 [在线练习](https://regex101.com/r/Sivu30/1)
 
-## 2.5 `(...)` 特征标群
+## 2.5 `(...)` 捕获组
 
-特征标群是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.
+捕获组是一组写在 `(...)` 中的子模式. 例如之前说的 `{}` 是用来表示前面一个字符出现指定次数. 但如果在 `{}` 前加入捕获组则表示整个标群内的字符重复 N 次. 例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`.
 
 我们还可以在 `()` 中用或字符 `|` 表示或. 例如, `(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
 

From 4c48458c422ae6d99a67c19fe0227f05ecd3f012 Mon Sep 17 00:00:00 2001
From: Jigao Luo_X1 <luojigao@outlook.com>
Date: Mon, 6 Jan 2020 17:49:36 +0100
Subject: [PATCH 114/185] new ch translation for word non capturing group

---
 translations/README-zh-simple.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 29a51933..7f7ba3af 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -348,7 +348,7 @@
 
 ## 4. 前后关联约束(前后预查)
 
-前置约束和后置约束都属于**非捕获簇**(用于匹配不在匹配列表中的格式).
+前置约束和后置约束都属于**非捕获组**(用于匹配不在匹配列表中的格式).
 前置约束用于判断所匹配的格式是否在另一个确定的格式之后.
 
 例如, 我们想要获得所有跟在 `$` 符号后的数字, 我们可以使用正向向后约束 `(?<=\$)[0-9\.]*`.

From 2411b31babe77ce6ebe37165ecef2f6e1ba41050 Mon Sep 17 00:00:00 2001
From: Jigao Luo_X1 <luojigao@outlook.com>
Date: Mon, 6 Jan 2020 21:20:47 +0100
Subject: [PATCH 115/185] 5.1, 5.2, 5.3 hyperlink fix

---
 translations/README-cn.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 55984ea1..9f5dddf0 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -431,7 +431,7 @@
 |g|全局搜索。|
 |m|多行修饰符：锚点元字符 `^` `$` 工作范围在每行的起始。|
 
-### 5.1 忽略大小写（Case Insensitive）
+### 5.1 忽略大小写 (Case Insensitive)
 
 修饰语 `i` 用于忽略大小写。
 例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`，`g` 表示全局搜索。
@@ -448,7 +448,7 @@
 
 [在线练习](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 全局搜索（Global search）
+### 5.2 全局搜索 (Global search)
 
 修饰符 `g` 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。
 例如，表达式 `/.(at)/g` 表示搜索 任意字符（除了换行）+ `at`，并返回全部结果。
@@ -465,7 +465,7 @@
 
 [在线练习](https://regex101.com/r/dO1nef/1)
 
-### 5.3 多行修饰符（Multiline）
+### 5.3 多行修饰符 (Multiline)
 
 多行修饰符 `m` 常用于执行一个多行匹配。
 
@@ -489,7 +489,7 @@
 
 [在线练习](https://regex101.com/r/E88WE2/1)
 
-### 6. 贪婪匹配与惰性匹配（Greedy vs lazy matching）
+### 6. 贪婪匹配与惰性匹配 (Greedy vs lazy matching)
 
 正则表达式默认采用贪婪匹配模式，在该模式下意味着会匹配尽可能长的子串。我们可以使用 `?` 将贪婪匹配模式转化为惰性匹配模式。
 

From 65cbea955e20035434d7492903f86451a4258177 Mon Sep 17 00:00:00 2001
From: wakeheart <60534224+wakeheart@users.noreply.github.com>
Date: Sat, 7 Mar 2020 14:24:18 +0800
Subject: [PATCH 116/185] Update README-cn.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改了2.4和2.5的讲解，使其更加符合中文的阅读方式和思考习惯，降低初学者的理解难度。
---
 translations/README-cn.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 55984ea1..fcd78ac3 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -227,7 +227,7 @@
 
 ## 2.4 `{}` 号
 
-在正则表达式中 `{}` 是一个量词，常用来一个或一组字符可以重复出现的次数。
+在正则表达式中 `{}` 是一个量词，常用来限定一个或一组字符可以重复出现的次数。
 例如， 表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。
 
 <pre>
@@ -256,7 +256,10 @@
 
 ## 2.5 `(...)` 特征标群
 
-特征标群是一组写在 `(...)` 中的子模式。例如之前说的 `{}` 是用来表示前面一个字符出现指定次数。但如果在 `{}` 前加入特征标群则表示整个标群内的字符重复 N 次。例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。
+## 2.5 `(...)` 特征标群
+
+特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b` 。再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。
+
 
 我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
 

From 6436a420594a5e3d326992a00d73ffa0e8fbc1fc Mon Sep 17 00:00:00 2001
From: wakeheart <60534224+wakeheart@users.noreply.github.com>
Date: Sat, 7 Mar 2020 14:25:32 +0800
Subject: [PATCH 117/185] Update README-cn.md

---
 translations/README-cn.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index fcd78ac3..237f4c00 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -256,8 +256,6 @@
 
 ## 2.5 `(...)` 特征标群
 
-## 2.5 `(...)` 特征标群
-
 特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b` 。再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。
 
 

From 18c6bf5a984bdc73126201858664858a7aa25cd6 Mon Sep 17 00:00:00 2001
From: Tom McAndrew <42588609+tommcandrew@users.noreply.github.com>
Date: Tue, 10 Mar 2020 17:11:31 +0000
Subject: [PATCH 118/185] Improve grammar and punctuation

---
 README.md | 304 +++++++++++++++++++++++++++---------------------------
 1 file changed, 150 insertions(+), 154 deletions(-)

diff --git a/README.md b/README.md
index 0546c6de..6d534fbe 100644
--- a/README.md
+++ b/README.md
@@ -33,62 +33,63 @@
 
 ## What is Regular Expression?
 
-> Regular expression is a group of characters or symbols which is used to find a specific pattern from a text.
+> A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 
 A regular expression is a pattern that is matched against a subject string from
-left to right. Regular expression is used for replacing a text within a string, 
-validating form, extract a substring from a string based upon a pattern match, 
-and so much more. The word "Regular expression" is a mouthful, so you will usually
-find the term abbreviated as "regex" or "regexp". 
+left to right. Regular expressions are used to replace text within a string, 
+validating forms, extracting a substring from a string based on a pattern match, 
+and so much more. The term "regular expression" is a mouthful, so you will usually
+find the term abbreviated to "regex" or "regexp". 
 
 Imagine you are writing an application and you want to set the rules for when a
 user chooses their username. We want to allow the username to contain letters,
 numbers, underscores and hyphens. We also want to limit the number of characters
-in username so it does not look ugly. We use the following regular expression to
-validate a username:
+in the username so it does not look ugly. We can use the following regular expression to
+validate the username:
 
 <br/><br/>
 <p align="center">
   <img src="./img/regexp-en.png" alt="Regular expression">
 </p>
 
-Above regular expression can accept the strings `john_doe`, `jo-hn_doe` and
-`john12_as`. It does not match `Jo` because that string contains uppercase
+The regular expression above can accept the strings `john_doe`, `jo-hn_doe` and
+`john12_as`. It does not match `Jo` because that string contains an uppercase
 letter and also it is too short.
 
 ## Table of Contents
 
 - [Basic Matchers](#1-basic-matchers)
-- [Meta character](#2-meta-characters)
-  - [Full stop](#21-full-stop)
-  - [Character set](#22-character-set)
-    - [Negated character set](#221-negated-character-set)
+- [Meta Characters](#2-meta-characters)
+  - [Full Stops](#21-full-stops)
+  - [Character Sets](#22-character-sets)
+    - [Negated Character Sets](#221-negated-character-sets)
   - [Repetitions](#23-repetitions)
     - [The Star](#231-the-star)
     - [The Plus](#232-the-plus)
     - [The Question Mark](#233-the-question-mark)
   - [Braces](#24-braces)
-  - [Character Group](#25-character-group)
+  - [Capturing Groups](#25-capturing-groups)
+      - [Non-Capturing Groups](#251-non-capturing-groups)
   - [Alternation](#26-alternation)
-  - [Escaping special character](#27-escaping-special-character)
+  - [Escaping Special Characters](#27-escaping-special-characters)
   - [Anchors](#28-anchors)
-    - [Caret](#281-caret)
-    - [Dollar](#282-dollar)
+    - [The Caret](#281-the-caret)
+    - [The Dollar Sign](#282-the-dollar-sign)
 - [Shorthand Character Sets](#3-shorthand-character-sets)
-- [Lookaround](#4-lookaround)
-  - [Positive Lookahead](#41-positive-lookahead)
-  - [Negative Lookahead](#42-negative-lookahead)
-  - [Positive Lookbehind](#43-positive-lookbehind)
-  - [Negative Lookbehind](#44-negative-lookbehind)
+- [Lookarounds](#4-lookarounds)
+  - [Positive Lookaheads](#41-positive-lookaheads)
+  - [Negative Lookaheads](#42-negative-lookaheads)
+  - [Positive Lookbehinds](#43-positive-lookbehinds)
+  - [Negative Lookbehinds](#44-negative-lookbehinds)
 - [Flags](#5-flags)
   - [Case Insensitive](#51-case-insensitive)
-  - [Global search](#52-global-search)
+  - [Global Search](#52-global-search)
   - [Multiline](#53-multiline)
-- [Greedy vs lazy matching](#6-greedy-vs-lazy-matching)
+- [Greedy vs Lazy Matching](#6-greedy-vs-lazy-matching)
 
 ## 1. Basic Matchers
 
-A regular expression is just a pattern of characters that we use to perform
+A regular expression is just a pattern of characters that we use to perform a
 search in a text.  For example, the regular expression `the` means: the letter
 `t`, followed by the letter `h`, followed by the letter `e`.
 
@@ -112,7 +113,7 @@ not match the string `the`.
 
 ## 2. Meta Characters
 
-Meta characters are the building blocks of the regular expressions.  Meta
+Meta characters are the building blocks of regular expressions.  Meta
 characters do not stand for themselves but instead are interpreted in some
 special way. Some meta characters have a special meaning and are written inside
 square brackets. The meta characters are as follows:
@@ -132,9 +133,9 @@ square brackets. The meta characters are as follows:
 |^|Matches the beginning of the input.|
 |$|Matches the end of the input.|
 
-## 2.1 Full stop
+## 2.1 Full Stops
 
-Full stop `.` is the simplest example of meta character. The meta character `.`
+The full stop `.` is the simplest example of a meta character. The meta character `.`
 matches any single character. It will not match return or newline characters.
 For example, the regular expression `.ar` means: any character, followed by the
 letter `a`, followed by the letter `r`.
@@ -145,11 +146,11 @@ letter `a`, followed by the letter `r`.
 
 [Test the regular expression](https://regex101.com/r/xc9GkU/1)
 
-## 2.2 Character set
+## 2.2 Character Sets
 
-Character sets are also called character class. Square brackets are used to
+Character sets are also called character classes. Square brackets are used to
 specify character sets. Use a hyphen inside a character set to specify the
-characters' range. The order of the character range inside square brackets
+characters' range. The order of the character range inside the square brackets
 doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
 `T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
 
@@ -160,7 +161,7 @@ doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
 [Test the regular expression](https://regex101.com/r/2ITLQ4/1)
 
 A period inside a character set, however, means a literal period. The regular
-expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
+expression `ar[.]` means: a lowercase character `a`, followed by the letter `r`,
 followed by a period `.` character.
 
 <pre>
@@ -169,7 +170,7 @@ followed by a period `.` character.
 
 [Test the regular expression](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Negated character set
+### 2.2.1 Negated Character Sets
 
 In general, the caret symbol represents the start of the string, but when it is
 typed after the opening square bracket it negates the character set. For
@@ -184,14 +185,14 @@ followed by the character `a`, followed by the letter `r`.
 
 ## 2.3 Repetitions
 
-Following meta characters `+`, `*` or `?` are used to specify how many times a
+The meta characters `+`, `*` or `?` are used to specify how many times a
 subpattern can occur. These meta characters act differently in different
 situations.
 
 ### 2.3.1 The Star
 
-The symbol `*` matches zero or more repetitions of the preceding matcher. The
-regular expression `a*` means: zero or more repetitions of preceding lowercase
+The `*` symbol matches zero or more repetitions of the preceding matcher. The
+regular expression `a*` means: zero or more repetitions of the preceding lowercase
 character `a`. But if it appears after a character set or class then it finds
 the repetitions of the whole character set. For example, the regular expression
 `[a-z]*` means: any number of lowercase letters in a row.
@@ -205,8 +206,8 @@ the repetitions of the whole character set. For example, the regular expression
 The `*` symbol can be used with the meta character `.` to match any string of
 characters `.*`. The `*` symbol can be used with the whitespace character `\s`
 to match a string of whitespace characters. For example, the expression
-`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
-followed by lowercase character `a`, followed by lowercase character `t`,
+`\s*cat\s*` means: zero or more spaces, followed by a lowercase `c`,
+followed by a lowercase `a`, followed by a lowercase `t`,
 followed by zero or more spaces.
 
 <pre>
@@ -217,10 +218,10 @@ followed by zero or more spaces.
 
 ### 2.3.2 The Plus
 
-The symbol `+` matches one or more repetitions of the preceding character. For
-example, the regular expression `c.+t` means: lowercase letter `c`, followed by
-at least one character, followed by the lowercase character `t`. It needs to be
-clarified that `t` is the last `t` in the sentence.
+The `+` symbol matches one or more repetitions of the preceding character. For
+example, the regular expression `c.+t` means: a lowercase `c`, followed by
+at least one character, followed by a lowercase `t`. It needs to be
+clarified that`t` is the last `t` in the sentence.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -230,11 +231,10 @@ clarified that `t` is the last `t` in the sentence.
 
 ### 2.3.3 The Question Mark
 
-In regular expression the meta character `?` makes the preceding character
+In regular expressions, the meta character `?` makes the preceding character
 optional. This symbol matches zero or one instance of the preceding character.
-For example, the regular expression `[T]?he` means: Optional the uppercase
-letter `T`, followed by the lowercase character `h`, followed by the lowercase
-character `e`.
+For example, the regular expression `[T]?he` means: Optional uppercase
+`T`, followed by a lowercase `h`, followed bya lowercase `e`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -250,10 +250,10 @@ character `e`.
 
 ## 2.4 Braces
 
-In regular expression braces that are also called quantifiers are used to
+In regular expressions, braces (also called quantifiers) are used to
 specify the number of times that a character or a group of characters can be
 repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
-2 digits but not more than 3 (characters in the range of 0 to 9).
+2 digits, but not more than 3, ranging from 0 to 9.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -262,7 +262,7 @@ repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
 [Test the regular expression](https://regex101.com/r/juM86s/1)
 
 We can leave out the second number. For example, the regular expression
-`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
+`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the
 regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 <pre>
@@ -277,16 +277,16 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 [Test the regular expression](https://regex101.com/r/Sivu30/1)
 
-## 2.5 Capturing Group
+## 2.5 Capturing Groups
 
-A capturing group is a group of sub-patterns that is written inside Parentheses 
-`(...)`. Like as we discussed before that in regular expression if we put a quantifier 
-after a character then it will repeat the preceding character. But if we put quantifier
+A capturing group is a group of sub-patterns that is written inside parentheses 
+`(...)`. As discussed before, in regular expressions, if we put a quantifier 
+after a character then it will repeat the preceding character. But if we put a quantifier
 after a capturing group then it repeats the whole capturing group. For example,
 the regular expression `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside capturing group.
-For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
-`g` or `p`, followed by character `a`, followed by character `r`.
+"ab". We can also use the alternation `|` meta character inside a capturing group.
+For example, the regular expression `(c|g|p)ar` means: a lowercase `c`,
+`g` or `p`, followed by `a`, followed by `r`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -294,15 +294,15 @@ For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
 
 [Test the regular expression](https://regex101.com/r/tUxrBG/1)
 
-Note that capturing groups do not only match but also capture the characters for use in 
-the parent language. The parent language could be python or javascript or virtually any
+Note that capturing groups do not only match, but also capture, the characters for use in 
+the parent language. The parent language could be Python or JavaScript or virtually any
 language that implements regular expressions in a function definition.
 
-### 2.5.1 Non-capturing group
+### 2.5.1 Non-Capturing Groups
 
-A non-capturing group is a capturing group that only matches the characters, but 
+A non-capturing group is a capturing group that matches the characters but 
 does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
-within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
 `(c|g|p)ar` in that it matches the same characters but will not create a capture group.
 
 <pre>
@@ -319,13 +319,13 @@ See also [4. Lookaround](#4-lookaround).
 
 In a regular expression, the vertical bar `|` is used to define alternation.
 Alternation is like an OR statement between multiple expressions. Now, you may be
-thinking that character set and alternation works the same way. But the big
-difference between character set and alternation is that character set works on
-character level but alternation works on expression level. For example, the
-regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
-`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
-(lowercase character `c`, followed by lowercase character `a`, followed by
-lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
+thinking that character sets and alternation work the same way. But the big
+difference between character sets and alternation is that character sets work at the
+character level but alternation works at the expression level. For example, the
+regular expression `(T|t)he|car` means: either (an uppercase `T` or a lowercase
+`t`, followed by a lowercase `h`, followed by a lowercase `e`) OR
+(a lowercase `c`, followed by a lowercase `a`, followed by
+a lowercase `r`). Note that I included the parentheses for clarity, to show that either expression
 in parentheses can be met and it will match.
 
 <pre>
@@ -334,17 +334,15 @@ in parentheses can be met and it will match.
 
 [Test the regular expression](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 Escaping special character
+## 2.7 Escaping Special Characters
 
-Backslash `\` is used in regular expression to escape the next character. This
-allows us to specify a symbol as a matching character including reserved
-characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
-character prepend `\` before it.
+A backslash `\` is used in regular expressions to escape the next character. This
+allows us to include reserved characters such as `{ } [ ] / \ + * . $ ^ | ?` as matching characters. To use one of these special character as a matching character, prepend it with `\`.
 
-For example, the regular expression `.` is used to match any character except
-newline. Now to match `.` in an input string the regular expression
-`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
-character `a`, followed by lowercase letter `t`, followed by optional `.`
+For example, the regular expression `.` is used to match any character except a
+newline. Now, to match `.` in an input string, the regular expression
+`(f|c|m)at\.?` means: a lowercase `f`, `c` or `m`, followed by a lowercase
+`a`, followed by a lowercase `t`, followed by an optional `.`
 character.
 
 <pre>
@@ -357,20 +355,20 @@ character.
 
 In regular expressions, we use anchors to check if the matching symbol is the
 starting symbol or ending symbol of the input string. Anchors are of two types:
-First type is Caret `^` that check if the matching character is the start
-character of the input and the second type is Dollar `$` that checks if matching
+The first type is the caret `^` that check if the matching character is the first
+character of the input and the second type is the dollar sign `$` which checks if a matching
 character is the last character of the input string.
 
-### 2.8.1 Caret
+### 2.8.1 The Caret
 
-Caret `^` symbol is used to check if matching character is the first character
-of the input string. If we apply the following regular expression `^a` (if a is
-the starting symbol) to input string `abc` it matches `a`. But if we apply
-regular expression `^b` on above input string it does not match anything.
-Because in input string `abc` "b" is not the starting symbol. Let's take a look
-at another regular expression `^(T|t)he` which means: uppercase character `T` or
-lowercase character `t` is the start symbol of the input string, followed by
-lowercase character `h`, followed by lowercase character `e`.
+The caret symbol `^` is used to check if a matching character is the first character
+of the input string. If we apply the following regular expression `^a` (meaning 'a' must be
+the starting character) to the string `abc`, it will match `a`. But if we apply
+the regular expression `^b` to the above string, it will not match anything.
+Because in the string `abc`, the "b" is not the starting character. Let's take a look
+at another regular expression `^(T|t)he` which means: an uppercase `T` or
+a lowercase `t` must be the first character in the string, followed by a
+lowercase `h`, followed by a lowercase `e`.
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -384,12 +382,12 @@ lowercase character `h`, followed by lowercase character `e`.
 
 [Test the regular expression](https://regex101.com/r/jXrKne/1)
 
-### 2.8.2 Dollar
+### 2.8.2 The Dollar Sign
 
-Dollar `$` symbol is used to check if matching character is the last character
-of the input string. For example, regular expression `(at\.)$` means: a
-lowercase character `a`, followed by lowercase character `t`, followed by a `.`
-character and the matcher must be end of the string.
+The dollar sign `$` is used to check if a matching character is the last character
+in the string. For example, the regular expression `(at\.)$` means: a
+lowercase `a`, followed by a lowercase `t`, followed by a `.`
+character and the matcher must be at the end of the string.
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -405,30 +403,29 @@ character and the matcher must be end of the string.
 
 ##  3. Shorthand Character Sets
 
-Regular expression provides shorthands for the commonly used character sets,
-which offer convenient shorthands for commonly used regular expressions. The
-shorthand character sets are as follows:
+There are a number of convenient shorthands for commonly used character sets/
+regular expressions:
 
 |Shorthand|Description|
 |:----:|----|
 |.|Any character except new line|
 |\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
 |\W|Matches non-alphanumeric characters: `[^\w]`|
-|\d|Matches digit: `[0-9]`|
-|\D|Matches non-digit: `[^\d]`|
-|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
-|\S|Matches non-whitespace character: `[^\s]`|
-
-## 4. Lookaround
-
-Lookbehind and lookahead (also called lookaround) are specific types of
-***non-capturing groups*** (used to match the pattern but not included in matching
-list). Lookarounds are used when we have the condition that this pattern is
-preceded or followed by another certain pattern. For example, we want to get all
-numbers that are preceded by `$` character from the following input string
-`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
-which means: get all the numbers which contain `.` character and  are preceded
-by `$` character. Following are the lookarounds that are used in regular
+|\d|Matches digits: `[0-9]`|
+|\D|Matches non-digits: `[^\d]`|
+|\s|Matches whitespace characters: `[\t\n\f\r\p{Z}]`|
+|\S|Matches non-whitespace characters: `[^\s]`|
+
+## 4. Lookarounds
+
+Lookbehinds and lookaheads (also called lookarounds) are specific types of
+***non-capturing groups*** (used to match a pattern but without including it in the matching
+list). Lookarounds are used when we a pattern must be
+preceded or followed by another pattern. For example, imagine we want to get all
+numbers that are preceded by the `$` character from the string
+`$4.44 and $10.88`. We will use the following regular expression `(?<=\$)[0-9\.]*`
+which means: get all the numbers which contain the `.` character and are preceded
+by the `$` character. These are the lookarounds that are used in regular
 expressions:
 
 |Symbol|Description|
@@ -438,18 +435,18 @@ expressions:
 |?<=|Positive Lookbehind|
 |?<!|Negative Lookbehind|
 
-### 4.1 Positive Lookahead
+### 4.1 Positive Lookaheads
 
 The positive lookahead asserts that the first part of the expression must be
 followed by the lookahead expression. The returned match only contains the text
 that is matched by the first part of the expression. To define a positive
 lookahead, parentheses are used. Within those parentheses, a question mark with
-equal sign is used like this: `(?=...)`. Lookahead expression is written after
-the equal sign inside parentheses. For example, the regular expression
-`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
-letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
-define positive lookahead which tells regular expression engine to match `The`
-or `the` which are followed by the word `fat`.
+an equals sign is used like this: `(?=...)`. The lookahead expressions is written after
+the equals sign inside parentheses. For example, the regular expression
+`(T|t)he(?=\sfat)` means: match either a lowercase `t` or an uppercase
+ `T`, followed by the letter `h`, followed by the letter `e`. In parentheses we
+define a positive lookahead which tells the regular expression engine to match `The`
+or `the` only if it's followed by the word `fat`.
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -457,15 +454,14 @@ or `the` which are followed by the word `fat`.
 
 [Test the regular expression](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negative Lookahead
+### 4.2 Negative Lookaheads
 
-Negative lookahead is used when we need to get all matches from input string
-that are not followed by a pattern. Negative lookahead is defined same as we define
-positive lookahead but the only difference is instead of equal `=` character we
-use negation `!` character i.e. `(?!...)`. Let's take a look at the following
+Negative lookaheads are used when we need to get all matches from an input string
+that are not followed by a certain pattern. A negative lookahead is written the same way as a
+positive lookahead. The only difference is, instead of an equals sign `=`, we
+use an exclamation mark `!` to indicate negation i.e. `(?!...)`. Let's take a look at the following
 regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
-from input string that are not followed by the word `fat` precedes by a space
-character.
+from the input string that are not followed by a space character and the word `fat`.
 
 <pre>
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -473,12 +469,12 @@ character.
 
 [Test the regular expression](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positive Lookbehind
+### 4.3 Positive Lookbehinds
 
-Positive lookbehind is used to get all the matches that are preceded by a
-specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
+Positive lookbehinds are used to get all the matches that are preceded by a
+specific pattern. Positive lookbehinds are written `(?<=...)`. For example, the
 regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
-from input string that are after the word `The` or `the`.
+from the input string that come after the word `The` or `the`.
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -486,11 +482,11 @@ from input string that are after the word `The` or `the`.
 
 [Test the regular expression](https://regex101.com/r/avH165/1)
 
-### 4.4 Negative Lookbehind
+### 4.4 Negative Lookbehinds
 
-Negative lookbehind is used to get all the matches that are not preceded by a
-specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
-regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
+Negative lookbehinds are used to get all the matches that are not preceded by a
+specific pattern. Negative lookbehinds are written `(?<!...)`. For example, the
+regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from the input
 string that are not after the word `The` or `the`.
 
 <pre>
@@ -507,17 +503,17 @@ integral part of the RegExp.
 
 |Flag|Description|
 |:----:|----|
-|i|Case insensitive: Sets matching to be case-insensitive.|
-|g|Global Search: Search for a pattern throughout the input string.|
-|m|Multiline: Anchor meta character works on each line.|
+|i|Case insensitive: Match will be case-insensitive.|
+|g|Global Search: Match all instances, not just the first.|
+|m|Multiline: Anchor meta characters work on each line.|
 
 ### 5.1 Case Insensitive
 
 The `i` modifier is used to perform case-insensitive matching. For example, the
-regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
-character `h`, followed by character `e`. And at the end of regular expression
+regular expression `/The/gi` means: an uppercase `T`, followed by a lowercase
+`h`, followed by an `e`. And at the end of regular expression
 the `i` flag tells the regular expression engine to ignore the case. As you can
-see we also provided `g` flag because we want to search for the pattern in the
+see, we also provided `g` flag because we want to search for the pattern in the
 whole input string.
 
 <pre>
@@ -532,13 +528,13 @@ whole input string.
 
 [Test the regular expression](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 Global search
+### 5.2 Global Search
 
-The `g` modifier is used to perform a global match (find all matches rather than
+The `g` modifier is used to perform a global match (finds all matches rather than
 stopping after the first match). For example, the regular expression`/.(at)/g`
-means: any character except new line, followed by lowercase character `a`,
-followed by lowercase character `t`. Because we provided `g` flag at the end of
-the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
+means: any character except a new line, followed by a lowercase `a`,
+followed by a lowercase `t`. Because we provided the `g` flag at the end of
+the regular expression, it will now find all matches in the input string, not just the first one (which is the default behavior).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -554,12 +550,12 @@ the regular expression now it will find all matches in the input string, not jus
 
 ### 5.3 Multiline
 
-The `m` modifier is used to perform a multi-line match. As we discussed earlier
-anchors `(^, $)` are used to check if pattern is the beginning of the input or
-end of the input string. But if we want that anchors works on each line we use
-`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
-character `a`, followed by lowercase character `t`, optionally anything except
-new line. And because of `m` flag now regular expression engine matches pattern
+The `m` modifier is used to perform a multi-line match. As we discussed earlier,
+anchors `(^, $)` are used to check if a pattern is at the beginning of the input or
+the end. But if we want the anchors to work on each line, we use
+the `m` flag. For example, the regular expression `/at(.)?$/gm` means: a lowercase
+`a`, followed by a lowercase `t` and, optionally, anything except
+a new line. And because of the `m` flag, the regular expression engine now matches patterns
 at the end of each line in a string.
 
 <pre>
@@ -578,9 +574,9 @@ at the end of each line in a string.
 
 [Test the regular expression](https://regex101.com/r/E88WE2/1)
 
-## 6. Greedy vs lazy matching
-By default regex will do greedy matching which means it will match as long as
-possible. We can use `?` to match in lazy way which means as short as possible.
+## 6. Greedy vs Lazy Matching
+By default, a regex will perform a greedy match, which means the match will be as long as
+possible. We can use `?` to match in a lazy way, which means the match should be as short as possible.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
@@ -597,7 +593,7 @@ possible. We can use `?` to match in lazy way which means as short as possible.
 
 ## Contribution
 
-* Open pull request with improvements
+* Open a pull request with improvements
 * Discuss ideas in issues
 * Spread the word
 * Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)

From 060cf5c5143552aa00fcd79e844e4cc3638bb103 Mon Sep 17 00:00:00 2001
From: Tom McAndrew <42588609+tommcandrew@users.noreply.github.com>
Date: Tue, 10 Mar 2020 17:13:25 +0000
Subject: [PATCH 119/185] Correct grammar in intro title

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6d534fbe..055550bf 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@
 * [Tiếng Việt](translations/README-vn.md)
 * [فارسی](translations/README-fa.md)
 
-## What is Regular Expression?
+## What are Regular Expressions?
 
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 

From 41e1eefca7c196f9265cacbca59480bad021ac89 Mon Sep 17 00:00:00 2001
From: Tom McAndrew <42588609+tommcandrew@users.noreply.github.com>
Date: Tue, 10 Mar 2020 17:14:48 +0000
Subject: [PATCH 120/185] Make section 2.1 title singular

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 055550bf..75d06393 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ letter and also it is too short.
 
 - [Basic Matchers](#1-basic-matchers)
 - [Meta Characters](#2-meta-characters)
-  - [Full Stops](#21-full-stops)
+  - [The Full Stop](#21-the-full-stops)
   - [Character Sets](#22-character-sets)
     - [Negated Character Sets](#221-negated-character-sets)
   - [Repetitions](#23-repetitions)
@@ -133,7 +133,7 @@ square brackets. The meta characters are as follows:
 |^|Matches the beginning of the input.|
 |$|Matches the end of the input.|
 
-## 2.1 Full Stops
+## 2.1 The Full Stop
 
 The full stop `.` is the simplest example of a meta character. The meta character `.`
 matches any single character. It will not match return or newline characters.

From f7e4c53376f90651a656bbbd098aada82d064fe7 Mon Sep 17 00:00:00 2001
From: Tom McAndrew <42588609+tommcandrew@users.noreply.github.com>
Date: Tue, 10 Mar 2020 17:17:18 +0000
Subject: [PATCH 121/185] Make section 4 titles singular

---
 README.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 75d06393..4ac6e0f9 100644
--- a/README.md
+++ b/README.md
@@ -77,10 +77,10 @@ letter and also it is too short.
     - [The Dollar Sign](#282-the-dollar-sign)
 - [Shorthand Character Sets](#3-shorthand-character-sets)
 - [Lookarounds](#4-lookarounds)
-  - [Positive Lookaheads](#41-positive-lookaheads)
-  - [Negative Lookaheads](#42-negative-lookaheads)
-  - [Positive Lookbehinds](#43-positive-lookbehinds)
-  - [Negative Lookbehinds](#44-negative-lookbehinds)
+  - [Positive Lookahead](#41-positive-lookahead)
+  - [Negative Lookahead](#42-negative-lookahead)
+  - [Positive Lookbehind](#43-positive-lookbehind)
+  - [Negative Lookbehind](#44-negative-lookbehind)
 - [Flags](#5-flags)
   - [Case Insensitive](#51-case-insensitive)
   - [Global Search](#52-global-search)
@@ -435,7 +435,7 @@ expressions:
 |?<=|Positive Lookbehind|
 |?<!|Negative Lookbehind|
 
-### 4.1 Positive Lookaheads
+### 4.1 Positive Lookahead
 
 The positive lookahead asserts that the first part of the expression must be
 followed by the lookahead expression. The returned match only contains the text
@@ -454,7 +454,7 @@ or `the` only if it's followed by the word `fat`.
 
 [Test the regular expression](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negative Lookaheads
+### 4.2 Negative Lookahead
 
 Negative lookaheads are used when we need to get all matches from an input string
 that are not followed by a certain pattern. A negative lookahead is written the same way as a
@@ -469,7 +469,7 @@ from the input string that are not followed by a space character and the word `f
 
 [Test the regular expression](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positive Lookbehinds
+### 4.3 Positive Lookbehind
 
 Positive lookbehinds are used to get all the matches that are preceded by a
 specific pattern. Positive lookbehinds are written `(?<=...)`. For example, the
@@ -482,7 +482,7 @@ from the input string that come after the word `The` or `the`.
 
 [Test the regular expression](https://regex101.com/r/avH165/1)
 
-### 4.4 Negative Lookbehinds
+### 4.4 Negative Lookbehind
 
 Negative lookbehinds are used to get all the matches that are not preceded by a
 specific pattern. Negative lookbehinds are written `(?<!...)`. For example, the

From 5ffb2a0a05f1c90882df71e6dcab7c11d51deca1 Mon Sep 17 00:00:00 2001
From: "yeongjun.kim" <5036939+wicksome@users.noreply.github.com>
Date: Wed, 18 Mar 2020 18:06:14 +0900
Subject: [PATCH 122/185] Update README-ko.md

---
 translations/README-ko.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-ko.md b/translations/README-ko.md
index d4c9c0bb..6d294956 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -77,7 +77,7 @@
   - [대소문자 구분없음](#51-대소문자-구분없음)
   - [전체 검색](#52-전체-검색)
   - [멀티 라인](#53-멀티-라인)
-- [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른 매칭)
+- [탐욕적 vs 게으른 매칭](#6-탐욕적-vs-게으른-매칭)
 
 ## 1. 기본 매쳐
 

From 26a9e2d94e4cae467884bbe14455d110ae981d79 Mon Sep 17 00:00:00 2001
From: Bueltge <frank@bueltge.de>
Date: Thu, 19 Mar 2020 14:54:57 +0100
Subject: [PATCH 123/185] Update my current status

---
 translations/README-de.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index ff2ebd4a..bbb2c4d6 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -95,23 +95,23 @@ Sonderzeichen sind Bausteine von regulären Ausdrücken. Sonderzeichen stehen ni
 
 |Sonderzeichen|Beschreibung|
 |:----:|----|
-|.|Period matches any single character except a line break.|
-|[ ]|Character class. Matches any character contained between the square brackets.|
-|[^ ]|Negated character class. Matches any character that is not contained between the square brackets|
-|*|Matches 0 or more repetitions of the preceding symbol.|
-|+|Matches 1 or more repetitions of the preceding symbol.|
-|?|Makes the preceding symbol optional.|
-|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.|
-|(xyz)|Character group. Matches the characters xyz in that exact order.|
-|||Alternation. Matches either the characters before or the characters after the symbol.|
-|\|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Matches the beginning of the input.|
-|$|Matches the end of the input.|
-
-## 2.1 Full stop
-
-Full stop `.` is the simplest example of meta character. The meta character `.`
-matches any single character. It will not match return or newline characters.
+|.|Der Punkt entspricht jedem einzelnen Zeichen, außer einem Zeilenumbruch.|
+|[ ]|Zeichen-Klasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|
+|[^ ]|Negierte Zeichen-Klasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|
+|*|Entspricht 0 oder mehr Wiederholungen der voran gestellten Zeichen.|
+|+|Entspricht 1 oder mehr Wiederholungen der voran gestellten Zeichen.|
+|?|Macht das vorhergehende Zeichen optional.|
+|{n,m}|Klammern, entspricht mindestens "n", aber nicht mehr als "m" Wiederholungen des Zeichens.|
+|(xyz)|Zeichengruppe, entspricht den Zeichen xyz in der exakten Reihenfolge.|
+|||Alternation, entspricht entweder den Zeichen vor oder nach dem Sonderzeichen \|.|
+|\|Entfernt das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Überprüft den Anfang einer Eingabe.|
+|$|Überprüft das Ende einer Eingabe.|
+
+## 2.1 Punkt
+
+Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeichen `.`
+ entspricht jedem einzelnen Zeichen. It will not match return or newline characters.
 For example, the regular expression `.ar` means: any character, followed by the
 letter `a`, followed by the letter `r`.
 

From ceb3d3bd74601f72d381fa9c993eae2157dc8cbc Mon Sep 17 00:00:00 2001
From: cuiyaocy <l>
Date: Wed, 1 Apr 2020 09:29:09 +0800
Subject: [PATCH 124/185] modify the desc of {n,m}

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 55984ea1..6ff3f4fd 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -119,7 +119,7 @@
 |*|匹配>=0个重复的在*号之前的字符。|
 |+|匹配>=1个重复的+号前的字符。
 |?|标记?之前的字符为可选.|
-|{n,m}|匹配num个大括号之间的字符 (n <= num <= m).|
+|{n,m}|匹配num个大括号之前的字符或字符集 (n <= num <= m).|
 |(xyz)|字符集，匹配与 xyz 完全相等的字符串.|
 |||或运算符，匹配符号前或后的字符.|
 |\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|

From b617729b2575ab3a30a2d01cac3697620cab1ac3 Mon Sep 17 00:00:00 2001
From: Frank Bueltge <frank@bueltge.de>
Date: Mon, 20 Apr 2020 15:26:55 +0200
Subject: [PATCH 125/185] Update chanpte 2

---
 translations/README-de.md | 112 ++++++++++++++++++--------------------
 1 file changed, 52 insertions(+), 60 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index bbb2c4d6..b8b09465 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -46,7 +46,7 @@ Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `
 - [Basis Vergleiche](#1-basic-matchers)
 - [Sonderzeichen](#2-meta-characters)
   - [Punkt](#21-full-stop)
-  - [Character set](#22-character-set)
+  - [Zeichensätze](#22-zeichensaetze)
     - [Invertierter Zeichensatz](#221-negated-character-set)
   - [Wiederholungen](#23-repetitions)
     - [Stern *](#231-the-star)
@@ -111,29 +111,21 @@ Sonderzeichen sind Bausteine von regulären Ausdrücken. Sonderzeichen stehen ni
 ## 2.1 Punkt
 
 Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeichen `.`
- entspricht jedem einzelnen Zeichen. It will not match return or newline characters.
-For example, the regular expression `.ar` means: any character, followed by the
-letter `a`, followed by the letter `r`.
+ entspricht jedem einzelnen Zeichen. Es wird kein Zeilenumbruch oder Enter-Zeichen gefunden. Als Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
+[Teste den regulären Ausdruck](https://regex101.com/r/xc9GkU/1)
 
-[Test the regular expression](https://regex101.com/r/xc9GkU/1)
+## 2.2 Zeichensätze
 
-## 2.2 Character set
-
-Character sets are also called character class. Square brackets are used to
-specify character sets. Use a hyphen inside a character set to specify the
-characters' range. The order of the character range inside square brackets
-doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
-`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+Zeichensätze werden auch als Zeichenklasse bezeichnet. Zeichensätze werden in eckige Klammern angegeben. Um den Bereich der Zeichen anzugeben ist ein Bindestrich zu verwenden. Die Reihenfolge des Bereiches in den 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
-
-[Test the regular expression](https://regex101.com/r/2ITLQ4/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1)
 
 A period inside a character set, however, means a literal period. The regular
 expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
@@ -143,20 +135,20 @@ followed by a period `.` character.
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/wL3xtE/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1)
 
 ### 2.2.1 Negated character set
 
 In general, the caret symbol represents the start of the string, but when it is
 typed after the opening square bracket it negates the character set. For
-example, the regular expression `[^c]ar` means: any character except `c`,
+example, der reguläre Ausdruck `[^c]ar` means: any character except `c`,
 followed by the character `a`, followed by the letter `r`.
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/nNNlq3/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/nNNlq3/1)
 
 ## 2.3 Repetitions
 
@@ -169,14 +161,14 @@ situations.
 The symbol `*` matches zero or more repetitions of the preceding matcher. The
 regular expression `a*` means: zero or more repetitions of preceding lowercase
 character `a`. But if it appears after a character set or class then it finds
-the repetitions of the whole character set. For example, the regular expression
+the repetitions of the whole character set. For example, der reguläre Ausdruck
 `[a-z]*` means: any number of lowercase letters in a row.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/7m8me5/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/7m8me5/1)
 
 The `*` symbol can be used with the meta character `.` to match any string of
 characters `.*`. The `*` symbol can be used with the whitespace character `\s`
@@ -189,12 +181,12 @@ followed by zero or more spaces.
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/gGrwuz/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1)
 
 ### 2.3.2 The Plus
 
 The symbol `+` matches one or more repetitions of the preceding character. For
-example, the regular expression `c.+t` means: lowercase letter `c`, followed by
+example, der reguläre Ausdruck `c.+t` means: lowercase letter `c`, followed by
 at least one character, followed by the lowercase character `t`. It needs to be
 clarified that `t` is the last `t` in the sentence.
 
@@ -202,13 +194,13 @@ clarified that `t` is the last `t` in the sentence.
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1)
 
 ### 2.3.3 The Question Mark
 
 In regular expression the meta character `?` makes the preceding character
 optional. This symbol matches zero or one instance of the preceding character.
-For example, the regular expression `[T]?he` means: Optional the uppercase
+For example, der reguläre Ausdruck `[T]?he` means: Optional the uppercase
 letter `T`, followed by the lowercase character `h`, followed by the lowercase
 character `e`.
 
@@ -216,28 +208,28 @@ character `e`.
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/cIg9zm/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/cIg9zm/1)
 
 <pre>
 "[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/kPpO2x/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/kPpO2x/1)
 
 ## 2.4 Braces
 
 In regular expression braces that are also called quantifiers are used to
 specify the number of times that a character or a group of characters can be
-repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
+repeated. For example, der reguläre Ausdruck `[0-9]{2,3}` means: Match at least
 2 digits but not more than 3 ( characters in the range of 0 to 9).
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/juM86s/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/juM86s/1)
 
-We can leave out the second number. For example, the regular expression
+We can leave out the second number. For example, der reguläre Ausdruck
 `[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
 regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
@@ -245,13 +237,13 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Gdy4w5/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/Gdy4w5/1)
 
 <pre>
 "[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Sivu30/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/Sivu30/1)
 
 ## 2.5 Capturing Group
 
@@ -259,16 +251,16 @@ A capturing group is a group of sub-patterns that is written inside Parentheses
 `(...)`. Like as we discussed before that in regular expression if we put a quantifier 
 after a character then it will repeat the preceding character. But if we put quantifier
 after a capturing group then it repeats the whole capturing group. For example,
-the regular expression `(ab)*` matches zero or more repetitions of the character
+der reguläre Ausdruck `(ab)*` matches zero or more repetitions of the character
 "ab". We can also use the alternation `|` meta character inside capturing group.
-For example, the regular expression `(c|g|p)ar` means: lowercase character `c`,
+For example, der reguläre Ausdruck `(c|g|p)ar` means: lowercase character `c`,
 `g` or `p`, followed by character `a`, followed by character `r`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/tUxrBG/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/tUxrBG/1)
 
 Note that capturing groups do not only match but also capture the characters for use in 
 the parent language. The parent language could be python or javascript or virtually any
@@ -278,14 +270,14 @@ language that implements regular expressions in a function definition.
 
 A non-capturing group is a capturing group that only matches the characters, but 
 does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
-within parenthesis `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
+within parenthesis `(...)`. For example, der reguläre Ausdruck `(?:c|g|p)ar` is similar to 
 `(c|g|p)ar` in that it matches the same characters but will not create a capture group.
 
 <pre>
 "(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/Rm7Me8/1)
 
 Non-capturing groups can come in handy when used in find-and-replace functionality or 
 when mixed with capturing groups to keep the overview when producing any other kind of output. 
@@ -308,7 +300,7 @@ in parentheses can be met and it will match.
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/fBXyX0/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)
 
 ## 2.7 Escaping special character
 
@@ -317,8 +309,8 @@ allows us to specify a symbol as a matching character including reserved
 characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
 character prepend `\` before it.
 
-For example, the regular expression `.` is used to match any character except
-newline. Now to match `.` in an input string the regular expression
+For example, der reguläre Ausdruck `.` is used to match any character except
+newline. Now to match `.` in an input string der reguläre Ausdruck
 `(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
 character `a`, followed by lowercase letter `t`, followed by optional `.`
 character.
@@ -327,7 +319,7 @@ character.
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/DOc5Nu/1)
 
 ## 2.8 Anchors
 
@@ -352,13 +344,13 @@ lowercase character `h`, followed by lowercase character `e`.
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/5ljjgB/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/5ljjgB/1)
 
 <pre>
 "^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/jXrKne/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/jXrKne/1)
 
 ### 2.8.2 Dollar
 
@@ -371,13 +363,13 @@ character and the matcher must be end of the string.
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/y4Au4D/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/y4Au4D/1)
 
 <pre>
 "(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/t0AkOd/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/t0AkOd/1)
 
 ##  3. Shorthand Character Sets
 
@@ -421,7 +413,7 @@ followed by the lookahead expression. The returned match only contains the text
 that is matched by the first part of the expression. To define a positive
 lookahead, parentheses are used. Within those parentheses, a question mark with
 equal sign is used like this: `(?=...)`. Lookahead expression is written after
-the equal sign inside parentheses. For example, the regular expression
+the equal sign inside parentheses. For example, der reguläre Ausdruck
 `(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
 letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
 define positive lookahead which tells regular expression engine to match `The`
@@ -431,7 +423,7 @@ or `the` which are followed by the word `fat`.
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/IDDARt/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)
 
 ### 4.2 Negative Lookahead
 
@@ -447,7 +439,7 @@ character.
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/V32Npg/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)
 
 ### 4.3 Positive Lookbehind
 
@@ -460,7 +452,7 @@ from input string that are after the word `The` or `the`.
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/avH165/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/avH165/1)
 
 ### 4.4 Negative Lookbehind
 
@@ -473,7 +465,7 @@ string that are not after the word `The` or `the`.
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/8Efx5G/1)
 
 ## 5. Flags
 
@@ -492,7 +484,7 @@ integral part of the RegExp.
 The `i` modifier is used to perform case-insensitive matching. For example, the
 regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
 character `h`, followed by character `e`. And at the end of regular expression
-the `i` flag tells the regular expression engine to ignore the case. As you can
+the `i` flag tells der reguläre Ausdruck engine to ignore the case. As you can
 see we also provided `g` flag because we want to search for the pattern in the
 whole input string.
 
@@ -500,40 +492,40 @@ whole input string.
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dpQyf9/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/dpQyf9/1)
 
 <pre>
 "/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/ahfiuh/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/ahfiuh/1)
 
 ### 5.2 Global search
 
 The `g` modifier is used to perform a global match (find all matches rather than
-stopping after the first match). For example, the regular expression`/.(at)/g`
+stopping after the first match). For example, der reguläre Ausdruck`/.(at)/g`
 means: any character except new line, followed by lowercase character `a`,
 followed by lowercase character `t`. Because we provided `g` flag at the end of
-the regular expression now it will find all matches in the input string, not just the first one (which is the default behavior).
+der reguläre Ausdruck now it will find all matches in the input string, not just the first one (which is the default behavior).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/jnk6gM/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/jnk6gM/1)
 
 <pre>
 "/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
 </pre>
 
-[Test the regular expression](https://regex101.com/r/dO1nef/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/dO1nef/1)
 
 ### 5.3 Multiline
 
 The `m` modifier is used to perform a multi-line match. As we discussed earlier
 anchors `(^, $)` are used to check if pattern is the beginning of the input or
 end of the input string. But if we want that anchors works on each line we use
-`m` flag. For example, the regular expression `/at(.)?$/gm` means: lowercase
+`m` flag. For example, der reguläre Ausdruck `/at(.)?$/gm` means: lowercase
 character `a`, followed by lowercase character `t`, optionally anything except
 new line. And because of `m` flag now regular expression engine matches pattern
 at the end of each line in a string.
@@ -544,7 +536,7 @@ at the end of each line in a string.
                 on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/hoGMkP/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/hoGMkP/1)
 
 <pre>
 "/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
@@ -552,7 +544,7 @@ at the end of each line in a string.
                   on the <a href="#learn-regex"><strong>mat.</strong></a>
 </pre>
 
-[Test the regular expression](https://regex101.com/r/E88WE2/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1)
 
 ## 6. Greedy vs lazy matching
 By default regex will do greedy matching , means it will match as long as
@@ -562,13 +554,13 @@ possible. we can use `?` to match in lazy way means as short as possible
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
 
 
-[Test the regular expression](https://regex101.com/r/AyAdgJ/1)
+[Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/1)
 
 <pre>
 "/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
 
 
-[Test the regular expression](https://regex101.com/r/AyAdgJ/2)
+[Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2)
 
 
 ## Contribution

From fc63d63974e9b6698b74553969e27a8df2c9faf5 Mon Sep 17 00:00:00 2001
From: Frank Bueltge <frank@bueltge.de>
Date: Mon, 20 Apr 2020 15:32:12 +0200
Subject: [PATCH 126/185] Update anker links

---
 translations/README-de.md | 48 +++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index b8b09465..586dccdc 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -43,33 +43,33 @@ Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `
 
 ## Table of Contents
 
-- [Basis Vergleiche](#1-basic-matchers)
-- [Sonderzeichen](#2-meta-characters)
-  - [Punkt](#21-full-stop)
-  - [Zeichensätze](#22-zeichensaetze)
-    - [Invertierter Zeichensatz](#221-negated-character-set)
-  - [Wiederholungen](#23-repetitions)
-    - [Stern *](#231-the-star)
-    - [Plus +](#232-the-plus)
-    - [Fragezeichen ?](#233-the-question-mark)
-  - [Klammern {}](#24-braces)
-  - [Zeichengruppen](#25-character-group)
+- [Basis Vergleiche](#1-basis-vergleiche)
+- [Sonderzeichen](#2-sonderzeichen)
+  - [Punkt](#21-punkt)
+  - [Zeichensätze](#22-zeichensätze)
+    - [Invertierter Zeichensatz](#221-invertierter-zeichensatz)
+  - [Wiederholungen](#23-wiederholungen)
+    - [Stern *](#231-stern)
+    - [Plus +](#232-plus)
+    - [Fragezeichen ?](#233-fragezeichen)
+  - [Klammern {}](#24-klammern)
+  - [Zeichengruppen](#25-zeichengruppen)
   - [Alternation |](#26-alternation)
-  - [Auswertung von Sonderzeichen](#27-escaping-special-character)
-  - [Anker](#28-anchors)
+  - [Auswertung von Sonderzeichen](#27-auswertung-von-sonderzeichen)
+  - [Anker](#28-anker)
     - [Caret ^](#281-caret)
     - [Dollar $](#282-dollar)
-- [Kurzschreibweisen](#3-shorthand-character-sets)
-- [Umschauen](#4-lookaround)
-  - [Positives Vorrausschauen](#41-positive-lookahead)
-  - [Negatives Vorrausschauen](#42-negative-lookahead)
-  - [Positives Zurückschauen](#43-positive-lookbehind)
-  - [Negatives Zurückschauen](#44-negative-lookbehind)
-- [Steuerparameter](#5-flags)
-  - [Groß-/Kleinschreibung](#51-case-insensitive)
-  - [Globale Suche](#52-global-search)
-  - [Mehrzeilig](#53-multiline)
-- [Gierige oder faule Übereinstimmung](#6-greedy-vs-lazy-matching)
+- [Kurzschreibweisen](#3-kurzschreibweisen)
+- [Umschauen](#4-umschauen)
+  - [Positives Vorrausschauen](#41-positives-vorausschauen)
+  - [Negatives Vorrausschauen](#42-negatives-vorausschauen)
+  - [Positives Zurückschauen](#43-positives-zurückschauen)
+  - [Negatives Zurückschauen](#44-negatives-zurückschauen)
+- [Steuerparameter](#5-steuerparameter)
+  - [Groß-/Kleinschreibung](#51-groß-kleinschreibung)
+  - [Globale Suche](#52-globale-suche)
+  - [Mehrzeilig](#53-mehrzeilig)
+- [Gierige oder faule Übereinstimmung](#6-gierige-oder-faule-übereinstimmung)
 
 ## 1. Basis Vergleiche
 

From b351c28cd855a0b771069b30bfdb7ab1215a6371 Mon Sep 17 00:00:00 2001
From: Frank Bueltge <frank@bueltge.de>
Date: Mon, 20 Apr 2020 15:46:14 +0200
Subject: [PATCH 127/185] chanpter 2.2 done

---
 translations/README-de.md | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 586dccdc..0533c61e 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -127,9 +127,7 @@ Zeichensätze werden auch als Zeichenklasse bezeichnet. Zeichensätze werden in
 </pre>
 [Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1)
 
-A period inside a character set, however, means a literal period. The regular
-expression `ar[.]` means: a lowercase character `a`, followed by letter `r`,
-followed by a period `.` character.
+Ein Punkt in einem Zeichensatz bedeutet jedoch einen wörtlichen Punkt. Der reguläre Ausdruck `ar[.]` bedeutet: ein kleingeschriebenes Zeichen `a`, gefolgt vom kleingeschriebenen Buchstaben `r`, gefolgt von dem wörtlichen Zeichen Punkt `.`.
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -137,12 +135,9 @@ followed by a period `.` character.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Negated character set
+### 2.2.1 Invertierter Zeichensatz
 
-In general, the caret symbol represents the start of the string, but when it is
-typed after the opening square bracket it negates the character set. For
-example, der reguläre Ausdruck `[^c]ar` means: any character except `c`,
-followed by the character `a`, followed by the letter `r`.
+Im Allgemeinen stellt das Caret-Symbol `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird der Zeichensatz negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: jeder Buchstabe außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. 
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.

From 4fc2c9ed700e10dfd4bcc9acd04fc91aa17df53c Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <johnnyjayjay02@gmail.com>
Date: Wed, 24 Jun 2020 22:36:42 +0200
Subject: [PATCH 128/185] Improve grammar and wording of previous sections,
 begin working on missing sections

---
 translations/README-de.md | 81 ++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 44 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 0533c61e..1de27b6f 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -71,9 +71,9 @@ Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `
   - [Mehrzeilig](#53-mehrzeilig)
 - [Gierige oder faule Übereinstimmung](#6-gierige-oder-faule-übereinstimmung)
 
-## 1. Basis Vergleiche
+## 1. Einfache Muster
 
-Ein regulärer Ausdruck ist ein einfaches Muster von Zeichen, welches für eine Suche in Text genutzt wird. Zum Beispiel, der reguläre Ausdruck `the` meint: der Buchstabe `t`, gefolgt durch den Buchstaben `h`, gefolgt durch den Buchstaben `e`.
+Ein regulärer Ausdruck ist einfach nur ein Muster von Zeichen, welches für eine Suche in Text genutzt wird. Der reguläre Ausdruck `the` heißt zum Beispiel: der Buchstabe `t`, gefolgt von dem Buchstaben `h`, gefolgt von dem Buchstaben `e`.
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -81,7 +81,7 @@ Ein regulärer Ausdruck ist ein einfaches Muster von Zeichen, welches für eine
 
 [Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1)
 
-Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre Ausdruck kann mit einer Zeichenkette verglichen werden, in dem jedes Zeichen in dem regulären Ausdruck nacheinander verglichen wird. Reguläre Ausdrücke sind normalerweise case sensitiv, Beachtung von Groß-/Kleinschreibung, so dass der Ausdruck `The` nicht mit der Zeichenkette  `the` überein stimmen würde. 
+Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre Ausdruck wird auf Übereinstimmung mit einer Zeichenkette überprüft, indem jedes Zeichen in dem regulären Ausdruck nacheinander mit den Zeichen in der Zeichenkette verglichen wird. Reguläre Ausdrücke sind normalerweise case sensitiv, Beachtung von Groß-/Kleinschreibung, sodass der Ausdruck `The` nicht mit der Zeichenkette  `the` überein stimmen würde. 
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -118,16 +118,16 @@ Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeich
 </pre>
 [Teste den regulären Ausdruck](https://regex101.com/r/xc9GkU/1)
 
-## 2.2 Zeichensätze
+## 2.2 Zeichenklasse
 
-Zeichensätze werden auch als Zeichenklasse bezeichnet. Zeichensätze werden in eckige Klammern angegeben. Um den Bereich der Zeichen anzugeben ist ein Bindestrich zu verwenden. Die Reihenfolge des Bereiches in den 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`.
+Zeichenklassen werden auch als Zeichenmengen oder -sätze bezeichnet. 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
 </pre>
 [Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1)
 
-Ein Punkt in einem Zeichensatz bedeutet jedoch einen wörtlichen Punkt. Der reguläre Ausdruck `ar[.]` bedeutet: ein kleingeschriebenes Zeichen `a`, gefolgt vom kleingeschriebenen Buchstaben `r`, gefolgt von dem wörtlichen Zeichen Punkt `.`.
+Ein 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 `.`.
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -135,9 +135,9 @@ Ein Punkt in einem Zeichensatz bedeutet jedoch einen wörtlichen Punkt. Der regu
 
 [Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Invertierter Zeichensatz
+### 2.2.1 Negierte Zeichenklasse
 
-Im Allgemeinen stellt das Caret-Symbol `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird der Zeichensatz negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: jeder Buchstabe außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. 
+Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird die Zeichenklasse negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: ein beliebiges Zeichen außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. 
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -145,19 +145,17 @@ Im Allgemeinen stellt das Caret-Symbol `^` den Anfang einer Zeichenkette dar. We
 
 [Teste den regulären Ausdruck](https://regex101.com/r/nNNlq3/1)
 
-## 2.3 Repetitions
+## 2.3 Wiederholungen
 
-Following meta characters `+`, `*` or `?` are used to specify how many times a
-subpattern can occur. These meta characters act differently in different
-situations.
+Die Metazeichen `+`, `*` und `?` bieten einen einfachen Weg, anzugeben, wie oft sich ein bestimmter Teilausdruck wiederholen soll. Sie gehören damit zu den sogenannten "Quantoren".
+Sie können sich je nach Situation unterschiedlich verhalten.
 
-### 2.3.1 The Star
+### 2.3.1 Der Stern
 
-The symbol `*` matches zero or more repetitions of the preceding matcher. The
-regular expression `a*` means: zero or more repetitions of preceding lowercase
-character `a`. But if it appears after a character set or class then it finds
-the repetitions of the whole character set. For example, der reguläre Ausdruck
-`[a-z]*` means: any number of lowercase letters in a row.
+Das Symbol `*` stimmt mit beliebig vielen Wiederholungen des vorhergehenden Teilausdrucks überein. Der Ausdruck `a*` heißt: 
+null, eins oder mehrere `a`s in Folge. Da sich der Stern auf Teilausdrücke bezieht, kann er auch bspw. hinter einer Zeichenklasse stehen
+und stimmt dann mit beliebig vielen Zeichen aus der Klasse in Folge überein. Zum Beispiel bedeutet der Ausdruck `[a-z]*`: eine 
+beliebige Anzahl von Kleinbuchstaben in Folge.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -165,12 +163,10 @@ the repetitions of the whole character set. For example, der reguläre Ausdruck
 
 [Teste den regulären Ausdruck](https://regex101.com/r/7m8me5/1)
 
-The `*` symbol can be used with the meta character `.` to match any string of
-characters `.*`. The `*` symbol can be used with the whitespace character `\s`
-to match a string of whitespace characters. For example, the expression
-`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`,
-followed by lowercase character `a`, followed by lowercase character `t`,
-followed by zero or more spaces.
+Das `*`-Symbol kann zusammen mit dem Metazeichen `.` verwendet werden, um mit einer vollkommen beliebigen Zeichenkette übereinzustimmen `.*`.
+Es kann auch mit der vordefinierten Zeichenklasse `\s` verwendet werden, um mit beliebig viel Leerraum (Leerzeichen, Tabulatoren, Zeilenumbrüchen)
+übereinzustimmen. Der Ausdruck `\s*cat\*` heißt zum Beispiel: null oder mehrere Leerzeichen, gefolgt von dem Buchstaben `c`, gefolgt vom Buchstaben `a`, 
+gefolgt vom Buchstaben `t` und schließlich gefolgt von null oder mehreren Leerzeichen.
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
@@ -178,12 +174,11 @@ followed by zero or more spaces.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1)
 
-### 2.3.2 The Plus
+### 2.3.2 Das Plus
 
-The symbol `+` matches one or more repetitions of the preceding character. For
-example, der reguläre Ausdruck `c.+t` means: lowercase letter `c`, followed by
-at least one character, followed by the lowercase character `t`. It needs to be
-clarified that `t` is the last `t` in the sentence.
+Das `+`-Symbol stimmt mit einer oder mehr Wiederholungen des vorhergehenden Teilausdrucks überein. Der reguläre Ausdruck
+`c.+t` bedeutet: Buchstabe `c`, gefolgt von mindestens einem beliebigen Zeichen, gefolgt vom Buchstaben `t`. Das `t` ist dabei
+das letzte `t` in der hier zu sehenden Übereinstimmung, wobei es hier auch weitere Übereinstimmungen gäbe (siehe "Teste den regulären Ausdruck").
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -191,13 +186,11 @@ clarified that `t` is the last `t` in the sentence.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1)
 
-### 2.3.3 The Question Mark
+### 2.3.3 Das Fragezeichen
 
-In regular expression the meta character `?` makes the preceding character
-optional. This symbol matches zero or one instance of the preceding character.
-For example, der reguläre Ausdruck `[T]?he` means: Optional the uppercase
-letter `T`, followed by the lowercase character `h`, followed by the lowercase
-character `e`.
+In regulären Ausdrücken sorgt das Metazeichen `?` dafür, dass der vorhergehende Teilausdruck optional wird.
+Somit stimmt es mit null oder einer Übereinstimmung des Teilausdrucks überein.
+Zum Beispiel heißt der reguläre Ausdruck `[T]?he`: ein oder kein `T`, gefolgt von dem Buchstaben `h`, gefolgt von dem Buchstaben `e`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -211,12 +204,11 @@ character `e`.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/kPpO2x/1)
 
-## 2.4 Braces
+## 2.4 Geschweifte Klammern
 
-In regular expression braces that are also called quantifiers are used to
-specify the number of times that a character or a group of characters can be
-repeated. For example, der reguläre Ausdruck `[0-9]{2,3}` means: Match at least
-2 digits but not more than 3 ( characters in the range of 0 to 9).
+Geschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantoren. Sie werden verwendet, 
+um genau anzugeben wie oft ein Teilausdruck minimal und maximal hintereinander übereinstimmen muss.
+Zum Beispiel bedeutet der reguläre Ausdruck `[0-9]{2,3}`: Mindestens zwei, aber maximal drei Ziffern (Zeichenfolge 0-9) hintereinander.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -224,9 +216,8 @@ repeated. For example, der reguläre Ausdruck `[0-9]{2,3}` means: Match at least
 
 [Teste den regulären Ausdruck](https://regex101.com/r/juM86s/1)
 
-We can leave out the second number. For example, der reguläre Ausdruck
-`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the
-regular expression `[0-9]{3}` means: Match exactly 3 digits.
+Die zweite Zahl kann ausgelassen werden. Somit heißt der Ausdruck `[0-9]{2,}`: zwei oder mehr Ziffern in Folge.
+Wenn wir auch das Komma entfernen, heißt `[0-9]{3}`: genau drei Ziffern in Folge.
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -240,7 +231,9 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/Sivu30/1)
 
-## 2.5 Capturing Group
+## 2.5 Gruppierungen
+
+Eine Gruppierung fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen. 
 
 A capturing group is a group of sub-patterns that is written inside Parentheses 
 `(...)`. Like as we discussed before that in regular expression if we put a quantifier 

From e21f70b7dc8bcba5792f91711c156aa18c06bacf Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <39348311+JohnnyJayJay@users.noreply.github.com>
Date: Thu, 25 Jun 2020 16:08:45 +0200
Subject: [PATCH 129/185] Continue work until flags

---
 translations/README-de.md | 278 +++++++++++++++++---------------------
 1 file changed, 126 insertions(+), 152 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 1de27b6f..fd85286b 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -46,14 +46,14 @@ Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `
 - [Basis Vergleiche](#1-basis-vergleiche)
 - [Sonderzeichen](#2-sonderzeichen)
   - [Punkt](#21-punkt)
-  - [Zeichensätze](#22-zeichensätze)
-    - [Invertierter Zeichensatz](#221-invertierter-zeichensatz)
+  - [Zeichenklasse](#22-zeichenklasse)
+    - [Negierte Zeichenklasse](#221-negierte-zeichenklasse)
   - [Wiederholungen](#23-wiederholungen)
-    - [Stern *](#231-stern)
-    - [Plus +](#232-plus)
-    - [Fragezeichen ?](#233-fragezeichen)
-  - [Klammern {}](#24-klammern)
-  - [Zeichengruppen](#25-zeichengruppen)
+    - [Stern *](#231-der-stern)
+    - [Plus +](#232-das-plus)
+    - [Fragezeichen ?](#233-das-fragezeichen)
+  - [Geschweifte Klammern {}](#24-geschweifte-klammern)
+  - [Gruppierung](#25-gruppierung)
   - [Alternation |](#26-alternation)
   - [Auswertung von Sonderzeichen](#27-auswertung-von-sonderzeichen)
   - [Anker](#28-anker)
@@ -89,29 +89,30 @@ Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre
 
 [Teste den regulären Ausdruck](https://regex101.com/r/1paXsy/1)
 
-## 2. Sonderzeichen
+## 2. Metazeichen
 
-Sonderzeichen sind Bausteine von regulären Ausdrücken. Sonderzeichen stehen nicht für sich selbst, sondern werden in speziellen Fällen interpretiert. Einige Sonderzeichen haben eine besondere Bedeutung und sind innerhalb eckiger Klammern `[]`. Folgende Sonderzeichen sind möglich:
+Metazeichen 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.
+Einige Metazeichen erhalten eine andere Bedeutung oder überhaupt erst eine besondere Bedeutung innerhalb eckiger Klammern `[]`. Folgende Metazeichen gibt es:
 
-|Sonderzeichen|Beschreibung|
+|Metazeichen|Beschreibung|
 |:----:|----|
-|.|Der Punkt entspricht jedem einzelnen Zeichen, außer einem Zeilenumbruch.|
-|[ ]|Zeichen-Klasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|
-|[^ ]|Negierte Zeichen-Klasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|
-|*|Entspricht 0 oder mehr Wiederholungen der voran gestellten Zeichen.|
-|+|Entspricht 1 oder mehr Wiederholungen der voran gestellten Zeichen.|
-|?|Macht das vorhergehende Zeichen optional.|
-|{n,m}|Klammern, entspricht mindestens "n", aber nicht mehr als "m" Wiederholungen des Zeichens.|
-|(xyz)|Zeichengruppe, entspricht den Zeichen xyz in der exakten Reihenfolge.|
-|||Alternation, entspricht entweder den Zeichen vor oder nach dem Sonderzeichen \|.|
-|\|Entfernt das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Überprüft den Anfang einer Eingabe.|
-|$|Überprüft das Ende einer Eingabe.|
+|.|Der Punkt entspricht jedem einzelnen Zeichen, außer Zeilenumbrüchen.|
+|[ ]|Zeichenklasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|
+|[^ ]|Negierte Zeichenklasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|
+|*|Entspricht 0 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|
+|+|Entspricht 1 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|
+|?|Macht den vorhergehenden Teilausdruck optional.|
+|{n,m}|Entspricht mindestens "n", aber nicht mehr als "m" Wiederholungen des vorhergehenden Teilausdrucks.|
+|(xyz)|Gruppierung, entspricht den Zeichen xyz in der exakten Reihenfolge.|
+|||Alternation, entspricht entweder dem Teilausdruck vor oder nach dem \|.|
+|\|Escaped das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Entspricht dem Anfang der Eingabe.|
+|$|Entspricht dem Ende der Eingabe.|
 
 ## 2.1 Punkt
 
-Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeichen `.`
- entspricht jedem einzelnen Zeichen. Es wird kein Zeilenumbruch oder Enter-Zeichen gefunden. Als Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.
+Der Punkt `.` ist das einfachste Beispiel für ein Metazeichen. Er steht für jedes beliebiges Zeichen mit der Ausnahme von Zeilenumbrüchen/Enter-Zeichen. 
+Als Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -120,7 +121,7 @@ Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeich
 
 ## 2.2 Zeichenklasse
 
-Zeichenklassen werden auch als Zeichenmengen oder -sätze bezeichnet. 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`.
+Zeichenklassen 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -137,7 +138,7 @@ Ein Punkt in einer Zeichenklasse bedeutet, anders als sonst, einen wörtlichen P
 
 ### 2.2.1 Negierte Zeichenklasse
 
-Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird die Zeichenklasse negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: ein beliebiges Zeichen außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. 
+Im 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`. 
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -147,7 +148,7 @@ Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn
 
 ## 2.3 Wiederholungen
 
-Die Metazeichen `+`, `*` und `?` bieten einen einfachen Weg, anzugeben, wie oft sich ein bestimmter Teilausdruck wiederholen soll. Sie gehören damit zu den sogenannten "Quantoren".
+Die 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*).
 Sie können sich je nach Situation unterschiedlich verhalten.
 
 ### 2.3.1 Der Stern
@@ -206,7 +207,7 @@ Zum Beispiel heißt der reguläre Ausdruck `[T]?he`: ein oder kein `T`, gefolgt
 
 ## 2.4 Geschweifte Klammern
 
-Geschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantoren. Sie werden verwendet, 
+Geschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantifizierern. Sie werden verwendet, 
 um genau anzugeben wie oft ein Teilausdruck minimal und maximal hintereinander übereinstimmen muss.
 Zum Beispiel bedeutet der reguläre Ausdruck `[0-9]{2,3}`: Mindestens zwei, aber maximal drei Ziffern (Zeichenfolge 0-9) hintereinander.
 
@@ -233,16 +234,11 @@ Wenn wir auch das Komma entfernen, heißt `[0-9]{3}`: genau drei Ziffern in Folg
 
 ## 2.5 Gruppierungen
 
-Eine Gruppierung fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen. 
-
-A capturing group is a group of sub-patterns that is written inside Parentheses 
-`(...)`. Like as we discussed before that in regular expression if we put a quantifier 
-after a character then it will repeat the preceding character. But if we put quantifier
-after a capturing group then it repeats the whole capturing group. For example,
-der reguläre Ausdruck `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside capturing group.
-For example, der reguläre Ausdruck `(c|g|p)ar` means: lowercase character `c`,
-`g` or `p`, followed by character `a`, followed by character `r`.
+Eine Gruppierung (eng. *capturing group*) fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen. 
+Eine Gruppierung selbst ist ebenfalls ein Teilausdruck, weshalb Quantoren wie `{}`, `*` oder `?` auf sie angewendet werden können.
+Zum Beispiel stimmt der reguläre Ausdruck `(ab)*` mit null oder mehr Vorkommen von `a` und `b` hintereinander überein.
+Auch das "Oder"-Metazeichen `|` kann innerhalb einer Gruppierung verwendet werden. Der reguläre Ausdruck `(c|g|p)ar` bedeutet:
+kleines `c`, `g` oder `p`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. Dies ist äquivalent zu `[cgp]ar`.
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -250,16 +246,16 @@ For example, der reguläre Ausdruck `(c|g|p)ar` means: lowercase character `c`,
 
 [Teste den regulären Ausdruck](https://regex101.com/r/tUxrBG/1)
 
-Note that capturing groups do not only match but also capture the characters for use in 
-the parent language. The parent language could be python or javascript or virtually any
-language that implements regular expressions in a function definition.
+Gruppierungen stimmen nicht nur mit Zeichenketten überein, sondern "merken" sich auch die übereinstimmenden Zeichen in der Gruppe für die Verwendung in der Elternsprache
+(auch Rückwärtsreferenz genannt).
+Die Elternsprache kann Python, JavaScript oder sonst irgendeine Sprache sein, die reguläre Ausdrücke implementiert.
+
 
-### 2.5.1 Non-capturing group
+### 2.5.1 Gruppierungen ohne Rückwärtsreferenz
 
-A non-capturing group is a capturing group that only matches the characters, but 
-does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
-within parenthesis `(...)`. For example, der reguläre Ausdruck `(?:c|g|p)ar` is similar to 
-`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+Gruppierungen 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.
+Solche Gruppierungen werden mit einem `?`, gefolgt von einem `:` in Klammern `(...)` definiert.
+Somit 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.
 
 <pre>
 "(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -267,22 +263,19 @@ within parenthesis `(...)`. For example, der reguläre Ausdruck `(?:c|g|p)ar` is
 
 [Teste den regulären Ausdruck](https://regex101.com/r/Rm7Me8/1)
 
-Non-capturing groups can come in handy when used in find-and-replace functionality or 
-when mixed with capturing groups to keep the overview when producing any other kind of output. 
-See also [4. Lookaround](#4-lookaround).
+Gruppierungen 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, 
+wenn auf Basis der Übereinstimmungen eine Ausgabe erzeugt wird. Siehe auch [4. Lookaround](#4-lookaround).
 
 ## 2.6 Alternation
 
-In a regular expression, the vertical bar `|` is used to define alternation.
-Alternation is like an OR statement between multiple expressions. Now, you may be
-thinking that character set and alternation works the same way. But the big
-difference between character set and alternation is that character set works on
-character level but alternation works on expression level. For example, the
-regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
-`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
-(lowercase character `c`, followed by lowercase character `a`, followed by
-lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
-in parentheses can be met and it will match.
+In einem regulären Ausdruck wird der Trennstrich `|` verwendet, um Alternativen (eng. *alternation*) zu definieren.
+Alternation ist wie ein "ODER" zwischen mehreren Teilausdrücken. Nun könnte man annehmen, dass
+Zeichenklassen und Alternation auf die gleiche Art und Weise funktionieren. Aber der große Unterschied 
+zwischen diesen beiden ist, dass Zeichenklassen für einzelne Zeichen funktionieren, während für Alternationen
+beliebige Teilausdrücke verwendet werden können. So heißt der reguläre Ausdruck `(T|t)he|car` beispielsweise:
+Entweder ein großes `T` oder kleines `t`, dann der Buchstabe `h` gefolgt vom Buchstaben `e` ODER 
+`c`, gefolgt von `a`, gefolgt von `r`. Man beachte die Klammern, die zur Trennung der einen Alternation von der anderen
+gesetzt wurden.
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -290,18 +283,15 @@ in parentheses can be met and it will match.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 Escaping special character
+## 2.7 Escape
 
-Backslash `\` is used in regular expression to escape the next character. This
-allows us to specify a symbol as a matching character including reserved
-characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
-character prepend `\` before it.
+Der 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 
+(s. [Vordefinierte Zeichenklassen](#3-vordefinierte-zeichenklassen)).
+Er erlaubt es, für andere Zwecke reservierte Zeichen wie die Metazeichen `{ } [ ] / \ + * . $ ^ | ?` als Literale, also wörtliche Übereinstimmungen zu nutzen.
+Um mit einem besonderen Zeichen wortwörtlich übereinzustimmen, muss es auf ein `\` folgen.
 
-For example, der reguläre Ausdruck `.` is used to match any character except
-newline. Now to match `.` in an input string der reguläre Ausdruck
-`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
-character `a`, followed by lowercase letter `t`, followed by optional `.`
-character.
+Der reguläre Ausdruck `.` zum Beispiel wird benutzt, um mit einem beliebigen Zeichen übereinzustimmen. 
+Der 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 `.`.
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -309,24 +299,19 @@ character.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/DOc5Nu/1)
 
-## 2.8 Anchors
+## 2.8 Anker
 
-In regular expressions, we use anchors to check if the matching symbol is the
-starting symbol or ending symbol of the input string. Anchors are of two types:
-First type is Caret `^` that check if the matching character is the start
-character of the input and the second type is Dollar `$` that checks if matching
-character is the last character of the input string.
+In regulären Audrücken werden Anker (eng. *anchor*) verwendet, um zu überprüfen, ob der Teilausdruck mit dem 
+Anfang oder dem Ende der Teilausgabe übereinstimmt. Es gibt zwei Arten von Ankern: das Zirkumflex `^`
+stimmt mit dem Anfang, das Dollarzeichen `$` mit dem Ende der Eingabe überein.  
 
-### 2.8.1 Caret
+### 2.8.1 Zirkumflex
 
-Caret `^` symbol is used to check if matching character is the first character
-of the input string. If we apply the following regular expression `^a` (if a is
-the starting symbol) to input string `abc` it matches `a`. But if we apply
-regular expression `^b` on above input string it does not match anything.
-Because in input string `abc` "b" is not the starting symbol. Let's take a look
-at another regular expression `^(T|t)he` which means: uppercase character `T` or
-lowercase character `t` is the start symbol of the input string, followed by
-lowercase character `h`, followed by lowercase character `e`.
+Das Zirkumflex `^` (eng. *caret*) wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Anfang der Zeichenkette übereinstimmt.
+Wenn wir den regulären Ausdruck `^a` auf die Eingabe `abc` anwenden, stimmt er mit `a` überein. 
+Aber wenn wir auf die gleiche Eingabe den Ausdruck `^b` anwenden, gibt es keine Übereinstimmungen, weil in der Zeichenkette `abc` kein "b"
+am Anfang steht. Schauen wir uns einen anderen Ausdruck an: `^(T|t)he`. Dieser bedeutet: kleines `t` oder großes `T` am Anfang der Eingabe,
+gefolgt von `h`, gefolgt von `e`.
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -342,10 +327,8 @@ lowercase character `h`, followed by lowercase character `e`.
 
 ### 2.8.2 Dollar
 
-Dollar `$` symbol is used to check if matching character is the last character
-of the input string. For example, regular expression `(at\.)$` means: a
-lowercase character `a`, followed by lowercase character `t`, followed by a `.`
-character and the matcher must be end of the string.
+Das Dollarzeichen `$` wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Ende der Zeichenkette übereinstimmt.
+Der reguläre Ausdruck `(at\.)$` etwa bedeutet: `a`, gefolgt von `t` und dann `.` am Ende der Eingabe.
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -359,53 +342,47 @@ character and the matcher must be end of the string.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/t0AkOd/1)
 
-##  3. Shorthand Character Sets
+##  3. Vordefinierte Zeichenklassen
 
-Regular expression provides shorthands for the commonly used character sets,
-which offer convenient shorthands for commonly used regular expressions. The
-shorthand character sets are as follows:
+Reguläre Ausdrücke haben Kürzel für die am häufigsten benötigten Zeichenklassen, was viele Ausdrücke vereinfacht und kürzer macht.
+Das sind die vordefinierten Zeichenklassen:
 
 |Shorthand|Description|
 |:----:|----|
-|.|Any character except new line|
-|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
-|\W|Matches non-alphanumeric characters: `[^\w]`|
-|\d|Matches digit: `[0-9]`|
-|\D|Matches non-digit: `[^\d]`|
-|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
-|\S|Matches non-whitespace character: `[^\s]`|
+|.|Beliebiges Zeichen außer Zeilenumbruch|
+|\w|Stimmt mit alphanumerischen Zeichen überein: `[a-zA-Z0-9_]`|
+|\W|Stimmt mit nicht-alphanumerischen Zeichen überein: `[^\w]`|
+|\d|Stimmt mit Ziffern überein: `[0-9]`|
+|\D|Stimmt mit Zeichen, die keine Ziffern sind überein: `[^\d]`|
+|\s|Stimmt mit Leerraum überein: `[\t\n\f\r\p{Z}]`|
+|\S|Stimmt mit allem außer Leerraum überein: `[^\s]`|
 
 ## 4. Lookaround
 
-Lookbehind and lookahead (also called lookaround) are specific types of
-***non-capturing groups*** (Used to match the pattern but not included in matching
-list). Lookarounds are used when we have the condition that this pattern is
-preceded or followed by another certain pattern. For example, we want to get all
-numbers that are preceded by `$` character from the following input string
-`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
-which means: get all the numbers which contain `.` character and  are preceded
-by `$` character. Following are the lookarounds that are used in regular
-expressions:
-
-|Symbol|Description|
+Lookbehind ("nach hinten sehend") und Lookahead ("vorausschauend") (auch Lookaround ("Umsehen") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**
+(zur Erinnerung: das sind Gruppierungen, die zwar mit dem Muster übereinstimmen, aber sich die Übereinstimmung nicht "merken").
+Sie werden in Situationen verwendet, wo wir ein Muster einfangen wollen, dem andere Muster folgen oder vorhergehen.
+Zum 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:
+`(?<=\$)[0-9.]*`. Das heißt: Stimme mit allen Zeichenketten überein, die Ziffern `0-9` oder Punkte `.` enthalten und die einem Dollarzeichen `$` folgen.
+
+Das sind die Lookarounds, die es gibt:
+
+|Symbol|Name|
 |:----:|----|
-|?=|Positive Lookahead|
-|?!|Negative Lookahead|
-|?<=|Positive Lookbehind|
-|?<!|Negative Lookbehind|
+|?=|Positiver Lookahead|
+|?!|Negativer Lookahead|
+|?<=|Positiver Lookbehind|
+|?<!|Negativer Lookbehind|
 
-### 4.1 Positive Lookahead
+### 4.1 Positiver Lookahead
 
-The positive lookahead asserts that the first part of the expression must be
-followed by the lookahead expression. The returned match only contains the text
-that is matched by the first part of the expression. To define a positive
-lookahead, parentheses are used. Within those parentheses, a question mark with
-equal sign is used like this: `(?=...)`. Lookahead expression is written after
-the equal sign inside parentheses. For example, der reguläre Ausdruck
-`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
-letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
-define positive lookahead which tells regular expression engine to match `The`
-or `the` which are followed by the word `fat`.
+Ein positiver Lookahead versichert, dass der Teilausdruck vor dem Lookahead von dem Lookahead-Teilausdruck gefolgt wird.
+Das Ergebnis der Übereinstimmung beinhaltet dabei nur den Teilausdruck vor dem Lookahead.
+Klammern werden genutzt, um positive Lookaheads zu definieren. Nach der öffnenden Klammer müssen ein Fragezeichen und ein Gleichheitszeichen
+stehen: `(?=...)`. Der Lookahead-Ausdruck wird nach dem Gleichheitszeichen notiert.
+Zum Beispiel bedeutet der reguläre Ausdruck `(T|t)he(?=\sfat)`: kleines `t` oder großes `T`, dann ein `h`, dann ein `e`. Der positive Lookahead in den Klammern 
+ist eine zusätzliche Bedingung, die dafür sorgt, dass der Ausdruck nur mit `the` oder `The` übereinstimmt, welches von einem Leerzeichen und den Buchstaben 
+`f`, `a` und `t` gefolgt wird.
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -413,15 +390,11 @@ or `the` which are followed by the word `fat`.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negative Lookahead
+### 4.2 Negativer Lookahead
 
-Negative lookahead is used when we need to get all matches from input string
-that are not followed by a pattern. Negative lookahead is defined same as we define
-positive lookahead but the only difference is instead of equal `=` character we
-use negation `!` character i.e. `(?!...)`. Let's take a look at the following
-regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
-from input string that are not followed by the word `fat` precedes by a space
-character.
+Negative Lookaheads werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, auf die **nicht** ein bestimmtes Muster folgt.
+Ein Negativer Lookahead wird wie ein positiver Lookahead definiert, nur dass statt einem Gleichheitszeichen ein Ausrufezeichen `!` benutzt wird, d.h.
+`(?!...)`. 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.
 
 <pre>
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -429,12 +402,11 @@ character.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positive Lookbehind
+### 4.3 Positiver Lookbehind
 
-Positive lookbehind is used to get all the matches that are preceded by a
-specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
-regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
-from input string that are after the word `The` or `the`.
+Positive Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen ein bestimmtes Muster vorhergeht.
+Postive Lookbehinds werden mit `(?<=...)` notiert. Der reguläre Ausdruck `(?<=(T|t)he\s)(fat|mat)` zum Beispiel bedeutet: alle `fat` oder `mat`, 
+die nach `The ` oder `the ` kommen, stimmen überein.
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -442,12 +414,11 @@ from input string that are after the word `The` or `the`.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/avH165/1)
 
-### 4.4 Negative Lookbehind
+### 4.4 Negativer Lookbehind
 
-Negative lookbehind is used to get all the matches that are not preceded by a
-specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
-regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
-string that are not after the word `The` or `the`.
+Negative Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen **nicht** ein bestimmtes Muster vorhergeht.
+Negative Lookbehinds werden mit `(?<!...)` notiert. Der reguläre Ausdruck `(?<!(T|t)he\s)(cat)` zum Beispiel bedeutet: alle `cat`, die nicht nach 
+`The ` oder `the ` kommen, stimmen überein.
 
 <pre>
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -455,19 +426,22 @@ string that are not after the word `The` or `the`.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/8Efx5G/1)
 
-## 5. Flags
+## 5. Modifikatoren
+
+Modifikatoren (eng. *flags* oder *modifiers*) verändern die Ausgabe eines regulären Ausdrucks. Sie können in beliebiger Kombination oder Reihenfolge 
+genutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.
 
-Flags are also called modifiers because they modify the output of a regular
-expression. These flags can be used in any order or combination, and are an
-integral part of the RegExp.
 
-|Flag|Description|
+|Modifikator|Beschreibung|
 |:----:|----|
-|i|Case insensitive: Sets matching to be case-insensitive.|
-|g|Global Search: Search for a pattern throughout the input string.|
-|m|Multiline: Anchor meta character works on each line.|
+|i|Schreibungsunabhängig: Unterschiede bei Groß- und Kleinschreibung in den Mustern werden ignoriert.|
+|g|Globale Suche: Die Suche geht durch die gesamte Eingabe.|
+|m|Mehrzeilig: Anker-Metazeichen funktionieren für Anfang/Ende jeder Zeile.|
+
+### 5.1 Schreibungsunabhängig
 
-### 5.1 Case Insensitive
+Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck
+`/The/gi`: großes `T`
 
 The `i` modifier is used to perform case-insensitive matching. For example, the
 regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase

From 18293bc13cc18c39bd6ac6ce4c78147dd0aba067 Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <johnnyjayjay02@gmail.com>
Date: Thu, 25 Jun 2020 19:14:32 +0200
Subject: [PATCH 130/185] Add information about i flag

---
 translations/README-de.md | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index fd85286b..f2d5536d 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -441,14 +441,9 @@ genutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.
 ### 5.1 Schreibungsunabhängig
 
 Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck
-`/The/gi`: großes `T`
-
-The `i` modifier is used to perform case-insensitive matching. For example, the
-regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase
-character `h`, followed by character `e`. And at the end of regular expression
-the `i` flag tells der reguläre Ausdruck engine to ignore the case. As you can
-see we also provided `g` flag because we want to search for the pattern in the
-whole input string.
+`/The/gi`: großes `T`, gefolgt von `h`, dann `e`. Und am Ende des Ausdrucks ist der `i` Modifikator zu finden, welcher der Maschine 
+zu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden soll. Wie zu sehen ist, wird auch der `g` Modifikator benutzt,
+da wir die gesamte Eingabe nach dem Muster absuchen wollen.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -462,7 +457,7 @@ whole input string.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 Global search
+### 5.2 Globale Suche
 
 The `g` modifier is used to perform a global match (find all matches rather than
 stopping after the first match). For example, der reguläre Ausdruck`/.(at)/g`

From c63cca4d220b1a32f5b6133d9a34e56af5869e58 Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <39348311+JohnnyJayJay@users.noreply.github.com>
Date: Fri, 26 Jun 2020 08:37:08 +0200
Subject: [PATCH 131/185] finish remaining translation

---
 translations/README-de.md | 44 ++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index f2d5536d..7db7222a 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -442,7 +442,7 @@ genutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.
 
 Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck
 `/The/gi`: großes `T`, gefolgt von `h`, dann `e`. Und am Ende des Ausdrucks ist der `i` Modifikator zu finden, welcher der Maschine 
-zu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden soll. Wie zu sehen ist, wird auch der `g` Modifikator benutzt,
+zu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden sollen. Wie zu sehen ist, wird auch der `g` Modifikator benutzt,
 da wir die gesamte Eingabe nach dem Muster absuchen wollen.
 
 <pre>
@@ -459,11 +459,10 @@ da wir die gesamte Eingabe nach dem Muster absuchen wollen.
 
 ### 5.2 Globale Suche
 
-The `g` modifier is used to perform a global match (find all matches rather than
-stopping after the first match). For example, der reguläre Ausdruck`/.(at)/g`
-means: any character except new line, followed by lowercase character `a`,
-followed by lowercase character `t`. Because we provided `g` flag at the end of
-der reguläre Ausdruck now it will find all matches in the input string, not just the first one (which is the default behavior).
+Der `g` Modifikator wird benutzt, um eine globale Suche durchzuführen (alle Übereinstimmungen finden, nicht nach der ersten aufhören).
+Zum Beispiel heißt der reguläre Ausdruck `/.(at)/g`: ein beliebiges Zeichen (außer Zeilenumbruch), gefolgt von `a`, gefolgt von `t`.
+Weil wir den `g` Modifikator angegeben haben, findet der reguläre Ausdruck nun alle Übereinstimmungen in der Eingabe, nicht nur die erste
+(was das Standardverhalten ist).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -477,15 +476,12 @@ der reguläre Ausdruck now it will find all matches in the input string, not jus
 
 [Teste den regulären Ausdruck](https://regex101.com/r/dO1nef/1)
 
-### 5.3 Multiline
+### 5.3 Mehrzeilig
 
-The `m` modifier is used to perform a multi-line match. As we discussed earlier
-anchors `(^, $)` are used to check if pattern is the beginning of the input or
-end of the input string. But if we want that anchors works on each line we use
-`m` flag. For example, der reguläre Ausdruck `/at(.)?$/gm` means: lowercase
-character `a`, followed by lowercase character `t`, optionally anything except
-new line. And because of `m` flag now regular expression engine matches pattern
-at the end of each line in a string.
+Der `m` Modifikator wird benutzt, um eine mehrzeilige Suche durchzuführen. Wie zuvor erwähnt werden Anker `(^, $)` genutzt, um zu überprüfen,
+ob ein Muster dem Anfang oder dem Ende der Eingabe entspricht. Wenn wir stattdessen wollen, dass Anker zeilenweise funktionieren, nutzen wir den `m`
+Modifikator. Zum Beispiel bedeutet der reguläre Ausdruck `/at(.)?$/gm`: `a`, gefolgt von `t`, dann optional ein beliebiges Zeichen außer 
+Zeilenumbruch. Wegen des `m` Modifikators wird das Muster nun auf das Ende jeder Zeile statt nur das Ende der gesamten Eingabe angewandt.
 
 <pre>
 "/.at(.)?$/" => The fat
@@ -503,9 +499,10 @@ at the end of each line in a string.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1)
 
-## 6. Greedy vs lazy matching
-By default regex will do greedy matching , means it will match as long as
-possible. we can use `?` to match in lazy way means as short as possible
+## 6. Gier vs Faulheit
+
+Standardmäßig finden reguläre Ausdrücke Übereinstimmungen mit Gier (eng. *greed*), d.h. es wird nach den längsten Übereinstimmungen gesucht. 
+Mit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten Übereinstimmungen gesucht.
 
 <pre>
 "/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
@@ -519,14 +516,13 @@ possible. we can use `?` to match in lazy way means as short as possible
 
 [Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2)
 
+## Beitragen
 
-## Contribution
-
-* Open pull request with improvements
-* Discuss ideas in issues
-* Spread the word
-* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Öffne pull requests mit Verbesserungen
+* Diskutiere Ideen in issues
+* Erzähl es anderen
+* Gebt Rückmeldung [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
-## License
+## Lizenz
 
 MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From f0a00dc5c93139975cb4dd3d0e9eb75f8dc33cbb Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <39348311+JohnnyJayJay@users.noreply.github.com>
Date: Fri, 26 Jun 2020 08:47:43 +0200
Subject: [PATCH 132/185] Adjust table of contents and a few titles

---
 translations/README-de.md | 50 +++++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 7db7222a..5fd85070 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -22,7 +22,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 
-## Was sind reguläre Ausdrücke
+## Was sind Reguläre Ausdrücke?
 
 > Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein spezifisches Muster in einem Text zu finden
 Ein regulärer Ausdruch ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
@@ -41,35 +41,35 @@ den Benutzernamen zu überprüfen:
 
 Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
 
-## Table of Contents
+## Inhaltsverzeichnis
 
-- [Basis Vergleiche](#1-basis-vergleiche)
-- [Sonderzeichen](#2-sonderzeichen)
+- [Einfache Muster](#1-einfache-muster)
+- [Metazeichen](#2-metazeichen)
   - [Punkt](#21-punkt)
   - [Zeichenklasse](#22-zeichenklasse)
     - [Negierte Zeichenklasse](#221-negierte-zeichenklasse)
   - [Wiederholungen](#23-wiederholungen)
-    - [Stern *](#231-der-stern)
-    - [Plus +](#232-das-plus)
-    - [Fragezeichen ?](#233-das-fragezeichen)
+    - [Stern *](#231-stern)
+    - [Plus +](#232-plus)
+    - [Fragezeichen ?](#233-fragezeichen)
   - [Geschweifte Klammern {}](#24-geschweifte-klammern)
-  - [Gruppierung](#25-gruppierung)
+  - [Gruppierung ()](#25-gruppierung)
   - [Alternation |](#26-alternation)
-  - [Auswertung von Sonderzeichen](#27-auswertung-von-sonderzeichen)
+  - [Escaping \](#27-escaping)
   - [Anker](#28-anker)
-    - [Caret ^](#281-caret)
+    - [Zirkumflex ^](#281-zirkumflex)
     - [Dollar $](#282-dollar)
-- [Kurzschreibweisen](#3-kurzschreibweisen)
-- [Umschauen](#4-umschauen)
-  - [Positives Vorrausschauen](#41-positives-vorausschauen)
-  - [Negatives Vorrausschauen](#42-negatives-vorausschauen)
-  - [Positives Zurückschauen](#43-positives-zurückschauen)
-  - [Negatives Zurückschauen](#44-negatives-zurückschauen)
-- [Steuerparameter](#5-steuerparameter)
-  - [Groß-/Kleinschreibung](#51-groß-kleinschreibung)
+- [Vordefinierte Zeichenklassen](#3-vordefinierte-zeichenklassen)
+- [Lookaround](#4-lookaround)
+  - [Positiver Lookahead](#41-positiver-lookahead)
+  - [Negativer Lookahead](#42-negativer-lookahead)
+  - [Positiver Lookbehind](#43-positiver-lookbehind)
+  - [Negativer Lookbehind](#44-negativer-lookbehind)
+- [Modifikatoren](#5-modifikatoren)
+  - [Schreibungsunabhängig i](#51-schreibungsunbhängig)
   - [Globale Suche](#52-globale-suche)
   - [Mehrzeilig](#53-mehrzeilig)
-- [Gierige oder faule Übereinstimmung](#6-gierige-oder-faule-übereinstimmung)
+- [Gierige vs Faule Übereinstimmung](#6-gierige-vs-faule-übereinstimmung)
 
 ## 1. Einfache Muster
 
@@ -151,7 +151,7 @@ Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn
 Die 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*).
 Sie können sich je nach Situation unterschiedlich verhalten.
 
-### 2.3.1 Der Stern
+### 2.3.1 Stern
 
 Das Symbol `*` stimmt mit beliebig vielen Wiederholungen des vorhergehenden Teilausdrucks überein. Der Ausdruck `a*` heißt: 
 null, eins oder mehrere `a`s in Folge. Da sich der Stern auf Teilausdrücke bezieht, kann er auch bspw. hinter einer Zeichenklasse stehen
@@ -175,7 +175,7 @@ gefolgt vom Buchstaben `t` und schließlich gefolgt von null oder mehreren Leerz
 
 [Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1)
 
-### 2.3.2 Das Plus
+### 2.3.2 Plus
 
 Das `+`-Symbol stimmt mit einer oder mehr Wiederholungen des vorhergehenden Teilausdrucks überein. Der reguläre Ausdruck
 `c.+t` bedeutet: Buchstabe `c`, gefolgt von mindestens einem beliebigen Zeichen, gefolgt vom Buchstaben `t`. Das `t` ist dabei
@@ -187,7 +187,7 @@ das letzte `t` in der hier zu sehenden Übereinstimmung, wobei es hier auch weit
 
 [Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1)
 
-### 2.3.3 Das Fragezeichen
+### 2.3.3 Fragezeichen
 
 In regulären Ausdrücken sorgt das Metazeichen `?` dafür, dass der vorhergehende Teilausdruck optional wird.
 Somit stimmt es mit null oder einer Übereinstimmung des Teilausdrucks überein.
@@ -283,7 +283,7 @@ gesetzt wurden.
 
 [Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 Escape
+## 2.7 Escaping
 
 Der 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 
 (s. [Vordefinierte Zeichenklassen](#3-vordefinierte-zeichenklassen)).
@@ -359,7 +359,7 @@ Das sind die vordefinierten Zeichenklassen:
 
 ## 4. Lookaround
 
-Lookbehind ("nach hinten sehend") und Lookahead ("vorausschauend") (auch Lookaround ("Umsehen") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**
+Lookbehind ("zurückschauen") und Lookahead ("vorausschauen") (auch Lookaround ("Umsehen") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**
 (zur Erinnerung: das sind Gruppierungen, die zwar mit dem Muster übereinstimmen, aber sich die Übereinstimmung nicht "merken").
 Sie werden in Situationen verwendet, wo wir ein Muster einfangen wollen, dem andere Muster folgen oder vorhergehen.
 Zum 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:
@@ -499,7 +499,7 @@ Zeilenumbruch. Wegen des `m` Modifikators wird das Muster nun auf das Ende jeder
 
 [Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1)
 
-## 6. Gier vs Faulheit
+## 6. Gierige vs Faule Übereinstimmung
 
 Standardmäßig finden reguläre Ausdrücke Übereinstimmungen mit Gier (eng. *greed*), d.h. es wird nach den längsten Übereinstimmungen gesucht. 
 Mit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten Übereinstimmungen gesucht.

From 0b5391fbd48ddd8f5ae1c26836a52cff4755c1a9 Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <39348311+JohnnyJayJay@users.noreply.github.com>
Date: Fri, 26 Jun 2020 08:52:43 +0200
Subject: [PATCH 133/185] Make contributing section grammar consistent

---
 translations/README-de.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 5fd85070..787e60f5 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -521,7 +521,7 @@ Mit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten
 * Öffne pull requests mit Verbesserungen
 * Diskutiere Ideen in issues
 * Erzähl es anderen
-* Gebt Rückmeldung [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Gib Rückmeldung [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
 ## Lizenz
 

From daf704e8c1286e37b37059b57eaf7c7601fc9de1 Mon Sep 17 00:00:00 2001
From: JohnnyJayJay <39348311+JohnnyJayJay@users.noreply.github.com>
Date: Fri, 26 Jun 2020 09:04:15 +0200
Subject: [PATCH 134/185] Fix old grammar in early sections

---
 translations/README-de.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index 787e60f5..f55f7289 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -24,22 +24,21 @@
 
 ## Was sind Reguläre Ausdrücke?
 
-> Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein spezifisches Muster in einem Text zu finden
+> Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein bestimmtes Muster in einem Text zu finden.
 Ein regulärer Ausdruch ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
-"Regulärer Ausdruck" ist in der Praxis unüblich und stattdessen wird häufig die Englische Abkürzung "Regex" verwendet. Reguläre
-Ausdrücke werden verwendet um Fragemente eines Textes zu ersetzen, Formulare zu validieren, Segmente eines Textes anhand eines
+"Regulärer Ausdruck" ist in der Praxis unüblich und stattdessen wird häufig die Englische Abkürzung "Regex" oder "RegExp" (*regular expression*) verwendet. Reguläre
+Ausdrücke werden verwendet, um Fragemente eines Textes zu ersetzen, Formulare zu validieren, Segmente eines Textes anhand eines
 Musters zu extrahieren und für vieles mehr.
 
-Angenommen Du schreibst eine Applikation und möchtest die Regeln definieren, nach denen ein Benutzer seinen Benutzernamen auswählen
+Angenommen, Du schreibst eine Anwendung und möchtest die Regeln definieren, nach denen ein Benutzer seinen Benutzernamen auswählen
 kann. Wir möchten festlegen, dass der Benutzernamen Buchstaben, Ziffern, Unter- und Bindestriche beinhalten darf. Außerdem wollen
-wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu verwenden wir den folgenden regulären Ausdruck um
-den Benutzernamen zu überprüfen:
+wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu verwenden wir den folgenden regulären Ausdruck:
 <br/><br/>
 <p align="center">
   <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
-Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
+Der abgebildete reguläre Ausdruck erlaubt bspw. die Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
 
 ## Inhaltsverzeichnis
 
@@ -81,7 +80,8 @@ Ein regulärer Ausdruck ist einfach nur ein Muster von Zeichen, welches für ein
 
 [Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1)
 
-Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre Ausdruck wird auf Übereinstimmung mit einer Zeichenkette überprüft, indem jedes Zeichen in dem regulären Ausdruck nacheinander mit den Zeichen in der Zeichenkette verglichen wird. Reguläre Ausdrücke sind normalerweise case sensitiv, Beachtung von Groß-/Kleinschreibung, sodass der Ausdruck `The` nicht mit der Zeichenkette  `the` überein stimmen würde. 
+Der 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. 
+Reguläre Ausdrücke berücksichtigen normalerweise Groß- und Kleinschreibung, sodass etwa der Ausdruck `The` nicht mit der Zeichenkette  `the` übereinstimmen würde. 
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.

From e3945a4cbcdf68baf8f6a734642ed3ca4f55e7be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ja=CC=81nos=20Orcsik?= <orcsikj@gmail.com>
Date: Tue, 30 Jun 2020 00:16:07 +0200
Subject: [PATCH 135/185] fix typo

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 1428d17f..55da5cec 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@
 * [Tiếng Việt](translations/README-vn.md)
 * [فارسی](translations/README-fa.md)
 
-## What are Regular Expressions?
+## What is Regular Expression?
 
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 
@@ -280,7 +280,7 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 ## 2.5 Capturing Groups
 
-A capturing group is a group of sub-patterns that is written inside parentheses 
+A capturing group is a group of subpatterns that is written inside parentheses 
 `(...)`. As discussed before, in regular expressions, if we put a quantifier 
 after a character then it will repeat the preceding character. But if we put a quantifier
 after a capturing group then it repeats the whole capturing group. For example,
@@ -356,7 +356,7 @@ character.
 
 In regular expressions, we use anchors to check if the matching symbol is the
 starting symbol or ending symbol of the input string. Anchors are of two types:
-The first type is the caret `^` that check if the matching character is the first
+The first type is the caret `^` that checks if the matching character is the first
 character of the input and the second type is the dollar sign `$` which checks if a matching
 character is the last character of the input string.
 

From 006b7a1a984b5f8cbd5dc6a76373cad123ff042e Mon Sep 17 00:00:00 2001
From: Daniel de Andrade Lopes <danieldeandradelopes@gmail.com>
Date: Sat, 4 Jul 2020 08:58:16 -0300
Subject: [PATCH 136/185] Update Readme.md

I see some errors in writing and in one expression, so I open this PR to improvements.
---
 translations/README-pt_BR.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 774cd219..1c8e474a 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -36,7 +36,7 @@
 
 > Expressão Regular é um grupo de caracteres ou símbolos utilizado para encontrar um padrão específico a partir de um texto.
 
-Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. A expressão "Expressão regular" é longa e difícil de falar; você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
+Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. O termo "Expressão regular" é longo e difícil de falar; você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
 
 Imagine que você está escrevendo uma aplicação e quer colocar regras para quando um usuário escolher seu username. Nós queremos permitir que o username contenha letras, números, underlines e hífens. Nós também queremos limitar o número de caracteres para não ficar muito feio. Então usamos a seguinte expressão regular para validar o username:
 
@@ -307,7 +307,7 @@ As expressões regulares fornecem abreviações para conjuntos de caracteres com
 
 ## 4. Olhar ao Redor
 
-Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrêncoas). 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:
+Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos como lookarounds (olhar ao redor), são tipos específicos de ***grupo de não captura*** (utilizado para encontrar um padrão, mas não incluí-lo na lista de ocorrências). Lookarounds são usados quando temos a condição de que determinado padrão seja precedido ou seguido de outro padrão. Por exemplo, queremos capturar todos os números precedidos do caractere `$` da seguinte string de entrada: `$4.44 and $10.88`. Vamos usar a seguinte expressão regular `(?<=\$)[0-9\.]*` que significa: procure todos os números que contêm o caractere `.` e são precedidos pelo caractere `$`. A seguir estão os lookarounds que são utilizados em expressões regulares:
 
 |Símbolo|Descrição|
 |:----:|----|
@@ -318,7 +318,7 @@ Lookbehind (olhar atrás) e lookahead (olhar à frente), às vezes conhecidos co
 
 ### 4.1 Lookahead Positivo
 
-O lookahead positivo impõe que a primeira parte da expressão deve ser seguida pela expressão lookahead. A combinação retornada contém apenas o texto que encontrado pela primeira parte da expressão. Para definir um lookahead positivo, deve-se usar parênteses. Dentro desses parênteses, é usado um ponto de interrogação seguido de um sinal de igual, dessa forma: `(?=...)`. Expressões lookahead são escritas depois do sinal de igual dentro do parênteses. Por exemplo, a expressão regular `[T|t]he(?=\sfat)` significa: encontre a letra minúscula `t` ou a letra maiúscula `T`, seguida da letra `h`, seguida da letra `e`. Entre parênteses, nós definimos o lookahead positivo que diz para o motor de expressões regulares para encontrar `The` ou `the` que são seguidos pela palavra `fat`.
+O lookahead positivo impõe que a primeira parte da expressão deve ser seguida pela expressão lookahead. A combinação retornada contém apenas o texto que é encontrado pela primeira parte da expressão. Para definir um lookahead positivo, deve-se usar parênteses. Dentro desses parênteses, é usado um ponto de interrogação seguido de um sinal de igual, dessa forma: `(?=...)`. Expressões lookahead são escritas depois do sinal de igual dentro do parênteses. Por exemplo, a expressão regular `[T|t]he(?=\sfat)` significa: encontre a letra minúscula `t` ou a letra maiúscula `T`, seguida da letra `h`, seguida da letra `e`. Entre parênteses, nós definimos o lookahead positivo que diz para o motor de expressões regulares para encontrar `The` ou `the` que são seguidos pela palavra `fat`.
 
 <pre>
 "[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -400,7 +400,7 @@ O modificador `g` é usado para realizar uma busca global (encontrar todas as oc
 
 ### 5.3 Multilinhas
 
-O modificador `m` é usado para realizar uma busca em várias linhas. Como falamos antes, as âncoras `(^, $)` são usadas para verificar se o padrão está no início ou no final da string de entrada. 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.
+O modificador `m` é usado para realizar uma busca em várias linhas. Como falamos antes, as âncoras `(^, $)` são usadas para verificar se o padrão está no início ou no final da string de entrada respectivamente. Mas se queremos que as âncoras funcionem em cada uma das linhas, usamos a flag `m`. Por exemplo, a expressão regular `/.at(.)?$/gm` significa: o caractere minúsculo `a`, seguido do caractere minúsculo `t`, opcionalmente seguido por qualquer caractere, exceto nova linha. E por causa da flag `m`, agora o motor de expressões regulares encontra o padrão no final de cada uma das linhas da string.
 
 <pre>
 "/.at(.)?$/" => The fat

From 2ad85e2142d1186a2accfbfca6e76b0143adc809 Mon Sep 17 00:00:00 2001
From: byNoobiYT <bynoobiyt@gmail.com>
Date: Tue, 14 Jul 2020 09:46:26 +0200
Subject: [PATCH 137/185] Ausdruch -> Ausdruck

---
 translations/README-de.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index f55f7289..f1f07d24 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -25,7 +25,7 @@
 ## Was sind Reguläre Ausdrücke?
 
 > Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein bestimmtes Muster in einem Text zu finden.
-Ein regulärer Ausdruch ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
+Ein regulärer Ausdruck ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
 "Regulärer Ausdruck" ist in der Praxis unüblich und stattdessen wird häufig die Englische Abkürzung "Regex" oder "RegExp" (*regular expression*) verwendet. Reguläre
 Ausdrücke werden verwendet, um Fragemente eines Textes zu ersetzen, Formulare zu validieren, Segmente eines Textes anhand eines
 Musters zu extrahieren und für vieles mehr.

From 17eee4f89d59ba2db486421199cd88f3ca741621 Mon Sep 17 00:00:00 2001
From: Femi Oladeji <f.oladeji@temper.works>
Date: Thu, 6 Aug 2020 09:27:35 +0200
Subject: [PATCH 138/185] fix The full stop link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 55da5cec..5e5acdbe 100644
--- a/README.md
+++ b/README.md
@@ -61,7 +61,7 @@ letter and also it is too short.
 
 - [Basic Matchers](#1-basic-matchers)
 - [Meta Characters](#2-meta-characters)
-  - [The Full Stop](#21-the-full-stops)
+  - [The Full Stop](#21-the-full-stop)
   - [Character Sets](#22-character-sets)
     - [Negated Character Sets](#221-negated-character-sets)
   - [Repetitions](#23-repetitions)

From 5dc6310c7901e03e08b065514fa67947f90563b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Frank=20B=C3=BCltge?= <frank@bueltge.de>
Date: Fri, 2 Oct 2020 12:29:09 +0200
Subject: [PATCH 139/185] Small improvements for clean German language

---
 translations/README-de.md | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index f55f7289..b888c806 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -357,7 +357,7 @@ Das sind die vordefinierten Zeichenklassen:
 |\s|Stimmt mit Leerraum überein: `[\t\n\f\r\p{Z}]`|
 |\S|Stimmt mit allem außer Leerraum überein: `[^\s]`|
 
-## 4. Lookaround
+## 4. Umsehen (Lookaround)
 
 Lookbehind ("zurückschauen") und Lookahead ("vorausschauen") (auch Lookaround ("Umsehen") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**
 (zur Erinnerung: das sind Gruppierungen, die zwar mit dem Muster übereinstimmen, aber sich die Übereinstimmung nicht "merken").
@@ -374,7 +374,7 @@ Das sind die Lookarounds, die es gibt:
 |?<=|Positiver Lookbehind|
 |?<!|Negativer Lookbehind|
 
-### 4.1 Positiver Lookahead
+### 4.1 Positives Vorausschauen (Lookahead)
 
 Ein positiver Lookahead versichert, dass der Teilausdruck vor dem Lookahead von dem Lookahead-Teilausdruck gefolgt wird.
 Das Ergebnis der Übereinstimmung beinhaltet dabei nur den Teilausdruck vor dem Lookahead.
@@ -390,7 +390,7 @@ ist eine zusätzliche Bedingung, die dafür sorgt, dass der Ausdruck nur mit `th
 
 [Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negativer Lookahead
+### 4.2 Negatives Vorausschauen (Lookahead)
 
 Negative Lookaheads werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, auf die **nicht** ein bestimmtes Muster folgt.
 Ein Negativer Lookahead wird wie ein positiver Lookahead definiert, nur dass statt einem Gleichheitszeichen ein Ausrufezeichen `!` benutzt wird, d.h.
@@ -402,7 +402,7 @@ Ein Negativer Lookahead wird wie ein positiver Lookahead definiert, nur dass sta
 
 [Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positiver Lookbehind
+### 4.3 Positives Zurückschauen (Lookbehind)
 
 Positive Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen ein bestimmtes Muster vorhergeht.
 Postive Lookbehinds werden mit `(?<=...)` notiert. Der reguläre Ausdruck `(?<=(T|t)he\s)(fat|mat)` zum Beispiel bedeutet: alle `fat` oder `mat`, 
@@ -438,9 +438,9 @@ genutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.
 |g|Globale Suche: Die Suche geht durch die gesamte Eingabe.|
 |m|Mehrzeilig: Anker-Metazeichen funktionieren für Anfang/Ende jeder Zeile.|
 
-### 5.1 Schreibungsunabhängig
+### 5.1 Groß-/Kleinschreibung unempfindlich
 
-Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck
+Der `i` Modifikator wird benutzt, um unabhängige Übereinstimmungen bei der Groß-/Kleinschreibung zu finden. Zum Beispiel heißt der reguläre Ausdruck
 `/The/gi`: großes `T`, gefolgt von `h`, dann `e`. Und am Ende des Ausdrucks ist der `i` Modifikator zu finden, welcher der Maschine 
 zu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden sollen. Wie zu sehen ist, wird auch der `g` Modifikator benutzt,
 da wir die gesamte Eingabe nach dem Muster absuchen wollen.
@@ -499,27 +499,29 @@ Zeilenumbruch. Wegen des `m` Modifikators wird das Muster nun auf das Ende jeder
 
 [Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1)
 
-## 6. Gierige vs Faule Übereinstimmung
+## 6. Gierige vs. faule Übereinstimmung
 
 Standardmäßig finden reguläre Ausdrücke Übereinstimmungen mit Gier (eng. *greed*), d.h. es wird nach den längsten Übereinstimmungen gesucht. 
 Mit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten Übereinstimmungen gesucht.
 
 <pre>
-"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>.
+</pre>
 
 
 [Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/1)
 
 <pre>
-"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat.
+</pre>
 
 
 [Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2)
 
 ## Beitragen
 
-* Öffne pull requests mit Verbesserungen
-* Diskutiere Ideen in issues
+* Öffne Pull Requests mit Verbesserungen
+* Diskutiere Ideen in Issues
 * Erzähl es anderen
 * Gib Rückmeldung [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 

From de9c5ca5e448f13a70a0b8f07d983a7d3a83d4ea Mon Sep 17 00:00:00 2001
From: Patrik P <p.pyrzano.s6@gmail.com>
Date: Tue, 6 Oct 2020 23:36:07 +0200
Subject: [PATCH 140/185] Fixed typo in the German translation at line 169

Fixed typo in the German translation at line 169
---
 translations/README-de.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index b888c806..d441c3f2 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -166,7 +166,7 @@ beliebige Anzahl von Kleinbuchstaben in Folge.
 
 Das `*`-Symbol kann zusammen mit dem Metazeichen `.` verwendet werden, um mit einer vollkommen beliebigen Zeichenkette übereinzustimmen `.*`.
 Es kann auch mit der vordefinierten Zeichenklasse `\s` verwendet werden, um mit beliebig viel Leerraum (Leerzeichen, Tabulatoren, Zeilenumbrüchen)
-übereinzustimmen. Der Ausdruck `\s*cat\*` heißt zum Beispiel: null oder mehrere Leerzeichen, gefolgt von dem Buchstaben `c`, gefolgt vom Buchstaben `a`, 
+übereinzustimmen. Der Ausdruck `\s*cat\s*` heißt zum Beispiel: null oder mehrere Leerzeichen, gefolgt von dem Buchstaben `c`, gefolgt vom Buchstaben `a`, 
 gefolgt vom Buchstaben `t` und schließlich gefolgt von null oder mehreren Leerzeichen.
 
 <pre>

From 506f0a464ce2d7192068f82e47bb20b8ea12e6e6 Mon Sep 17 00:00:00 2001
From: 0x4kgi <0x4kgi@protonmail.com>
Date: Mon, 26 Oct 2020 09:36:57 +0800
Subject: [PATCH 141/185] Fix minor typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 55da5cec..3a913cb2 100644
--- a/README.md
+++ b/README.md
@@ -235,7 +235,7 @@ clarified that`t` is the last `t` in the sentence.
 In regular expressions, the meta character `?` makes the preceding character
 optional. This symbol matches zero or one instance of the preceding character.
 For example, the regular expression `[T]?he` means: Optional uppercase
-`T`, followed by a lowercase `h`, followed bya lowercase `e`.
+`T`, followed by a lowercase `h`, followed by a lowercase `e`.
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.

From a4028b6de7019e3c1a6695a65ff9b7abb961cf9f Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 14 Dec 2020 07:13:07 +0000
Subject: [PATCH 142/185] remove .github

---
 .github/FUNDING.yml | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index 42e653b6..00000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-open_collective: learn-regex
-patreon: ziishaned

From e1e4ad83a2e414e81f501da53870d295809f97a1 Mon Sep 17 00:00:00 2001
From: mcantonbul <53213891+mcantonbul@users.noreply.github.com>
Date: Mon, 14 Dec 2020 14:36:46 +0300
Subject: [PATCH 143/185] Update README-tr.md

Fix wrong number on 2.4 Braces
---
 translations/README-tr.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index 41be9dd9..da70f2f9 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -266,7 +266,7 @@ Düzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler,
 karakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için
 kullanılırlar.
 
-Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 0 aralığındaki karakterlerden, en
+Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 9 aralığındaki karakterlerden, en
 az 2 en fazla 3 defa ile eşleş.
 
 <pre>

From 24be3ab783847dbd9fc285b005c4bd5214bd1385 Mon Sep 17 00:00:00 2001
From: mcantonbul <53213891+mcantonbul@users.noreply.github.com>
Date: Mon, 14 Dec 2020 14:53:57 +0300
Subject: [PATCH 144/185] Update README-tr.md

Add missing brackets for `Lookarounds` description.
---
 translations/README-tr.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index 41be9dd9..4475ac53 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -444,7 +444,7 @@ Düzenli ifadelerde kullanılan bakınma sembolleri aşadaki gibidir:
 |?=|Positive Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme varsa` sonuç döndürür.)|
 |?!|Negative Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme yoksa` sonuç döndürür.)|
 |?<=|Positive Lookbehind (Verdiğimiz ifade öncesini arar ve `eşleşme varsa` sonuç döndürür.)|
-|?<-!-|Negative Lookbehind Verdiğimiz ifade öncesini arar ve `eşleşme yoksa` sonuç döndürür.|
+|?<-!-|Negative Lookbehind (Verdiğimiz ifade öncesini arar ve `eşleşme yoksa` sonuç döndürür.)|
 
 ### 4.1 Positive Lookahead
 

From 8002f6d9d4c75b93a18e3599dff606ec604c333a Mon Sep 17 00:00:00 2001
From: Citrodata <39993466+Citrodata@users.noreply.github.com>
Date: Wed, 16 Dec 2020 07:18:24 +0100
Subject: [PATCH 145/185] Update README-de.md

---
 translations/README-de.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-de.md b/translations/README-de.md
index b888c806..15c2f432 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -38,7 +38,7 @@ wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu
   <img src="../img/regexp-en.png" alt="Regular expression">
 </p>
 
-Der abgebildete reguläre Ausdruck erlaubt bspw. die Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Der Eingabe `Jo` wird nicht akzeptiert, da sie einen Großbuchstaben enthält und zu kurz ist.
+Der abgebildete reguläre Ausdruck erlaubt bspw. Die Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Die Eingabe `Jo` wird nicht akzeptiert, weil sie einen Großbuchstaben enthält und zu kurz ist.
 
 ## Inhaltsverzeichnis
 

From bc7437ae5cc0b9ee046734c9372ff34b09bf8296 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Wed, 23 Dec 2020 18:37:14 +0400
Subject: [PATCH 146/185] Add download the guide as pdf button

---
 README.md                        | 2 ++
 translations/README-cn.md        | 2 ++
 translations/README-de.md        | 2 ++
 translations/README-es.md        | 2 ++
 translations/README-fa.md        | 3 +++
 translations/README-fr.md        | 2 ++
 translations/README-gr.md        | 2 ++
 translations/README-hu.md        | 2 ++
 translations/README-ja.md        | 2 ++
 translations/README-ko.md        | 2 ++
 translations/README-pl.md        | 2 ++
 translations/README-pt_BR.md     | 2 ++
 translations/README-ru.md        | 2 ++
 translations/README-tr.md        | 2 ++
 translations/README-vn.md        | 2 ++
 translations/README-zh-simple.md | 2 ++
 16 files changed, 33 insertions(+)

diff --git a/README.md b/README.md
index 55da5cec..2412c131 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,8 @@
 
 ## What is Regular Expression?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 
 A regular expression is a pattern that is matched against a subject string from
diff --git a/translations/README-cn.md b/translations/README-cn.md
index 977e8134..c29158a7 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -34,6 +34,8 @@
 
 ## 什么是正则表达式？
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
 
 一个正则表达式是一种从左到右匹配主体字符串的模式。
diff --git a/translations/README-de.md b/translations/README-de.md
index b888c806..c2c179fc 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -24,6 +24,8 @@
 
 ## Was sind Reguläre Ausdrücke?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Ein regulärer Ausdruck ist eine Gruppe von Buchstaben und Symbolen, die benutzt werden um ein bestimmtes Muster in einem Text zu finden.
 Ein regulärer Ausdruch ist ein Muster, das mit einem zu durchsuchenden Text von links nach rechts abgeglichen wird. Die Bezeichnung
 "Regulärer Ausdruck" ist in der Praxis unüblich und stattdessen wird häufig die Englische Abkürzung "Regex" oder "RegExp" (*regular expression*) verwendet. Reguläre
diff --git a/translations/README-es.md b/translations/README-es.md
index 366b209e..907f9a1a 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -34,6 +34,8 @@
 
 ## Qué es una expresión regular?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
 
 Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para reemplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
diff --git a/translations/README-fa.md b/translations/README-fa.md
index c95869a8..5595d455 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -35,6 +35,9 @@
 
 ## عبارت منظم چیست؟
 </div>
+
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 <div dir="rtl">
 
 > عبارت منظم یک گروه از کارکترها یا نمادهاست که برای پیدا کردن یک الگوی مشخص در یک متن به کار گرفته می شود.
diff --git a/translations/README-fr.md b/translations/README-fr.md
index c51668cc..46016160 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -34,6 +34,8 @@
 
 ## Qu'est-ce qu'une expression régulière?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Une expression régulière est un groupement de caractères ou symboles utilisés pour trouver un schéma spécifique dans un texte.
 
 Une expression régulière est un schéma qui est comparé à une chaîne de caractères (string) de gauche à droite. Le mot "Expression régulière"
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 2e6dd9d9..763bd8f9 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -34,6 +34,8 @@
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Μια κανονική έκφραση είναι μια ομάδα χαρακτήρων ή συμβόλων που χρησιμοποιούνται για την εύρεση ενός συγκεκριμένου μοτίβου χαρακτήρων μέσα σ'ένα κείμενο.
 
 Μια κανονική έκφραση, είναι μια σειρά χαρακτήρων τους οποίους αναζητούμε μέσα σε ένα κείμενο. Η αναζήτηση αυτή
diff --git a/translations/README-hu.md b/translations/README-hu.md
index e8c52394..16a6804e 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -34,6 +34,8 @@
 
 ## Mi az a reguláris kifejezés?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > A reguláris kifejezés karakterek vagy szimbólumok egy csoportja, amelyet egy szövegből adott minták megtalálására használnak.
 
 A reguláris kifejezés egy olyan minta, amely illeszkedik egy adott karakterláncra
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 6acf9ae4..308b6391 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -34,6 +34,8 @@
 
 ## 正規表現とは
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > 正規表現とは文中からある文字列のパターンを見つけるために使用される文字列や記号の組み合わせのことです。
 
 正規表現とは対象の文字列に左から右にマッチするパターンのことを言います。
diff --git a/translations/README-ko.md b/translations/README-ko.md
index 6d294956..e210de48 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -34,6 +34,8 @@
 
 ## 정규표현식이란 무엇인가?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > 정규표현식은 텍스트에서 특정 패턴을 찾아내는데 사용되는 문자 혹은 기호들의 집합이다.
 
 정규표현식(Regular expression)은 대상 문자열에 왼쪽에서 오른쪽 방향으로 매칭되는 하나의 패턴이다. "Regular expression"이라고 매번 발음하기 어렵기 때문에, 보통 약어로 "regex" 혹은 "regexp", "정규식"으로 축약되어 사용된다. 정규 표현식은 문자열 내부의 텍스트 대체, 포맷의 유효성 검사, 패턴 매칭을 기반으로한 문자열에서 일부 텍스트를 추출, 그리고 그 외에 다양한 목적을 위해 사용된다.
diff --git a/translations/README-pl.md b/translations/README-pl.md
index fd1d04ca..13f1e9a0 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -34,6 +34,8 @@
 
 ## Co to jest wyrażenie regularne?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Wyrażenie regularne to grupa znaków lub symboli, które służą do odnalezienia określonego wzoru w tekście.
 
 Wyrażenie regularne to wzorzec, który jest dopasowywany do tekstu od lewej
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 1c8e474a..68db0e19 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -34,6 +34,8 @@
 
 ## O que é uma Expressão Regular?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Expressão Regular é um grupo de caracteres ou símbolos utilizado para encontrar um padrão específico a partir de um texto.
 
 Uma expressão regular é um padrão que é comparado com uma cadeia de caracteres da esquerda para a direita. O termo "Expressão regular" é longo e difícil de falar; você geralmente vai encontrar o termo abreviado como "regex" ou "regexp". Expressões regulares são usadas para substituir um texto dentro de uma string, validar formulários, extrair uma parte de uma string baseada em um padrão encontrado e muito mais.
diff --git a/translations/README-ru.md b/translations/README-ru.md
index 614d9ebf..d76116c5 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -33,6 +33,8 @@
 
 ## Что такое Регулярное выражение?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Регулярное выражение - это группа букв или символов, которая используется для поиска определенного шаблона в тексте.
 
 Регулярное выражение - это шаблон, сопоставляемый с искомой строкой слева направо.
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 41be9dd9..f3a3967e 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -34,6 +34,8 @@
 
 ## Düzenli İfade Nedir?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Düzenli ifade, bir metinden belirli bir deseni bulmak için kullanılan bir karakter veya sembol grubudur.
 
 Bir düzenli ifade soldan sağa söz konusu harf öbekleriyle eşleşen bir desendir.
diff --git a/translations/README-vn.md b/translations/README-vn.md
index 0c38faa2..c6d15f87 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -36,6 +36,8 @@
 
 ## Biểu thức chính quy là gì?
 
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+
 > Biểu thức chính quy là một nhóm các ký tự hoặc ký hiệu được sử dụng để tìm một mẫu cụ thể từ một văn bản.
 
 Biểu thức chính quy là một khuôn mẫu được khớp với chuỗi các từ, từ trái sang phải. Từ "Biểu thức chính quy" là một câu cửa miệng, bạn thường sẽ tìm thấy thuật ngữ viết tắt là "regex" hoặc "regexp". Biểu thức chính quy được sử dụng để thay thế một văn bản trong một chuỗi, xác thực mẫu, trích xuất một chuỗi con từ một chuỗi dựa trên khớp mẫu và hơn thế nữa.
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index 292e8778..f591052a 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -32,6 +32,8 @@
 * [فارسی](../translations/README-fa.md)
 
 ## 什么是正则表达式?
+
+[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
  
 > 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子.
 

From fc31f33b49a061ead9a00344569a496c20488582 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 22 Jan 2021 18:57:44 +0400
Subject: [PATCH 147/185] Update README.md

---
 README.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index c5c4f041..89915466 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,13 @@
 <p align="center">
     <br/>
-    <a href="https://github.com/ziishaned/learn-regex">
-        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    <a href="https://gum.co/learn-regex">
+        <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
     </a>
+    
+        <a href="https://twitter.com/ziishaned">
+            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
+        </a>
+
     <br /><br />
     <p>
         <a href="https://twitter.com/ziishaned">

From af59a7900f62ebd8d2799bbad66a10efc2c6e4df Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 22 Jan 2021 18:59:08 +0400
Subject: [PATCH 148/185] Update README.md

---
 README.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 89915466..c1a375fa 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,13 @@
 <p align="center">
     <br/>
+    <a href="https://github.com/ziishaned/learn-regex">	
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">	
+    </a>	
+    
+    <br />
     <a href="https://gum.co/learn-regex">
         <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
     </a>
-    
-        <a href="https://twitter.com/ziishaned">
-            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
-        </a>
 
     <br /><br />
     <p>

From dde1ed1a34432ccdfbf016766a3fdc91b3527d56 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 22 Jan 2021 19:02:20 +0400
Subject: [PATCH 149/185] Update README.md

---
 README.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index c1a375fa..2b577497 100644
--- a/README.md
+++ b/README.md
@@ -1,23 +1,23 @@
 <p align="center">
     <br/>
     <a href="https://github.com/ziishaned/learn-regex">	
-        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">	
-    </a>	
-    
-    <br />
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+</p>
+<br/>
+<p align="center">
     <a href="https://gum.co/learn-regex">
         <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
     </a>
+</p>
 
-    <br /><br />
-    <p>
-        <a href="https://twitter.com/ziishaned">
-            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
-        </a>
-        <a href="https://github.com/ziishaned">
-            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
-        </a>
-    </p>
+<p align="center">
+    <a href="https://twitter.com/ziishaned">
+        <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
+    </a>
+    <a href="https://github.com/ziishaned">
+        <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
+    </a>
 </p>
 
 ## Translations:

From bace74c087c06e05e8f80806f38e8fc13b3ec0e6 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 22 Jan 2021 19:03:54 +0400
Subject: [PATCH 150/185] Update README.md

---
 README.md | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 2b577497..2d37abd9 100644
--- a/README.md
+++ b/README.md
@@ -5,20 +5,10 @@
     </a>
 </p>
 <br/>
-<p align="center">
-    <a href="https://gum.co/learn-regex">
-        <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
-    </a>
-</p>
+<a href="https://gum.co/learn-regex">
+    <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
+</a>
 
-<p align="center">
-    <a href="https://twitter.com/ziishaned">
-        <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
-    </a>
-    <a href="https://github.com/ziishaned">
-        <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
-    </a>
-</p>
 
 ## Translations:
 

From de27b744cc68d5dffa390c958846e69de9c51848 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Fri, 22 Jan 2021 19:05:29 +0400
Subject: [PATCH 151/185] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 2d37abd9..ee4b84ea 100644
--- a/README.md
+++ b/README.md
@@ -30,8 +30,6 @@
 
 ## What is Regular Expression?
 
-[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
-
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 
 A regular expression is a pattern that is matched against a subject string from

From 5d56ad1e8b736e39fe4c04f5ae011e8e4fb7f6cb Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sun, 24 Jan 2021 21:20:49 +0400
Subject: [PATCH 152/185] Update README.md

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index ee4b84ea..8dcd5c7f 100644
--- a/README.md
+++ b/README.md
@@ -4,10 +4,6 @@
         <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
     </a>
 </p>
-<br/>
-<a href="https://gum.co/learn-regex">
-    <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
-</a>
 
 
 ## Translations:
@@ -30,6 +26,10 @@
 
 ## What is Regular Expression?
 
+<a href="https://gum.co/learn-regex">
+    <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
+</a>
+
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 
 A regular expression is a pattern that is matched against a subject string from

From d6c5519e1989cd1edef9f436aaaceb0fba7c2f52 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sun, 24 Jan 2021 21:22:04 +0400
Subject: [PATCH 153/185] Update README.md

---
 README.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 8dcd5c7f..fb0753a7 100644
--- a/README.md
+++ b/README.md
@@ -26,9 +26,11 @@
 
 ## What is Regular Expression?
 
-<a href="https://gum.co/learn-regex">
-    <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
-</a>
+<p>
+    <a href="https://gum.co/learn-regex">
+        <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
+    </a>
+</p>
 
 > A regular expression is a group of characters or symbols which is used to find a specific pattern in a text.
 

From 6f4fd0660d762b5214f51445137956821c53ce94 Mon Sep 17 00:00:00 2001
From: edte <zzzzip6@gmail.com>
Date: Thu, 15 Apr 2021 19:25:15 +0800
Subject: [PATCH 154/185] fix a zh translation typo

---
 translations/README-zh-simple.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index f591052a..a8df3c08 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -300,7 +300,7 @@
 
 `^` 用来检查匹配的字符串是否在所匹配字符串的开头.
 
-例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 应为在字符串 `abc` 中并不是以 `b` 开头.
+例如, 在 `abc` 中使用表达式 `^a` 会得到结果 `a`. 但如果使用 `^b` 将匹配不到任何结果. 因为在字符串 `abc` 中并不是以 `b` 开头.
 
 例如, `^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串.
 

From 9498781445347c1550af7f4cf9f61f091e6e7b7b Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Sat, 1 May 2021 11:25:57 +0400
Subject: [PATCH 155/185] update readme

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index fb0753a7..34ef8d6b 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,5 @@
+<a href="https://www.buymeacoffee.com/ziishaned" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
+
 <p align="center">
     <br/>
     <a href="https://github.com/ziishaned/learn-regex">	

From e8afa6111029bec5229150e49b772dd6c61a38c2 Mon Sep 17 00:00:00 2001
From: Erick Lara Cardenas <ericklarac@uber.com>
Date: Fri, 14 May 2021 21:34:06 -0700
Subject: [PATCH 156/185] Fix spanish links, typos and context

---
 translations/README-es.md | 81 +++++++++++++++++++--------------------
 1 file changed, 40 insertions(+), 41 deletions(-)

diff --git a/translations/README-es.md b/translations/README-es.md
index 907f9a1a..5e9c3edf 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -38,10 +38,9 @@
 
 > Una expresión regular es un grupo de caracteres o símbolos, los cuales son usados para buscar un patrón específico dentro de un texto.
 
-Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para reemplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de una patrón, y muchas cosas más.
-
-Imagina que estás escribiendo una aplicación y quieres agregar reglas para cuando el usuario elija su nombre de usuario. Nosotros queremos permitir que el nombre de usuario contenga letras, números, guión bajo (raya), y guión medio. También queremos limitar el número de caracteres en el nombre de usuario para que no se vea feo. Para ello usamos la siguiente expresión regular para validar el nombre de usuario.
+Una expresión regular es un patrón que que se compara con una cadena de caracteres de izquierda a derecha. La palabra "expresión regular" puede también ser escrita como "Regex" o "Regexp". Las expresiones regulares se utilizan para reemplazar un texto dentro de una cadena de caracteres (*string*), validar formularios, extraer una porción de una cadena de caracteres (*substring*) basado en la coincidencia de un patrón, y muchas cosas más.
 
+Imagina que estás escribiendo una aplicación y quieres agregar reglas para cuando el usuario elija su nombre de usuario. Nosotros queremos permitir que el nombre de usuario contenga letras, números, guion bajo (raya), y guion medio. También queremos limitar el número de caracteres en el nombre de usuario para que no se vea feo. Para ello, usamos la siguiente expresión regular para validar el nombre de usuario.
 
 <br/><br/>
 <p align="center">
@@ -59,25 +58,25 @@ La expresión regular anterior puede aceptar las cadenas `john_doe`, `jo-hn_doe`
     - [Conjunto de caracteres negados](#221-conjunto-de-caracteres-negado)
   - [Repeticiones](#23-repeticiones)
     - [Asterisco](#231-asterisco)
-    - [Signo más](#232-signo-mas)
-    - [Signo de interrogación](#233-signo-de-pregunta)
+    - [Signo más](#232-signo-de-más)
+    - [Signo de interrogación](#233-signo-de-interrogación)
   - [Llaves](#24-llaves)
-  - [Grupo de caracteres](#25-grupo-de-caracteres)
-  - [Alternancia](#26-alternacia)
+  - [Grupos de caracteres](#25-grupos-de-caracteres)
+  - [Alternancia](#26-alternancia)
   - [Caracteres especiales de escape](#27-caracteres-especiales-de-escape)
   - [Anclas](#28-anclas)
-    - [Símbolo de intercalación](#281-simbolo-de-intercalacion)
-    - [Símbolo del dólar](#282-simbolo-dolar)
+    - [Símbolo de intercalación](#281-símbolo-de-intercalación)
+    - [Símbolo del dólar](#282-símbolo-del-dólar)
 - [Conjunto de caracteres abreviados](#3-conjunto-de-caracteres-abreviados)
 - [Mirar alrededor](#4-mirar-alrededor)
-  - [Mirar hacia delante positivo](#41-mirar-hacia-delante-positivo)
-  - [Mirar hacia delante negativo](#41-mirar-hacia-delaten-negativo)
-  - [Mirar hacia atrás positivo](#41-mirar-hacia-atras-positivo)
-  - [Mirar hacia atrás negativo](#41-mirar-hacia-atras-negativo)
+  - [Mirar hacia delante positivo](#41-mirar-hacia-adelate-positivo)
+  - [Mirar hacia delante negativo](#42-mirar-hacia-delaten-negativo)
+  - [Mirar hacia atrás positivo](#43-mirar-hacia-atras-positivo)
+  - [Mirar hacia atrás negativo](#44-mirar-hacia-atras-negativo)
 - [Indicadores](#5-indicadores)
-  - [Mayúsculas y minúsculas](#51-mayusculas-y-minusculas)
-  - [Búsqueda global](#52-busqueda-global)
-  - [Multilínea](#53-multilinea)
+  - [Mayúsculas y minúsculas](#51-mayúsculas-y-minúsculas)
+  - [Búsqueda global](#52-búsqueda-global)
+  - [Multilínea](#53-multilínea)
 
 
 ## 1. Introducción
@@ -100,22 +99,22 @@ La expresión regular `123` coincide con la cadena `123`. La expresión regular
 
 ## 2. Meta-caracteres
 
-Los meta-caracteres son los bloques de construcción de las expresiones regulares. Los meta-caracteres no se sostienen a 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:
+Los 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:
 
 |Meta-carácter|Descripción|
 |:----:|----|
-|.|Período. Coincide con cualquier carácter excepto un salto de línea.|
-|[ ]|Clase de caracteres. Coincide con cualquier carácter contenido entre corchetes.|
-|[^ ]|Clase de caracteres negados. Coincide con cualquier carácter que no está contenido dentro de los corchetes.|
-|*|Corresponde con 0 o más repeticiones del símbolo precedente.|
-|+|Corresponde con 1 o más repeticiones del símbolo precedente.|
-|?|Hace que el símbolo precedente sea opcional.|
-|{n,m}|Llaves. Corresponde al menos "n" pero no más de "m" repeticiones del símbolo precedente.|
-|(xyz)|Grupo carácter. Hace coincidir los caracteres xyz en ese orden exacto.|
-|||Alternancia. Corresponde a los caracteres anteriores o los caracteres después del símbolo.|
-|\|Escapa el siguiente carácter. Esto le permite hacer coincidir los caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|Hace coincidir el principio de la entrada.|
-|$|Corresponde al final de la entrada.|
+|.|Punto: Coincide con cualquier carácter excepto un salto de línea.|
+|[ ]|Clase de caracteres: Coincide con cualquier carácter contenido entre corchetes.|
+|[^ ]|Clase de caracteres negados: Coincide con cualquier carácter que no está contenido dentro de los corchetes.|
+|*|Asterisco: Corresponde con 0 o más repeticiones del símbolo precedente.|
+|+|Signo de más: Corresponde con 1 o más repeticiones del símbolo precedente.|
+|?|Signo de interrogación: Hace que el símbolo precedente sea opcional.|
+|{n,m}|Llaves: Corresponde al menos "n" pero no más de "m" repeticiones del símbolo precedente.|
+|(xyz)|Grupo de caracter: Hace coincidir los caracteres xyz en ese orden exacto.|
+|||Alternancia: Corresponde a los caracteres anteriores o los caracteres después del símbolo.|
+|\|Escapa el siguiente carácter: Esto le permite hacer coincidir los caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Acento circunflejo: Hace coincidir el principio de la entrada.|
+|$|Símbolo de dólar: Corresponde al final de la entrada.|
 
 ## 2.1 Full stop
 
@@ -129,7 +128,7 @@ Full stop `.` es el ejemplo más simple del meta-carácter. El meta-carácter `.
 
 ## 2.2 Conjunto de caracteres
 
-Los conjuntos de caracteres también se llaman clase de caracteres. Los corchetes se utilizan para especificar conjuntos de caracteres. Utilice un guión 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`.
+Los 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`.
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -161,7 +160,7 @@ Los siguientes caracteres meta `+`, `*` o `?`, se utilizan para especificar cuá
 
 ### 2.3.1 Asterisco
 
-El 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.
+El 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.
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -177,7 +176,7 @@ El símbolo `*` se puede utilizar con el meta-carácter `.` para que coincida co
 
 [Prueba la expresión regular](https://regex101.com/r/gGrwuz/1)
 
-### 2.3.2 Signo más
+### 2.3.2 Signo de más
 
 El 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`.
 
@@ -305,10 +304,10 @@ regulares de uso común. Los conjuntos de caracteres abreviados son los siguient
 |.|Cualquier carácter excepto nueva línea|
 |\w|Coincide con los caracteres alfanuméricos: `[a-zA-Z0-9_]`|
 |\W|Coincide con los caracteres no alfanuméricos: `[^\w]`|
-|\d|Coincide con dígitos: `[0-9]`|
-|\D|Coincide con no dígitos: `[^\d]`|
-|\s|Coincide con caracteres espaciales: `[\t\n\f\r\p{Z}]`|
-|\S|Coincide con caracteres no espaciales: `[^\s]`|
+|\d|Coincide con los dígitos: `[0-9]`|
+|\D|Coincide con los no dígitos: `[^\d]`|
+|\s|Coincide con los caracteres espaciales: `[\t\n\f\r\p{Z}]`|
+|\S|Coincide con los caracteres no espaciales: `[^\s]`|
 
 ## 4. Mirar alrededor
 
@@ -330,7 +329,7 @@ que se utilizan en expresiones regulares:
 |?<=|Lookbehind Positivo|
 |?<\!|Lookbehind Negativo|
 
-## 4.1 Mirar hacia adelate positiva
+## 4.1 Mirar hacia adelate positivo
 
 El lookahead positivo afirma que la primera parte de la expresión debe ser
 seguida por la expresión lookahead. La coincidencia devuelta sólo contiene el texto que
@@ -349,7 +348,7 @@ de expresión regular que coincida con `The` o `the` seguido de la palabra `fat`
 
 [Prueba la expresión regular](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Mirar hacia adelate negativa
+### 4.2 Mirar hacia adelate negativo
 
 El lookahead negativo se usa cuando necesitamos obtener todas las coincidencias
 de la cadena de entrada que no son seguidas por un patrón. El aspecto negativo se
@@ -365,7 +364,7 @@ que significa: obtener todas las `The` o `the` seguidos por la palabra `fat` pre
 
 [Prueba la expresión](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Mirar hacia atras positiva
+### 4.3 Mirar hacia atras positivo
 
 Positivo lookbehind se utiliza para obtener todos los caracteres que están precedidos
 por un patrón específico. La apariencia positiva se denotar por `(?<=...)`.
@@ -378,7 +377,7 @@ Por ejemplo, la expresión regular `(? <= [T|t]he\s)(fat|mat)` significa: obtene
 
 [Prueba la expresión regular](https://regex101.com/r/avH165/1)
 
-### 4.4 Mirar hacia atras negativa
+### 4.4 Mirar hacia atras negativo
 
 El lookbehind negativo se utiliza para obtener todas las coincidencias que no
 están precedidas por un patrón específico. El lookbehind negativo se denota por
@@ -405,7 +404,7 @@ o combinación, y son una parte integral de RegExp.
 |g|Búsqueda global: Busca un patrón en toda la cadena de entrada.|
 |m|Multilínea: Ancla meta carácter trabaja en cada línea.|
 
-### 5.1 Mayúscula y minúscula
+### 5.1 Mayúsculas y minúsculas
 
 El modificador `i` se utiliza para realizar la coincidencia entre mayúsculas y
 minúsculas. Por ejemplo, la expresión regular `/The/gi` significa: carácter en mayúscula

From 26943d3ba2629eaa2adab45f1fad9dcc3107a05c Mon Sep 17 00:00:00 2001
From: Sezer Esim <sezeresim@gmail.com>
Date: Fri, 28 May 2021 00:36:41 +0300
Subject: [PATCH 157/185] section 6 ,2.5.1 added and fixed some translate issue

---
 translations/README-tr.md | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index f3a3967e..b0a412fe 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -73,6 +73,7 @@ Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri
     - [Soru İşareti](#233-soru-İşareti)
   - [Süslü Parantez](#24-süslü-parantez)
   - [Karakter Grubu](#25-karakter-grubu)
+      - [Karakter Grubu Olmayanlar](#251-karakter-grubu-olmayanlar)
   - [Değişim](#26-değişim)
   - [Özel Karakter Hariç Tutma](#27-Özel-karakter-hariç-tutma)
   - [Sabitleyiciler](#28-sabitleyiciler)
@@ -88,7 +89,7 @@ Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri
   - [Büyük/Küçük harf duyarlılığı](#51-büyükküçük-harf-duyarlılığı)
   - [Bütünsel Arama](#52-genel-arama)
   - [Çok satırlı](#53-Çok-satırlı)
-
+- [Açgözlü vs Tembel Eşleştirme](#6-açgözlü-vs-tembel-eşleştirme)
 ## 1. Temel Eşleştiriciler
 
 Bir düzenli ifade bir metin içinde arama yapabilmek için kullandığımız bir karakter desenidir.
@@ -268,7 +269,7 @@ Düzenli ifadelerde miktar belirliyiciler olarakda bilinen süslü parantezler,
 karakterin veya karakter grubunun kaç defa tekrar edebileceğini belirtmek için
 kullanılırlar.
 
-Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 0 aralığındaki karakterlerden, en
+Örneğin, `[0-9]{2,3}` ifadesinin anlamı: 0 ile 9 aralığındaki karakterlerden, en
 az 2 en fazla 3 defa ile eşleş.
 
 <pre>
@@ -315,6 +316,21 @@ karakteri, ardından `a` karakteri, ardından `r` karakteri gelir.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/tUxrBG/1)
 
+Not 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.
+
+### 2.5.1 Karakter Grubu Olmayanlar
+
+Karakter 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.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/Rm7Me8/1)
+
+Karakter 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.
+Ayrıca bakınız [4. Bakınmak](#4-bakınmak).
+
 ## 2.6 Değişim
 
 Düzenli ifadede dik çizgi alternasyon(değişim, dönüşüm) tanımlamak için
@@ -592,6 +608,21 @@ eşleştirir.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/E88WE2/1)
 
+## 6. Açgözlü vs Tembel Eşleştirme
+
+Varsayı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.
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Düzenli ifadeyi test edin](https://regex101.com/r/AyAdgJ/2)
+
 ## Contribution
 
 * Report issues

From 8ef3f8402e08488d11f8140d640f5624b38e74ae Mon Sep 17 00:00:00 2001
From: Ciprian <cipriancip344@gmail.com>
Date: Tue, 17 Aug 2021 12:14:55 +0300
Subject: [PATCH 158/185] Fixed typo for en translation in section 4.1

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 34ef8d6b..223e6a2d 100644
--- a/README.md
+++ b/README.md
@@ -421,7 +421,7 @@ regular expressions:
 
 Lookbehinds and lookaheads (also called lookarounds) are specific types of
 ***non-capturing groups*** (used to match a pattern but without including it in the matching
-list). Lookarounds are used when we a pattern must be
+list). Lookarounds are used when a pattern must be
 preceded or followed by another pattern. For example, imagine we want to get all
 numbers that are preceded by the `$` character from the string
 `$4.44 and $10.88`. We will use the following regular expression `(?<=\$)[0-9\.]*`

From bd2d95b3511d9b0c938631c27da46f2c93bb0ba1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aykut=20Karda=C5=9F?= <aykutkrds@gmail.com>
Date: Sun, 3 Oct 2021 15:17:23 +0300
Subject: [PATCH 159/185] Fix typo in decription of dot character on Turkish

---
 translations/README-tr.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index f3a3967e..f9d82262 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -121,7 +121,7 @@ Meta karakterler aşağıdaki gibidir:
 
 |Meta karakter|Açıklama|
 |:----:|----|
-|.|Satır sonuç hariç herhangi bir karakterle eşleşir.|
+|.|Satır başlangıcı hariç herhangi bir karakterle eşleşir.|
 |[ ]|Köşeli parantezler arasında bulunan herhangi bir karakterle eşleşir.|
 |[^ ]|Köşeli parantez içerisinde yer alan `^` işaretinden sonra girilen karakterler haricindeki karakterlerle eşleşir.|
 |*|Kendisinden önce yazılan karakterin sıfır veya daha fazla tekrarı ile eşleşir.|

From bcc9b0079d5c825d05d8d8d7b81c79e55b4a5779 Mon Sep 17 00:00:00 2001
From: Thiago May <thiago.may@qulture.rocks>
Date: Tue, 5 Oct 2021 20:09:22 -0300
Subject: [PATCH 160/185] Add chapter six translation to Portuguese

---
 translations/README-pt_BR.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 68db0e19..58dfe3bf 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -78,6 +78,7 @@ A expressão regular acima aceita as strings `john_doe`, `jo-hn_doe` e `john12_a
   - [Indiferente à Maiúsculas](#51-indiferente-à-maiúsculas)
   - [Busca Global](#52-busca-global)
   - [Multilinhas](#53-multilinhas)
+- [Guloso vs Não-Guloso](#6-guloso-vs-não-guloso)
 
 ## 1. Combinações Básicas
 
@@ -420,6 +421,23 @@ O modificador `m` é usado para realizar uma busca em várias linhas. Como falam
 
 [Teste a RegExp](https://regex101.com/r/E88WE2/1)
 
+### 6. Guloso vs Não-Guloso
+
+Por padrão, uma regex irá realizar uma consulta gulosa, isto significa que a busca irá capturar ao padrão mais longo possível. Nós podemos usar `?` para buscar de uma forma não-gulosa, isto significa que a busca irá capturar ao padrão mais curto possível.
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Teste a RegExp](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Teste a RegExp](https://regex101.com/r/AyAdgJ/2)
+
+
 ## Contribution
 
 * Reporte bugs

From 365cea3690fadc9e2b419ecb0567d78bb646a921 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aykut=20Karda=C5=9F?= <aykutkrds@gmail.com>
Date: Thu, 14 Oct 2021 01:37:24 +0300
Subject: [PATCH 161/185] Fix typo on Turkish README

---
 translations/README-tr.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index f3a3967e..5dd0f2d9 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -149,7 +149,7 @@ gelir.
 
 ## 2.2 Karakter Takımı
 
-Karakter takımları aryıca Karakter sınıfı olarak bilinir. Karakter takımlarını
+Karakter takımları ayrıca Karakter sınıfı olarak bilinir. Karakter takımlarını
 belirtmek için köşeli ayraçlar kullanılır. Karakterin aralığını belirtmek için
 bir karakter takımında tire kullanın. Köşeli parantezlerdeki karakter aralığının
 sıralaması önemli değildir.

From 823ba4869cf7889d420d277db4bacc7f6e6defa9 Mon Sep 17 00:00:00 2001
From: Recurduck Greco <ilaigreco@gmail.com>
Date: Sat, 16 Oct 2021 02:50:27 +0300
Subject: [PATCH 162/185] Add hebrew translation

---
 img/regexp-he.png         | Bin 0 -> 14036 bytes
 translations/README-he.md | 577 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 577 insertions(+)
 create mode 100644 img/regexp-he.png
 create mode 100644 translations/README-he.md

diff --git a/img/regexp-he.png b/img/regexp-he.png
new file mode 100644
index 0000000000000000000000000000000000000000..c09457ed8ebd7ce9790b239e38a00adef191f88b
GIT binary patch
literal 14036
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%0DU0Zlr8h8nWGallRY5^yV*lWc_GoTWp~c
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
MF}huT)A8y50MQ@}e*gdg

literal 0
HcmV?d00001

diff --git a/translations/README-he.md b/translations/README-he.md
new file mode 100644
index 00000000..f8ec8537
--- /dev/null
+++ b/translations/README-he.md
@@ -0,0 +1,577 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">	
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+</p>
+
+<div dir="rtl">
+
+## תרגומים:
+
+* [English](README.md)
+* [German](translations/README-de.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
+* [Tiếng Việt](translations/README-vn.md)
+* [فارسی](translations/README-fa.md)
+* [עברית](translations/README-he.md)
+
+## מה זה ביטוי רגולרי?
+
+<p>
+    <a href="https://gum.co/learn-regex">
+        <img src="https://img.shields.io/badge/-%20PDF%20%D7%93%D7%A8%D7%95%D7%94%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="הורד PDF">
+    </a>
+</p>
+
+> ביטוי רגולרי (regular expression) הוא קבוצת תוים או סימנים אשר משמשים למציאת תבנית ספציפית בתוך טקסט. 
+
+ביטוי רגולרי הוא תבנית המתאימה את עצמה לנושא במחרוזת משמאל לימין.
+ביטויים רגולרים משמשים להחלפת טקסט בתוך מחרוזת, אימות טפסים,
+חילוץ מחרוזת משנית ממחרוזת ראשית על בסיס התבנית המתאימה, ועוד.
+המונח "Regular expression" (ביטוי רגולרי) הוא יחסית ארוך ולכן בדרך כלל
+נמצא את המונח מקוצר ל-"regex" או "regexp".
+
+תדמיין.י שאת.ה כותב.ת אפליקציה ואת.ה רוצה להציב חוקים למצב בו המשתמש בוחר את
+שם המשתמש. אנחנו רוצים לאפשר לשם המשתמש להכיל אותיות, מספרים, קוים תחתונים ומקפים.
+בנוסף נרצה גם להגביל את מספר התוים בשם המשתמש בכדי שלא יראה מכוער.
+נוכל להשתמש בביטוי הרגולרי הבא בכדי לאמת את שם המשתמש:
+
+<br/><br/>
+
+<p align="center">
+  <img src="../img/regexp-he.png" alt="Regular expression">
+</p>
+
+הביטוי הרגולרי למעלה יכול לאשר את המחרוזות  `john_doe`, `jo-hn_doe`
+ו-`john12_as`. אך הוא לא יתאים למחרוזת `Jo` בגלל שמחרוזת זו מכילה אות גדולה
+ ובנוסף לכך היא קצרה מדי (פחות משלושה תוים).
+
+## תוכן עניינים
+
+- [התאמות בסיסיות](#1-התאמות-בסיסיות)
+- [תווי-מטא](#2-תווי-מטא)
+  - [עצירה מלאה](#21-עצירה-מלאה)
+  - [מערכות תוים](#22-מערכות-תוים)
+    - [מערכות תוים שליליות](#221-מערכות-תוים-שליליות)
+  - [חזרות](#23-חזרות)
+    - [הכוכבית](#231-הכוכבית)
+    - [הפלוס](#232-הפלוס)
+    - [סימן השאלה](#233-סימן-השאלה)
+  - [סוגרים מסולסלים](#24-סוגרים-מסולסלים)
+  - [קבוצות לכידה](#25-קבוצות-לכידה)
+      - [קבוצות שאינן לוכדות](#251-קבוצות-שאינן-לוכדות)
+  - [חלופה](#26-חלופה)
+  - [התעלמות מתווים מיוחדים](#27-התעלמות-מתווים-מיוחדים)
+  - [עוגנים](#28-עוגנים)
+    - [ה-"קרט"](#281-ה-"קרט")
+    - [סימן הדולר](#282-סימן-הדולר)
+- [קיצורי מערכות תווים](#3-קיצורי-מערכות-תווים)
+- [הסתכלויות](#4-הסתכלויות)
+  - [מבט קדימה חיובי](#41-מבט-קדימה-חיובי)
+  - [מבט קדימה שלילי](#42-מבט-קדימה-שלילי)
+  - [מבט אחורה חיובי](#43-מבט-אחורה-חיובי)
+  - [מבט אחורה שלילי](#44-מבט-אחורה-שלילי)
+- [דגלים](#5-דגלים)
+  - [חוסר רגישות לאותיות](#51-חוסר-רגישות-לאותיות)
+  - [חיפוש גלובלי](#52-חיפוש-גלובלי)
+  - [רב-שורות](#53-רב-שורות)
+- [התאמה חמדנית מול עצלה](#6-התאמה-חמדנית-מול-עצלה)
+
+## 1. התאמות בסיסיות
+
+ביטוי רגולרי הוא בסף הכל תבנית של תוים שאנו משתמשים בהם בכדי לבצע חיפוש 
+בתוך הטקסט. לדוגמא, הביטוי הרגולרי `the` פירושו: האות `t`, ואחריה האות `h`, ואחריה האות `e`.
+
+<pre dir="ltr">
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dmRygT/1)
+
+הביטוי הרגולרי `123` מתאים למחרוזת `123`. הביטוי הרגולרי מותאם למחרוזת קלט על ידי השוואת כל תו 
+בביטוי הרגולרי לכל תו במחרוזת הקלט, אחד אחרי השני. ביטויים רגולרים לרוב יהיו 
+תלויי אותיות קטנות או גדולות כך שהביטוי הרגולרי `The` לא יתאים למחרוזת `the`.
+
+<pre dir="ltr">
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/1paXsy/1)
+
+## 2. תווי-מטא
+
+תווי-מטא אלו הם אבני הבניין של ביטויים רגולרים. תווי-מטא לא מסמלים את עצמם, אלא מתפרשים באופן מיוחד.
+לכמה תווי-מטא יש משמעויות מיוחדות והם נכתבים בתוך סוגריים מרובעים.
+תווי-המטא הם כדלקמן: 
+
+|תווי-מטא|תיאור|
+|:----:|----|
+|.|נקודה תואמת כל תו בודד למעט שבירת שורות.|
+|[ ]|מחלקת תווים. תואם כל תו הכלול בין הסוגריים המרובעים.|
+|[^ ]|מחלקת תווים שלילית. תואם כל תו שאינו כלול בין הסוגריים המרובעים|
+|*|תואם 0 או יותר חזרות של הסמל הקודם.|
+|+|תואם חזרה אחת או יותר של הסמל הקודם.|
+|?|הופך את הסמל הקודם לאופציונלי.|
+|{n,m}|סוגריים מסולסלים. תואם לפחות חזרות "n" אך לא יותר מ- "m" של הסמל הקודם.|
+|(xyz)|קבוצת תווים. תואם את התווים xyz בסדר המדויק הזה.|
+|||חלופה (או). התאמה בין התווים שלפני או לתווים שאחרי הסמל.|
+|\|מתעלם מהתו הבא. זה מאפשר לך להתאים תווים שמורים <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|תואם את תחילת הקלט.|
+|$|תואם את סוף הקלט.|
+
+## 2.1 עצירה מלאה
+
+עצירה מלאה `.` היר דוגמא פשוטה לשימוש בתו-מטא. תו-המטא `.` מתאים לכל תו בודד. הוא לא יתאים
+לתו return (\r) או לתו newline (\n). למשל, הביטוי הרגולרי `.ar` פירושו: כל תו, שאחריו האות `a`, ואחריה האות `r`.
+
+<pre dir="ltr">
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 מערכות תוים
+
+מערכות תוים נקראים גם מחלקות תוים. סוגריים מרובעים משמשים לציון מערכות תוים.
+השתמש במקף בתוך ערכת התוים בכדי לציין את טווח התוים. סדר טווח התוים לא משנה.
+לדוגמא, הביטוי הרגולרי <span dir='ltr'>`[Tt]he`</span> פירושו: אות גדולה
+`T` או אות קטנה `t`, שאחריה מופיעה האות `h`, ואחריה מופיעה האות `e`.
+
+<pre dir="ltr">
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/2ITLQ4/1)
+
+נקודה בתוך ערכת התוים בשונה מבחוץ תחשב כתו נקודה. הביטוי הרגולרי 
+<span dir='ltr'>`ar[.]`</span> פירושו: תו האות הקטנה `a`, שאחריו האות `r`,
+ואחריה התו נקודה `.`.
+
+<pre dir="ltr">
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 מערכות תוים שליליות 
+
+באופן כללי, הסימן "קרט"(גג) מייצג את תחילתה של מחרוזת, אך במידה והוא מוקלד לאחר סוגר מרובע פותח,
+הוא שולל את מערכת ההתוים שיהיו תחת אותם סוגרים. לדוגמא, הביטוי הרגולרי <span dir='ltr'>`[^c]ar`</span> פירושו: כל תו חוץ מ-`c`,
+שלאחריו יופיע התו `a`, שאחריו יופיע התו `r`.
+
+<pre dir="ltr">
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 חזרות
+
+תווי-המטא `+`, `*` או `?` משמשים לציון כמה פעמים דפוסי משני יכולים להתרחש.
+תווי-מטא אלו פועלים אחרת במצבים שונים.
+
+### 2.3.1 הכוכבית
+
+הסימן - `*` תואם אפס או יותר חזרות של המתאם הקודם. הביטוי הרגולרי <span dir='ltr'>`a*`</span> פירושו: 
+אפס או יותר חזרות של התו הקודם- `a`. אבל אם הכוכבית תופיע לאחר מערכת או מערך תוים אז
+הוא ימצא את החזרות של מערכת התוים כולה. לדוגמא, הביטוי הרגולרי <span dir='ltr'>`[a-z]*`</span> פירושו: 
+כל מספר של אותיות קטנות בשורה.
+
+<pre dir="ltr">
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/7m8me5/1)
+
+הסימן - `*` יכול לשמש יחד עם התו-מטא `.` בכדי להתאים כל מחרוזת תוים <span dir='ltr'>`.*`</span>.
+הסימון - `*` יכול לשמש יחד עם התו רווח - <span dir='ltr'>`\s`</span> בכדי להתאים מחרוזת של תוי רווח.
+לדוגמא, הביטוי <span dir='ltr'>`\s*cat\s*`</span> פירושו: אפס או יותר רווחים, שאחריהם תופיעה האות הקטנה `c`,
+שאחריה תופיע האות הקטנה `a`, ואחריה האות הקטנה `t`, ולבסוף אחריה יופיעו אפס או יותר תווי רווח.
+
+<pre dir="ltr">
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 הפלוס
+
+הסימן `+` מתאים לאחת או יותר חזרות של התו הקודם לו. לדוגמא, הביטוי הרגולרי
+ <span dir='ltr'>`c.+t`</span> פירושו: האות הקטנה - `c`, לאחריה לפחות תו אחד או יותר,
+  ואחריה האות הקטנה  `t`. חשוב לציין שה - `t` יהיה התו `t` האחרון במשפט.
+
+<pre dir="ltr">
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 סימן השאלה
+
+בביטוי רגולרי, התו-מטא `?` הופך את התו הקודם לאופציונלי, 
+סמל זה יתאים לאפס או יותר הופעות של אותו תו קודם. לדוגמא, הביטוי הרגולרי 
+<span dir='ltr'>`[T]?he`</span> פירושו: אופציה לאות
+`T` גדולה, ולאחריה אות קטנה `h`, ולאחריה תופיע האות - `e`.
+
+<pre dir="ltr">
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/cIg9zm/1)
+
+<pre dir="ltr">
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 סוגרים מסולסלים
+
+בביטויים רגולרים, סוגרים מסולסלים (נקראים גם מכמתים) משמשים לציון
+מספר הפעמים שניתן לחזור על תו או קבוצת תוים מסויימת. לדוגמא, הביטור הרגולרי
+ <span dir='ltr'>`[0-9]{2,3}`</span> פירושו: התאם לפחות שתי ספרות, אבל לא יותר משלוש, בטווח שבין 0 ל-9
+
+<pre dir="ltr">
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/juM86s/1)
+
+אנחנו יכולים לוותר על המספר השני בסוגרים המסולסלים. לדוגמא, בביטוי הרגולרי 
+<span dir='ltr'>`[0-9]{2,}`</span> פירושו: התאמת שתי ספרות או יותר. בנוסף אם 
+נוריד את הפסיק, לדוגמא בביטוי הרגולרי <span dir='ltr'>`[0-9]{3}`</span> פירושו: 
+התאם בדיוק שלוש ספרות.
+
+<pre dir="ltr">
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Gdy4w5/1)
+
+<pre dir="ltr">
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Sivu30/1)
+
+## 2.5 קבוצות לכידה
+
+קבוצה מלכדת היא קבוצה של תת-תבניות שנכתבות בתוך סוגריים רגילים <span dir='ltr'> `(...)` </span>. 
+כפי שצויין קודם לכן, בביטוי רגולרי, אם נניח מכמת אחרי תו הוא יחזור על התו הקודם. 
+אבל אם נניח מכמת אחרי קבוצה מלכדת אז המכמת יתיחס לכל הקבוצה המלכדת. לדוגמא, הביטוי הרגולרי 
+<span dir='ltr'>`(ab)*`</span> תואם אפס או יותר חזרות של המחרוזת "ab". אנחנו יכולים גם להשתמש 
+בתו-מטא `|` המשמש לבצע את הפעולה 'OR'(או) בתוך קבוצה מלכדת.
+לדוגמא, הביטוי הרגולרי <span dir='ltr'>`(c|g|p)ar`</span> פירושו: אות קטנה `c`,
+`g` או `p`, שאחריהן תופיע האות `a`, ואחריה האות `r`.
+
+<pre dir="ltr">
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/tUxrBG/1)
+
+יש לשים לב כי קבוצות מלכדות לא רק תואמות, אלא גם תופסות את התוים לשימוש בשפת האם. 
+שפת האם יכולה להיות Python או JavaScript או כמעט כל שפה שמיישמת ביטויים רגולרים 
+בבגדרת פונקציה.
+
+### 2.5.1 קבוצות שאינן לוכדות
+
+קבוצה שאינה מלכדת זוהי קבוצת לוכדת התואמת את התוים אבל לא תופסת את הקבוצה.
+קבוצה שאינה מלכדת מסומנת על ידי התו `?` ואחריו `:` בתוך הסוגריים הרגילים. <span dir='ltr'>`(...)`</span>. 
+לדוגמא, בביטוי הרגולרי <span dir='ltr'>`(?:c|g|p)ar`</span> שדומה ל-<span dir='ltr'>`(c|g|p)ar`</span> 
+בכך שהוא תואם לאותם תווים אך לא ייצר קבוצת לכידה.
+
+<pre dir="ltr">
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/Rm7Me8/1)
+
+קבוצות שאינן מלכדות יכולות להיות שימושיות כאשר יש צורך בפונקציונליות של חיפוש והחלפה
+או כאשר מעורבת גם קבוצת לכידה בכדי לשמור על הסקירה כאשר מפיקים כל סוג אחר של פלט. 
+ניתן לראות גם ב [4. Lookaround](#4-lookaround).
+
+## 2.6 חלופה
+
+בביטוי רגולרי, הקו ניצב `|` משמש בכדי להגדיר חלופה. חלופה היא כמו הצהרת OR (או) 
+בין ביטויים שונים. כעט את.ה עלול לחשוב שמערכות התווים והתו המשמש להגדרת חלופה יעבדו באותה הדרך. 
+אך ההבדל העיקרי בין מערכת תווים לבין חלופה הוא שמערכת תווים פועלת ברמת התו והחלופה
+עובדת ברמת הביטוי. לדוגמא, הביטוי הרגולרי <span dir='ltr'>`(T|t)he|car`</span> פירושו: או (אות גדולה `T` או אות קטנה
+`t`, שלאחריהן אות קטנה `h`, שאחריה אות קטנה `e`) או (אות קטנה `c`, שאחריה תופיע האות `a`, 
+ולאחריה תופיע האות `r`). יש לשים לב שהכללתי את הסוגריים לשם ההבהרה, 
+בכדי להראות שאפשר להתמודד עם כל ביטוי בסוגריים והוא יתאים. 
+
+<pre dir="ltr">
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 התעלמות מתווים מיוחדים
+
+לוכסן שמאלי `\` משמש בביטוי רגולרי בכדי להתעלם מהתו הבא. זה מאפשר לנו לכלול תוים שמורים כמו 
+`{ } [ ] / \ + * . $ ^ | ?` כתוים להתאמות. הכדי להשתמש בתוים המיוחדים הללו התו התאמה, 
+יש להוסיף אותו מראש עם `\` לפניו. לדוגמא, הביטוי הרגולרי `.` משמש בכדי להתאים כל תו חוץ משורה חדשה. 
+כעט בכדי לבצע התאמה עם הסימן `.` במחרוזת קלט, יהיה צורך בהוספת הלוכסן השמאלי. למשל בביטוי הרגולרי 
+`(f|c|m)at\.?` פירושו: אות קטנה `f`, `c` או `m`, שאחריהן תופיע האות הקטנה
+`a`, ואחריה תופיע האות הקטנה `t`, ולבסוף יופיע באופן אופציונלי התו - `.`.
+
+<pre dir="ltr">
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 עוגנים
+
+בביטויים רגולרים, אנחנו משתמשים בעוגנים בכדי לבדוק אם סימן ההתאמה הוא סימן התחלה או 
+סימן סיום של מחרוזת הקלט. ישנם שני סוגי עוגנים: 
+הסוג הראשון הוא ה"קרט"(גג) `^` שבודק אם תו תואם הוא התו הראשון של הקלט והסוג השני הוא סימן הדולר 
+`$` אשר בודק אם תו תואם הוא התו האחרון שבקלט
+
+### 2.8.1 ה-"קרט"
+
+הסימן "קרט" `^` משמש לבדיקה אם תו תואם הוא התו הראשון של מחרוזת הקלט. 
+אם ניישם את הביטור הרגולרי הבא <span dir='ltr'>`^a`</span> (כלומר 'a' חייב להיות התו ההתחלתי) 
+המחרוזת `abc`, תתאים לדרישות `a`. 
+אך אם ניישם את הביטוי הרגולרי <span dir='ltr'>`^b`</span> על במחרוזת למעלה, היא לא תמצא אף התאמה. 
+בגלל שבמחרוזת `abc`, ה-"b" אינו תו התחלתי. בואו נסתכל על ביטוי רגולרי אחר 
+<span dir='ltr'>`^(T|t)he`</span> שפירושו: אות גדולה `T` או אות קטנה `t` חייבת להיות התו הראשון של המחרוזת, 
+ואחריה האות הקטנה `h`, ולאחריה האות הקטנה `e`.
+
+<pre dir="ltr">
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/5ljjgB/1)
+
+<pre dir="ltr">
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 סימן הדולר
+
+סימן הדולר `$` משמש בכדי לבדוק אם התו התואם הוא התו האחרון במחרוזת. לדוגמא, 
+הביטוי הרגולרי <span dir='ltr'>`(at\.)$`</span> פירושו: האות הקטנה `a`, שאחריה תיהיה האות הקטנה `t`, ואחריה התו נקודה `.`
+וכל ההתאמה חייבת לביות בסופה של המחרוזת.
+
+<pre dir="ltr">
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/y4Au4D/1)
+
+<pre dir="ltr">
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/t0AkOd/1)
+
+##  3. קיצורי מערכות תווים
+
+ישנם מספר קיצורים נוחים למערכות תווים נפוצות / ביטויים רגולרים: 
+
+|קיצור|תיאור|
+|:----:|----|
+|.|תואם כל תו חוץ מתחילת שורה חדשה|
+|<span dir='ltr'>\w</span>|תואם תוים אלפא-נומריים (אותיות ומספרים): `[a-zA-Z0-9_]`|
+|<span dir='ltr'>\W</span>|תואם תוים לא אלפא-נומריים: <span dir='ltr'>`[^\w]`</span>|
+|<span dir='ltr'>\d</span>|תואם ספרות: `[0-9]`|
+|<span dir='ltr'>\D</span>|תואם תוים שאינם ספרות: <span dir='ltr'>`[^\d]`</span>|
+|<span dir='ltr'>\s</span>|תואם תוי רווח: <span dir='ltr'>`[\t\n\f\r\p{Z}]`</span>|
+|<span dir='ltr'>\S</span>|תואם תוים שאינם רווח: <span dir='ltr'>`[^\s]`</span>|
+
+## 4. הסתכלויות
+
+מבט לאחור ומבט לפנים (נקראים גם הסתכלויות) אלו הם סוגים ספציפים של קבוצות שאינן לוכדות. 
+(משמשות בכדי להתאים תבנית אך ללא הכנסתה לרשימת ההתאמות).
+הסתכלויות משמשות כאשר יש להקדים תבנית בכך שזו תלויה בתבנית אחרת בכדי שהראשונה תתאים. 
+לדוגמא, תדמיין.י שאנחנו רוצים לקבל את כל המספרים שלפניהם יש את התו `$` מהמחרוזת 
+<span dir='ltr'>`$4.44 and $10.88`</span>. אנחנו נשתמש בביטוי הרגולרי הבא: 
+<span dir='ltr'>`(?<=\$)[0-9\.]*`</span> שפירושו: התאם את כל הספרות או התו `.` שלפני ההתאמה 
+קיים התו `$`. בטבלה מטה מוצגים סוגי המבטים המשמשים ביטויים רגולרים: 
+
+|סימן|תיאור|
+|:----:|----|
+|<span dir='ltr'>?=</span>|מבט קדימה חיובי|
+|<span dir='ltr'>?!</span>|מבט קדימה שלילי|
+|<span dir='ltr'>?<=</span>|מבט אחורה חיובי|
+|<span dir='ltr'>?<!</span>|מבט אחורה שלילי|
+
+### 4.1 מבט קדימה חיובי
+
+מבט קדימה חיובי דורש שבחלקו הראשון של ביטוי חייב להתקיים הביטוי מבט קדימה חיובי. 
+ההתאמה המוחזרת מכילה רק את הטקסט המתאים לחלק הראשון של הביטוי לפני המבט קדימה. 
+בכדי להגדיר מבט קדימה חיובי, משתמשים בסוגריים. בתוך הסוגריים, משתמשים בסימן שאלה 
+ואחריו סימן השוואה כך: <span dir='ltr'>`(?=...)`</span>. ביטויי המבט קדימה נכתבים אחרי סימני סוג 
+המבט בתוך הסוגריים. לדוגמא, הביטוי הרגולרי <span dir='ltr'>`(T|t)he(?=\sfat)`</span> פירושו: 
+התאם או את האות הקטנה `t` או את האות הגדולה `T`, שאחריה תיהיה האות `h`, ואחריה האות `e`. 
+בסוגריים אנחנו מגדירים מבט קדימה חיובי שאומר למנוע של הביטוי הרגולרי להתאים `The` או `the` 
+רק אם אחרי ההתאמה מופיעה המחרוזתS ` fat`.
+
+<pre dir="ltr">
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/IDDARt/1)
+
+### 4.2 מבט קדימה שלילי
+
+משתמשים במבט קדימה שלילי כשאנחנו צריכים לקבל את כל ההתאמות ממחרוזת קלט שלאחריהן אין תבנית מסויימת. 
+מבט קדימה שלילי יכתב באותה הדרך כמו שנכתב המבט קדימה החיובי. ההבדל היחיד הוא שמבקום 
+סימן השווה `=`, עלינו להשתמש בסימן קריאה `!` בכדי לציין את השלילה כלומר: <span dir='ltr'>`(?!...)`</span>. 
+בואו נסתכל על הביטוי הרגולרי הבא <span dir='ltr'>`(T|t)he(?!\sfat)`</span> שפירושו: התאם את כל המילים `The` או `the` 
+ממחרוזת קלט שאחריהן אין את התו רווח ולאחר מכן את המילה `fat`.
+
+<pre dir="ltr">
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/V32Npg/1)
+
+### 4.3 מבט אחורה חיובי
+
+משתמשים במבט אחורה חיובי בכדי לקבל את כל ההתאמות שלפניהן יש תבנית ספציפית מסויימת. 
+מבטים אחורה חיוביים נכתבים כך: <span dir='ltr'>`(?<=...)`</span>. לדוגמא, 
+הביטוי הרגולרי <span dir='ltr'>`(?<=(T|t)he\s)(fat|mat)`</span> פירושו: התאם 
+את כל המילים `fat` או `mat` ממחרוזת קלט שנמצאות לפני המילים `The` או `the` ויש רווח 
+שמפריד בינהן.
+
+<pre dir="ltr">
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/avH165/1)
+
+### 4.4 מבט אחורה שלילי
+
+משתמשים במבט אחורה שלילי בכדי לקבל את כל ההתאמות שלפניהן אין תבנית ספציפית מסויימת.
+מבטים אחורה שליליים יכתבו כך: <span dir='ltr'>`(?<!...)`</span>. לדוגמא, הביטוי הרגולרי 
+<span dir='ltr'>`(?<!(T|t)he\s)(cat)`</span> פירושו: התאם את כל המילים `cat` 
+ממחרוזת קלט שלא נמצאות אחרי המילים `The` or `the` כאשר רווח מפריד בינהן.
+
+<pre dir="ltr">
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/8Efx5G/1)
+
+## 5. דגלים
+
+דגלים נקראים גם משנים בגלל שהם משנים את הפלט של הביטוי הרגולרי. 
+ניתן להשתמש בדגלים הללו בכל סדר או שילוב והם חלק בלתי נפרד 
+מהביטוי הרולרי (RegExp).
+
+|דגל|תיאור|
+|:----:|----|
+|i|חוסר רגישות לאותיות: ההתאמה לא תהיה רגישה לאותיות קטנות או גדולות.|
+|g|חיפוש גלובלי: התאם את כל ההאמות שהופיעו, לא רק את הראשונה.|
+|m|רב-שורות: תווי-המטא העוגנים (`$` או `^`) עובדים על כל שורה.|
+
+### 5.1 חוסר רגישות לאותיות
+
+המשנה `i` משמש בכדי לבצע התאמות חסרות רגישות לאותיות קטנות או גדולות.
+לדוגמא, בביטוי הרגולרי <span dir='ltr'>`/The/gi`</span> פירושו: אות גדולה `T`, ואחריה אות קטנה
+`h`, ואחריה אות קטנה `e`. ובסוף הביטוי הרגולרי יש את הדגל `i` שאומר למנוע הביטוי הרגולרי 
+להתעלם מהבדלי אותיות גדולות או קטנות. וכפי שאת.ה יכול לראות,
+סיפקנו גם דגל `g` בגדלל שאנחנו רוצים לחפש את התבנית בכל מחרוזת הקלט. 
+
+<pre dir="ltr">
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dpQyf9/1)
+
+<pre dir="ltr">
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 חיפוש גלובלי
+
+המשנה `g` משמש בכדי לבצע התאמות גלובליות (מוצא את כל ההתאמות במקום לעצור בהתאמה הראשונה). 
+לדוגמא, בביטוי הרגולרי <span dir='ltr'>`/.(at)/g`</span> פירושו: כל תו חות משורה חדשה, שאחריו תיהיה האות הקטנה `a`,
+ואחריה תיהיה האות הקטנה `t`. בגלל שסיפקנו את הדגל `g` בסופו של הביטוי הרגולרי, 
+הוא עכשיו ימצא את כל ההתאמות במחרוזת הקלט, לא רק את ההתאמה הראשונה (שזו התנהגות ברירת המחדל).
+
+<pre dir="ltr">
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/jnk6gM/1)
+
+<pre dir="ltr">
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/dO1nef/1)
+
+### 5.3 רב-שורות
+
+המשנה `m` משמש בכדי לבצע התאמות במספר רב של שורות. כפי שדנו על כך קודם לכן, 
+העוגנים `(^, $)` משמשים לבדיקה אם תבנית היא בהתחלה או בסופו של קלט. 
+אבל אם אנחנו רוצים שהעוגנים הללו יעבדו על כל שורה, אנחנו נשתמש בדגל `m`. לדוגמא, 
+בביטוי הרגולרי <span dir='ltr'>`/at(.)?$/gm`</span> פירושו: אות קטנה
+`a`, שלאחריה האות הקטנה `t` וכאופציה, כל תו שאינו שורה חדשה. ובגלל הדגל `m`, 
+המנוע של הביטוי הרגולרי יתאים את התבנית בכל סוף שורה במחרוזת. 
+
+<pre dir="ltr">
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/hoGMkP/1)
+
+<pre dir="ltr">
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/E88WE2/1)
+
+## 6. התאמה חמדנית מול עצלה
+
+כברירת מחדל, ביטוי רגולרי יבצע התאמה חמדנית, זאת אומרת שביצוע ההתאמה תיהיה ארוכה ככל הניתן. 
+אנחנו יכולים להשתמש ב-`?` בכדי לבצע התאמה בצורה עצלה, פירוש הדבר שההתאמה תיהיה קצרה ככל שניתן.
+
+<pre dir="ltr">
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/1)
+
+<pre dir="ltr">
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[בדוק.י את הביטוי הרגולרי](https://regex101.com/r/AyAdgJ/2)
+
+
+## תרומה
+
+* Open a pull request with improvements
+* Discuss ideas in issues
+* Spread the word
+* Reach out with any feedback 
+* [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## רישיון
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
+</div>
\ No newline at end of file

From 3eed853d45a2671717db853c113192f41c0ea86d Mon Sep 17 00:00:00 2001
From: Recurduck Greco <ilaigreco@gmail.com>
Date: Sat, 16 Oct 2021 03:01:36 +0300
Subject: [PATCH 163/185] Add hebrew translation link to all README files

---
 translations/README-cn.md        | 1 +
 translations/README-de.md        | 1 +
 translations/README-es.md        | 1 +
 translations/README-fa.md        | 1 +
 translations/README-fr.md        | 1 +
 translations/README-gr.md        | 1 +
 translations/README-hu.md        | 1 +
 translations/README-ja.md        | 1 +
 translations/README-ko.md        | 1 +
 translations/README-pl.md        | 1 +
 translations/README-pt_BR.md     | 1 +
 translations/README-ru.md        | 1 +
 translations/README-tr.md        | 1 +
 translations/README-vn.md        | 1 +
 translations/README-zh-simple.md | 1 +
 15 files changed, 15 insertions(+)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index c29158a7..c0756803 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## 什么是正则表达式？
 
diff --git a/translations/README-de.md b/translations/README-de.md
index c2c179fc..92ac194d 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -21,6 +21,7 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
+* [עברית](translations/README-he.md)
 
 ## Was sind Reguläre Ausdrücke?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index 907f9a1a..065edeb3 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Qué es una expresión regular?
 
diff --git a/translations/README-fa.md b/translations/README-fa.md
index 5595d455..74e35deb 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -30,6 +30,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 <div dir="rtl">
 
diff --git a/translations/README-fr.md b/translations/README-fr.md
index 46016160..face914f 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 763bd8f9..2da80b53 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index 16a6804e..726abf2d 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index 308b6391..ef9a2894 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index e210de48..c41feb6a 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index 13f1e9a0..1569b31a 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Co to jest wyrażenie regularne?
 
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index 68db0e19..3bcde4fd 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-ru.md b/translations/README-ru.md
index d76116c5..8cfe2c3e 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -30,6 +30,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Что такое Регулярное выражение?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index f3a3967e..d891a641 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -31,6 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-vn.md b/translations/README-vn.md
index c6d15f87..f975cd7a 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -32,6 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 
 ## Biểu thức chính quy là gì?
diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index f591052a..d79767cb 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -30,6 +30,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
+* [עברית](translations/README-he.md)
 
 ## 什么是正则表达式?
 

From 8608347dea36b4fc658742f5860b84742fa80289 Mon Sep 17 00:00:00 2001
From: Recurduck Greco <ilaigreco@gmail.com>
Date: Sat, 16 Oct 2021 17:06:09 +0300
Subject: [PATCH 164/185] fix typo hebrew

---
 README.md                 | 2 ++
 translations/README-he.md | 8 ++++----
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 34ef8d6b..54c46380 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,8 @@
 * [Русский](translations/README-ru.md)
 * [Tiếng Việt](translations/README-vn.md)
 * [فارسی](translations/README-fa.md)
+* [עברית](translations/README-he.md)
+
 
 ## What is Regular Expression?
 
diff --git a/translations/README-he.md b/translations/README-he.md
index f8ec8537..a66099f7 100644
--- a/translations/README-he.md
+++ b/translations/README-he.md
@@ -120,10 +120,10 @@
 |.|נקודה תואמת כל תו בודד למעט שבירת שורות.|
 |[ ]|מחלקת תווים. תואם כל תו הכלול בין הסוגריים המרובעים.|
 |[^ ]|מחלקת תווים שלילית. תואם כל תו שאינו כלול בין הסוגריים המרובעים|
-|*|תואם 0 או יותר חזרות של הסמל הקודם.|
-|+|תואם חזרה אחת או יותר של הסמל הקודם.|
-|?|הופך את הסמל הקודם לאופציונלי.|
-|{n,m}|סוגריים מסולסלים. תואם לפחות חזרות "n" אך לא יותר מ- "m" של הסמל הקודם.|
+|*|תואם 0 או יותר חזרות של התו הקודם.|
+|+|תואם חזרה אחת או יותר של התו הקודם.|
+|?|הופך את התו הקודם לאופציונלי.|
+|{n,m}|סוגריים מסולסלים. תואם לפחות חזרות "n" אך לא יותר מ- "m" של התו הקודם.|
 |(xyz)|קבוצת תווים. תואם את התווים xyz בסדר המדויק הזה.|
 |||חלופה (או). התאמה בין התווים שלפני או לתווים שאחרי הסמל.|
 |\|מתעלם מהתו הבא. זה מאפשר לך להתאים תווים שמורים <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|

From 554f46d6da0ef2ba3c3b05fac3e14416c06da186 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aykut=20Karda=C5=9F?= <aykutkrds@gmail.com>
Date: Sun, 17 Oct 2021 13:43:51 +0300
Subject: [PATCH 165/185] Fix some thread title on Turkish

---
 translations/README-tr.md | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index 939120da..483a7fae 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -66,8 +66,8 @@ Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri
 - [Temel Eşleştiriciler](#1-temel-eşleştiriciler)
 - [Meta Karakterler](#2-meta-karakterler)
   - [Nokta](#21-nokta)
-  - [Karakter takımı](#22-karakter-takımı)
-    - [Negatiflenmiş karakter seti](#221-negatiflenmiş-karakter-seti)
+  - [Karakter Takımı](#22-karakter-takımı)
+    - [Negatiflenmiş Karakter Seti](#221-negatiflenmiş-karakter-seti)
   - [Tekrarlar](#23-tekrarlar)
     - [Yıldız İşareti](#231-yıldız-İşareti)
     - [Artı İşareti](#232-artı-İşareti)
@@ -78,8 +78,8 @@ Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri
   - [Değişim](#26-değişim)
   - [Özel Karakter Hariç Tutma](#27-Özel-karakter-hariç-tutma)
   - [Sabitleyiciler](#28-sabitleyiciler)
-    - [Ters v işareti](#281-Şapka-İşareti)
-    - [Dolar işareti](#282-dolar-İşareti)
+    - [Şapka İşareti](#281-Şapka-İşareti)
+    - [Dolar İşareti](#282-dolar-İşareti)
 - [Kısaltma Karakter Takımları](#3-kısaltma-karakter-takımları)
 - [Bakınmak](#4-bakınmak)
   - [Olumlu Bakınma](#41-positive-lookahead)
@@ -87,10 +87,11 @@ Yukardaki düzenli ifade `john_doe`, `jo-hn_doe` ve `john12_as` gibi girişleri
   - [Positive Lookbehind](#43-positive-lookbehind)
   - [Negative Lookbehind](#44-negative-lookbehind)
 - [İşaretler](#5-İşaretler)
-  - [Büyük/Küçük harf duyarlılığı](#51-büyükküçük-harf-duyarlılığı)
+  - [Büyük/Küçük Harf Duyarlılığı](#51-büyükküçük-harf-duyarlılığı)
   - [Bütünsel Arama](#52-genel-arama)
-  - [Çok satırlı](#53-Çok-satırlı)
+  - [Çok Satırlı](#53-Çok-satırlı)
 - [Açgözlü vs Tembel Eşleştirme](#6-açgözlü-vs-tembel-eşleştirme)
+
 ## 1. Temel Eşleştiriciler
 
 Bir düzenli ifade bir metin içinde arama yapabilmek için kullandığımız bir karakter desenidir.

From 04936755d234709b074f9da43f7ef26687269c87 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Tue, 19 Oct 2021 14:32:57 +0400
Subject: [PATCH 166/185] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 6dc3094b..9651e152 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,3 @@
-<a href="https://www.buymeacoffee.com/ziishaned" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
-
 <p align="center">
     <br/>
     <a href="https://github.com/ziishaned/learn-regex">	

From aed29db0d25ffa1a18dc0f629217b951bad76a2f Mon Sep 17 00:00:00 2001
From: Claudio Marconato <claudio@cmpro.it>
Date: Sat, 11 Dec 2021 09:16:33 +0100
Subject: [PATCH 167/185] Create README-it.md

---
 translations/README-it.md | 477 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 477 insertions(+)
 create mode 100644 translations/README-it.md

diff --git a/translations/README-it.md b/translations/README-it.md
new file mode 100644
index 00000000..1d4a3021
--- /dev/null
+++ b/translations/README-it.md
@@ -0,0 +1,477 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">	
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+</p>
+
+
+## Translations:
+
+* [English](README.md)
+* [German](translations/README-de.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
+* [Tiếng Việt](translations/README-vn.md)
+* [فارسی](translations/README-fa.md)
+* [עברית](translations/README-he.md)
+
+
+## Cosa sono le Espressioni Regolari?
+
+<p>
+    <a href="https://gum.co/learn-regex">
+        <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
+    </a>
+</p>
+
+> Un'espressione regolare è un insieme di caratteri e simboli utilizzati per trovare una specifica sequenza (pattern) di testo.
+
+
+Un'espressione regolare è una sequenza che corrisponde a una stringa di testo letta da sinistra a destra. Le espressioni regolari sono utilizzate per sostituire parti di testo in una stringa, validare moduli, estrarre parti di stringhe basate sulla corrispondenza di uno schema e molto altro. Il termine "Espressione regolare" è molto lungo quindi è normalmente abbreviato con "regex" o "regexp".
+
+Immagina che stai scrivendo un applicazione e hai bisogno di impostare una regola per quando un utente sceglie il suo nome utente. Vogliamo consentire che il nome utente contenga lettere, numeri, carattere di sottolineo e il trattino, vogliamo inoltre limitare il numero di caratteri del nome utente. Possiamo utilizzare la seguente espressione regolare per validare il nome utente:
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+L'espressione regolare riportata sopra può accettare le stringhe `john_doe`, `jo-hn_doe` e `john12_as`. Non c'è corrispondenza con `Jo` perché contiene una lettera maiuscola ed inoltre è troppo breve.
+
+## Sommario
+
+- [Corrispondenze di base](#1-basic-matchers)
+- [Caratteri jolly](#2-meta-characters)
+  - [Il punto](#21-the-full-stop)
+  - [Classe di caratteri](#22-character-sets)
+    - [Negazione di classe di carattere](#221-negated-character-sets)
+  - [Ripetizioni](#23-repetitions)
+    - [Simbolo Asterisco](#231-the-star)
+    - [Simbolo Più](#232-the-plus)
+    - [Carattere Punto di Domanda](#233-the-question-mark)
+  - [Parentesi](#24-braces)
+  - [Raggruppamento e cattura di caratteri](#25-capturing-groups)
+      - [Raggruppamento di caratteri senza cattura](#251-non-capturing-groups)
+  - [Alternativa](#26-alternation)
+  - [Carattere speciale Escape](#27-escaping-special-characters)
+  - [Ancore](#28-anchors)
+    - [Segno di omissione ^](#281-the-caret)
+    - [Il simbolo del dollaro](#282-the-dollar-sign)
+- [Classe di caratteri rapide](#3-shorthand-character-sets)
+- [Guardarsi intorno](#4-lookarounds)
+  - [Lookahead positivo](#41-positive-lookahead)
+  - [Lookahead negativo](#42-negative-lookahead)
+  - [Lookbehind positivo](#43-positive-lookbehind)
+  - [Lookbehind negativo](#44-negative-lookbehind)
+- [Opzioni](#5-flags)
+  - [Sensibilità ai caratteri maiuscoli e minuscoli](#51-case-insensitive)
+  - [Ricerca globale](#52-global-search)
+  - [Riga multipla](#53-multiline)
+- [Corrispondenza vorace vs pigra](#6-greedy-vs-lazy-matching)
+
+## 1. Corrispondenze di base
+
+Un'espressione regolare non è altro che una sequenza di caratteri usati per eseguire ricerche in un testo. Ad esempio, l'espressione regolare `the` corrisponde a: la lettera `t`, seguita dalla lettera `h`, seguita dalla lettera `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/dmRygT/1)
+
+L'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.
+Le espressioni regolari sono normalmente sensibili a caratteri maiuscoli e minuscoli, perciò l'espressione regolare `The` non troverà corrispondenza con il testo `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/1paXsy/1)
+
+## 2. Caratteri jolly
+
+I 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:
+
+|Carattere jolly|Descrizione|
+|:----:|----|
+|.|Il punto corrisponde ad ogni carattere eccetto l'invio e l'interruzione di riga.|
+|[ ]|Classe di caratteri. Corrispondenza con ciascun carattere contenuto tra le parentesi.|
+|[^ ]|Negazione di classe di caratteri. Corrispondenza con ciascun carattere non contenuto all'interno delle parentesi|
+|*|Corrispondenza con zero o più ripetizioni del carattere che lo precede.|
+|+|Corrispondenza con una o più ripetizioni del carattere che lo precede|
+|?|Rende opzionale il carattere che lo precede.|
+|{n,m}|Parentesi graffe. Corrisponde con le ripetizione minima di "n" ma non più di "m", del carattere che le precede.|
+|(xyz)|Gruppo di caratteri. Corrispondenza con i caratteri tra parentesi xyz solo nell'ordine esatto.|
+|||Alternativa. Corrispondenza con il carattere che precede o con quello che segue.|
+|\|Escape sul carattere successivo. Consente la corrispondenza con i caratteri riservati <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Corrispondenza con l'inizio del testo.|
+|$|Corrispondenza con la fine del testo.|
+
+## 2.1 Il punto
+
+Il 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.
+Ad esempio, l'espressione regolare `.ar` significa: ciascun carattere, seguito dalla lettera `a`, seguita dalla lettera `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Classi di carattere
+
+Le 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`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/2ITLQ4/1)
+
+Un 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 `.`.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Negazione di classe di carattere
+
+In 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`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Ripetizioni
+
+I caratteri jolly `+`, `*` o `?` sono utilizzati per specificare quante volte uno schema si può ripetere. Questi caratteri jolly agiscono in modo differente per differenti situazioni.
+
+### 2.3.1 Simbolo Asterisco
+
+Il 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`.
+Se 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.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/7m8me5/1)
+
+Il 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.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Simbolo Più
+
+Il 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`. 
+È importante chiarire che `t` corrisponde all'ultima lettera `t` nella stringa.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Carattere Punto di Domanda
+
+Nelle 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.
+Ad esempio, l'espressione regolare `[T]?he` corrisponde a: Lettera maiuscola opzionale `T`, seguita, se presente, dalla lettera maiuscola `h`, seguita dalla lettera minuscola `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Parentesi graffe
+
+Nelle 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.
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/juM86s/1)
+
+Si 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.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Raggruppamento e cattura di caratteri
+
+Un 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". 
+Si può inoltre utilizzare il carattere di alternativa `|` all'interno di un gruppo di caratteri.
+Ad 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`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/tUxrBG/1)
+
+Nota 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.
+
+### 2.5.1 Raggruppamento di caratteri senza cattura
+
+Un 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.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/Rm7Me8/1)
+
+I 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.
+Vedere anche [4. Guardarsi intorno](#4-lookaround).
+
+## 2.6 Alternativa
+
+In un'espressione regolare, la barra verticale `|` è utilizzata per definire alternative.
+L'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
+(Una lettera minuscola `c`, seguita da una lettera minuscola `a`, seguita dalla lettera minuscola `r`).
+Nota che sono state incluse le parentesi per chiarezza, per dimostrare come le espressioni possono funzionare anche all'interno delle parentesi stesse.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Carattere speciale Escape
+
+Il 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.
+
+Ad 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.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Ancore
+
+Nelle espressioni regolari, si usano le ancore per la corrispondenza dell'espressione stessa, all'inizio o al termine di un testo.
+Le ancora sono di due tipi:
+Il 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.
+
+### 2.8.1 Il carattere di negazione ^
+
+Il 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.
+Questo 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`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Il simbolo del Dollaro
+
+Il 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.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/t0AkOd/1)
+
+##  3. Classe di caratteri rapide
+
+Ci sono alcune classe di caratteri rapide per l'utilizzo nelle espressioni regolari:
+
+|Classe di caratteri rapide|Descrizione|
+|:----:|----|
+|.|Qualsiasi carattere tranne invio e fine riga|
+|\w|Corrispondenza con caratteri alfanumerici: `[a-zA-Z0-9_]`|
+|\W|Corrispondenza con caratteri non alfanumerici: `[^\w]`|
+|\d|Corrispondenza con numeri: `[0-9]`|
+|\D|Corrispondenza con caratteri che non siano numeri: `[^\d]`|
+|\s|Corrispondenza con spazi vuoti: `[\t\n\f\r\p{Z}]`|
+|\S|Corrispondenza con caratteri che non siano spazi vuoti: `[^\s]`|
+
+## 4. Guardarsi intorno
+
+Lookbehinds 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:
+
+|Simbolo|Descrizione|
+|:----:|----|
+|?=|Lookahead positivo|
+|?!|Lookahead negativo|
+|?<=|Lookbehind positivo|
+|?<!|Lookbehind negativo|
+
+### 4.1 Lookahead positivo
+
+Il lookahead positivo assume che la prima parte dell'espressione deve essere seguita dall'espressione di lookahead. Il risultato corrisponde solo alla prima parte dell'espressione. Per definire un lookahead positivo, sono utilizzate le parentesi. All'interno delle parentesi, si utilizza un carattere di punto di domanda seguito dal segno uguale: `(?=...)`. L'espressione lookahead viene scritta dopo il segno di uguale all'interno delle parentesi. Ad esempio, l'espressione regolare `(T|t)he(?=\sfat)` corrisponde a: una lettera minuscola `t` o una lettera maiuscola `T`, seguita dalla lettera minuscola `h`, seguita dalla lettera minuscola `e`. Nelle parentesi è definita l'espressione di lookahead positivo che trova corrispondenza con le parole `The` o `the` solo se seguite dalla parola `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Lookahead negativo
+
+Lookahead 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`.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Lookbehind positivo
+
+Lookbehind 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`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/avH165/1)
+
+### 4.4 Lookbehind negativo
+
+Lookbehind negativo è utilizzato per trovare il testo non preceduto da uno specifico schema. Il lookbehind negativo è sxcritto come `(?<!...)`. Ad esempio, l'espressione regolare `(?<!(T|t)he\s)(cat)` corrisponde a: tutte le parole `fat` o `mat` che non seguono la parola `The` o `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/8Efx5G/1)
+
+## 5. Opzioni
+
+Le opzioni (o modificatori) modificano il risultato delle espressioni regolari. Queste opzioni possono essere utilizzate in qualsiasi ordine o combinazione, sono parti integranti di RegExp.
+
+|Opzione|Descrizione|
+|:----:|----|
+|i|Non sensibilità maiuscolo / minuscolo|
+|g|Ricerca globale: trova tutte le corrispondenze, non solo la prima.|
+|m|Multi riga: estende il funzionamento delle ancore su ogni riga.|
+
+### 5.1 Non sensibilità maiuscolo / minuscolo
+
+L'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.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Ricerca globale
+
+L'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.
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multi riga
+
+L'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.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Verifica l'espressione regolare](https://regex101.com/r/E88WE2/1)
+
+## 6. Corrispondenza vorace vs pigra
+Regex 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.
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Verifica l'espressione regolare](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Verifica l'espressione regolare](https://regex101.com/r/AyAdgJ/2)
+
+
+## Contribution
+
+* Open a pull request with improvements
+* Discuss ideas in issues
+* Spread the word
+* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Traduzione italiana: Claudio Marconato (cmpro.it)
+
+## License
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
\ No newline at end of file

From c81ccac43279301cf09da251c62922bfbd456542 Mon Sep 17 00:00:00 2001
From: Shaun Sandstrom <42827574+sandstroms@users.noreply.github.com>
Date: Wed, 19 Jan 2022 14:45:38 -0700
Subject: [PATCH 168/185] Updated introduction

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9651e152..3a038560 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@
 
 A regular expression is a pattern that is matched against a subject string from
 left to right. Regular expressions are used to replace text within a string, 
-validating forms, extracting a substring from a string based on a pattern match, 
+validate forms, extract a substring from a string based on a pattern match, 
 and so much more. The term "regular expression" is a mouthful, so you will usually
 find the term abbreviated to "regex" or "regexp". 
 

From b347848518b0d217204fedfb377f9ef56412ce17 Mon Sep 17 00:00:00 2001
From: Volkan Sahin <bm.volkansahin@gmail.com>
Date: Sun, 30 Jan 2022 14:45:29 +0300
Subject: [PATCH 169/185] Update README-tr.md

Updates about typos, style, formatting, untranslated words
---
 translations/README-tr.md | 52 +++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/translations/README-tr.md b/translations/README-tr.md
index 483a7fae..35f6824b 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -178,7 +178,7 @@ ardından bir `.` karakteri gelir.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Negatiflenmiş karakter seti
+### 2.2.1 Dışlanmış Karakter Seti
 
 Genellikle, şapka `^` sembolü harf öbeğinin başlangıcını temsil eder, ama köşeli
 parantez içinde kullanıldığında verilen karakter takımını hariç tutar.
@@ -223,7 +223,7 @@ ardından küçük `c` karakteri gelir, ardından küçük `a` karakteri gelir,
 küçük `t` karakteri gelir, ardından sıfır veya daha fazla boşluk gelir.
 
 <pre>
-"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the <a href="#learn-regex">con<strong>cat</strong>enation</a>.
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
 </pre>
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/gGrwuz/1)
@@ -247,7 +247,7 @@ az bir karakter vardır.
 ### 2.3.3 Soru İşareti
 
 Düzenli ifadelerde `?` meta karakterinden önce girilen karakteri opsiyonel
-olarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örbeğiyle
+olarak tanımlar. Bu sembol önce gelen karakterin sıfır veya bir örneğiyle
 eşleşir.
 
 Örneğin, `[T]?he` ifadesinin anlamı: opsiyonel büyük `T` harfi, ardından küçük
@@ -318,7 +318,7 @@ karakteri, ardından `a` karakteri, ardından `r` karakteri gelir.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/tUxrBG/1)
 
-Not 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.
+Not 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.
 
 ### 2.5.1 Karakter Grubu Olmayanlar
 
@@ -461,14 +461,14 @@ Düzenli ifadelerde kullanılan bakınma sembolleri aşadaki gibidir:
 
 |Sembol|Açıklama|
 |:----:|----|
-|?=|Positive Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme varsa` sonuç döndürür.)|
-|?!|Negative Lookahead (Verdiğimiz ifade sonrası arar ve `eşleşme yoksa` sonuç döndürür.)|
-|?<=|Positive Lookbehind (Verdiğimiz ifade öncesini arar ve `eşleşme varsa` sonuç döndürür.)|
-|?<-!-|Negative Lookbehind (Verdiğimiz ifade öncesini arar ve `eşleşme yoksa` sonuç döndürür.)|
+|?=|Pozitif İleri Bakınma (Verdiğimiz ifade sonrası arar ve `eşleşme varsa` sonuç döndürür.)|
+|?!|Negatif İleri Bakınma (Verdiğimiz ifade sonrası arar ve `eşleşme yoksa` sonuç döndürür.)|
+|?<=|Pozitif Geri Bakınma (Verdiğimiz ifade öncesini arar ve `eşleşme varsa` sonuç döndürür.)|
+|?<!|Negatif Geri Bakınma (Verdiğimiz ifade öncesini arar ve `eşleşme yoksa` sonuç döndürür.)|
 
-### 4.1 Positive Lookahead
+### 4.1 Pozitif İleri Bakınma
 
-Positive Lookahead, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi
+Pozitif ileri bakınma, ifadenin ilk bölümü bakınma ifadesiyle devam etmesi
 gerektiğini savunur. Bulunan eşleşme yalnızca ifadenin ilk bölümüyle eşleşen
 metin içerir. Olumlu bir bakınma tanımlamak için, içinde eşittir işareti yer
 alan parantezler `(?=...)` şeklinde kullanılır. Bakınma ifadesi parantezler
@@ -485,10 +485,10 @@ edeceğini tanımlıyoruz.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negative Lookahead
+### 4.2 Negatif İleri Bakınma
 
-Negative Lookahead sembolü positive lookahead tersine, verdiğimiz desenle devam
-etmemesi durumunda eşleşir. Bu sembol positive lookahead gibi tanımlanır ama `=`
+Negatif ileri bakınma sembolü positive lookahead tersine, verdiğimiz desenle devam
+etmemesi durumunda eşleşir. Bu sembol pozitif ileri bakınma gibi tanımlanır ama `=`
 işareti yerine `!` kullanılır.
 
 `[T|t]he(?!\sfat)` ifadesinin anlamı: opsiyonel küçük bir `t` ya da büyük `T`
@@ -502,9 +502,9 @@ boşluk olan bir `fat` öbeği olmamalıdır.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positive Lookbehind
+### 4.3 Pozitif Geri Bakınma
 
-Positive Lookbehind, belirli bir desenden önceki eşleşmeleri almak için
+Pozitif geri bakınma, belirli bir desenden önceki eşleşmeleri almak için
 kullanılır. `(?<=...)` ile gösterilir.
 
 Örneğin, `(?<=[T|t]he\s)(fat|mat)` ifadesinin anlamı: Öncesinde `The` veya `the`
@@ -516,9 +516,9 @@ kullanılır. `(?<=...)` ile gösterilir.
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/avH165/1)
 
-### 4.4 Negative Lookbehind
+### 4.4 Negatif Geri Bakınma
 
-Negative Lookbehind, belirli bir desenden önce olmayan eşleşmeleri almak için
+Negatif geri bakınma, belirli bir desenden önce olmayan eşleşmeleri almak için
 kullanılır. `(?<=!..)` ile gösterilir.
 
 Örneğin, `(?<!(T|t)he\s)(cat)` ifadesinin anlamı: Öncesinde `The` veya `the`
@@ -532,9 +532,9 @@ kullanılır. `(?<=!..)` ile gösterilir.
 
 ## 5. İşaretler
 
-İşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü onlar bir düzenli
+İşaretler ayrıca düzenleyiciler olarak bilinirler, çünkü bir düzenli
 ifadenin çıktısını düzenlerler. Bu işaretler herhangi bir sırada veya
-kombinasyonda kullanılabilirler, ve bunlar Düzenli İfadelerin ayrılmaz bir
+kombinasyonda kullanılabilirler ve Düzenli İfadelerin ayrılmaz bir
 parçasıdırlar.
 
 |İşaret|Açıklama|
@@ -543,7 +543,7 @@ parçasıdırlar.
 |g|Genel Arama: Girilen harf öbeği boyunca bir desen arar.|
 |m|Çok satırlı: Sabitleyici meta karakteri her satırda çalışır.|
 
-### 5.1 Büyük/Küçük harf duyarlılığı
+### 5.1 Büyük/Küçük Harf Duyarlılığı
 
 `i` işaretleyicisi büyük/küçük harfe duyarsız eşleştirme yapmak için kullanılır.
 
@@ -625,13 +625,13 @@ Varsayılan olarak, bir düzenli ifade açgözlü bir eşleştirme yapacaktır,
 
 [Düzenli ifadeyi test edin](https://regex101.com/r/AyAdgJ/2)
 
-## Contribution
+## Katkı Sağla
 
-* Report issues
-* Open pull request with improvements
-* Spread the word
-* Reach out to me directly at ziishaned@gmail.com or [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Hataları Raporla
+* İyileştirmeler iç Pull Request aç
+* Paylaş
+* Geri bildirim için [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)'den eriş
 
-## License
+## Lisans
 
 MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From 97f751de35dd7bfce7732c95d0e4507d19423363 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Mon, 31 Jan 2022 17:48:33 +0400
Subject: [PATCH 170/185] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 3a038560..ed24f8c7 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,7 @@
     </a>
 </p>
 
+<a href="https://liberapay.com/ziishaned/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a>
 
 ## Translations:
 

From 40f1207d9a1329ee2a498bfd3c67f14acd103010 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Tue, 1 Feb 2022 12:10:49 +0400
Subject: [PATCH 171/185] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index ed24f8c7..9c1c4b2e 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,6 @@
     </a>
 </p>
 
-<a href="https://liberapay.com/ziishaned/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a>
-
 ## Translations:
 
 * [English](README.md)

From b02f98adda116ef01e1fca91481ea72b344c02ca Mon Sep 17 00:00:00 2001
From: Cygra <sjtuwbh@gmail.com>
Date: Sun, 1 May 2022 22:22:25 +0800
Subject: [PATCH 172/185] Update README-cn.md

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 2a94abe2..44999549 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -31,7 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## 什么是正则表达式？
 

From 3497a310c3e3f082f4d7eec6e77f98fec22f082c Mon Sep 17 00:00:00 2001
From: Cygra <sjtuwbh@gmail.com>
Date: Mon, 2 May 2022 12:32:42 +0800
Subject: [PATCH 173/185] Update README-cn.md

---
 translations/README-cn.md | 105 +++++++++++++++++++++++---------------
 1 file changed, 64 insertions(+), 41 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 44999549..d98f3c9b 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -18,6 +18,7 @@
 ## 翻译：
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -40,8 +41,8 @@
 > 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
 
 一个正则表达式是一种从左到右匹配主体字符串的模式。
-“Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。
 正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等。
+“Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。
 
 想象你正在写一个应用，然后你想设定一个用户命名的规则，让用户名包含字符、数字、下划线和连字符，以及限制字符的个数，好让名字看起来没那么丑。
 我们使用以下正则表达式来验证一个用户名：
@@ -91,7 +92,7 @@
 ## 1. 基本匹配
 
 正则表达式其实就是在执行搜索时的格式，它由一些字母和数字组合而成。
-例如：一个正则表达式 `the`，它表示一个规则：由字母`t`开始，接着是`h`，再接着是`e`。
+例如：一个正则表达式 `the`，它表示一个规则：由字母 `t` 开始，接着是 `h`，再接着是 `e`。
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -99,9 +100,9 @@
 
 [在线练习](https://regex101.com/r/dmRygT/1)
 
-正则表达式`123`匹配字符串`123`。它逐个字符的与输入的正则表达式做比较。
+正则表达式 `123` 匹配字符串 `123`。它逐个字符的与输入的正则表达式做比较。
 
-正则表达式是大小写敏感的，所以`The`不会匹配`the`。
+正则表达式是大小写敏感的，所以 `The` 不会匹配 `the`。
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -119,21 +120,21 @@
 |.|句号匹配任意单个字符除了换行符。|
 |[ ]|字符种类。匹配方括号内的任意字符。|
 |[^ ]|否定的字符种类。匹配除了方括号里的任意字符|
-|*|匹配>=0个重复的在*号之前的字符。|
-|+|匹配>=1个重复的+号前的字符。
-|?|标记?之前的字符为可选.|
-|{n,m}|匹配num个大括号之前的字符或字符集 (n <= num <= m).|
-|(xyz)|字符集，匹配与 xyz 完全相等的字符串.|
-|||或运算符，匹配符号前或后的字符.|
-|\|转义字符,用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
-|^|从开始行开始匹配.|
-|$|从末端开始匹配.|
+|*|匹配 >=0 个重复的在 * 号之前的字符。|
+|+|匹配 >=1 个重复的 + 号前的字符。|
+|?|标记 ? 之前的字符为可选。|
+|{n,m}|匹配 num 个大括号之前的字符或字符集 (n <= num <= m)。|
+|(xyz)|字符集，匹配与 xyz 完全相等的字符串。|
+|||或运算符，匹配符号前或后的字符。|
+|\|转义字符，用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|从开始行开始匹配。|
+|$|从末端开始匹配。|
 
 ## 2.1 点运算符 `.`
 
-`.`是元字符中最简单的例子。
-`.`匹配任意单个字符，但不匹配换行符。
-例如，表达式`.ar`匹配一个任意字符后面跟着是`a`和`r`的字符串。
+`.` 是元字符中最简单的例子。
+`.` 匹配任意单个字符，但不匹配换行符。
+例如，表达式 `.ar` 匹配一个任意字符后面跟着是 `a` 和 `r` 的字符串。
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -147,7 +148,7 @@
 方括号用来指定一个字符集。
 在方括号中使用连字符来指定字符集的范围。
 在方括号中的字符集不关心顺序。
-例如，表达式`[Tt]he` 匹配 `the` 和 `The`。
+例如，表达式 `[Tt]he` 匹配 `the` 和 `The`。
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -156,7 +157,7 @@
 [在线练习](https://regex101.com/r/2ITLQ4/1)
 
 方括号的句号就表示句号。
-表达式 `ar[.]` 匹配 `ar.`字符串
+表达式 `ar[.]` 匹配 `ar.` 字符串。
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -167,7 +168,7 @@
 ### 2.2.1 否定字符集
 
 一般来说 `^` 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的。
-例如，表达式`[^c]ar` 匹配一个后面跟着`ar`的除了`c`的任意字符。
+例如，表达式 `[^c]ar` 匹配一个后面跟着 `ar` 的除了 `c` 的任意字符。
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -182,8 +183,8 @@
 
 ### 2.3.1 `*` 号
 
-`*`号匹配 在`*`之前的字符出现`大于等于0`次。
-例如，表达式 `a*` 匹配0或更多个以a开头的字符。表达式`[a-z]*` 匹配一个行中所有以小写字母开头的字符串。
+`*` 号匹配在 `*` 之前的字符出现 `大于等于0` 次。
+例如，表达式 `a*` 匹配 0 或更多个以 a 开头的字符。表达式 `[a-z]*` 匹配一个行中所有以小写字母开头的字符串。
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -191,8 +192,8 @@
 
 [在线练习](https://regex101.com/r/7m8me5/1)
 
-`*`字符和`.`字符搭配可以匹配所有的字符`.*`。
-`*`和表示匹配空格的符号`\s`连起来用，如表达式`\s*cat\s*`匹配0或更多个空格开头和0或更多个空格结尾的cat字符串。
+`*` 字符和 `.` 字符搭配可以匹配所有的字符 `.*`。
+`*` 和表示匹配空格的符号 `\s` 连起来用，如表达式 `\s*cat\s*` 匹配 0 或更多个空格开头和 0 或更多个空格结尾的 cat 字符串。
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
@@ -202,8 +203,8 @@
 
 ### 2.3.2 `+` 号
 
-`+`号匹配`+`号之前的字符出现 >=1 次。
-例如表达式`c.+t` 匹配以首字母`c`开头以`t`结尾，中间跟着至少一个字符的字符串。
+`+` 号匹配 `+` 号之前的字符出现 >=1 次。
+例如表达式 `c.+t` 匹配以首字母 `c` 开头以 `t` 结尾，中间跟着至少一个字符的字符串。
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -231,7 +232,7 @@
 ## 2.4 `{}` 号
 
 在正则表达式中 `{}` 是一个量词，常用来限定一个或一组字符可以重复出现的次数。
-例如， 表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。
+例如，表达式 `[0-9]{2,3}` 匹配最少 2 位最多 3 位 0~9 的数字。
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -241,6 +242,8 @@
 
 我们可以省略第二个参数。
 例如，`[0-9]{2,}` 匹配至少两位 0~9 的数字。
+如果逗号也省略掉则表示重复固定的次数。
+例如，`[0-9]{3}` 匹配3位数字
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -248,20 +251,19 @@
 
 [在线练习](https://regex101.com/r/Gdy4w5/1)
 
-如果逗号也省略掉则表示重复固定的次数。
-例如，`[0-9]{3}` 匹配3位数字
-
 <pre>
 "[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
 </pre>
 
 [在线练习](https://regex101.com/r/Sivu30/1)
 
-## 2.5 `(...)` 特征标群
-
-特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。例如, 表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b` 。再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。
-
+## 2.5 `(...)` 捕获组
 
+特征标群是一组写在 `(...)` 中的子模式。`(...)` 中包含的内容将会被看成一个整体，和数学中小括号（ ）的作用相同。
+例如，表达式 `(ab)*` 匹配连续出现 0 或更多个 `ab`。
+如果没有使用 `(...)` ，那么表达式 `ab*` 将匹配连续出现 0 或更多个 `b`。
+再比如之前说的 `{}` 是用来表示前面一个字符出现指定次数。
+但如果在 `{}` 前加上特征标群 `(...)` 则表示整个标群内的字符重复 N 次。
 我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(c|g|p)ar` 匹配 `car` 或 `gar` 或 `par`.
 
 <pre>
@@ -270,6 +272,22 @@
 
 [在线练习](https://regex101.com/r/tUxrBG/1)
 
+请注意，特征标群不仅会匹配，而且会捕获，可以在宿主语言中被引用。
+宿主语言可以是 Python 或 JavaScript 或几乎任何在函数定义中实现正则表达式的语言。
+
+### 2.5.1 非捕获组
+
+非捕获组匹配字符但不捕获该组。 一个非捕获组由在括号 `（...）` 内的一个 `?` 后跟一个 `:` 表示。 例如，正则表达式 `(?:c|g|p)ar` 和 `(c|g|p)ar` 类似，可以匹配相同的字符，但不会创建捕获组。
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[在线练习](https://regex101.com/r/Rm7Me8/1)
+
+非捕获组用于查找和替换功能，或与捕获组混合以在生成任何其他类型的输出的时候，不记录匹配的内容。
+可参考 [4. 零宽度断言(前后预查)](#4-零宽度断言前后预查)。
+
 ## 2.6 `|` 或运算符
 
 或运算符就表示或，用作判断条件。
@@ -282,11 +300,14 @@
 
 [在线练习](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 转码特殊字符
+## 2.7 转义特殊字符
 
-反斜线 `\` 在表达式中用于转码紧跟其后的字符。用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符。如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`。
+反斜线 `\` 在表达式中用于转义紧跟其后的字符。
+用于指定 `{ } [ ] / \ + * . $ ^ | ?` 这些特殊字符。
+如果想要匹配这些特殊字符则要在其前面加上反斜线 `\`。
 
-例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\.` 以下这个例子 `\.?`是选择性匹配`.`
+例如 `.` 是用来匹配除换行符外的所有字符的。如果想要匹配句子中的 `.` 则要写成 `\.`。
+以下这个例子 `\.?` 是选择性匹配 `.`。
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -302,7 +323,9 @@
 
 `^` 用来检查匹配的字符串是否在所匹配字符串的开头。
 
-例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。但如果使用 `^b` 将匹配不到任何结果。因为在字符串 `abc` 中并不是以 `b` 开头。
+例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。
+但如果使用 `^b` 将匹配不到任何结果。
+因为字符串 `abc` 并不是以 b 开头。
 
 例如，`^(T|t)he` 匹配以 `The` 或 `the` 开头的字符串。
 
@@ -373,7 +396,7 @@
 
 ### 4.1 `?=...` 正先行断言
 
-`?=...` 正先行断言，表示第一部分表达式之后必须跟着 `?=...`定义的表达式。
+`?=...` 正先行断言，表示第一部分表达式之后必须跟着 `?=...` 定义的表达式（正先行断言）。
 
 返回结果只包含满足匹配条件的第一部分表达式。
 定义一个正先行断言要使用 `()`。在括号内部使用一个问号和等号： `(?=...)`。
@@ -389,7 +412,7 @@
 
 ### 4.2 `?!...` 负先行断言
 
-负先行断言 `?!` 用于筛选所有匹配结果，筛选条件为 其后不跟随着断言中定义的格式。
+负先行断言 `?!` 用于筛选所有匹配结果，筛选条件为其后 不跟随着断言中定义的格式。
 `正先行断言`  定义和 `负先行断言` 一样，区别就是 `=` 替换成 `!` 也就是 `(?!...)`。
 
 表达式 `(T|t)he(?!\sfat)` 匹配 `The` 和 `the`，且其后不跟着 `(空格)fat`。
@@ -402,7 +425,7 @@
 
 ### 4.3 `?<= ...` 正后发断言
 
-正后发断言 记作`(?<=...)` 用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。
+正后发断言记作 `(?<=...)`，用于筛选所有匹配结果，筛选条件为 其前跟随着断言中定义的格式。
 例如，表达式 `(?<=(T|t)he\s)(fat|mat)` 匹配 `fat` 和 `mat`，且其前跟着 `The` 或 `the`。
 
 <pre>
@@ -413,7 +436,7 @@
 
 ### 4.4 `?<!...` 负后发断言
 
-负后发断言 记作 `(?<!...)` 用于筛选所有匹配结果，筛选条件为 其前不跟随着断言中定义的格式。
+负后发断言记作 `(?<!...)`，用于筛选所有匹配结果，筛选条件为 其前不跟随着断言中定义的格式。
 例如，表达式 `(?<!(T|t)he\s)(cat)` 匹配 `cat`，且其前不跟着 `The` 或 `the`。
 
 <pre>

From cc5f395184c8a77b4220448d97078dd228dcf124 Mon Sep 17 00:00:00 2001
From: Cygra <sjtuwbh@gmail.com>
Date: Wed, 4 May 2022 13:02:39 +0800
Subject: [PATCH 174/185] fix: spaces and period

---
 translations/README-cn.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index d98f3c9b..c8925d1d 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -243,7 +243,7 @@
 我们可以省略第二个参数。
 例如，`[0-9]{2,}` 匹配至少两位 0~9 的数字。
 如果逗号也省略掉则表示重复固定的次数。
-例如，`[0-9]{3}` 匹配3位数字
+例如，`[0-9]{3}` 匹配 3 位数字。
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.

From d9f1393d0eaaa338843b98a63f7013fde1e7cf0a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=9C=A8=E5=8D=97?= <442951562@qq.com>
Date: Fri, 8 Jul 2022 21:18:23 +0800
Subject: [PATCH 175/185] Correct a mistake in Chinese version

---
 translations/README-zh-simple.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/translations/README-zh-simple.md b/translations/README-zh-simple.md
index d8e0f60c..83b4d8ab 100644
--- a/translations/README-zh-simple.md
+++ b/translations/README-zh-simple.md
@@ -35,7 +35,7 @@
 ## 什么是正则表达式?
 
 [![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
- 
+
 > 正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子.
 
 
@@ -468,7 +468,7 @@
 
 像之前介绍的 `(^,$)` 用于检查格式是否是在待检测字符串的开头或结尾. 但我们如果想要它在每行的开头和结尾生效, 我们需要用到多行修饰符 `m`.
 
-例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟一个或多个 `.` 的字符串, 并返回全部结果.
+例如, 表达式 `/at(.)?$/gm` 表示在待检测字符串每行的末尾搜索 `at`后跟0个或1个 `.` 的字符串, 并返回全部结果.
 
 <pre>
 "/.at(.)?$/" => The fat

From e5058aee378c72356a84a792c941715b7235f620 Mon Sep 17 00:00:00 2001
From: Mari Adhari <74663874+mariadhari6@users.noreply.github.com>
Date: Sat, 13 Aug 2022 16:34:16 +0700
Subject: [PATCH 176/185] Create README-id.md

---
 translations/README-id.md | 604 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 604 insertions(+)
 create mode 100644 translations/README-id.md

diff --git a/translations/README-id.md b/translations/README-id.md
new file mode 100644
index 00000000..548aec16
--- /dev/null
+++ b/translations/README-id.md
@@ -0,0 +1,604 @@
+<p align="center">
+    <br/>
+    <a href="https://github.com/ziishaned/learn-regex">	
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    </a>
+</p>
+
+## Terjemahan:
+
+* [English](README.md)
+* [German](translations/README-de.md)
+* [Español](translations/README-es.md)
+* [Français](translations/README-fr.md)
+* [Português do Brasil](translations/README-pt_BR.md)
+* [中文版](translations/README-cn.md)
+* [日本語](translations/README-ja.md)
+* [한국어](translations/README-ko.md)
+* [Turkish](translations/README-tr.md)
+* [Greek](translations/README-gr.md)
+* [Magyar](translations/README-hu.md)
+* [Polish](translations/README-pl.md)
+* [Русский](translations/README-ru.md)
+* [Tiếng Việt](translations/README-vn.md)
+* [Bahasa Indonesia](translations/README-id.md)
+* [فارسی](translations/README-fa.md)
+* [עברית](translations/README-he.md)
+
+
+## Apa itu Ekspresi Reguler?
+
+<p>
+    <a href="https://gum.co/learn-regex">
+        <img src="https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a" alt="Download PDF">
+    </a>
+</p>
+
+> Ekspresi reguler adalah sekelompok karakter atau simbol yang digunakan untuk menemukan pola tertentu dalam sebuah teks.
+
+Ekspresi reguler adalah pola yang dicocokkan dengan string subjek dari
+kiri ke kanan. Ekspresi reguler digunakan untuk mengganti teks dalam string,
+memvalidasi formulir, mengekstrak substring dari string berdasarkan kecocokan pola,
+dan masih banyak lagi. Istilah "ekspresi reguler" adalah suap, jadi kamu biasanya akan
+temukan istilah yang disingkat "regex" atau "regexp". 
+
+Bayangkan Anda sedang menulis aplikasi dan Anda ingin menetapkan aturan kapan a
+pengguna memilih nama pengguna mereka. Kami ingin mengizinkan nama pengguna berisi huruf,
+angka, garis bawah, dan tanda hubung. Kami juga ingin membatasi jumlah karakter
+di username agar tidak terlihat jelek. Kita dapat menggunakan ekspresi reguler berikut untuk
+memvalidasi nama pengguna:
+
+<br/><br/>
+<p align="center">
+  <img src="./img/regexp-en.png" alt="Regular expression">
+</p>
+
+Ekspresi reguler di atas dapat menerima string `john_doe`, `jo-hn_doe` dan
+`john12_as`. Itu tidak cocok dengan `Jo` karena string itu berisi huruf besar
+surat dan juga terlalu pendek.
+
+## Table of Contents
+
+- [Pencocokan Dasar](#1-basic-matchers)
+- [Karakter Meta](#2-meta-characters)
+  - [Perhentian Penuh](#21-the-full-stop)
+  - [Set Karakter](#22-character-sets)
+    - [Set Karakter yang Dinegasikan](#221-negated-character-sets)
+  - [Pengulangan](#23-repetitions)
+    - [Tanda Bintang](#231-the-star)
+    - [Tanda Tambah](#232-the-plus)
+    - [Tanda Tanya](#233-the-question-mark)
+  - [Kurung Kurawal](#24-braces)
+  - [Menangkap Grup](#25-capturing-groups)
+      - [Grup yang Tidak Menangkap](#251-non-capturing-groups)
+  - [Alternasi](#26-alternation)
+  - [Karakter Spesial](#27-escaping-special-characters)
+  - [Anchor Text](#28-anchors)
+    - [Tanda Sisipan](#281-the-caret)
+    - [Tanda Dollar](#282-the-dollar-sign)
+- [Set Karakter Singkatan](#3-shorthand-character-sets)
+- [Melihat](#4-lookarounds)
+  - [Pandangan ke Depan Positif](#41-positive-lookahead)
+  - [Pandangan ke Depan Negatif](#42-negative-lookahead)
+  - [Pandangan Positif ke Belakang](#43-positive-lookbehind)
+  - [Pandangan negatif ke belakang](#44-negative-lookbehind)
+- [Bendera](#5-flags)
+  - [Tidak peka huruf besar/kecil](#51-case-insensitive)
+  - [Pencarian Global](#52-global-search)
+  - [Multiline](#53-multiline)
+- [Greedy vs Lazy Matching](#6-greedy-vs-lazy-matching)
+
+## 1. Pencocokan Dasar
+
+Ekspresi reguler hanyalah pola karakter yang kita gunakan untuk melakukan
+pencarian dalam sebuah teks. Misalnya, ekspresi reguler `the` berarti: huruf
+`t`, diikuti huruf `h`, diikuti huruf `e`.
+
+<pre>
+"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/dmRygT/1)
+
+Ekspresi reguler `123` cocok dengan string `123`. Ekspresi reguler adalah
+dicocokkan dengan string input dengan membandingkan setiap karakter di reguler
+ekspresi ke setiap karakter dalam string input, satu demi satu. Reguler
+ekspresi biasanya peka huruf besar/kecil sehingga ekspresi reguler `The` akan
+tidak cocok dengan string `the`.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/1paXsy/1)
+
+## 2. Karakter Meta
+
+Karakter meta adalah blok bangunan ekspresi reguler. Meta
+karakter tidak berdiri sendiri tetapi sebaliknya ditafsirkan dalam beberapa
+cara spesial. Beberapa karakter meta memiliki arti khusus dan tertulis di dalamnya
+tanda kurung siku. Karakter metanya adalah sebagai berikut:
+
+|Meta karakter|Deskripsi|
+|:----:|----|
+|.|Titik cocok dengan karakter tunggal apa pun kecuali jeda baris.|
+|[ ]|Kelas karakter. Mencocokkan karakter apa pun yang ada di antara tanda kurung siku.|
+|[^ ]|Kelas karakter yang dinegasikan. Cocok dengan karakter apa pun yang tidak ada di antara tanda kurung siku|
+|*|Mencocokkan dengan 0 atau lebih pengulangan dari simbol sebelumnya.|
+|+|Mencocokkan 1 atau lebih pengulangan dari simbol sebelumnya.|
+|?|Jadikan simbol sebelumnya opsional.|
+|{n,m}|Kurung Kurawal. Mencocokkan setidaknya "n" tetapi tidak lebih dari "m" pengulangan simbol sebelumnya.|
+|(xyz)|Kelompok karakter. Mencocokkan karakter xyz dalam urutan yang tepat.|
+|||Alternasi. Mencocokkan dengan karakter sebelum atau karakter setelah simbol.|
+|\|Meloloskan dari karakter berikutnya. Ini memungkinkan Anda untuk mencocokkan karakter yang dipesan <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|^|Mencocokkan dengan awal input.|
+|$|Mencocokkan dengan akhir input.|
+
+## 2.1 Perhentian Penuh
+
+Tanda titik `.` adalah contoh paling sederhana dari karakter meta. Karakter meta `.`
+cocok dengan karakter tunggal apa pun. Itu tidak akan cocok dengan karakter kembali atau baris baru.
+Misalnya, ekspresi reguler `.ar` berarti: karakter apa pun, diikuti oleh
+huruf `a`, diikuti dengan huruf `r`.
+
+<pre>
+".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/xc9GkU/1)
+
+## 2.2 Set Karakter
+
+Kumpulan karakter juga disebut kelas karakter. Tanda kurung siku digunakan untuk
+menentukan set karakter. Gunakan tanda hubung di dalam set karakter untuk menentukan
+jangkauan karakter. Urutan rentang karakter di dalam tanda kurung siku
+tidak masalah. Misalnya, ekspresi reguler `[Tt]he` berarti: huruf besar
+`T` atau huruf kecil `t`, diikuti huruf `h`, diikuti huruf `e`.
+
+<pre>
+"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/2ITLQ4/1)
+
+Sebuah periode di dalam set karakter, bagaimanapun, berarti periode literal. yang biasa
+ekspresi `ar[.]` berarti: karakter huruf kecil `a`, diikuti dengan huruf `r`,
+diikuti dengan karakter titik `.`.
+
+<pre>
+"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/wL3xtE/1)
+
+### 2.2.1 Set Karakter yang Dinegasikan
+
+Secara umum, simbol tanda sisipan mewakili awal string, tetapi ketika itu
+diketik setelah kurung siku pembuka itu meniadakan set karakter. Untuk
+contoh, ekspresi reguler `[^c]ar` berarti: karakter apa pun kecuali `c`,
+diikuti dengan karakter `a`, diikuti dengan huruf `r`.
+
+<pre>
+"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/nNNlq3/1)
+
+## 2.3 Pengulangan
+
+Karakter meta `+`, `*` atau `?` digunakan untuk menentukan berapa kali a
+subpola dapat terjadi. Karakter meta ini bertindak secara berbeda di berbagai
+situasi.
+
+### 2.3.1 Tanda Bintang
+
+Simbol `*` cocok dengan nol atau lebih pengulangan dari pencocokan sebelumnya. Itu
+ekspresi reguler `a*` berarti: nol atau lebih pengulangan dari huruf kecil sebelumnya
+karakter `a`. Tetapi jika itu muncul setelah set karakter atau kelas maka ia menemukan
+pengulangan seluruh set karakter. Misalnya, ekspresi reguler
+`[a-z]*` artinya: sejumlah huruf kecil dalam satu baris.
+
+<pre>
+"[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/7m8me5/1)
+
+Simbol `*` dapat digunakan dengan karakter meta `.` untuk mencocokkan string apa pun dari
+karakter `.*`. Simbol `*` dapat digunakan dengan karakter spasi putih `\s`
+untuk mencocokkan string karakter spasi. Misalnya, ungkapan
+`\s*cat\s*` artinya: nol spasi atau lebih, diikuti dengan huruf kecil `c`,
+diikuti dengan huruf kecil `a`, diikuti dengan huruf kecil `t`,
+diikuti oleh nol atau lebih spasi.
+
+<pre>
+"\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/gGrwuz/1)
+
+### 2.3.2 Tanda Tambah
+
+Simbol `+` cocok dengan satu atau lebih pengulangan karakter sebelumnya. Untuk
+contoh, ekspresi reguler `c.+t` berarti: huruf kecil `c`, diikuti oleh
+setidaknya satu karakter, diikuti dengan huruf kecil `t`. Itu perlu
+mengklarifikasi bahwa `t` adalah `t` terakhir dalam kalimat.
+
+<pre>
+"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/Dzf9Aa/1)
+
+### 2.3.3 Tanda Tanya
+
+Dalam ekspresi reguler, karakter meta `?` membuat karakter sebelumnya
+opsional. Simbol ini cocok dengan nol atau satu contoh karakter sebelumnya.
+Misalnya, ekspresi reguler `[T]?he` artinya: Huruf besar opsional
+`T`, diikuti dengan huruf kecil `h`, diikuti dengan huruf kecil `e`.
+
+<pre>
+"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/cIg9zm/1)
+
+<pre>
+"[T]?he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in t<a href="#learn-regex"><strong>he</strong></a> garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/kPpO2x/1)
+
+## 2.4 Braces
+
+Dalam ekspresi reguler, kurung kurawal (juga disebut quantifier) ​​digunakan untuk
+tentukan berapa kali karakter atau sekelompok karakter dapat
+ulang. Misalnya, ekspresi reguler `[0-9]{2,3}` berarti: Setidaknya cocok
+2 digit, tetapi tidak lebih dari 3, mulai dari 0 hingga 9.
+
+<pre>
+"[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/juM86s/1)
+
+Kita bisa meninggalkan nomor kedua. Misalnya, ekspresi reguler
+`[0-9]{2,}` berarti: Mencocokkan 2 digit atau lebih. Jika kita juga menghapus koma,
+ekspresi reguler `[0-9]{3}` berarti: Sama persis dengan 3 digit.
+
+<pre>
+"[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/Gdy4w5/1)
+
+<pre>
+"[0-9]{3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to 10.0.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Sivu30/1)
+
+## 2.5 Menangkap Grup
+
+Grup penangkap adalah grup subpola yang ditulis di dalam tanda kurung
+`(...)`. Seperti yang dibahas sebelumnya, dalam ekspresi reguler, jika kita menempatkan quantifier
+setelah karakter maka akan mengulangi karakter sebelumnya. Tetapi jika kita menempatkan quantifier
+setelah grup penangkap kemudian mengulangi seluruh grup penangkap. Sebagai contoh,
+ekspresi reguler `(ab)*` cocok dengan nol atau lebih pengulangan karakter
+"ab". Kita juga dapat menggunakan karakter meta `|` bergantian di dalam grup penangkap.
+Misalnya, ekspresi reguler `(c|g|p)ar` berarti: huruf kecil `c`,
+`g` atau `p`, diikuti oleh `a`, diikuti oleh `r`.
+
+<pre>
+"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/tUxrBG/1)
+
+Perhatikan bahwa menangkap grup tidak hanya cocok, tetapi juga menangkap, karakter untuk digunakan dalam
+bahasa induk. Bahasa induk bisa berupa Python atau JavaScript atau hampir semua
+bahasa yang mengimplementasikan ekspresi reguler dalam definisi fungsi.
+
+### 2.5.1 Grup yang Tidak Menangkap
+
+Grup yang tidak menangkap adalah grup yang cocok dengan karakter tetapi
+tidak menangkap kelompok. Grup yang tidak menangkap dilambangkan dengan `?` diikuti oleh `:`
+dalam tanda kurung `(...)`. Misalnya, ekspresi reguler `(?:c|g|p)ar` mirip dengan
+`(c|g|p)ar` karena cocok dengan karakter yang sama tetapi tidak akan membuat grup tangkapan.
+
+<pre>
+"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/Rm7Me8/1)
+
+Grup yang tidak menangkap dapat berguna saat digunakan dalam fungsi temukan-dan-ganti atau
+ketika dicampur dengan grup penangkap untuk menjaga gambaran umum saat memproduksi jenis keluaran lainnya.
+Lihat juga [4. Melihat-lihat](#4-lookaround).
+
+## 2.6 Alternasi
+
+Dalam ekspresi reguler, bilah vertikal `|` digunakan untuk mendefinisikan pergantian.
+Pergantian seperti pernyataan OR antara beberapa ekspresi. Sekarang, Anda mungkin
+berpikir bahwa set karakter dan pergantian bekerja dengan cara yang sama. Tapi yang besar
+perbedaan antara set karakter dan pergantian adalah bahwa set karakter bekerja di
+tingkat karakter tetapi pergantian bekerja pada tingkat ekspresi. Misalnya,
+ekspresi reguler `(T|t)he|car` berarti: baik (huruf besar `T` atau huruf kecil
+`t`, diikuti dengan huruf kecil `h`, diikuti dengan huruf kecil `e`) ATAU
+(huruf kecil `c`, diikuti dengan huruf kecil `a`, diikuti oleh
+huruf kecil `r`). Perhatikan bahwa saya menyertakan tanda kurung untuk kejelasan, untuk menunjukkan bahwa salah satu ekspresi
+dalam tanda kurung dapat dipenuhi dan itu akan cocok.
+
+<pre>
+"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/fBXyX0/1)
+
+## 2.7 Karakter Spesial
+
+Garis miring terbalik `\` digunakan dalam ekspresi reguler untuk keluar dari karakter berikutnya. Ini
+memungkinkan kita untuk menyertakan karakter yang dicadangkan seperti `{ } [ ] / \ + * . $ ^ | ?` sebagai karakter yang cocok. Untuk menggunakan salah satu karakter khusus ini sebagai karakter yang cocok, awali dengan `\`.
+
+Misalnya, ekspresi reguler `.` digunakan untuk mencocokkan karakter apa pun kecuali a
+garis baru. Sekarang, untuk mencocokkan `.` dalam string input, ekspresi reguler
+`(f|c|m)at\.?` artinya: huruf kecil `f`, `c` atau `m`, diikuti dengan huruf kecil
+`a`, diikuti dengan huruf kecil `t`, diikuti dengan `.` . opsional
+karakter.
+
+<pre>
+"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Test the regular expression](https://regex101.com/r/DOc5Nu/1)
+
+## 2.8 Anchor Text
+
+Dalam ekspresi reguler, kami menggunakan jangkar untuk memeriksa apakah simbol yang cocok adalah
+simbol awal atau simbol akhir dari string input. Jangkar terdiri dari dua jenis:
+Tipe pertama adalah tanda sisipan `^` yang memeriksa apakah karakter yang cocok adalah yang pertama
+karakter input dan tipe kedua adalah tanda dolar `$` yang memeriksa apakah cocok
+karakter adalah karakter terakhir dari string input.
+
+### 2.8.1 Tanda Sisipan
+
+Simbol tanda sisipan `^` digunakan untuk memeriksa apakah karakter yang cocok adalah karakter pertama
+dari string masukan. Jika kita menerapkan ekspresi reguler berikut `^a` (artinya 'a' harus
+karakter awal) ke string `abc`, itu akan cocok dengan `a`. Tapi jika kita melamar
+ekspresi reguler `^b` ke string di atas, itu tidak akan cocok dengan apa pun.
+Karena dalam string `abc`, "b" bukanlah karakter awal. Mari lihat
+di ekspresi reguler lain `^(T|t)he` yang artinya: huruf besar `T` atau
+huruf kecil `t` harus menjadi karakter pertama dalam string, diikuti oleh a
+huruf kecil `h`, diikuti dengan huruf kecil `e`.
+
+<pre>
+"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/5ljjgB/1)
+
+<pre>
+"^(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/jXrKne/1)
+
+### 2.8.2 Tanda Dolar
+
+Tanda dolar `$` digunakan untuk memeriksa apakah karakter yang cocok adalah karakter terakhir
+dalam tali. Misalnya, ekspresi reguler `(at\.)$` berarti: a
+huruf kecil `a`, diikuti dengan huruf kecil `t`, diikuti oleh `.`
+karakter dan matcher harus berada di akhir string.
+
+<pre>
+"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/y4Au4D/1)
+
+<pre>
+"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/t0AkOd/1)
+
+##  3. Set Karakter Singkatan
+
+Ada sejumlah singkatan yang mudah digunakan untuk set karakter yang umum digunakan/
+ekspresi reguler:
+
+|Singkatan|Deskripsi|
+|:----:|----|
+|.|Karakter apa pun kecuali baris baru|
+|\w|Mencocokkan karakter alfanumerik: `[a-zA-Z0-9_]`|
+|\W|Mencocokkan karakter non-alfanumerik: `[^\w]`|
+|\d|Mencocokkan digit: `[0-9]`|
+|\D|Mencocokkan non-digit: `[^\d]`|
+|\s|Mencocokkan karakter spasi putih: `[\t\n\f\r\p{Z}]`|
+|\S|Mencocokkan karakter non-spasi: `[^\s]`|
+
+## 4. Melihat-lihat
+
+Melihat ke belakang dan melihat ke depan (juga disebut melihat sekeliling) adalah jenis tertentu dari
+***grup non-penangkapan*** (digunakan untuk mencocokkan pola tetapi tanpa menyertakannya dalam pencocokan
+daftar). Lookarounds digunakan ketika sebuah pola harus
+didahului atau diikuti oleh pola lain. Misalnya, bayangkan kita ingin mendapatkan semua
+angka yang didahului oleh karakter `$` dari string
+`$4,44 dan $10,88`. Kami akan menggunakan ekspresi reguler berikut `(?<=\$)[0-9\.]*`
+yang artinya: dapatkan semua angka yang mengandung karakter `.` dan didahului
+oleh karakter `$`. Ini adalah lookaround yang biasa digunakan
+ekspresi:
+
+|Simbol|Deskripsi|
+|:----:|----|
+|?=|Pandangan ke Depan Positif|
+|?!|Melihat ke Depan Negatif|
+|?<=|Tampilan Positif di Belakang|
+|?<!|Tampilan Negatif di Belakang|
+
+### 4.1 Pandangan ke Depan Positif
+
+Pandangan ke depan positif menegaskan bahwa bagian pertama dari ekspresi harus
+diikuti oleh ekspresi lookahead. Pertandingan yang dikembalikan hanya berisi teks
+yang dicocokkan dengan bagian pertama dari ekspresi. Untuk mendefinisikan positif
+lookahead, tanda kurung digunakan. Di dalam tanda kurung itu, tanda tanya dengan
+tanda sama dengan digunakan seperti ini: `(?=...)`. Ekspresi lookahead ditulis setelah
+tanda sama dengan di dalam kurung. Misalnya, ekspresi reguler
+`(T|t)he(?=\sfat)` artinya: cocok dengan huruf kecil `t` atau huruf besar
+ `T`, diikuti huruf `h`, diikuti huruf `e`. Dalam tanda kurung kita
+mendefinisikan lookahead positif yang memberitahu mesin ekspresi reguler untuk mencocokkan `The`
+atau `the` hanya jika diikuti oleh kata `fat`.
+
+<pre>
+"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/IDDARt/1)
+
+### 4.2 Pandangan ke Depan Negatif
+
+Pandangan negatif ke depan digunakan ketika kita perlu mendapatkan semua kecocokan dari string input
+yang tidak mengikuti pola tertentu. Sebuah lookahead negatif ditulis dengan cara yang sama seperti a
+pandangan positif ke depan. Satu-satunya perbedaan adalah, alih-alih tanda sama dengan `=`, kami
+gunakan tanda seru `!` untuk menunjukkan negasi yaitu `(?!...)`. Yuk simak berikut ini
+ekspresi reguler `(T|t)he(?!\sfat)` yang artinya: dapatkan semua kata `The` atau `the`
+dari string input yang tidak diikuti oleh karakter spasi dan kata `fat`.
+
+<pre>
+"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/V32Npg/1)
+
+### 4.3 Pandangan Positif ke Belakang
+
+Positif melihat ke belakang digunakan untuk mendapatkan semua kecocokan yang didahului oleh a
+pola tertentu. Positif lookbehinds ditulis `(?<=...)`. Misalnya,
+ekspresi reguler `(?<=(T|t)he\s)(fat|mat)` artinya: dapatkan semua kata `fat` atau `mat`
+dari string input yang datang setelah kata `The` atau `the`.
+
+<pre>
+"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/avH165/1)
+
+### 4.4 Pandangan negatif ke belakang
+
+Pandangan belakang negatif digunakan untuk mendapatkan semua kecocokan yang tidak didahului oleh a
+pola tertentu. Tampilan negatif di belakang ditulis `(?<!...)`. Misalnya,
+ekspresi reguler `(?<!(T|t)he\s)(cat)` artinya: dapatkan semua kata `cat` dari input
+string yang tidak setelah kata `The` atau `the`.
+
+<pre>
+"(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
+</pre>
+
+[Test the regular expression](https://regex101.com/r/8Efx5G/1)
+
+## 5. Bendera
+
+Bendera juga disebut pengubah karena mereka memodifikasi output dari regular
+ekspresi. Bendera ini dapat digunakan dalam urutan atau kombinasi apa pun, dan merupakan
+bagian integral dari RegExp.
+
+|Bendera|Deskripsi|
+|:----:|----|
+|i|Tidak peka huruf besar/kecil: Pencocokan tidak peka huruf besar/kecil.|
+|g|Penelusuran Global: Cocokkan semua instance, bukan hanya yang pertama.|
+|m|Multiline: Karakter meta jangkar bekerja di setiap baris.|
+
+### 5.1 Tidak peka huruf besar/kecil
+
+Pengubah `i` digunakan untuk melakukan pencocokan case-insensitive. Misalnya,
+ekspresi reguler `/The/gi` berarti: huruf besar `T`, diikuti dengan huruf kecil
+`h`, diikuti oleh `e`. Dan di akhir ekspresi reguler
+flag `i` memberitahu mesin ekspresi reguler untuk mengabaikan kasus ini. Sebisa kamu
+lihat, kami juga menyediakan flag `g` karena kami ingin mencari pola di
+seluruh string masukan.
+
+<pre>
+"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/dpQyf9/1)
+
+<pre>
+"/The/gi" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/ahfiuh/1)
+
+### 5.2 Pencarian Global
+
+Pengubah `g` digunakan untuk melakukan kecocokan global (menemukan semua kecocokan daripada
+berhenti setelah pertandingan pertama). Misalnya, ekspresi reguler`/.(at)/g`
+berarti: karakter apa pun kecuali baris baru, diikuti dengan huruf kecil `a`,
+diikuti dengan huruf kecil `t`. Karena kami menyediakan flag `g` di akhir
+ekspresi reguler, sekarang akan menemukan semua kecocokan dalam string input, bukan hanya yang pertama (yang merupakan perilaku default).
+
+<pre>
+"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/jnk6gM/1)
+
+<pre>
+"/.(at)/g" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> <a href="#learn-regex"><strong>sat</strong></a> on the <a href="#learn-regex"><strong>mat</strong></a>.
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/dO1nef/1)
+
+### 5.3 Multiline
+
+Pengubah `m` digunakan untuk melakukan pencocokan multi-baris. Seperti yang telah kita bahas sebelumnya,
+jangkar `(^, $)` digunakan untuk memeriksa apakah suatu pola ada di awal input atau
+tamat. Tetapi jika kita ingin jangkar bekerja pada setiap baris, kita menggunakan
+bendera `m`. Misalnya, ekspresi reguler `/at(.)?$/gm` berarti: huruf kecil
+`a`, diikuti dengan huruf kecil `t` dan, opsional, apa pun kecuali
+baris baru. Dan karena flag `m`, mesin ekspresi reguler sekarang cocok dengan pola
+di akhir setiap baris dalam sebuah string.
+
+<pre>
+"/.at(.)?$/" => The fat
+                cat sat
+                on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/hoGMkP/1)
+
+<pre>
+"/.at(.)?$/gm" => The <a href="#learn-regex"><strong>fat</strong></a>
+                  cat <a href="#learn-regex"><strong>sat</strong></a>
+                  on the <a href="#learn-regex"><strong>mat.</strong></a>
+</pre>
+
+[Uji ekspresi reguler](https://regex101.com/r/E88WE2/1)
+
+## 6. Greedy vs Lazy Matching
+Secara default, regex akan melakukan kecocokan greedy, yang berarti kecocokan akan berlangsung selama
+mungkin. Kita dapat menggunakan `?` untuk mencocokkan dengan cara yang lazy, yang berarti pencocokan harus sesingkat mungkin.
+
+<pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+
+
+[Uji ekspresi reguler](https://regex101.com/r/AyAdgJ/1)
+
+<pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+
+
+[Uji ekspresi reguler](https://regex101.com/r/AyAdgJ/2)
+
+
+## Kontribusi
+
+* Buka pull request dengan peningkatan
+* Diskusikan ide dalam issue
+* Sebarkan materinya
+* Jangkau dengan umpan balik apa pun [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+
+## Lisensi
+
+MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)

From 881a4bd4f17bbecbe66d5b2a5ab94802a23ec891 Mon Sep 17 00:00:00 2001
From: Mari Adhari <74663874+mariadhari6@users.noreply.github.com>
Date: Sat, 13 Aug 2022 16:38:26 +0700
Subject: [PATCH 177/185] update: add indonesian translation

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 9c1c4b2e..e60496fd 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@
 * [Polish](translations/README-pl.md)
 * [Русский](translations/README-ru.md)
 * [Tiếng Việt](translations/README-vn.md)
+* [Bahasa Indonesia](translations/README-id.md)
 * [فارسی](translations/README-fa.md)
 * [עברית](translations/README-he.md)
 

From 172a004d4643d67f40702ad55c701acfed467aba Mon Sep 17 00:00:00 2001
From: Mari Adhari <74663874+mariadhari6@users.noreply.github.com>
Date: Sat, 13 Aug 2022 16:49:57 +0700
Subject: [PATCH 178/185] add: indonesian image translation

---
 img/regexp-id.png | Bin 0 -> 7470 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 img/regexp-id.png

diff --git a/img/regexp-id.png b/img/regexp-id.png
new file mode 100644
index 0000000000000000000000000000000000000000..9a93f87cda2e234dcaa3caaee457b8f57064b6a2
GIT binary patch
literal 7470
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

literal 0
HcmV?d00001


From 8518c43af4721383eba9ae3c4aa00606af24c5a2 Mon Sep 17 00:00:00 2001
From: AHOHNMYC <24810600+AHOHNMYC@users.noreply.github.com>
Date: Fri, 21 Oct 2022 06:39:52 +0300
Subject: [PATCH 179/185] Russian language update

Corrected some grammar and serious logical and factual mistakes.
Updated header and footer, translated shields.
---
 translations/README-ru.md | 405 +++++++++++++++++++++-----------------
 1 file changed, 219 insertions(+), 186 deletions(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index 8cfe2c3e..10767210 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -1,22 +1,14 @@
 <p align="center">
     <br/>
-    <a href="https://github.com/ziishaned/learn-regex">
-        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Learn Regex">
+    <a href="https://github.com/ziishaned/learn-regex">	
+        <img src="https://i.imgur.com/bYwl7Vf.png" alt="Учим регулярки">
     </a>
-    <br /><br />
-    <p>
-        <a href="https://twitter.com/ziishaned">
-            <img src="https://img.shields.io/twitter/follow/ziishaned.svg?style=social" />
-        </a>
-        <a href="https://github.com/ziishaned">
-            <img src="https://img.shields.io/github/followers/ziishaned.svg?label=Follow%20%40ziishaned&style=social" />
-        </a>
-    </p>
 </p>
 
-## Translations:
+## Переводы:
 
 * [English](../README.md)
+* [German](translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -32,28 +24,34 @@
 * [فارسی](../translations/README-fa.md)
 * [עברית](translations/README-he.md)
 
+
 ## Что такое Регулярное выражение?
 
-[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
+[![](https://img.shields.io/badge/Загрузить%20PDF-0a0a0a.svg)](https://gum.co/learn-regex)
 
-> Регулярное выражение - это группа букв или символов, которая используется для поиска определенного шаблона в тексте.
+> Регулярное выражение — это группа букв или символов, которая используется для поиска определенного шаблона в тексте.
 
-Регулярное выражение - это шаблон, сопоставляемый с искомой строкой слева направо.
-Термин «Регулярное выражение» сложно произносить каждый раз, поэтому, обычно, вы будете сталкиваться с сокращениями "регэкспы" или "регулярки".
+Регулярное выражение — это шаблон, сопоставляемый с искомой строкой слева
+направо. Термин "Регулярное выражение" сложно произносить каждый раз, поэтому,
+обычно, вы будете сталкиваться с сокращениями "регэкспы" или "регулярки".
 Регулярные выражения используются для замен текста внутри строк, валидации форм,
 извлечений подстрок по определенным шаблонам и множества других вещей.
 
-Представьте, что вы пишете приложение и хотите установить правила, по которым пользователь выбирает свой юзернейм. Мы хотим, чтобы имя пользователя содержало буквы, цифры, подчеркивания и дефисы. Мы также хотим ограничить количество символов в имени пользователя, чтобы оно не выглядело безобразно.
-Для этого, используем следующее регулярное выражение:
+Представьте, что вы пишете приложение и хотите установить правила, по которым
+пользователь выбирает свой юзернейм. Мы хотим, чтобы имя пользователя содержало
+буквы, цифры, подчеркивания и дефисы. Мы также хотим ограничить количество
+символов в имени пользователя, чтобы оно не выглядело безобразно. Для этого
+используем следующее регулярное выражение:
 
 
-<br/><br/>
+<br/>
 <p align="center">
-  <img src="../img/regexp-ru.png" alt="Regular expression">
+  <img src="../img/regexp-ru.png" alt="Регулярное выражение">
 </p>
 
-Регулярное выражения выше может принимать строки `john_doe`,`jo-hn_doe` и `john12_as`.
-Оно не валидирует `Jo`, поскольку эта строка содержит заглавные буквы, а также она слишком короткая.
+Регулярное выражения выше может принимать строки `john_doe`,`jo-hn_doe` и
+`john12_as`. Оно не валидирует `Jo`, поскольку эта строка содержит заглавные
+буквы, а также она слишком короткая.
 
 ## Содержание
 
@@ -68,8 +66,8 @@
     - [Знак вопроса](#233-знак-вопроса)
   - [Фигурные скобки](#24-фигурные-скобки)
   - [Скобочные группы](#25-скобочные-группы)
-  - [Альтернация](#26-альтернация)
-  - [Экранирование](#27-экранирование)
+  - [Перечисление](#26-перечисление)
+  - [Экранирование спецсимволов](#27-экранирование-спецсимволов)
   - [Якоря](#28-якоря)
     - [Каретка](#281-каретка)
     - [Доллар](#282-доллар)
@@ -83,12 +81,13 @@
   - [Поиск без учета регистра](#51-поиск-без-учета-регистра)
   - [Глобальный поиск](#52-глобальный-поиск)
   - [Мультистроковый поиск](#53-мультистроковый-поиск)
-- [Жадные vs ленивые квантификаторы](#6-жадные-vs-ленивые-квантификаторы)
+- [Жадная и ленивая квантификация](#6-жадная-и-ленивая-квантификация)
 
 ## 1. Совпадения.
 
-В сущности, регулярное выражение - это просто набор символов, который мы используем для поиска в тексте.
-Например, регулярное выражение `the` состоит из буквы `t`, за которой следует буква `h`, за которой следует буква `e`.
+В сущности, регулярное выражение — это просто набор символов, который мы
+используем для поиска в тексте. Например, регулярное выражение `the` состоит из
+буквы `t`, за которой следует буква `h`, за которой следует буква `e`.
 
 <pre>
 "the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -96,9 +95,11 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/dmRygT/1)
 
-Регулярное выражение `123` соответствует строке `123`. Регулярное выражение сопоставляется с входной строкой, сравнивая
-каждый символ в регулярном выражении с каждым символом во входной строке по одному символу за другим. Регулярные выражения
-обычно чувствительны к регистру, поэтому регулярное выражение `The` не будет соответствовать строке `the`.
+Регулярное выражение `123` соответствует строке `123`. Регулярное выражение
+сопоставляется с входной строкой посимвольно. Каждый символ в регулярном
+выражении сравнивается с каждым символом во входной строке, один символ за
+другим. Регулярные выражения обычно чувствительны к регистру, поэтому регулярное
+выражение `The` не будет соответствовать строке `the`.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -108,30 +109,32 @@
 
 ## 2. Метасимволы
 
-Метасимволы это блоки, из которых строятся регулярные выражения. Метасимволы не означают что-то сами по себе,
-вместо этого они интерпретируются для распознавания специальных групп символов. Некоторые метасимволы имеют
-особые обозначения и пишутся в квадратных скобках. Существуют следующие метасимволы:
+Метасимволы — это строительные блоки для регулярных выражений. Метасимволы не
+ищутся в строке как есть, они интерпретируются особым образом. Некоторые
+метасимволы имеют особое значение и пишутся в квадратных скобках. Существуют
+следующие метасимволы:
 
-|Метасимволы|Описание|
+|Метасимвол|Описание|
 |:----:|----|
-|.|Точка соответствует любому отдельному символу, кроме разрыва строки.|
-|[ ]|Класс символов. Находить любые символы заключенные в квадратных скобках.|
-|[^ ]|Отрицание класа символов. Находить любые символы не заключенные в квадратных скобках.|
-|*|Находить 0 или более повторений предыдущего символа.|
-|+|Находить 1 или более повторений предыдущего символа.|
-|?|Сделать предыдущий символ необязательным.|
-|{n,m}|Скобки. Находить по крайней мере "n" но не более чем "m" повторений предыдущего символа.|
-|(xyz)|Группа символов. Находить только символы xyz в указанном порядке.|
-|||Чередование. Находить либо буквы до, либо буквы после символа.|
-|\|Экранирование. Позволяет находить зарезервированные символы: <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
+|.|Точка соответствует любому отдельному символу, кроме перевода строки.|
+|[ ]|Класс символов. Заменяет любой из символов, заключенных в квадратных скобках.|
+|[^ ]|Отрицание класа символов. Соответствует любом символу, не содержащемуся в квадратных скобках.|
+|\*|Искать 0 или более повторов предыдущего символа.|
+|+|Искать 1 или более повторов предыдущего символа.|
+|?|Делает предыдущий символ необязательным.|
+|{n,m}|Скобки. Искать не менее "n" и не более "m" повторов предыдущего символа.|
+|(xyz)|Группа символов. Искать только символы xyz в указанном порядке.|
+|||Чередование. Искать либо знаки до этого символа, либо знаки после символа.|
+|\|Экранирование следующего символа. Позволяет искать специальные знаки: <code>[ ] ( ) { } . * + ? ^ $ \ |</code>|
 |^|Обозначает начало пользовательского ввода.|
 |$|Обозначает конец пользовательского ввода.|
 
 ## 2.1 Точка
 
-Точка `.` это простейший пример метасимвола. Метасимвол `.`
-находит любой отдельный символ. Точка не будет находить символы перехода или перевода строки.
-Например, регулярное выражение `.ar` обозначает: любой символ, за которым следуют буквы `a` и `r`.
+Точка `.` — это простейший пример метасимвола. Метасимвол `.`
+находит любой отдельный символ. Точка не будет находить символы возврата каретки
+(CR) или перевода строки (LF). Например, регулярное выражение `.ar` обозначает
+"любой символ, за которым следуют буквы `a` и `r`".
 
 <pre>
 ".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -141,10 +144,11 @@
 
 ## 2.2 Набор символов.
 
-Набор символов также называется классом символов. Квадратные скобки используются
-для определения набора символов. Дефис используется для указания диапазона символов.
-Порядок следования символов, заданный в квадратных скобках, не важен. Например,
-регулярное выражение `[Tt]he` обозначает заглавную `T` или строчную `t`, за которой следуют буквы `h` и `e`.
+Набор символов, также называется классом символов. Для определения набора
+символов используются квадратные скобки. Дефис используется для указания
+диапазона символов. Порядок следования символов, заданный в квадратных скобках,
+не важен. Например, регулярное выражение `[Tt]he` интерпретируется как
+"заглавная `T` или строчная `t`, за которой следуют буквы `h` и `e`".
 
 <pre>
 "[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -152,8 +156,9 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/2ITLQ4/1)
 
-Точка внутри набора символов, однако, обозначает непосредственно точку, как символ.
-Регулярное выражение `ar[.]` обозначает строчную `a`, за которой следует `r`, за которой следует `.` (символ точки).
+Точка внутри набора символов, внезапно, обозначает непосредственно точку как
+символ. Регулярное выражение `ar[.]` обозначает строчную `a`, за которой следует
+`r`, за которой следует `.` (символ точки).
 
 <pre>
 "ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
@@ -163,8 +168,9 @@
 
 ### 2.2.1 Отрицание набора символов
 
-Знак вставки `^` обозначает начало строки, однако, когда вы вписываете его после открытия квадратных скобок, он отрицает набор символов.
-Например, регулярное выражение `[^c]ar` обозначает любой символ, кроме `c`, за которым следуют буквы `a` и `r`.
+Карет `^` обозначает начало строки, но если вы поставите его после открывающей
+квадратной скобки, он инвертирует набор символов. Например, регулярное выражение
+`[^c]ar` обозначает "любой символ, кроме `c`, за которым следуют буквы `a` и `r`".
 
 <pre>
 "[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -174,16 +180,16 @@
 
 ## 2.3 Повторения
 
-Символы `+`, `*` или `?` используются для обозначения того сколько раз появляется какой-либо подшаблон.
-Данные метасимволы могут вести себя по-разному, в зависимости от ситуации.
+Символы `+`, `*` и `?` используются для обозначения того, сколько раз появляется
+символ перед ними. Эти метасимволы ведут себя в разных ситуациях по-разному.
 
 ### 2.3.1 Звёздочка
 
-Символ `*` обозначает ноль или более повторений предыдущего совпадения.
-Регулярное выражение `a*` означает ноль или более повторений предыдущего
-строчного символа `a`. Если же символ появляется после набора или класса символов,
-он находит повторения всего набора символов. Например, регулярное выражение `[a-z]*`
-означает любое количество строчных букв в строке.
+Символ `*` обозначает ноль или более повторений предыдущего символа. Регулярное
+выражение `a*` толкуется как "ноль или более повторений предыдущего строчного
+символа `a`". Если же символ появляется после набора или класса символов, он
+ищет повторения всего набора символов. Например, регулярное выражение `[a-z]*`
+означает "любое количество строчных букв".
 
 <pre>
 "[a-z]*" => T<a href="#learn-regex"><strong>he</strong></a> <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>parked</strong></a> <a href="#learn-regex"><strong>in</strong></a> <a href="#learn-regex"><strong>the</strong></a> <a href="#learn-regex"><strong>garage</strong></a> #21.
@@ -191,11 +197,12 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/7m8me5/1)
 
-Символы можно комбинировать, так, например, символ `*` может использоваться с метасимволом `.`
-для поиска одной строки с произвольным содержанием `.*`. Символ `*` может использоваться
-с символом пробела `\s`, чтобы находить строки с символами пробела. Например, выражение
-`\s*cat\s*` означает: ноль или более пробелов, за которыми следует слово `cat`,
-за которым следует ноль или более символов пробела.
+Символы можно комбинировать. Например, метасимвол `*` может использоваться с
+метасимволом `.` для поиска строки с произвольным содержанием: `.*`. Символ `*`
+может использоваться с символом пробела `\s`, чтобы искать строки с символами
+пробела. Например, выражение `\s*cat\s*` означает: "ноль или более пробелов, за
+которыми следует слово `cat`, за которым следует ноль или более символов
+пробела".
 
 <pre>
 "\s*cat\s*" => The fat<a href="#learn-regex"><strong> cat </strong></a>sat on the con<a href="#learn-regex"><strong>cat</strong></a>enation.
@@ -205,9 +212,11 @@
 
 ### 2.3.2 Плюс
 
-Символ `+` соответствует одному или более повторению предыдущего символа. Например,
-регулярное выражение `c.+t` означает строчную `c`, за которой следует по крайней мере один символ,
-следом за которым идёт символ `t`. Стоит уточнить, что в данном шаблоне, `t` является последним `t` в предложении.
+Символ `+` соответствует одному или более повторению предыдущего символа.
+Например, регулярное выражение `c.+t` интерпретируется так: "строчная `c`, за
+которой следует по крайней мере один любой символ, следом за которым(и) идёт
+символ `t`. Стоит уточнить, что в данном шаблоне, `t` является последним `t` в
+строке.
 
 <pre>
 "c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
@@ -218,8 +227,9 @@
 ### 2.3.3 Знак вопроса
 
 В регулярном выражении метасимвол `?` делает предыдущий символ необязательным.
-Этот символ соответствует нулю или одному экземпляру предыдущего символа.
-Например, регулярное выражение `[T]?he` означает необязательную заглавную букву `T`, за которой следуют символы `h` и `e`.
+Этот символ соответствует нулю или одному вхождению предыдущего символа.
+Например, регулярное выражение `[T]?he` означает: "необязательная заглавная
+буква `T`, за которой следуют символы `h` и `e`".
 
 <pre>
 "[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
@@ -236,8 +246,8 @@
 ## 2.4 Фигурные скобки
 
 В фигурных скобках, которые также называются квантификаторами, указывается,
-сколько раз символ или группа символов могут повторяться. Например, регулярное выражение
-`[0-9]{2,3}` означает совпадение не менее 2 но не более 3 цифр в диапазоне от 0 до 9.
+сколько раз символ или группа символов могут повторяться. Например, регулярное
+выражение `[0-9]{2,3}` означает: "от 2 до 3 цифр в диапазоне от 0 до 9.
 
 <pre>
 "[0-9]{2,3}" => The number was 9.<a href="#learn-regex"><strong>999</strong></a>7 but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -245,9 +255,9 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/juM86s/1)
 
-Уберём второй номер (цифру 3), тогда, регулярное выражение `[0-9]{2,}` будет означать
-совпадение 2 или более цифр. Если мы также удалим запятую, то регулярное выражение
-`[0-9]{3}` будет означать совпадение точно с 3 цифрами.
+Мы можем опустить второе число (цифру 3), тогда регулярное выражение `[0-9]{2,}`
+будет значить "2 или более цифр". А если мы удалим запятую, регулярное выражение
+`[0-9]{3}` будет искать ровно 3 цифры.
 
 <pre>
 "[0-9]{2,}" => The number was 9.<a href="#learn-regex"><strong>9997</strong></a> but we rounded it off to <a href="#learn-regex"><strong>10</strong></a>.0.
@@ -263,13 +273,14 @@
 
 ## 2.5 Скобочные группы
 
-Скобочные группы это группы подшаблонов, которые написаны в круглых скобках
-`(...)`. Как мы уже говорили ранее в регулярном выражении, если мы поставим квантификатор
-после символа, он будет повторять предыдущий символ. Но если мы поставим квантификатор после
-скобочной группы, он будет искать всю группу. Например, регулярное выражение `(ab)*` соответствует
-нулю или более повторений символа "ab". Мы также можем использовать метасимвол чередования `|`
-внутри скобочной группы. Например, регулярное выражение `(c|g|p)ar` означает поиск одной из строчных букв `c`,
-`g` или `p`, за которыми следуют буквы `a` и `r`.
+Скобочные группы — это группы подшаблонов, которые написаны в круглых скобках
+`(...)`. Как мы уже говорили ранее, в регулярном выражении, квантификатор после
+символа, ищет повторы символа перед квантификатором. Если мы поставим
+квантификатор после скобочной группы, он будет искать повторы всей группы. К
+примеру, регулярное выражение `(ab)*` соответствует нулю или более повторений
+строки "ab". Мы также можем использовать метасимвол чередования `|` внутри
+скобочной группы. Так, регулярное выражение `(c|g|p)ar` означает: "любая из
+строчных букв `c`, `g` или `p`, за которой следуют буквы `a` и `r`".
 
 <pre>
 "(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -277,15 +288,18 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/tUxrBG/1)
 
-Обратите внимание, что скобочные группы не только находят, но и захватывают символы для использования на родительском языке.
-Родительским языком может быть python, javascript или практически любой язык, который реализует использование регулярных выражений как параметров функций.
+Обратите внимание, что скобочные группы не только находят, но и захватывают
+символы для использования в языке программирования. Таким языком может быть
+Python, JavaScript и практически любой язык, в котором регулярные выражения
+можно использовать в параметрах функций.
 
-### 2.5.1 Не запоминающие скобочные группы
+### 2.5.1 Незахватывающие скобочные группы
 
-Бывает так, что группу определить нужно, а вот запоминать их содержимое в массиве не требуется.
-Подобный трюк осуществляется при помощи зарезервированной комбинации `?:`
-в круглых скобках `(...)`. Например, регулярное выражение `(?:c|g|p)ar` будет находить такие же шаблоны как и
-`(c|g|p)ar`, однако скобочная группа при этом создана не будет.
+Бывает так, что группу определить нужно, а вот захватывать её содержимое в
+массив не требуется. Подобный трюк осуществляется при помощи специальной
+комбинации `?:` в круглых скобках `(...)`. Так, регулярное выражение
+`(?:c|g|p)ar` будет искать те же шаблоны, что и `(c|g|p)ar`, но группа захвата
+при этом создана не будет.
 
 <pre>
 "(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@@ -293,19 +307,20 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/Rm7Me8/1)
 
-Незапоминающиеся группы могут пригодиться, когда они используются в функциях поиска и замены,
-или в сочетании со скобочными группами, например, для предпросмотра при создании скобочной группы или другого вида выходных данных,
-смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).
+Незахватывающие группы могут пригодиться, в ситуациях типа найти-и-заменить, или
+вместе со скобочными группами, чтобы не засорять массив из захваченных данных
+ненужными строками. Смотрите также [4. Опережающие и ретроспективные проверки](#4-опережающие-и-ретроспективные-проверки).
 
-## 2.6 Альтернация
+## 2.6 Перечисление
 
-В регулярных выражениях, вертикальная черта `|` используется для определения альтернации (чередования).
-Альтернация по своей сути похожа на оператор ИЛИ между логическими выражениями. Может создаться впечатление, что
-чередование это то же самое, что и определение набора символов. Однако, большая разница между ними в том, что
-набор символов работает на уровне конкретных символов, в то время как альтернация работает на уровне выражений.
-Например, регулярное выражение `(T|t)he|car` объединяет два шаблона (заглавная `T` ИЛИ строчная `t`, с продолжением из `h` и `e`) и шаблон
-(строчная `c`, затем строчная `a`, за которой следует строчная `r`). Таким образом, в поиске будет участвовать любой из данных шаблонов,
-по аналогии с логической операцией ИЛИ в программировании и алгебре выражений.
+В регулярных выражениях вертикальная черта `|` используется для определения
+перечисления (выбора). Перечисление похоже на оператор ИЛИ между выражениями.
+Может создаться впечатление, что перечисление — это то же, что и набор символов.
+Но набор символов работает на уровне конкретных символов, а перечисление
+работает на уровне выражений. К примеру, регулярное выражение `(T|t)he|car`
+значит: либо "заглавная `T` ИЛИ строчная `t`, с продолжением из `h` и `e`", либо
+"строчная `c`, затем строчная `a`, за которой следует строчная `r`". Во входных
+данных будут искаться оба шаблона, для удобства заключённые в кавычки.
 
 <pre>
 "(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -315,13 +330,15 @@
 
 ## 2.7 Экранирование спецсимволов
 
-Обратный слэш `\` используется в регулярных выражениях для экранирования следующего символа.
-Это позволяет формировать шаблоны с поиском зарезервированных символов, таких как `{ } [ ] / \ + * . $ ^ | ?`.
-Для использования спецсимвола в шаблоне необходимо указать символ `\` перед ним.
+Обратный слэш `\` используется в регулярных выражениях для экранирования
+следующего символа. Это позволяет формировать шаблоны с поиском специальных
+символов, таких как `{ } [ ] / \ + * . $ ^ | ?`. Для использования спецсимвола в
+шаблоне необходимо указать символ `\` перед ним.
 
-Как упомянуто выше, символ `.` является зарезервированным и соответствует любому значению, кроме символа новой строки.
-Бывают ситуации, когда необходимо найти точку в предложении, для таких случаев применимо экранирование. Рассмотрим выражение
-`(f|c|m)at\.?`, что соответствует следующему шаблону: строчный символ `f`, `c` или `m`, за которым следует строчные буквы `a` и `t`, с опциональной `.` точкой в конце.
+Например: символ `.` является специальным и соответствует любому знаку, кроме
+символа новой строки. Чтобы найти точку во входных данных, воспользуется
+выражением `(f|c|m)at\.?`: "строчный символ `f`, `c` или `m`, за которым следует
+строчные буквы `a` и `t`, с необязательной `.` точкой в конце".
 
 <pre>
 "(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@@ -331,19 +348,22 @@
 
 ## 2.8 Якоря
 
-Понятие якорей в регулярных выражениях используется для обозначения проверок, является ли
-соответствующий символ начальным или конечным символом входной строки. Якоря бывают двух типов:
-Первый тип - Каретка `^`, проверяет, является ли соответствующий символ начальным символом в тексте.
-Второй тип - Доллар `$`, проверяет, является ли соответствующий символ последним символом входной строки.
+Якоря в регулярных выражениях используются для проверки, является ли
+соответствующий символ первым или последним символом входной строки. Есть два
+типа якорей: каретка `^` — проверяет, является ли соответствующий символ первым
+символом в тексте, и доллар `$` — проверяет, является ли соответствующий символ
+последним символом входной строки.
 
 ### 2.8.1 Каретка
 
-Символ каретки `^` используется для проверки, является ли соответствующий символ первым символом входной строки.
-Если мы применяем следующее регулярное выражение `^a` (если a является начальным символом) для строки `abc`,
-совпадение будет соответствовать букве `a`. Если же мы используем регулярное выражение `^b` на той же строке,
-мы не получим совпадения, поскольку во входящей строке `abc` "b" не является первым символом. Рассмотрим другое
-регулярное выражение: `^(T|t)he`, обозначающее заглавную `T` или строчную `t` как первый символ, за которым следуют
-символы букв `h` и `e`. Cоответственно:
+Символ каретки `^` используется для проверки, является ли соответствующий символ
+первым символом входной строки. Если мы применяем следующее регулярное выражение
+`^a` ('a' является первым символом) для строки `abc`, совпадение будет
+соответствовать букве `a`. Если же мы используем регулярное выражение `^b` на
+той же строке, мы не получим совпадения, поскольку во входящей строке `abc` "b"
+не является первым символом. Рассмотрим другое регулярное выражение: `^(T|t)he`,
+оно значит "заглавная `T` или строчная `t` как первый символ, за которым следуют
+буквы `h` и `e`". Cоответственно:
 
 <pre>
 "(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@@ -360,9 +380,9 @@
 ### 2.8.2 Доллар
 
 Символ доллара `$` используется для проверки, является ли соответствующий символ
-последним символом входной строки. Например, регулярное выражение `(at\.)$` последовательность из
-строчной `a`, строчной `t`, и точки `.`, ключевой момент в том, что благодаря доллару этот шаблон будет
-находить совпадения только в том случае, если будет наблюдаться в конце строки. Например:
+последним символом входной строки. Например, регулярное выражение `(at\.)$`
+значит: "последовательность из строчной `a`, строчной `t`, точки `.`, находящая
+в конце строки". Пример:
 
 <pre>
 "(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@@ -378,29 +398,28 @@
 
 ## 3. Наборы сокращений и диапазоны
 
-Регулярные выражения предоставляют сокращения для часто используемых наборов символов,
-которые предлагают удобные сокращения для часто используемых регулярных выражений.
-Наборы сокращенных символов следующие:
+В регулярных выражениях есть сокращения для часто используемых наборов символов:
 
 |Сокращение|Описание|
 |:----:|----|
-|.|Любой символ кроме символа новой строки|
-|\w|Поиск буквенно-цифрового диапазона символов: `[a-zA-Z0-9_]`|
-|\W|Поиск не буквенно-цифрового диапазона символов: `[^\w]`|
-|\d|Поиск цифр: `[0-9]`|
+|.|Любой символ, кроме символа перевода строки|
+|\w|Английская буква либо цифра: `[a-zA-Z0-9_]`|
+|\W|Любой символ, кроме английских букв и цифр: `[^\w]`|
+|\d|Цифра: `[0-9]`|
 |\D|Поиск всего, что не является цифрой: `[^\d]`|
-|\s|Поиск пробелов и символов начала строки: `[\t\n\f\r\p{Z}]`|
-|\S|Поиск всего кроме пробелов и символов начала строки: `[^\s]`|
+|\s|Пробел либо символ начала строки: `[\t\n\f\r\p{Z}]`|
+|\S|Любой символ, кроме пробела и символа начала строки: `[^\s]`|
 
 ## 4. Опережающие и ретроспективные проверки
 
-Опережающие и ретроспективные проверки (в английской литературе lookbehind, lookahead) это особый вид
-***не запоминающих скобочных групп*** (находящих совпадения, но не добавляющих в массив).
-Данные проверки используются когда мы знаем, что шаблон предшествует или сопровождается другим шаблоном.
-Например, мы хотим получить цену в долларах `$` из следующей входной строки
-`$4.44 and $10.88`. Для этого используем следующее регулярное выражение `(?<=\$)[0-9\.]*`, означающее
-получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара `$`. Существуют
-следующие виды проверок:
+Опережающие и ретроспективные проверки (lookbehind, lookahead) — это особый вид
+***незахватывающих скобочных групп*** (находящих совпадения, но не добавляющих
+в массив совпадений). Данные проверки используются, когда мы знаем, что шаблон
+предшествует или сопровождается другим шаблоном. Например, мы хотим получить
+цену в долларах `$` из следующей входной строки `$4.44 and $10.88`. Для этого
+используем следующее регулярное выражение `(?<=\$)[0-9\.]*`, означающее
+получение всех дробных (с точкой `.`) цифр, которым предшествует знак доллара
+`$`. Существуют следующие виды проверок:
 
 |Символ|Описание|
 |:----:|----|
@@ -411,14 +430,17 @@
 
 ### 4.1 Положительное опережающее условие
 
-Положительное опережающее утверждение (assert) означает, что за первой частью выражения должно следовать
-опережающее выражение (lookahead expression). (по аналогии с условиями, if (..) then (..)).
-Возвращенное совпадение содержит только текст, который соответствует первой части выражения.
-Для определения положительного опережающего условия используются круглые скобки. В этих скобках используется
-знак вопроса со знаком равенства: `(?=...)`. Опережающее выражение, записывается в скобках после знака равенства.
-Рассмотрим пример регулярного выражения: `(T|t)he(?=\sfat)`, обозначающее опциональное наличие строчной `t` или заглавной `T`,
-следом буквы `h` и `e`. В скобках, мы определяем положительное опережающее условие, которое сообщает движку регулярных выражений
-информацию о том, что после шаблона `The` или `the` будет следовать слово `fat`.
+Положительное опережающее условие требует, чтобы за первой частью выражения
+обязательно следовало выражение из условия. Возвращенное совпадение содержит
+только текст, который соответствует первой части выражения. Для определения
+положительного опережающего условия используются круглые скобки. В этих скобках
+используется знак вопроса со знаком равенства: `(?=...)`. Опережающее выражение
+записывается внутри скобок после знака равенства. Рассмотрим пример регулярного
+выражения: `(T|t)he(?=\sfat)` "заглавная `T` или строчная `t`, следом буквы `h`
+и `e`. Всё это должно быть перед пробелом и словом 'fat'". В скобках мы
+определяем положительное опережающее условие, которое говорит библиотеке
+регулярных выражений о том, что после шаблона `The` или `the` будет следовать
+слово `fat`.
 
 <pre>
 "(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -428,11 +450,13 @@
 
 ### 4.2 Отрицательное опережающее условие
 
-Отрицательное опережающее условие работает по обратному принципу: используется, когда нам нужно получить
-все совпадения из входной строки, за которыми НЕ следует определенный шаблон. Отрицательное опережающее условие
-определяется таким же образом, как и позитивное, с той лишь разницей, что вместо равенства `=` мы ставим
-восклицательный знак `!` (отрицание) например: `(?!...)`. Рассмотрим выражение `(T|t)he(?!\sfat)`, в котором мы
-находим все `The` или `the` слова из входной строки, за которыми не следует слово `fat`.
+Отрицательное опережающее условие работает по обратному принципу: используется,
+когда нам нужно получить все совпадения из входной строки, за которыми НЕ
+следует определенный шаблон. Отрицательное опережающее условие определяется
+таким же образом, как и положительное, с той лишь разницей, что вместо равенства
+`=` мы ставим восклицательный знак `!` (логическое отрицание): `(?!...)`.
+Пример: `(T|t)he(?!\sfat)` — ищем слова `The` или `the`, за которыми не следует
+пробел и слово `fat`.
 
 <pre>
 "(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@@ -442,9 +466,10 @@
 
 ### 4.3 Положительное ретроспективное условие
 
-Положительное ретроспективное условие используется чтобы найти все совпадения, которым предшествует
-определенный шаблон. Условие определяется как `(?<=...)`. Например, выражение `(?<=(T|t)he\s)(fat|mat)` означает,
-найти все слова `fat` или `mat` из входной строки, которым предшествует слово `The` или `the`.
+Положительное ретроспективное условие используется чтобы найти все совпадения,
+которым предшествует определенный шаблон. Условие определяется как `(?<=...)`.
+Например, выражение `(?<=(T|t)he\s)(fat|mat)` означает: "найти все слова `fat`
+или `mat` из входной строки, которым предшествует слово `The` или `the`".
 
 <pre>
 "(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@@ -454,9 +479,10 @@
 
 ### 4.4 Отрицательное ретроспективное условие
 
-Отрицательное ретроспективное условие используется чтобы найти все совпадения, которым НЕ предшествует
-определенный шаблон. Условие определяется как `(?<!...)`. Например, выражение `(?<!(T|t)he\s)(cat)` означает
-найти все слова `cat` из входной строки, которым не предшествует определенный артикль `The` или `the`.
+Отрицательное ретроспективное условие используется, чтобы найти все совпадения,
+которым НЕ предшествует определенный шаблон. Условие определяется так:
+`(?<!...)`. Выражение `(?<!(T|t)he\s)(cat)` означает "найти все слова `cat` из
+входной строки, которым не предшествует определенный артикль `The` или `the`".
 
 <pre>
 "(?<!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@@ -466,22 +492,23 @@
 
 ## 5. Флаги
 
-Флаги, также называемые модификаторами, изменяют вывод регулярного выражения.
-Эти флаги могут быть использованы в любом порядке или комбинации, и являются
-неотъемлемой частью регулярных выражений.
+Флаги, также называемые модификаторами, изменяют принцип работы регулярного
+выражения. Эти флаги могут быть использованы в любом порядке или комбинации, и
+являются неотъемлемой частью регулярных выражений.
 
 |Флаг|Описание|
 |:----:|----|
-|i|Поиск без учета регистра|
-|g|Глобальный поиск: поиск шаблона во всем входном тексте|
-|m|Мультистроковый поиск: Якоря применяются к каждой строке.|
+|i|Поиск без учета регистра.|
+|g|Глобальный поиск: искать все вхождения шаблона в тексте, а не только первое совпадение.|
+|m|Мультистроковый поиск: якоря применяются к строкам, а не ко всему тексту.|
 
 ### 5.1 Поиск без учета регистра
 
-Модификатор `i` используется для поиска без учета регистра. Например, регулярное выражение
-`/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце регулярного выражения флаг `i`,
-указывающий движку регулярных выражений игнорировать регистр. Помимо `i`, для поиска шаблона во
-всем входном тексте, использован флаг `g`.
+Модификатор `i` используется для поиска без учета регистра. Например, регулярное
+выражение `/The/gi` означает заглавную `T` следом строчные `h` и `e`. В конце
+регулярного выражения флаг `i`, указывающий библиотеке регулярных выражений
+игнорировать регистр символов. Дополнительно для поиска шаблона во всем входном
+тексте, использован флаг `g`.
 
 <pre>
 "The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@@ -497,10 +524,12 @@
 
 ### 5.2 Глобальный поиск
 
-Модификатор `g` используется для выполнения глобального сопоставления (найти все совпадения, а не останавливаться после первого).
-Например, регулярное выражение `/.(at)/g` означает любой символ кроме символа новой строки, следом строчная `a`, далее строчная `t`.
-Из-за использования флага `g` в конце регулярного выражения, теперь оно найдет все совпадения во входной строке, а не остановится на первом
-(что является поведением по умолчанию).
+Модификатор `g` используется для выполнения глобального сопоставления (найти все
+совпадения, а не останавливаться после первого). К примеру, регулярное выражение
+`/.(at)/g` означает: "любой символ (кроме начала новой строки), следом строчная
+`a` и `t`". Благодаря флагу `g`, такое регулярное выражение найдёт все
+совпадения во входной строке, а не остановится на первом (что является
+поведением по умолчанию).
 
 <pre>
 "/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
@@ -517,11 +546,12 @@
 ### 5.3 Мультистроковый поиск
 
 Модификатор `m` используется для многострочного поиска. Как мы обсуждали ранее,
-якоря `(^, $)` используются для проверки, является ли шаблон началом или концом входной строки.
-Но если мы хотим, чтобы якоря работали в каждой строке, мы используем флаг `m`. Например,
-регулярное выражение `/at(.)?$/gm` означает строчную `a`, следом строчная `t` и любой
-символ кроме начала новой строки, идущий опционально (не обязательно). Из-за флага `m` механизм
-регулярных выражений будет искать данный шаблон в конце каждой строки в тексте.
+якоря `(^, $)` используются для проверки, является ли шаблон началом или концом
+входных данных. Но если мы хотим, чтобы якоря работали в каждой строке, мы
+используем флаг `m`. Например, регулярное выражение `/at(.)?$/gm` означает:
+"строчная `a`, следом строчная `t` и необязательный любой символ (кроме начала
+новой строки)". Благодаря флагу `m` библиотека регулярных выражений будет искать
+данный шаблон в конце каждой строки в тексте.
 
 <pre>
 "/.at(.)?$/" => The fat
@@ -539,30 +569,33 @@
 
 [Запустить регулярное выражение](https://regex101.com/r/E88WE2/1)
 
-## 6. Жадные vs ленивые квантификаторы
-По умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно будет
-искать совпадения как можно дольше. Мы можем использовать `?` для ленивого поиска, который
-будет стремиться быть как можно более коротким по времени.
+## 6. Жадная и ленивая квантификация
+По умолчанию регулярное выражение выполняет жадное сопоставление, то есть оно
+будет искать самые длинные возможные совпадения. Мы можем использовать `?` для
+ленивого поиска, который будет искать наименьшие возможные совпадения во входных
+данных.
 
 <pre>
-"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>. </pre>
+"/(.*at)/" => <a href="#learn-regex"><strong>The fat cat sat on the mat</strong></a>.
+</pre>
 
 
 [Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/1)
 
 <pre>
-"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat. </pre>
+"/(.*?at)/" => <a href="#learn-regex"><strong>The fat</strong></a> cat sat on the mat.
+</pre>
 
 
 [Запустить регулярное выражение](https://regex101.com/r/AyAdgJ/2)
 
 
-## Содействие
+## Участвуйте в жизни репозитория
 
-* Вы можете открыть пулл реквест с улучшением
-* Обсуждать идеи в issues
-* Распространять ссылку на репозиторий
-* Получить обратную связь через [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Откройте пулл реквест с исправлением
+* Обсуждайте идеи в issues
+* Распространяйте знания и ссылку на репозиторий
+* Приходите с отзывами к [![@ziishaned в Twitter](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=%40ziishaned)](https://twitter.com/ziishaned)
 
 ## Лицензия
 

From 70659cf5c5b8196368b173ca6f9b2d2b3cf98d77 Mon Sep 17 00:00:00 2001
From: AHOHNMYC <24810600+AHOHNMYC@users.noreply.github.com>
Date: Fri, 21 Oct 2022 07:09:58 +0300
Subject: [PATCH 180/185] [ru] Remove extra space

---
 translations/README-ru.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index 10767210..74b983f2 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -1,6 +1,6 @@
 <p align="center">
     <br/>
-    <a href="https://github.com/ziishaned/learn-regex">	
+    <a href="https://github.com/ziishaned/learn-regex">
         <img src="https://i.imgur.com/bYwl7Vf.png" alt="Учим регулярки">
     </a>
 </p>

From 92fe3f245930190c71e006afee0f0af9cc58da08 Mon Sep 17 00:00:00 2001
From: AHOHNMYC <24810600+AHOHNMYC@users.noreply.github.com>
Date: Sun, 23 Oct 2022 09:20:09 +0300
Subject: [PATCH 181/185] [ru] Fix link to German translation

---
 translations/README-ru.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/translations/README-ru.md b/translations/README-ru.md
index 74b983f2..1f4025c0 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -8,7 +8,7 @@
 ## Переводы:
 
 * [English](../README.md)
-* [German](translations/README-de.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)

From 22901bc1db0eb357dc5b2bdc5b2476f97b887b74 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Thu, 1 Jun 2023 09:29:16 -0400
Subject: [PATCH 182/185] add FUNDING.yml file

---
 .github/FUNDING.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..f5160b29
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [ziishaned]

From 6cf0c2b3c7d7f516bc326c88921440b85415b6d6 Mon Sep 17 00:00:00 2001
From: Amirreza A <arjmandamirreza@gmail.com>
Date: Thu, 6 Jul 2023 13:16:13 +0330
Subject: [PATCH 183/185] fixed translation hyperlinks.

---
 translations/README-cn.md    |  3 ++-
 translations/README-de.md    |  5 +++--
 translations/README-es.md    |  3 ++-
 translations/README-fa.md    |  3 ++-
 translations/README-fr.md    |  3 ++-
 translations/README-gr.md    |  3 ++-
 translations/README-he.md    | 32 ++++++++++++++++----------------
 translations/README-hu.md    |  3 ++-
 translations/README-ja.md    |  3 ++-
 translations/README-ko.md    |  3 ++-
 translations/README-pl.md    |  4 ++--
 translations/README-pt_BR.md |  3 ++-
 translations/README-ru.md    |  3 ++-
 translations/README-tr.md    |  3 ++-
 translations/README-vn.md    |  3 ++-
 15 files changed, 45 insertions(+), 32 deletions(-)

diff --git a/translations/README-cn.md b/translations/README-cn.md
index 2a94abe2..f001ae48 100644
--- a/translations/README-cn.md
+++ b/translations/README-cn.md
@@ -18,6 +18,7 @@
 ## 翻译：
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## 什么是正则表达式？
 
diff --git a/translations/README-de.md b/translations/README-de.md
index 967b7f33..c48621e3 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -8,7 +8,7 @@
 ## Translations:
 
 * [English](../README.md)
-* German
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -21,7 +21,8 @@
 * [Polish](../translations/README-pl.md)
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
-* [עברית](translations/README-he.md)
+* [فارسی](../translations/README-fa.md)
+* [עברית](../translations/README-he.md)
 
 ## Was sind Reguläre Ausdrücke?
 
diff --git a/translations/README-es.md b/translations/README-es.md
index 914ffc30..7c3fab7f 100644
--- a/translations/README-es.md
+++ b/translations/README-es.md
@@ -18,6 +18,7 @@
 ## Traducciones:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Qué es una expresión regular?
 
diff --git a/translations/README-fa.md b/translations/README-fa.md
index 74e35deb..362ecec2 100644
--- a/translations/README-fa.md
+++ b/translations/README-fa.md
@@ -17,6 +17,7 @@
 ## برگردان ها:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -30,7 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 <div dir="rtl">
 
diff --git a/translations/README-fr.md b/translations/README-fr.md
index face914f..4bccd742 100644
--- a/translations/README-fr.md
+++ b/translations/README-fr.md
@@ -18,6 +18,7 @@
 ## Traductions:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Qu'est-ce qu'une expression régulière?
 
diff --git a/translations/README-gr.md b/translations/README-gr.md
index 2da80b53..31b1ee64 100644
--- a/translations/README-gr.md
+++ b/translations/README-gr.md
@@ -18,6 +18,7 @@
 ## Μεταφράσεις:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Τι είναι μια Κανονική Έκφραση (Regular Expression);
 
diff --git a/translations/README-he.md b/translations/README-he.md
index a66099f7..411dccfe 100644
--- a/translations/README-he.md
+++ b/translations/README-he.md
@@ -9,22 +9,22 @@
 
 ## תרגומים:
 
-* [English](README.md)
-* [German](translations/README-de.md)
-* [Español](translations/README-es.md)
-* [Français](translations/README-fr.md)
-* [Português do Brasil](translations/README-pt_BR.md)
-* [中文版](translations/README-cn.md)
-* [日本語](translations/README-ja.md)
-* [한국어](translations/README-ko.md)
-* [Turkish](translations/README-tr.md)
-* [Greek](translations/README-gr.md)
-* [Magyar](translations/README-hu.md)
-* [Polish](translations/README-pl.md)
-* [Русский](translations/README-ru.md)
-* [Tiếng Việt](translations/README-vn.md)
-* [فارسی](translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [English](../README.md)
+* [German](../translations/README-de.md)
+* [Español](../translations/README-es.md)
+* [Français](../translations/README-fr.md)
+* [Português do Brasil](../translations/README-pt_BR.md)
+* [中文版](../translations/README-cn.md)
+* [日本語](../translations/README-ja.md)
+* [한국어](../translations/README-ko.md)
+* [Turkish](../translations/README-tr.md)
+* [Greek](../translations/README-gr.md)
+* [Magyar](../translations/README-hu.md)
+* [Polish](../translations/README-pl.md)
+* [Русский](../translations/README-ru.md)
+* [Tiếng Việt](../translations/README-vn.md)
+* [فارسی](../translations/README-fa.md)
+* [עברית](../translations/README-he.md)
 
 ## מה זה ביטוי רגולרי?
 
diff --git a/translations/README-hu.md b/translations/README-hu.md
index 726abf2d..78c6ef86 100644
--- a/translations/README-hu.md
+++ b/translations/README-hu.md
@@ -18,6 +18,7 @@
 ## Fordítások:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Mi az a reguláris kifejezés?
 
diff --git a/translations/README-ja.md b/translations/README-ja.md
index ef9a2894..31c62402 100644
--- a/translations/README-ja.md
+++ b/translations/README-ja.md
@@ -18,6 +18,7 @@
 ## 翻訳
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## 正規表現とは
 
diff --git a/translations/README-ko.md b/translations/README-ko.md
index c41feb6a..e34f3d25 100644
--- a/translations/README-ko.md
+++ b/translations/README-ko.md
@@ -18,6 +18,7 @@
 ## 번역:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## 정규표현식이란 무엇인가?
 
diff --git a/translations/README-pl.md b/translations/README-pl.md
index 1569b31a..92519d53 100644
--- a/translations/README-pl.md
+++ b/translations/README-pl.md
@@ -18,6 +18,7 @@
 ## Tłumaczenia:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,8 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
-
+* [עברית](../translations/README-he.md)
 ## Co to jest wyrażenie regularne?
 
 [![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)
diff --git a/translations/README-pt_BR.md b/translations/README-pt_BR.md
index eda70936..653138f1 100644
--- a/translations/README-pt_BR.md
+++ b/translations/README-pt_BR.md
@@ -18,6 +18,7 @@
 ## Traduções:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## O que é uma Expressão Regular?
 
diff --git a/translations/README-ru.md b/translations/README-ru.md
index 8cfe2c3e..3c565f5a 100644
--- a/translations/README-ru.md
+++ b/translations/README-ru.md
@@ -17,6 +17,7 @@
 ## Translations:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -30,7 +31,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Что такое Регулярное выражение?
 
diff --git a/translations/README-tr.md b/translations/README-tr.md
index 483a7fae..2edf15fb 100644
--- a/translations/README-tr.md
+++ b/translations/README-tr.md
@@ -18,6 +18,7 @@
 ## Çeviriler:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -31,7 +32,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 ## Düzenli İfade Nedir?
 
diff --git a/translations/README-vn.md b/translations/README-vn.md
index f975cd7a..3a5b2908 100644
--- a/translations/README-vn.md
+++ b/translations/README-vn.md
@@ -19,6 +19,7 @@
 ## Translations:
 
 * [English](../README.md)
+* [German](../translations/README-de.md)
 * [Español](../translations/README-es.md)
 * [Français](../translations/README-fr.md)
 * [Português do Brasil](../translations/README-pt_BR.md)
@@ -32,7 +33,7 @@
 * [Русский](../translations/README-ru.md)
 * [Tiếng Việt](../translations/README-vn.md)
 * [فارسی](../translations/README-fa.md)
-* [עברית](translations/README-he.md)
+* [עברית](../translations/README-he.md)
 
 
 ## Biểu thức chính quy là gì?

From a6c6e17ed583aceff421ef04be11686d36ad087e Mon Sep 17 00:00:00 2001
From: Daniel Scherf <munita.gavai@gmail.com>
Date: Fri, 23 Feb 2024 14:15:23 +0100
Subject: [PATCH 184/185] Translate German image

---
 img/regexp-de.png         | Bin 0 -> 15072 bytes
 translations/README-de.md |   2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 img/regexp-de.png

diff --git a/img/regexp-de.png b/img/regexp-de.png
new file mode 100644
index 0000000000000000000000000000000000000000..824e586aee418901030faf0f42f8e99bfe3566d7
GIT binary patch
literal 15072
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
MoY~nD1J@h>1<R^l^#A|>

literal 0
HcmV?d00001

diff --git a/translations/README-de.md b/translations/README-de.md
index 967b7f33..8c95c06a 100644
--- a/translations/README-de.md
+++ b/translations/README-de.md
@@ -38,7 +38,7 @@ kann. Wir möchten festlegen, dass der Benutzernamen Buchstaben, Ziffern, Unter-
 wir die Anzahl der Zeichen limitieren, damit der Name nicht unlesbar wird. Dazu verwenden wir den folgenden regulären Ausdruck:
 <br/><br/>
 <p align="center">
-  <img src="../img/regexp-en.png" alt="Regular expression">
+  <img src="../img/regexp-de.png" alt="Regular expression">
 </p>
 
 Der abgebildete reguläre Ausdruck erlaubt bspw. Die Eingaben `john_doe`, `jo-hn_doe` und `john12_as`. Die Eingabe `Jo` wird nicht akzeptiert, weil sie einen Großbuchstaben enthält und zu kurz ist.

From ee0cf94e89c33a454e701cec22c78a6e802454a0 Mon Sep 17 00:00:00 2001
From: Zeeshan Ahmad <ziishaned@gmail.com>
Date: Wed, 5 Feb 2025 13:51:04 -0500
Subject: [PATCH 185/185] Update README.md

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 9c1c4b2e..8052154d 100644
--- a/README.md
+++ b/README.md
@@ -596,8 +596,7 @@ possible. We can use `?` to match in a lazy way, which means the match should be
 * Open a pull request with improvements
 * Discuss ideas in issues
 * Spread the word
-* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
 ## License
 
-MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)
+MIT © Zeeshan Ahmad