RegEX

M(?(?=.*?\bher\b)s|r)\.

### Примеры {.col-span-2 .row-span-3}

#### re.search()
``python
>>> sentence = 'Это пример строки'
>>> bool(re.search(r'this', sentence, flags=re.I))
True
>>> bool(re.search(r'xyz', sentence))
False

#### re.finditer()
``python
>>> m_iter = re.finditer(r'[0-9]+', '45 349 651 593 4 204')
>>> [m[0] for m in m_iter if int(m[0]) < 350]
['45', '349', '4', '204']

#### re.sub()
``python
>>> ip_lines = "catapults\nconcatenate\ncat"
>>> print(re.sub(r'^', r'* ', ip_lines, flags=re.M))
* catapults
* конкатенат
* cat

### Функции

| Функция | Описание |
|---------------|-------------------------------------------------------------------|
| `re.findall` | Возвращает список, содержащий все совпадения |
| | `re.finditer` | Возвращает итерабель объектов match (по одному на каждое совпадение) |
| | `re.search` | Возвращает объект Match, если в строке есть совпадение |
| `re.split` | Возвращает список, в котором строка была разделена на каждое совпадение |
| `re.sub` | Заменяет одно или несколько совпадений строкой |
| | `re.compile` | Компиляция шаблона регулярного выражения для последующего использования |
| `re.escape` | Возвращает строку, в которой все неалфавитно-цифровые символы отделены обратной косой чертой |



### Флаги


| - | - | - |
|--------|-----------------|----------------------------------------------|
| `re.I` | `re.IGNORECASE` | Игнорировать регистр |
| `re.M` | `re.MULTILINE` | Многострочный |
| `re.L` | `re.LOCALE` | Сделать `\w`,`\b`,`\s` _локально зависимыми_ |
| `re.S` | `re.DOTALL` | Точка совпадает со всеми _(включая новую строку)_ |
| | `re.U` | `re.UNICODE` | Сделать `\w`,`\b`,`\d`,`\s` _юникод-зависимыми_ |
| | `re.X` | `re.VERBOSE` | Стиль для чтения |



Regex в JavaScript
---------------

### test()
``javascript
let textA = 'Мне очень нравятся яблоки';
let textB = 'Мне нравятся яблоки';
let regex = /apples$/i
 
// Выход: false
console.log(regex.test(textA));
 
// Вывод: true
console.log(regex.test(textB));

let text = 'Мне очень нравятся яблоки';
let regexA = /apples/;
let regexB = /apples/i;
 
// Выходные данные: -1
console.log(text.search(regexA));
 
// Вывод: 7
console.log(text.search(regexB));

### match()

``javascript
let text = 'Здесь яблоки и апплС';
let regex = /apples/gi;
 
// Вывод: ["apples", "apPleS" ].
console.log(text.match(regex));

### matchAll()

``javascript
let regex = /t(e)(st(\d?))/g;
let text = 'test1test2';
let array = [...text.matchAll(regex)];

// Выходные данные: ["test1", "e", "st1", "1"]
console.log(array[0]);

// Выходные данные: ["test2", "e", "st2", "2"]
console.log(array[1]);

### replaceAll()

```javascript
let regex = /apples/gi;
let text = 'Здесь яблоки и апплС';

// Вывод: Здесь манго и манго
let result = text.replaceAll(regex, "mangoes");
console.log(result);

### preg_match
```php
$str = "Посетите CheatSheets";
$regex = "#cheatsheets#i";

// Вывод: 1
echo preg_match($regex, $str);

$regex = "/[a-zA-Z]+ (\d+)/";
$input_str = "24 июня, 13 августа и 30 декабря";
if (preg_match_all($regex, $input_str, $matches_out)) {

    // Выход: 2
    echo count($matches_out);

    // Вывод: 3
    echo count($matches_out[0]);

    // Выходные данные: Array("24 июня", "13 августа", "30 декабря")
    print_r($matches_out[0]);

    // Выходные данные: Array("24", "13", "30")
    print_r($matches_out[1]);
}

### preg_split {.col-span-2}
``php
$str = "Jane\tKate\nLucy Marion";
$regex = "@\s@";

// Выходные данные: Array("Jane", "Kate", "Lucy", "Marion")
print_r(preg_split($regex, $str));

#### Второй способ
``java
boolean s2 = Pattern.compile("[0-9]+").matcher("123").matches();
System.out.println(s2); // Вывод: true

### Поля шаблона


| - | - |
|--------------------|---------------------------------|
| `CANON_EQ` | Каноническая эквивалентность |
| `CASE_INSENSITIVE` | Сопоставление без учета регистра |
| `COMMENTS` | Разрешает пробельные символы и комментарии |
| `DOTALL` | Точечный режим |
| `MULTILINE` | Многострочный режим |
| `UNICODE_CASE` | Свертывание регистра с учетом юникода |
| `UNIX_LINES` | Режим строк Unix |





### Методы

#### Pattern
- Pattern compile(String regex [, int flags])
- boolean matches([String regex, ] CharSequence input)
- String[] split(String regex [, int limit])
- String quote(String s)

#### Matcher
- int start([int group | String name])
- int end([int group | String name])
- boolean find([int start])
- String group([int group | String name])
- Matcher reset()

#### String

- boolean matches(String regex)
- String replaceAll(String regex, String replacement)
- String[] split(String regex[, int limit])

Есть и другие методы ...




### Примеры {.col-span-2}

Замените предложение:
``java
String regex = "[A-Z\n]{5}$";
String str = "Мне нравится APP\nLE";

Pattern p = Pattern.compile(regex, Pattern.MULTILINE);
Matcher m = p.matcher(str);

// Выходные данные: Мне нравится Apple!
System.out.println(m.replaceAll("pple!"));

Regex в MySQL {.cols-2}
-------------

### Функции
| Имя | Описание |
|--------------------|--------------------------------------------------------------------------|
| `REGEXP` | Совпадает ли строка с regex |
| `REGEXP_INSTR() ` | Начальный индекс подстроки, соответствующей regex <br>_(NOTE: Только MySQL 8.0+)_ |
| `REGEXP_LIKE() ` | Совпадает ли строка с regex <br>_(ПРИМЕЧАНИЕ: Только MySQL 8.0+)_ |
| `REGEXP_REPLACE()` | Замена подстрок, соответствующих regex <br>_(ПРИМЕЧАНИЕ: Только MySQL 8.0+)_ |
| `REGEXP_SUBSTR()` | Вернуть подстроку, соответствующую regex <br>_(ПРИМЕЧАНИЕ: Только MySQL 8.0+)_ |



### REGEXP
```sql {.wrap}
expr REGEXP pat

mysql> SELECT 'abc' REGEXP '^[a-d]';
1
mysql> SELECT name FROM cities WHERE name REGEXP '^A';
mysql> SELECT name FROM cities WHERE name NOT REGEXP '^A';
mysql> SELECT name FROM cities WHERE name REGEXP 'A|B|R';
mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
1 0

REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

mysql> SELECT REGEXP_REPLACE('a b c', 'b', 'X');
a X c
mysql> SELECT REGEXP_REPLACE('abc ghi', '[a-z]+', 'X', 1, 2);
abc X

REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])

mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+');
abc
mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3);
ghi

REGEXP_LIKE(expr, pat[, match_type])

mysql> SELECT regexp_like('aba', 'b+')
1
mysql> SELECT regexp_like('aba', 'b{2}')
0
mysql> # i: нечувствительно к регистру
mysql> SELECT regexp_like('Abba', 'ABBA', 'i');
1
mysql> # m: многострочный
mysql> SELECT regexp_like('a\nb\nc', '^b$', 'm');
1

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

mysql> SELECT regexp_instr('aa aaa aaaa', 'a{3}');
2
mysql> SELECT regexp_instr('abba', 'b{2}', 2);
2
mysql> SELECT regexp_instr('abbabba', 'b{2}', 1, 2);
5
mysql> SELECT regexp_instr('abbabba', 'b{2}', 1, 3, 1);
7