Full Code of ziishaned/learn-regex for AI

Repository: ziishaned/learn-regex
Branch: master
Commit: 5a5252eb51fd
Files: 23
Total size: 440.1 KB

Directory structure:
gitextract_ycr5_2bq/

├── .github/
│   └── FUNDING.yml
├── .gitignore
├── LICENSE.md
├── README.md
└── translations/
    ├── README-cn.md
    ├── README-de.md
    ├── README-es.md
    ├── README-fa.md
    ├── README-fr.md
    ├── README-gr.md
    ├── README-he.md
    ├── README-hu.md
    ├── README-id.md
    ├── README-it.md
    ├── README-ja.md
    ├── README-ko.md
    ├── README-pl.md
    ├── README-pt_BR.md
    ├── README-ru.md
    ├── README-tr.md
    ├── README-vn.md
    ├── README-zh-simple.md
    └── how-to.md

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms

github: [ziishaned]


================================================
FILE: .gitignore
================================================
.vscode
.DS_STORE

================================================
FILE: LICENSE.md
================================================
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.


================================================
FILE: README.md
================================================
<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)
* [Bahasa Indonesia](translations/README-id.md)
* [فارسی](translations/README-fa.md)
* [עברית](translations/README-he.md)


## What is Regular Expression?

<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.

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, 
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". 

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

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 Characters](#2-meta-characters)
  - [The Full Stop](#21-the-full-stop)
  - [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)
  - [Capturing Groups](#25-capturing-groups)
      - [Non-Capturing Groups](#251-non-capturing-groups)
  - [Alternation](#26-alternation)
  - [Escaping Special Characters](#27-escaping-special-characters)
  - [Anchors](#28-anchors)
    - [The Caret](#281-the-caret)
    - [The Dollar Sign](#282-the-dollar-sign)
- [Shorthand Character Sets](#3-shorthand-character-sets)
- [Lookarounds](#4-lookarounds)
  - [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 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`.

<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 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.|
|&#124;|Alternation. Matches either the characters before or the characters after the symbol.|
|&#92;|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</code>|
|^|Matches the beginning of the input.|
|$|Matches the end of the input.|

## 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.
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 Sets

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 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`.

<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 the 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 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
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

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 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.

<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 a lowercase `c`,
followed by a lowercase `a`, followed by a lowercase `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: 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>.
</pre>

[Test the regular expression](https://regex101.com/r/Dzf9Aa/1)

### 2.3.3 The Question Mark

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 by a lowercase `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 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, 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.
</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 Groups

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,
the regular expression `(ab)*` matches zero or more repetitions of the character
"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.
</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 Groups

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 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>
"(?: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 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>
"(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 Characters

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 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>
"(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:
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.

### 2.8.1 The Caret

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.
</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 The Dollar Sign

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>
</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

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 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 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|
|:----:|----|
|?=|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
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.
</pre>

[Test the regular expression](https://regex101.com/r/IDDARt/1)

### 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
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 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.
</pre>

[Test the regular expression](https://regex101.com/r/V32Npg/1)

### 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
regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
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>.
</pre>

[Test the regular expression](https://regex101.com/r/avH165/1)

### 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
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>
"(?&lt;!(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: 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: 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
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 (finds all matches rather than
stopping after the first match). For example, the regular expression`/.(at)/g`
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.
</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 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>
"/.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, 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>


[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 a pull request with improvements
* Discuss ideas in issues
* Spread the word

## License

MIT &copy; Zeeshan Ahmad


================================================
FILE: translations/README-cn.md
================================================
<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/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>


## 翻译：

* [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)

## 什么是正则表达式？

[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)

> 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。

一个正则表达式是一种从左到右匹配主体字符串的模式。
正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、验证表单、提取字符串等等。
“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`，因为它包含了大写的字母而且太短了。

目录
=================

 * [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 ?&lt;= ... 正后发断言](#43---正后发断言)
	* [4.4 ?&lt;!... 负后发断言](#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`。

<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}|匹配 num 个大括号之前的字符或字符集 (n <= num <= m)。|
|(xyz)|字符集，匹配与 xyz 完全相等的字符串。|
|&#124;|或运算符，匹配符号前或后的字符。|
|&#92;|转义字符，用于匹配一些保留的字符 <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</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` 匹配 `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.
</pre>

[在线练习](https://regex101.com/r/2ITLQ4/1)

方括号的句号就表示句号。
表达式 `ar[.]` 匹配 `ar.` 字符串。

<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` 匹配一个后面跟着 `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.
</pre>

[在线练习](https://regex101.com/r/nNNlq3/1)

## 2.3 重复次数

后面跟着元字符 `+`，`*` or `?` 的，用来指定匹配子模式的次数。
这些元字符在不同的情况下有着不同的意思。

### 2.3.1 `*` 号

`*` 号匹配在 `*` 之前的字符出现 `大于等于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.
</pre>

[在线练习](https://regex101.com/r/7m8me5/1)

`*` 字符和 `.` 字符搭配可以匹配所有的字符 `.*`。
`*` 和表示匹配空格的符号 `\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.
</pre>

[在线练习](https://regex101.com/r/gGrwuz/1)

### 2.3.2 `+` 号

`+` 号匹配 `+` 号之前的字符出现 >=1 次。
例如表达式 `c.+t` 匹配以首字母 `c` 开头以 `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 `?` 号

在正则表达式中元字符 `?` 标记在符号前面的字符为可选，即出现 0 或 1 次。
例如，表达式 `[T]?he` 匹配字符串 `he` 和 `The`。

<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,}` 匹配至少两位 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)

<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 次。
我们还可以在 `()` 中用或字符 `|` 表示或。例如，`(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.
</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)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.
</pre>

[在线练习](https://regex101.com/r/fBXyX0/1)

## 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>
</pre>

[在线练习](https://regex101.com/r/DOc5Nu/1)

## 2.8 锚点

在正则表达式中，想要匹配指定开头或结尾的字符串就要使用到锚点。`^` 指定开头，`$` 指定结尾。

### 2.8.1 `^` 号

`^` 用来检查匹配的字符串是否在所匹配字符串的开头。

例如，在 `abc` 中使用表达式 `^a` 会得到结果 `a`。
但如果使用 `^b` 将匹配不到任何结果。
因为字符串 `abc` 并不是以 b 开头。

例如，`^(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.
</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\.)$` 匹配以 `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>
</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]`|
|\f|匹配一个换页符|
|\n|匹配一个换行符|
|\r|匹配一个回车符|
|\t|匹配一个制表符|
|\v|匹配一个垂直制表符|
|\p|匹配 CR/LF（等同于 `\r\n`），用来匹配 DOS 行终止符|

## 4. 零宽度断言（前后预查）

先行断言和后发断言（合称 lookaround）都属于**非捕获组**（用于匹配模式，但不包括在匹配列表中）。当我们需要一个模式的前面或后面有另一个特定的模式时，就可以使用它们。

例如，我们希望从下面的输入字符串 `$4.44` 和 `$10.88` 中获得所有以 `$` 字符开头的数字，我们将使用以下的正则表达式 `(?<=\$)[0-9\.]*`。意思是：获取所有包含 `.` 并且前面是 `$` 的数字。

零宽度断言如下：

|符号|描述|
|:----:|----|
|?=|正先行断言-存在|
|?!|负先行断言-排除|
|?<=|正后发断言-存在|
|?<!|负后发断言-排除|

### 4.1 `?=...` 正先行断言

`?=...` 正先行断言，表示第一部分表达式之后必须跟着 `?=...` 定义的表达式（正先行断言）。

返回结果只包含满足匹配条件的第一部分表达式。
定义一个正先行断言要使用 `()`。在括号内部使用一个问号和等号： `(?=...)`。

正先行断言的内容写在括号中的等号后面。
例如，表达式 `(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.
</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` 或 `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>
"(?&lt;!(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 忽略大小写 (Case Insensitive)

修饰语 `i` 用于忽略大小写。
例如，表达式 `/The/gi` 表示在全局搜索 `The`，在后面的 `i` 将其条件修改为忽略大小写，则变成搜索 `the` 和 `The`，`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 全局搜索 (Global search)

修饰符 `g` 常用于执行一个全局搜索匹配，即（不仅仅返回第一个匹配的，而是返回全部）。
例如，表达式 `/.(at)/g` 表示搜索 任意字符（除了换行）+ `at`，并返回全部结果。

<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 多行修饰符 (Multiline)

多行修饰符 `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. 贪婪匹配与惰性匹配 (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)

## 贡献

* 报告问题
* 开放合并请求
* 传播此文档
* 直接和我联系 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 &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-de.md
================================================
<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)

## 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 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.

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:
<br/><br/>
<p align="center">
  <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.

## Inhaltsverzeichnis

- [Einfache Muster](#1-einfache-muster)
- [Metazeichen](#2-metazeichen)
  - [Punkt](#21-punkt)
  - [Zeichenklasse](#22-zeichenklasse)
    - [Negierte Zeichenklasse](#221-negierte-zeichenklasse)
  - [Wiederholungen](#23-wiederholungen)
    - [Stern *](#231-stern)
    - [Plus +](#232-plus)
    - [Fragezeichen ?](#233-fragezeichen)
  - [Geschweifte Klammern {}](#24-geschweifte-klammern)
  - [Gruppierung ()](#25-gruppierung)
  - [Alternation |](#26-alternation)
  - [Escaping \](#27-escaping)
  - [Anker](#28-anker)
    - [Zirkumflex ^](#281-zirkumflex)
    - [Dollar $](#282-dollar)
- [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 vs Faule Übereinstimmung](#6-gierige-vs-faule-übereinstimmung)

## 1. Einfache Muster

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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1)

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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/1paXsy/1)

## 2. Metazeichen

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:

|Metazeichen|Beschreibung|
|:----:|----|
|.|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.|
|&#124;|Alternation, entspricht entweder dem Teilausdruck vor oder nach dem \|.|
|&#92;|Escaped das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</code>|
|^|Entspricht dem Anfang der Eingabe.|
|$|Entspricht dem Ende der Eingabe.|

## 2.1 Punkt

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.
</pre>
[Teste den regulären Ausdruck](https://regex101.com/r/xc9GkU/1)

## 2.2 Zeichenklasse

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.
</pre>
[Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1)

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>
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1)

### 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 (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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/nNNlq3/1)

## 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 "Quantifizierern" (eng. *quantifier*).
Sie können sich je nach Situation unterschiedlich verhalten.

### 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
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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/7m8me5/1)

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\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>
"\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>

[Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1)

### 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
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>.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1)

### 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.
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.
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/kPpO2x/1)

## 2.4 Geschweifte Klammern

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.

<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 den regulären Ausdruck](https://regex101.com/r/juM86s/1)

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.
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/Sivu30/1)

## 2.5 Gruppierungen

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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/tUxrBG/1)

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 Gruppierungen ohne Rückwärtsreferenz

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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/Rm7Me8/1)

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 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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)

## 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)).
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.

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>
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/DOc5Nu/1)

## 2.8 Anker

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 Zirkumflex

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.
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/jXrKne/1)

### 2.8.2 Dollar

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>
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/t0AkOd/1)

##  3. Vordefinierte Zeichenklassen

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|
|:----:|----|
|.|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. 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").
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|
|:----:|----|
|?=|Positiver Lookahead|
|?!|Negativer Lookahead|
|?<=|Positiver Lookbehind|
|?<!|Negativer Lookbehind|

### 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.
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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)

### 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.
`(?!...)`. 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.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)

### 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`, 
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>.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/avH165/1)

### 4.4 Negativer Lookbehind

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>
"(?&lt;!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
</pre>

[Teste den regulären Ausdruck](https://regex101.com/r/8Efx5G/1)

## 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.


|Modifikator|Beschreibung|
|:----:|----|
|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 Groß-/Kleinschreibung unempfindlich

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.

<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/ahfiuh/1)

### 5.2 Globale Suche

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.
</pre>

[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>

[Teste den regulären Ausdruck](https://regex101.com/r/dO1nef/1)

### 5.3 Mehrzeilig

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
                cat sat
                on the <a href="#learn-regex"><strong>mat.</strong></a>
</pre>

[Teste den regulären Ausdruck](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 den regulären Ausdruck](https://regex101.com/r/E88WE2/1)

## 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>


[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>


[Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2)

## Beitragen

* Ö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)

## Lizenz

MIT &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-es.md
================================================
<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/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:

* [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)

## 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 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">
  <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.

## Tabla de contenido

- [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)
    - [Asterisco](#231-asterisco)
    - [Signo más](#232-signo-de-más)
    - [Signo de interrogación](#233-signo-de-interrogación)
  - [Llaves](#24-llaves)
  - [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-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-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-mayúsculas-y-minúsculas)
  - [Búsqueda global](#52-búsqueda-global)
  - [Multilínea](#53-multilínea)


## 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`.

<pre>
"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
</pre>

[Prueba la expresión regular](https://regex101.com/r/dmRygT/1)

La expresión regular `123` coincide con la cadena `123`. La expresión regular se compara con una cadena de entrada al comparar cada carácter de la expresión regular con cada carácter de la cadena de entrada, uno tras otro. Las expresiones regulares son normalmente sensibles a mayúsculas y minúsculas, por lo que la expresión regular `The` no coincide con la cadena `the`.

<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[Prueba la expresión regular](https://regex101.com/r/1paXsy/1)

## 2. Meta-caracteres

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|
|:----:|----|
|.|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.|
|&#124;|Alternancia: Corresponde a los caracteres anteriores o los caracteres después del símbolo.|
|&#92;|Escapa el siguiente carácter: Esto le permite hacer coincidir los caracteres reservados <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</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

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.
</pre>

[Prueba la expresión regular](https://regex101.com/r/xc9GkU/1)

## 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 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.
</pre>

[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 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>
</pre>

[Prueba la expresión regular](https://regex101.com/r/wL3xtE/1)

### 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 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.
</pre>

[Prueba la expresión regular](https://regex101.com/r/nNNlq3/1)

## 2.3 Repeticiones

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 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.

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

[Prueba la expresión regular](https://regex101.com/r/7m8me5/1)

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>.
</pre>

[Prueba la expresión regular](https://regex101.com/r/gGrwuz/1)

### 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`.

<pre>
"c.+t" => The fat <a href="#learn-regex"><strong>cat sat on the mat</strong></a>.
</pre>

[Prueba la expresión regular](https://regex101.com/r/Dzf9Aa/1)

### 2.3.3 Signo de interrogación

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.
</pre>

[Prueba la expresión regular](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>

[Prueba la expresión regular](https://regex101.com/r/kPpO2x/1)

## 2.4 Llaves

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.
</pre>

[Prueba la expresión regular](https://regex101.com/r/juM86s/1)

Podemos dejar fuera el segundo número. Por ejemplo, la expresión regular `[0-9] {2,}` significa: Combina 2 o más dígitos. Si también eliminamos la coma, la expresión regular `[0-9]{3}` significa: coincidir exactamente con 3 dígitos.

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

[Prueba la expresión regular](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>

[Prueba la expresión regular](https://regex101.com/r/Sivu30/1)

## 2.5 Grupos de caracteres

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>

[Prueba la expresión regular](https://regex101.com/r/tUxrBG/1)

## 2.6 Alternancia

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.
</pre>

[Prueba la expresión regular](https://regex101.com/r/fBXyX0/1)

## 2.7 Caracteres especiales de escape

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>
</pre>

[Prueba la expresión regular](https://regex101.com/r/DOc5Nu/1)

## 2.8 Anclas

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 Símbolo de intercalación

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.
</pre>

[Prueba la expresión regular](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>

[Prueba la expresión regular](https://regex101.com/r/jXrKne/1)

### 2.8.2 Símbolo del dólar

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>
</pre>

[Prueba la expresión regular](https://regex101.com/r/y4Au4D/1)

<pre>
"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
</pre>

[Pueba la expresión regular](https://regex101.com/r/t0AkOd/1)

##  3. Conjunto de caracteres abreviados

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:

|Abreviatura|Descripción|
|:----:|----|
|.|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 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

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
`$4.44 y $10.88`. Usaremos la siguiente expresión regular `(?<=\$)[0-9\.] *`,
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:

|Símbolo|Descripción|
|:----:|----|
|?=|Lookahead Positivo|
|?!|Lookahead Negativo|
|?<=|Lookbehind Positivo|
|?<\!|Lookbehind Negativo|

## 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
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
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.
</pre>

[Prueba la expresión regular](https://regex101.com/r/IDDARt/1)

### 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
define de la misma manera que definimos el aspecto positivo, pero la única diferencia
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.


<pre>
"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
</pre>

[Prueba la expresión](https://regex101.com/r/V32Npg/1)

### 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 `(?<=...)`.
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`.

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

[Prueba la expresión regular](https://regex101.com/r/avH165/1)

### 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
`(? <! ...)`. Por ejemplo, la expresión regular `(?<!(T|t)he(s)(cat)` significa:
obtener todas las palabras `cat` de la cadena de entrada que no están después de
la palabra` The` o `the`.

<pre>
"(?&lt;![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
</pre>

[Prueba la expresión regular](https://regex101.com/r/8Efx5G/1)

## 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.


|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: 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ú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
`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 proveimos el indicador
`g` porque queremos buscar el patrón en toda la cadena de entrada.


<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[Prueba la expresión regularn](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>

[Prueba la expresión regular](https://regex101.com/r/ahfiuh/1)

### 5.2 Búsqueda global

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 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>
"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
</pre>

[Prueba la expresión regular](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>

[Prueba la expresión regular](https://regex101.com/r/dO1nef/1)

### 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 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>
"/.at(.)?$/" => The fat
                cat sat
                on the <a href="#learn-regex"><strong>mat.</strong></a>
</pre>

[Prueba la expresión regular](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>

[Prueba la expresión regular](https://regex101.com/r/E88WE2/1)

## Contribución

* 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)

## Licencia

MIT &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-fa.md
================================================
<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)
* [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)

<div dir="rtl">

## عبارت منظم چیست؟
</div>

[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)

<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">
</p>
<div dir="rtl">
عبارت منظم به کار رفته در اینجا رشته `john_doe` و `jo-hn_doe` و `john12_as` می پذیرد ولی `Jo` را به دلیل کوتاه بودن بیش از حد و همچنین به کار بردن حروف بزرگ نمی پذیرد.
</div>
<div dir="rtl">

## فهرست

- [پایه ای ترین همخوانی](#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)
</div>
<div dir="rtl">

## 1. پایه ای ترین همخوانی

یک عبارت منظم در واقع یک الگو برای جست و جو در یک متن است. برای مثال عبارت منظم  `the` به معنی : حرف
`t`, پس از آن حرف `h`, پس از آن حرف  `e` است.
</div>
<pre>
"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` همخوان نیست.
</div>

<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

<div dir="rtl">

[این عبارت منظم را در عمل ببنیند](https://regex101.com/r/1paXsy/1)
</div>

## 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.|
|&#124;|Alternation. Matches either the characters before or the characters after the symbol.|
|&#92;|Escapes the next character. This allows you to match reserved characters <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</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>
"(?&lt;!(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 &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-fr.md
================================================
<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/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:

* [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)

## 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"
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 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
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">
</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.

## 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 texte.
Par exemple, l'expression régulière `the` signifie : la lettre `t`, suivie de la lettre `h`, suivie de la lettre `e`.

<pre>
"the" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
</pre>

[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 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`.

<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[Essayer l'expression régulière](https://regex101.com/r/1paXsy/1)

## 2. Meta-caractères

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 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.|
|&#124;|Alternation (ou). Coïncide soit avec le caractère avant ou après le symbole.|
|&#92;|Échappe le prochain caractère. Cela permet de faire coïncider des caractères réservés tels que <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</code>|
|^|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

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`.

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

[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` 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.
</pre>

[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, suivie par un `.` (point).

<pre>
"ar[.]" => A garage is a good place to park a c<a href="#learn-regex"><strong>ar.</strong></a>
</pre>

[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 (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.
</pre>

[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 : 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.
</pre>

[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 (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.

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

[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, 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>.
</pre>

[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 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.

<pre>
"[T]he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in the garage.
</pre>

[Essayer l'expression régulière](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>

[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é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).

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

[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.

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

[Essayer l'expression régulière](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>

[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 é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 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`.

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

[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.

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

[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 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 `.`.

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

[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
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 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>
"(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>

[Essayer l'expression régulière](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>

[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 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 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>
</pre>

[Essayer l'expression régulière](https://regex101.com/r/y4Au4D/1)

<pre>
"(at\.)$" => The fat cat. sat. on the m<a href="#learn-regex"><strong>at.</strong></a>
</pre>

[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 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:

|Symbole|Description|
|:----:|----|
|?=|Recherche en avant positive|
|?!|Recherche en avant négative|
|?<=|Recherche en arrière positive|
|?<!|Recherche en arrière négative|

### 4.1 Recherche en avant positive

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 é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.

<pre>
"[T|t]he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[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 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 chaine de caractères (string)
qui ne sont pas suivis du mot `fat` précédé d'un espace.

<pre>
"[T|t]he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
</pre>

[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 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>
"(?<=[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>

[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 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>
"(?&lt;![T|t]he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
</pre>

[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 chaine de caractères (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` 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 chaine de caractères (string) entière.

<pre>
"The" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
</pre>

[Essayer l'expression régulière](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>

[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 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 chaine de caractères (string).

<pre>
"/.(at)/" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the mat.
</pre>

[Essayer l'expression régulière](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>

[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 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 chaine de caractères (string).

<pre>
"/.at(.)?$/" => The fat
                cat sat
                on the <a href="#learn-regex"><strong>mat.</strong></a>
</pre>

[Essayer l'expression régulière](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>

[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 &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-gr.md
================================================
<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/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>


## Μεταφράσεις:

* [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)

## Τι είναι μια Κανονική Έκφραση (Regular Expression);

[![](https://img.shields.io/badge/-Download%20PDF%20-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://gum.co/learn-regex)

> Μια κανονική έκφραση είναι μια ομάδα χαρακτήρων ή συμβόλων που χρησιμοποιούνται για την εύρεση ενός συγκεκριμένου μοτίβου χαρακτήρων μέσα σ'ένα κείμενο.

Μια κανονική έκφραση, είναι μια σειρά χαρακτήρων τους οποίους αναζητούμε μέσα σε ένα κείμενο. Η αναζήτηση αυτή
ξεκινά από τα αριστερά και συνεχίζει προς τα δεξιά. Ο όρος "Κανονική Έκφραση" είναι κάπως μεγάλος οπότε πολύ συχνά
θα τον συναντήσετε στην συντομότερη μορφή του ως "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 ακριβώς με την σειρά στην οποία βρίσκονται.|
|&#124;|Εναλλαγή. Ταιριάζει είτε με τους χαρακτήρες που βρίσκονται πριν είτε μετά το σύμβολο.|
|&#92;|Παραλείπει το ειδικό νόημα του χαρακτήρα. Αυτό μας επιτρέπει να ταιριάξουμε χαρακτήρες
ειδικής χρήσης <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</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>
"(?&lt;!(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 &copy; [Zeeshan Ahmad](https://twitter.com/ziishaned)


================================================
FILE: translations/README-he.md
================================================
<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 בסדר המדויק הזה.|
|&#124;|חלופה (או). התאמה בין התווים שלפני או לתווים שאחרי הסמל.|
|&#92;|מתעלם מהתו הבא. זה מאפשר לך להתאים תווים שמורים <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</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">
"(?&lt;!(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.