Add languages Russian, Arabic, Chinese, Portuguese (#18305)
This commit is contained in:
Beau Carnes
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
09d3eca712
commit
2ca3a2093f
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 587d7dba367417b2b2512ba8
|
||||
title: Check for All or None
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Проверить все или нет.
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Иногда шаблоны, которые вы хотите найти, могут иметь части, которые могут или не могут существовать. Однако, тем не менее, может быть важно проверить их. Вы можете указать возможное существование элемента с вопросительным знаком <code>?</code> , Это проверяет нуль или один из предыдущего элемента. Вы можете думать об этом символе как о том, что предыдущий элемент является необязательным. Например, есть небольшие отличия в американском и британском английском, и вы можете использовать знак вопроса, чтобы соответствовать обоим написаниям. <blockquote> let american = "color"; <br> let british = "color"; <br> let rainbowRegex = / colou? r /; <br> rainbowRegex.test (американский); // Возвращает true <br> rainbowRegex.test (Великобритания); // Возвращает true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените regex <code>favRegex</code> чтобы он соответствовал английской (любимой) и английской (любимой) версии слова. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Ваше регулярное выражение должно использовать необязательный символ <code>?</code> ,'
|
||||
testString: 'assert(favRegex.source.match(/\?/).length > 0, "Your regex should use the optional symbol, <code>?</code>.");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"favorite"</code>
|
||||
testString: 'assert(favRegex.test("favorite"), "Your regex should match <code>"favorite"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"favourite"</code>
|
||||
testString: 'assert(favRegex.test("favourite"), "Your regex should match <code>"favourite"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"fav"</code>
|
||||
testString: 'assert(!favRegex.test("fav"), "Your regex should not match <code>"fav"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let favWord = "favorite";
|
||||
let favRegex = /change/; // Change this line
|
||||
let result = favRegex.test(favWord);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db4367417b2b2512b92
|
||||
title: Extract Matches
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Экстракционные матчи
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> До сих пор вы проверяли, существует ли шаблон в строке или нет. Вы также можете извлечь фактические совпадения, найденные с помощью <code>.match()</code> . Чтобы использовать метод <code>.match()</code> , примените метод к строке и передайте в регулярное выражение внутри круглых скобок. Вот пример: <blockquote> «Hello, World!». Match (/ Hello /); <br> // Возвращает ["Hello"] <br> let ourStr = "Регулярные выражения"; <br> пусть нашRegex = / выражения /; <br> ourStr.match (ourRegex); <br> // Возвращает ["выражения"] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Нанести <code>.match()</code> метод , чтобы извлечь слово <code>coding</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>result</code> должен иметь слово <code>coding</code>
|
||||
testString: 'assert(result.join() === "coding", "The <code>result</code> should have the word <code>coding</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(codingRegex.source === "coding", "Your regex <code>codingRegex</code> should search for <code>coding</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(code.match(/\.match\(.*\)/), "You should use the <code>.match()</code> method.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let extractStr = "Extract the word 'coding' from this string.";
|
||||
let codingRegex = /change/; // Change this line
|
||||
let result = extractStr; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,51 @@
|
||||
---
|
||||
id: 587d7db6367417b2b2512b9b
|
||||
title: Find Characters with Lazy Matching
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Найти персонажей с ленивым соответствием
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> В регулярных выражениях <code>greedy</code> соответствие находит самую длинную возможную часть строки, которая соответствует шаблону регулярного выражения и возвращает его как совпадение. Альтернативой называется <code>lazy</code> совпадение, которое находит наименьшую возможную часть строки, которая удовлетворяет шаблону регулярного выражения. Вы можете применить regex <code>/t[az]*i/</code> к строке <code>"titanic"</code> . Это регулярное выражение в основном является шаблоном, начинающимся с <code>t</code> , заканчивается <code>i</code> , и между ними есть несколько букв. Регулярные выражения по умолчанию <code>greedy</code> , поэтому матч вернет <code>["titani"]</code> . Он находит самую большую подстроку, которая может соответствовать шаблону. Однако вы можете использовать <code>?</code> чтобы изменить его на <code>lazy</code> соответствие. <code>"titanic"</code> соответствует настроенному регулярному выражению <code>/t[az]*?i/</code> возвращает <code>["ti"]</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Исправьте regex <code>/<.*>/</code> чтобы вернуть HTML-тег <code><h1></code> а не текст <code>"<h1>Winter is coming</h1>"</code> . Помните шаблон <code>.</code> в регулярном выражении соответствует любому символу. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>result</code> переменной должен быть массив с <code><h1></code> в нем
|
||||
testString: 'assert(result[0] == "<h1>", "The <code>result</code> variable should be an array with <code><h1></code> in it");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let text = "<h1>Winter is coming</h1>";
|
||||
let myRegex = /<.*>/; // Change this line
|
||||
let result = text.match(myRegex);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 587d7db4367417b2b2512b93
|
||||
title: Find More Than the First Match
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: 'Найдите больше, чем первый матч'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> До сих пор вы могли только извлекать или искать шаблон один раз. <blockquote> let testStr = "Повторить, Повторить, Повторить"; <br> let ourRegex = / Repeat /; <br> testStr.match (ourRegex); <br> // Возвращает ["Повторить"] </blockquote> Чтобы искать или извлекать шаблон более одного раза, вы можете использовать флаг <code>g</code> . <blockquote> пусть repeatRegex = / Repeat / g; <br> testStr.match (repeatRegex); <br> // Возвращает ["Повторить", "Повторить", "Повторить"] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
undefined
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению <code>starRegex</code> следует использовать глобальный флаг <code>g</code>
|
||||
testString: 'assert(starRegex.flags.match(/g/).length == 1, "Your regex <code>starRegex</code> should use the global flag <code>g</code>");'
|
||||
- text: '<code>starRegex</code> выражение regex <code>starRegex</code> должно использовать флаг, нечувствительный к регистру <code>i</code>'
|
||||
testString: 'assert(starRegex.flags.match(/i/).length == 1, "Your regex <code>starRegex</code> should use the case insensitive flag <code>i</code>");'
|
||||
- text: Ваш матч должен совпадать с вхождением слова <code>"Twinkle"</code>
|
||||
testString: 'assert(result.sort().join() == twinkleStar.match(/twinkle/gi).sort().join(), "Your match should match both occurrences of the word <code>"Twinkle"</code>");'
|
||||
- text: <code>result</code> матча должен состоять из двух элементов.
|
||||
testString: 'assert(result.length == 2, "Your match <code>result</code> should have two elements in it.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let twinkleStar = "Twinkle, twinkle, little star";
|
||||
let starRegex = /change/; // Change this line
|
||||
let result = twinkleStar; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,67 @@
|
||||
---
|
||||
id: 587d7db7367417b2b2512b9c
|
||||
title: Find One or More Criminals in a Hunt
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Найти одного или нескольких преступников в охоте
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Время для приостановки и тестирования ваших новых навыков написания регулярных выражений. Группа преступников убежала из тюрьмы и убежала, но вы не знаете, сколько. Однако вы знаете, что они остаются рядом друг с другом, когда они вокруг других людей. Вы несете ответственность за обнаружение всех преступников сразу. Вот пример, чтобы посмотреть, как это сделать: regex <code>/z+/</code> соответствует букве <code>z</code> когда она появляется один или несколько раз подряд. Он найдет совпадения во всех следующих строках: <blockquote> «Г» <br> "Zzzzzz" <br> "ABCzzzz" <br> "ZzzzABC" <br> "Abczzzzzzzzzzzzzzzzzzzzzabc" </blockquote> Но он не находит совпадений в следующих строках, поскольку буквы буквы <code>z</code> : <blockquote> «» <br> "ABC" <br> "Abcabc" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Напишите <code>greedy</code> регулярное выражение, которое находит одного или нескольких преступников внутри группы других людей. Преступник представлен заглавной буквой <code>C</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>one</code> преступнику (« <code>C</code> ») в <code>"C"</code>
|
||||
testString: 'assert("C".match(reCriminals) && "C".match(reCriminals)[0] == "C", "Your regex should match <code>one</code> criminal ("<code>C</code>") in <code>"C"</code>");'
|
||||
- text: Ваше регулярное выражение должно совпадать с <code>two</code> преступниками (« <code>CC</code> ») в <code>"CC"</code>
|
||||
testString: 'assert("CC".match(reCriminals) && "CC".match(reCriminals)[0] == "CC", "Your regex should match <code>two</code> criminals ("<code>CC</code>") in <code>"CC"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>three</code> преступникам (« <code>CCC</code> ») в <code>"P1P5P4CCCP2P6P3"</code>
|
||||
testString: 'assert("P1P5P4CCCP2P6P3".match(reCriminals) && "P1P5P4CCCP2P6P3".match(reCriminals)[0] == "CCC", "Your regex should match <code>three</code> criminals ("<code>CCC</code>") in <code>"P1P5P4CCCP2P6P3"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>five</code> преступникам (« <code>CCCCC</code> ») в <code>"P6P2P7P4P5CCCCCP3P1"</code>
|
||||
testString: 'assert("P6P2P7P4P5CCCCCP3P1".match(reCriminals) && "P6P2P7P4P5CCCCCP3P1".match(reCriminals)[0] == "CCCCC", "Your regex should match <code>five</code> criminals ("<code>CCCCC</code>") in <code>"P6P2P7P4P5CCCCCP3P1"</code>");'
|
||||
- text: Ваше регулярное выражение не должно соответствовать никаким преступникам в <code>""</code>
|
||||
testString: 'assert(!reCriminals.test(""), "Your regex should not match any criminals in <code>""</code>");'
|
||||
- text: Ваше регулярное выражение не должно соответствовать никаким преступникам в <code>"P1P2P3"</code>
|
||||
testString: 'assert(!reCriminals.test("P1P2P3"), "Your regex should not match any criminals in <code>"P1P2P3"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>fifty</code> преступникам (« <code>CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC</code> ») в <code>"P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3"</code> .
|
||||
testString: 'assert("P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3".match(reCriminals) && "P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3".match(reCriminals)[0] == "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC", "Your regex should match <code>fifty</code> criminals ("<code>CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC</code>") in <code>"P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// example crowd gathering
|
||||
let crowd = 'P1P2P3P4P5P6CCCP7P8P9';
|
||||
|
||||
let reCriminals = /./; // Change this line
|
||||
|
||||
let matchedCriminals = crowd.match(reCriminals);
|
||||
console.log(matchedCriminals);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: 587d7db4367417b2b2512b91
|
||||
title: Ignore Case While Matching
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Игнорировать случай при сопоставлении
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> До сих пор вы смотрели на регулярные выражения для выполнения буквальных совпадений строк. Но иногда, возможно, вы также захотите сопоставить разницу между случаями. Случай (или иногда буквенный регистр) - это разница между прописными и строчными буквами. Примеры прописных букв: <code>"A"</code> , <code>"B"</code> и <code>"C"</code> . Примеры строчных букв: <code>"a"</code> , <code>"b"</code> и <code>"c"</code> . Вы можете сопоставить оба случая с использованием так называемого флага. Существуют и другие флаги, но здесь вы сосредоточитесь на флагове, который игнорирует регистр - флаг <code>i</code> . Вы можете использовать его, добавив его в регулярное выражение. Примером использования этого флага является <code>/ignorecase/i</code> . Это регулярное выражение может соответствовать строкам <code>"ignorecase"</code> , <code>"igNoreCase"</code> и <code>"IgnoreCase"</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Напишите регулярное выражение <code>fccRegex</code> для соответствия <code>"freeCodeCamp"</code> , независимо от его случая. Ваше регулярное выражение не должно соответствовать аббревиатурам или вариациям с пробелами. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>freeCodeCamp</code>
|
||||
testString: 'assert(fccRegex.test("freeCodeCamp"), "Your regex should match <code>freeCodeCamp</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>FreeCodeCamp</code>
|
||||
testString: 'assert(fccRegex.test("FreeCodeCamp"), "Your regex should match <code>FreeCodeCamp</code>");'
|
||||
- text: Ваше регулярное выражение должно совпадать с <code>FreecodeCamp</code>
|
||||
testString: 'assert(fccRegex.test("FreecodeCamp"), "Your regex should match <code>FreecodeCamp</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>FreeCodecamp</code>
|
||||
testString: 'assert(fccRegex.test("FreeCodecamp"), "Your regex should match <code>FreeCodecamp</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>Free Code Camp</code>
|
||||
testString: 'assert(!fccRegex.test("Free Code Camp"), "Your regex should not match <code>Free Code Camp</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>FreeCOdeCamp</code>
|
||||
testString: 'assert(fccRegex.test("FreeCOdeCamp"), "Your regex should match <code>FreeCOdeCamp</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>FCC</code>
|
||||
testString: 'assert(!fccRegex.test("FCC"), "Your regex should not match <code>FCC</code>");'
|
||||
- text: Ваше регулярное выражение должно совпадать с <code>FrEeCoDeCamp</code>
|
||||
testString: 'assert(fccRegex.test("FrEeCoDeCamp"), "Your regex should match <code>FrEeCoDeCamp</code>");'
|
||||
- text: Ваше регулярное выражение должно совпадать с <code>FrEeCodECamp</code>
|
||||
testString: 'assert(fccRegex.test("FrEeCodECamp"), "Your regex should match <code>FrEeCodECamp</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>FReeCodeCAmp</code>
|
||||
testString: 'assert(fccRegex.test("FReeCodeCAmp"), "Your regex should match <code>FReeCodeCAmp</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let myString = "freeCodeCamp";
|
||||
let fccRegex = /change/; // Change this line
|
||||
let result = fccRegex.test(myString);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 587d7db4367417b2b2512b90
|
||||
title: Match a Literal String with Different Possibilities
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Сопоставьте литеральную строку с различными возможностями
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Используя регулярные выражения, такие как <code>/coding/</code> , вы можете искать шаблон <code>"coding"</code> в другой строке. Это мощно для поиска одиночных строк, но ограничивается только одним шаблоном. Вы можете искать несколько шаблонов с помощью <code>alternation</code> или оператора <code>OR</code> : <code>|</code> , Этот оператор соответствует шаблонам до или после него. Например, если вы хотите совместить <code>"yes"</code> или <code>"no"</code> , вам нужно иметь регулярное выражение <code>/yes|no/</code> . Вы также можете искать не более двух шаблонов. Вы можете сделать это, добавив больше шаблонов с большим количеством операторов <code>OR</code> разделяющих их, например <code>/yes|no|maybe/</code> . </section>
|
||||
|
||||
## Instructions
|
||||
undefined
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение <code>petRegex</code> должно возвращать значение <code>true</code> для строки <code>"John has a pet dog."</code>
|
||||
testString: 'assert(petRegex.test("John has a pet dog."), "Your regex <code>petRegex</code> should return <code>true</code> for the string <code>"John has a pet dog."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!petRegex.test("Emma has a pet rock."), "Your regex <code>petRegex</code> should return <code>false</code> for the string <code>"Emma has a pet rock."</code>");'
|
||||
- text: Ваше регулярное выражение <code>petRegex</code> должно возвращать <code>true</code> для строки <code>"Emma has a pet bird."</code>
|
||||
testString: 'assert(petRegex.test("Emma has a pet bird."), "Your regex <code>petRegex</code> should return <code>true</code> for the string <code>"Emma has a pet bird."</code>");'
|
||||
- text: Ваше регулярное выражение <code>petRegex</code> должно возвращать значение <code>true</code> для строки <code>"Liz has a pet cat."</code>
|
||||
testString: 'assert(petRegex.test("Liz has a pet cat."), "Your regex <code>petRegex</code> should return <code>true</code> for the string <code>"Liz has a pet cat."</code>");'
|
||||
- text: Ваше регулярное выражение <code>petRegex</code> должно возвращать <code>false</code> для строки <code>"Kara has a pet dolphin."</code>
|
||||
testString: 'assert(!petRegex.test("Kara has a pet dolphin."), "Your regex <code>petRegex</code> should return <code>false</code> for the string <code>"Kara has a pet dolphin."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(petRegex.test("Alice has a pet fish."), "Your regex <code>petRegex</code> should return <code>true</code> for the string <code>"Alice has a pet fish."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!petRegex.test("Jimmy has a pet computer."), "Your regex <code>petRegex</code> should return <code>false</code> for the string <code>"Jimmy has a pet computer."</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let petString = "James has a pet cat.";
|
||||
let petRegex = /change/; // Change this line
|
||||
let result = petRegex.test(petString);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7db7367417b2b2512b9f
|
||||
title: Match All Letters and Numbers
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение всех букв и цифр
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Используя классы символов, вы смогли найти все буквы алфавита с помощью <code>[az]</code> . Такой класс символов достаточно распространен, что есть ярлык для него, хотя он включает и несколько дополнительных символов. Самый близкий класс символов в JavaScript для соответствия алфавиту - <code>\w</code> . Этот ярлык равен <code>[A-Za-z0-9_]</code> . Этот класс символов соответствует буквам верхнего и нижнего регистра плюс номерам. Обратите внимание: этот класс символов также включает символ подчеркивания ( <code>_</code> ). <blockquote> пусть longHand = / [A-Za-z0-9 _] + /; <br> пусть shortHand = / \ w + /; <br> пусть числа = «42»; <br> пусть varNames = "important_var"; <br> longHand.test (номера); // Возвращает true <br> shortHand.test (номера); // Возвращает true <br> longHand.test (имя переменный); // Возвращает true <br> shortHand.test (имя переменный); // Возвращает true </blockquote> Эти классы ярлыков символов также известны как <code>shorthand character classes</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте класс символьных символов <code>\w</code> чтобы подсчитать количество буквенно-цифровых символов в разных кавычках и строках. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(alphabetRegexV2.global, "Your regex should use the global flag.");'
|
||||
- text: Вашему регулярному выражению следует использовать сокращенный символ
|
||||
testString: 'assert(/\\w/.test(alphabetRegexV2.source), "Your regex should use the shorthand character <code>\w</code> to match all characters which are alphanumeric.");'
|
||||
- text: Ваше регулярное выражение должно найти 31 буквенно-цифровой символ в <code>"The five boxing wizards jump quickly."</code>
|
||||
testString: 'assert("The five boxing wizards jump quickly.".match(alphabetRegexV2).length === 31, "Your regex should find 31 alphanumeric characters in <code>"The five boxing wizards jump quickly."</code>");'
|
||||
- text: Ваше регулярное выражение должно найти 32 буквенно-цифровых символа в <code>"Pack my box with five dozen liquor jugs."</code>
|
||||
testString: 'assert("Pack my box with five dozen liquor jugs.".match(alphabetRegexV2).length === 32, "Your regex should find 32 alphanumeric characters in <code>"Pack my box with five dozen liquor jugs."</code>");'
|
||||
- text: Вашему регулярному выражению должно быть найдено 30 буквенно-цифровых символов в <code>"How vexingly quick daft zebras jump!"</code>
|
||||
testString: 'assert("How vexingly quick daft zebras jump!".match(alphabetRegexV2).length === 30, "Your regex should find 30 alphanumeric characters in <code>"How vexingly quick daft zebras jump!"</code>");'
|
||||
- text: Ваше регулярное выражение должно найти 36 буквенно-цифровых символов в <code>"123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ."</code>
|
||||
testString: 'assert("123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.".match(alphabetRegexV2).length === 36, "Your regex should find 36 alphanumeric characters in <code>"123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ."</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "The five boxing wizards jump quickly.";
|
||||
let alphabetRegexV2 = /change/; // Change this line
|
||||
let result = quoteSample.match(alphabetRegexV2).length;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 587d7db8367417b2b2512ba1
|
||||
title: Match All Non-Numbers
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение всех не-чисел
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Последняя задача показала, как искать цифры с помощью ярлыка <code>\d</code> с нижним регистром <code>d</code> . Вы также можете искать нецифровые символы, используя аналогичный ярлык, который использует вместо этого верхний регистр <code>D</code> Ярлык поиска несимметричных символов - <code>\D</code> Это равно классу символов <code>[^0-9]</code> , который ищет один символ, который не является числом от нуля до девяти. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте класс сокращенного символа для нецифровых цифр <code>\D</code> чтобы подсчитать, сколько цифр не указано в названиях фильмов. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать символ ярлыка для соответствия несимметричным символам
|
||||
testString: 'assert(/\\D/.test(noNumRegex.source), "Your regex should use the shortcut character to match non-digit characters");'
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(noNumRegex.global, "Your regex should use the global flag.");'
|
||||
- text: Ваше регулярное выражение не должно содержать никаких цифр в <code>"9"</code> .
|
||||
testString: 'assert("9".match(noNumRegex) == null, "Your regex should find no non-digits in <code>"9"</code>.");'
|
||||
- text: Ваше регулярное выражение должно найти 6 цифр в <code>"Catch 22"</code> .
|
||||
testString: 'assert("Catch 22".match(noNumRegex).length == 6, "Your regex should find 6 non-digits in <code>"Catch 22"</code>.");'
|
||||
- text: Ваше регулярное выражение должно найти 11 разрядов в <code>"101 Dalmatians"</code> .
|
||||
testString: 'assert("101 Dalmatians".match(noNumRegex).length == 11, "Your regex should find 11 non-digits in <code>"101 Dalmatians"</code>.");'
|
||||
- text: 'Ваше регулярное выражение должно найти 15 цифр в <code>"One, Two, Three"</code> .'
|
||||
testString: 'assert("One, Two, Three".match(noNumRegex).length == 15, "Your regex should find 15 non-digits in <code>"One, Two, Three"</code>.");'
|
||||
- text: Ваше регулярное выражение должно найти 12 разрядов в <code>"21 Jump Street"</code> .
|
||||
testString: 'assert("21 Jump Street".match(noNumRegex).length == 12, "Your regex should find 12 non-digits in <code>"21 Jump Street"</code>.");'
|
||||
- text: 'Ваше регулярное выражение должно найти 17 разрядов в <code>"2001: A Space Odyssey"</code> .'
|
||||
testString: 'assert("2001: A Space Odyssey".match(noNumRegex).length == 17, "Your regex should find 17 non-digits in <code>"2001: A Space Odyssey"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let numString = "Your sandwich will be $5.00";
|
||||
let noNumRegex = /change/; // Change this line
|
||||
let result = numString.match(noNumRegex).length;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5d712346c441eddfaeb5bdef
|
||||
title: Match All Numbers
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение всех номеров
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы узнали ярлыки для общих строковых шаблонов, таких как alphanumerics. Другой общий шаблон - это просто цифры или цифры. Ярлык для поиска цифровых символов - <code>\d</code> , с нижним регистром <code>d</code> . Это равно классу символов <code>[0-9]</code> , который ищет один символ любого числа от нуля до девяти. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте класс сокращенного символа <code>\d</code> чтобы подсчитать, сколько цифр указано в названиях фильмов. Письменные номера («шесть» вместо 6) не учитываются. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать символ ярлыка для соответствия символам цифр
|
||||
testString: 'assert(/\\d/.test(numRegex.source), "Your regex should use the shortcut character to match digit characters");'
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(numRegex.global, "Your regex should use the global flag.");'
|
||||
- text: Ваше регулярное выражение должно найти 1 цифру в <code>"9"</code> .
|
||||
testString: 'assert("9".match(numRegex).length == 1, "Your regex should find 1 digit in <code>"9"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert("Catch 22".match(numRegex).length == 2, "Your regex should find 2 digits in <code>"Catch 22"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert("101 Dalmatians".match(numRegex).length == 3, "Your regex should find 3 digits in <code>"101 Dalmatians"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert("One, Two, Three".match(numRegex) == null, "Your regex should find no digits in <code>"One, Two, Three"</code>.");'
|
||||
- text: Ваше регулярное выражение должно найти 2 цифры в <code>"21 Jump Street"</code> .
|
||||
testString: 'assert("21 Jump Street".match(numRegex).length == 2, "Your regex should find 2 digits in <code>"21 Jump Street"</code>.");'
|
||||
- text: 'Ваше регулярное выражение должно найти 4 цифры в <code>"2001: A Space Odyssey"</code> .'
|
||||
testString: 'assert("2001: A Space Odyssey".match(numRegex).length == 4, "Your regex should find 4 digits in <code>"2001: A Space Odyssey"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let numString = "Your sandwich will be $5.00";
|
||||
let numRegex = /change/; // Change this line
|
||||
let result = numString.match(numRegex).length;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: 587d7db5367417b2b2512b94
|
||||
title: Match Anything with Wildcard Period
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Сопоставить все с подстановочным периодом
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Иногда вам не нужно (или не нужно) знать точные символы в ваших шаблонах. Думать обо всех словах, которые совпадают, скажем, с орфографией, займет много времени. К счастью, вы можете сэкономить время , используя подстановочные символы: <code>.</code> Символ подстановки <code>.</code> будет соответствовать любому персонажу. Подстановочный знак также называется <code>dot</code> и <code>period</code> . Вы можете использовать подстановочный знак, как и любой другой символ в регулярном выражении. Например, если вы хотите совместить <code>"hug"</code> , <code>"huh"</code> , <code>"hut"</code> и <code>"hum"</code> , вы можете использовать regex <code>/hu./</code> для соответствия всем четырем словам. <blockquote> пусть humStr = «Я буду напевать песню»; <br> let hugStr = «Обнимать медведя»; <br> пусть huRegex = /hu./; <br> humStr.match (huRegex); // Возвращает ["гул"] <br> hugStr.match (huRegex); // Возвращает ["hug"] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Заполните regex <code>unRegex</code> так, чтобы он соответствовал строкам <code>"run"</code> , <code>"sun"</code> , <code>"fun"</code> , <code>"pun"</code> , <code>"nun"</code> и <code>"bun"</code> . В вашем регулярном выражении должен использоваться символ подстановки. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вы должны использовать метод <code>.test()</code> .
|
||||
testString: 'assert(code.match(/\.test\(.*\)/), "You should use the <code>.test()</code> method.");'
|
||||
- text: Вы должны использовать символ подстановки в своем регулярном выражении <code>unRegex</code>
|
||||
testString: 'assert(/\./.test(unRegex.source), "You should use the wildcard character in your regex <code>unRegex</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("Let us go on a run."), "Your regex <code>unRegex</code> should match <code>"run"</code> in <code>"Let us go on a run."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("The sun is out today."), "Your regex <code>unRegex</code> should match <code>"sun"</code> in <code>"The sun is out today."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("Coding is a lot of fun."), "Your regex <code>unRegex</code> should match <code>"fun"</code> in <code>"Coding is a lot of fun."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("Seven days without a pun makes one weak."), "Your regex <code>unRegex</code> should match <code>"pun"</code> in <code>"Seven days without a pun makes one weak."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("One takes a vow to be a nun."), "Your regex <code>unRegex</code> should match <code>"nun"</code> in <code>"One takes a vow to be a nun."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(unRegex.test("She got fired from the hot dog stand for putting her hair in a bun."), "Your regex <code>unRegex</code> should match <code>"bun"</code> in <code>"She got fired from the hot dog stand for putting her hair in a bun."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!unRegex.test("There is a bug in my code."), "Your regex <code>unRegex</code> should not match <code>"There is a bug in my code."</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!unRegex.test("Can me if you can."), "Your regex <code>unRegex</code> should not match <code>"Catch me if you can."</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let exampleStr = "Let's have fun with regular expressions!";
|
||||
let unRegex = /change/; // Change this line
|
||||
let result = unRegex.test(exampleStr);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 587d7db7367417b2b2512b9d
|
||||
title: Match Beginning String Patterns
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Сопоставление начальных шаблонов строк
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Предыдущие проблемы показали, что регулярные выражения могут использоваться для поиска нескольких совпадений. Они также используются для поиска шаблонов в определенных положениях в строках. В более ранней задаче вы использовали символ <code>caret</code> ( <code>^</code> ) внутри <code>character set</code> чтобы создать <code>negated character set</code> в форме <code>[^thingsThatWillNotBeMatched]</code> . Вне <code>character set</code> <code>caret</code> используется для поиска шаблонов в начале строк. <blockquote> пусть firstString = "Ricky является первым и может быть найден."; <br> пусть firstRegex = / ^ Ricky /; <br> firstRegex.test (firstString); <br> // Возвращает true <br> let notFirst = «Теперь вы не можете найти Рики»; <br> firstRegex.test (notFirst); <br> // Возвращает false </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте символ <code>caret</code> в регулярном выражении, чтобы найти <code>"Cal"</code> только в начале строки <code>rickyAndCal</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует искать <code>"Cal"</code> с большой буквы.
|
||||
testString: 'assert(calRegex.source == "^Cal", "Your regex should search for <code>"Cal"</code> with a capital letter.");'
|
||||
- text: В вашем регулярном выражении не должно использоваться никаких флагов.
|
||||
testString: 'assert(calRegex.flags == "", "Your regex should not use any flags.");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Cal"</code> в начале строки.
|
||||
testString: 'assert(calRegex.test("Cal and Ricky both like racing."), "Your regex should match <code>"Cal"</code> at the beginning of the string.");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Cal"</code> в середине строки.
|
||||
testString: 'assert(!calRegex.test("Ricky and Cal both like racing."), "Your regex should not match <code>"Cal"</code> in the middle of a string.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let rickyAndCal = "Cal and Ricky both like racing.";
|
||||
let calRegex = /change/; // Change this line
|
||||
let result = calRegex.test(rickyAndCal);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db6367417b2b2512b99
|
||||
title: Match Characters that Occur One or More Times
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: 'Символы, которые встречаются один или несколько раз'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Иногда вам нужно сопоставить символ (или группу символов), который появляется один или несколько раз подряд. Это означает, что это происходит по крайней мере один раз и может повторяться. Вы можете использовать символ <code>+</code> чтобы проверить, так ли это. Помните, что персонаж или шаблон должны присутствовать последовательно. То есть, персонаж должен повторять один за другим. Например, <code>/a+/g</code> найдет одно совпадение в <code>"abc"</code> и вернет <code>["a"]</code> . Из-за <code>+</code> , он также найдет одно совпадение в <code>"aabc"</code> и вернет <code>["aa"]</code> . Если бы это было вместо проверки строки <code>"abab"</code> , было бы найти два матча и вернуться <code>["a", "a"]</code> , потому что <code>a</code> символы не в ряд - есть <code>b</code> между ними. Наконец, поскольку в строке <code>"bcd"</code> нет <code>"a"</code> <code>"bcd"</code> , он не найдет соответствия. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Вы хотите , чтобы найти спички , когда буква <code>s</code> происходит один или несколько раз в <code>"Mississippi"</code> . Напишите регулярное выражение, которое использует знак <code>+</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Ваше регулярное выражение <code>myRegex</code> следует использовать <code>+</code> знак , чтобы соответствовать один или несколько <code>s</code> символов.'
|
||||
testString: 'assert(/\+/.test(myRegex.source), "Your regex <code>myRegex</code> should use the <code>+</code> sign to match one or more <code>s</code> characters.");'
|
||||
- text: Ваше регулярное выражение <code>myRegex</code> должно совпадать с двумя элементами.
|
||||
testString: 'assert(result.length == 2, "Your regex <code>myRegex</code> should match 2 items.");'
|
||||
- text: <code>result</code> переменной должен быть массив с двумя совпадениями <code>"ss"</code>
|
||||
testString: 'assert(result[0] == "ss" && result[1] == "ss", "The <code>result</code> variable should be an array with two matches of <code>"ss"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let difficultSpelling = "Mississippi";
|
||||
let myRegex = /change/; // Change this line
|
||||
let result = difficultSpelling.match(myRegex);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 587d7db6367417b2b2512b9a
|
||||
title: Match Characters that Occur Zero or More Times
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: 'Символы соответствия, которые имеют нулевой или более длительный период'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Последний вызов использовал знак плюс <code>+</code> для поиска символов, которые происходят один или несколько раз. Также есть опция, которая соответствует символам, которые появляются ноль или более раз. Характер для этого - <code>asterisk</code> или <code>star</code> : <code>*</code> . <blockquote> let soccerWord = "gooooooooal!"; <br> пусть gPhrase = «чувство кишки»; <br> пусть oPhrase = "над луной"; <br> let goRegex = / go * /; <br> soccerWord.match (goRegex); // Возвращает ["goooooooo"] <br> gPhrase.match (goRegex); // Возвращает ["g"] <br> oPhrase.match (goRegex); // Возвращает значение null </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Создайте regex <code>chewieRegex</code> который использует символ <code>*</code> чтобы соответствовать всем верхним и нижним символам <code>"a"</code> в <code>chewieQuote</code> . Вашему регулярному выражению не нужны флаги, и он не должен совпадать с какими-либо другими цитатами. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваша регулярное выражение <code>chewieRegex</code> следует использовать <code>*</code> символ соответствует нулю или более символов. <code>a</code>
|
||||
testString: 'assert(/\*/.test(chewieRegex.source), "Your regex <code>chewieRegex</code> should use the <code>*</code> character to match zero or more <code>a</code> characters.");'
|
||||
- text: Ваше регулярное выражение <code>chewieRegex</code> должно совпадать с 16 символами.
|
||||
testString: 'assert(result[0].length === 16, "Your regex <code>chewieRegex</code> should match 16 characters.");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Aaaaaaaaaaaaaaaa"</code> .
|
||||
testString: 'assert(result[0] === "Aaaaaaaaaaaaaaaa", "Your regex should match <code>"Aaaaaaaaaaaaaaaa"</code>.");'
|
||||
- text: 'Ваше регулярное выражение не должно совпадать с символами в <code>"He made a fair move. Screaming about it can't help you."</code>'
|
||||
testString: 'assert(!"He made a fair move. Screaming about it can\"t help you.".match(chewieRegex), "Your regex should not match any characters in <code>"He made a fair move. Screaming about it can't help you."</code>");'
|
||||
- text: 'Ваше регулярное выражение не должно совпадать с символами в <code>"Let him have it. It's not wise to upset a Wookiee."</code>'
|
||||
testString: 'assert(!"Let him have it. It\"s not wise to upset a Wookiee.".match(chewieRegex), "Your regex should not match any characters in <code>"Let him have it. It's not wise to upset a Wookiee."</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
|
||||
let chewieRegex = /change/; // Change this line
|
||||
let result = chewieQuote.match(chewieRegex);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db7367417b2b2512b9e
|
||||
title: Match Ending String Patterns
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Шаблоны контуров соответствия
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> В последней задаче вы научились использовать символ <code>caret</code> для поиска шаблонов в начале строк. Существует также способ поиска шаблонов в конце строк. Вы можете искать конец строк, используя <code>dollar sign</code> <code>$</code> в конце регулярного выражения. <blockquote> пусть TheEnding = «Это бесконечная история»; <br> let storyRegex = / story $ /; <br> storyRegex.test (theEnding); <br> // Возвращает true <br> let noEnding = "Иногда история должна закончиться"; <br> storyRegex.test (noEnding); <br> // Возвращает false <br></blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте символ привязки ( <code>$</code> ), чтобы соответствовать строке <code>"caboose"</code> в конце строки <code>caboose</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ''
|
||||
testString: 'assert(lastRegex.source == "caboose$", "You should search for <code>"caboose"</code> with the dollar sign <code>$</code> anchor in your regex.");'
|
||||
- text: ''
|
||||
testString: 'assert(lastRegex.flags == "", "Your regex should not use any flags.");'
|
||||
- text: Вы должны соответствовать <code>"caboose"</code> в конце строки <code>"The last car on a train is the caboose"</code>
|
||||
testString: 'assert(lastRegex.test("The last car on a train is the caboose"), "You should match <code>"caboose"</code> at the end of the string <code>"The last car on a train is the caboose"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let caboose = "The last car on a train is the caboose";
|
||||
let lastRegex = /change/; // Change this line
|
||||
let result = lastRegex.test(caboose);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7db8367417b2b2512ba0
|
||||
title: Match Everything But Letters and Numbers
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: 'Совсем все, кроме букв и цифр'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы узнали, что вы можете использовать ярлык для соответствия буквенно-цифровым <code>[A-Za-z0-9_]</code> с помощью <code>\w</code> . Естественным шаблоном, который вы, возможно, захотите найти, является противоположность буквенно-цифровых символов. Вы можете искать противоположное <code>\w</code> с <code>\W</code> Обратите внимание, что противоположный шаблон использует заглавную букву. Этот ярлык совпадает с <code>[^A-Za-z0-9_]</code> . <blockquote> пусть shortHand = / \ W /; <br> пусть числа = «42%»; <br> пусть предложение = «Кодирование!»; <br> numbers.match (стенографии); // Возвращает ["%"] <br> sentence.match (стенографии); // Возвращает ["!"] <br></blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте класс сокращенного символа <code>\W</code> чтобы подсчитать количество не буквенно-цифровых символов в разных кавычках и строках. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(nonAlphabetRegex.global, "Your regex should use the global flag.");'
|
||||
- text: 'Ваше регулярное выражение должно найти 6 букв в алфавитном порядке в <code>"The five boxing wizards jump quickly."</code> ,'
|
||||
testString: 'assert("The five boxing wizards jump quickly.".match(nonAlphabetRegex).length == 6, "Your regex should find 6 non-alphanumeric characters in <code>"The five boxing wizards jump quickly."</code>.");'
|
||||
- text: В вашем регулярном выражении должен использоваться сокращенный символ.
|
||||
testString: 'assert(/\\W/.test(nonAlphabetRegex.source), "Your regex should use the shorthand character to match characters which are non-alphanumeric.");'
|
||||
- text: Ваше регулярное выражение должно найти 8 букв в алфавитном порядке в <code>"Pack my box with five dozen liquor jugs."</code>
|
||||
testString: 'assert("Pack my box with five dozen liquor jugs.".match(nonAlphabetRegex).length == 8, "Your regex should find 8 non-alphanumeric characters in <code>"Pack my box with five dozen liquor jugs."</code>");'
|
||||
- text: 'В вашем регулярном выражении должно быть найдено 6 символов, отличных от алфавитно-цифровых символов, в <code>"How vexingly quick daft zebras jump!"</code>'
|
||||
testString: 'assert("How vexingly quick daft zebras jump!".match(nonAlphabetRegex).length == 6, "Your regex should find 6 non-alphanumeric characters in <code>"How vexingly quick daft zebras jump!"</code>");'
|
||||
- text: 'В вашем регулярном выражении должно быть найдено 12 символов, отличных от буквенно-цифровых символов, в <code>"123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ."</code>'
|
||||
testString: 'assert("123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.".match(nonAlphabetRegex).length == 12, "Your regex should find 12 non-alphanumeric characters in <code>"123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ."</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "The five boxing wizards jump quickly.";
|
||||
let nonAlphabetRegex = /change/; // Change this line
|
||||
let result = quoteSample.match(nonAlphabetRegex).length;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db5367417b2b2512b96
|
||||
title: Match Letters of the Alphabet
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Матч-буквы алфавита
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы видели, как вы можете использовать <code>character sets</code> чтобы указать группу символов для соответствия, но это очень много, когда вам нужно сопоставить большой диапазон символов (например, каждую букву в алфавите). К счастью, есть встроенная функция, которая делает это коротким и простым. Внутри <code>character set</code> вы можете определить диапазон символов в соответствии с символом <code>hyphen</code> : <code>-</code> . Например, чтобы соответствовать строчным буквам от <code>a</code> до <code>e</code> вы должны использовать <code>[ae]</code> . <blockquote> let catStr = "cat"; <br> let batStr = "bat"; <br> пусть matStr = "мат"; <br> пусть bgRegex = / [ae] at /; <br> catStr.match (bgRegex); // Возвращает ["cat"] <br> batStr.match (bgRegex); // Возвращает ["bat"] <br> matStr.match (bgRegex); // Возвращает значение null </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Сопоставьте все буквы в строке <code>quoteSample</code> . <strong>Заметка</strong> <br> Обязательно сопоставляйте <strong>буквы</strong> верхнего и нижнего регистра <strong><strong>.</strong></strong> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение <code>alphabetRegex</code> должно соответствовать 35 пунктам.
|
||||
testString: 'assert(result.length == 35, "Your regex <code>alphabetRegex</code> should match 35 items.");'
|
||||
- text: Ваша регулярное выражение <code>alphabetRegex</code> следует использовать глобальный флаг.
|
||||
testString: 'assert(alphabetRegex.flags.match(/g/).length == 1, "Your regex <code>alphabetRegex</code> should use the global flag.");'
|
||||
- text: Ваша регулярное выражение <code>alphabetRegex</code> следует использовать регистрозависимости флаг.
|
||||
testString: 'assert(alphabetRegex.flags.match(/i/).length == 1, "Your regex <code>alphabetRegex</code> should use the case insensitive flag.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "The quick brown fox jumps over the lazy dog.";
|
||||
let alphabetRegex = /change/; // Change this line
|
||||
let result = alphabetRegex; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db3367417b2b2512b8f
|
||||
title: Match Literal Strings
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Литературные строки
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> В последнем вызове вы искали слово <code>"Hello"</code> используя регулярное выражение <code>/Hello/</code> . Это регулярное выражение искало буквальное совпадение строки <code>"Hello"</code> . Вот еще один пример поиска литерального соответствия строки <code>"Kevin"</code> : <blockquote> пусть testStr = «Привет, меня зовут Кевин»; <br> пусть testRegex = / Kevin /; <br> testRegex.test (testStr); <br> // Возвращает true </blockquote> Любые другие формы <code>"Kevin"</code> не совпадают. Например, regex <code>/Kevin/</code> не будет соответствовать <code>"kevin"</code> или <code>"KEVIN"</code> . <blockquote> let wrongRegex = / kevin /; <br> wrongRegex.test (testStr); <br> // Возвращает false </blockquote> Будущая задача покажет, как соотнести эти другие формы. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Заполните regex <code>waldoRegex</code> чтобы найти <code>"Waldo"</code> в строке <code>waldoIsHiding</code> с буквальным совпадением. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение <code>waldoRegex</code> должно найти <code>"Waldo"</code>
|
||||
testString: 'assert(waldoRegex.test(waldoIsHiding), "Your regex <code>waldoRegex</code> should find <code>"Waldo"</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!waldoRegex.test("Somewhere is hiding in this text."), "Your regex <code>waldoRegex</code> should not search for anything else.");'
|
||||
- text: Вы должны выполнить буквальное совпадение строк с вашим регулярным выражением.
|
||||
testString: 'assert(!/\/.*\/i/.test(code), "You should perform a literal string match with your regex.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
|
||||
let waldoRegex = /search/; // Change this line
|
||||
let result = waldoRegex.test(waldoIsHiding);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 587d7db9367417b2b2512ba4
|
||||
title: Match Non-Whitespace Characters
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение символов без пробелов
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы узнали о поиске пробельных с помощью <code>\s</code> , со строчной <code>s</code> . Вы также можете искать все, кроме пробелов. Поиск непробельных с помощью <code>\S</code> , который является прописной <code>s</code> . Этот шаблон не будет соответствовать пробелам, возврату каретки, вкладке, фиду формы и новым строковым символам. Вы можете думать, что это похоже на класс символов <code>[^ \r\t\f\n\v]</code> . <blockquote> let whiteSpace = "Пробел. Пробел везде!" <br> пусть nonSpaceRegex = / \ S / g; <br> whiteSpace.match (nonSpaceRegex) .length; // Возвращает 32 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените регулярное выражение <code>countNonWhiteSpace</code> чтобы искать несколько небелых символов в строке. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(countNonWhiteSpace.global, "Your regex should use the global flag.");'
|
||||
- text: Вашему регулярному выражению следует использовать сокращенный символ
|
||||
testString: 'assert(/\\S/.test(countNonWhiteSpace.source), "Your regex should use the shorthand character <code>\S/code> to match all non-whitespace characters.");'
|
||||
- text: Ваше регулярное выражение должно найти 35 не-пробелов в <code>"Men are from Mars and women are from Venus."</code>
|
||||
testString: 'assert("Men are from Mars and women are from Venus.".match(countNonWhiteSpace).length == 35, "Your regex should find 35 non-spaces in <code>"Men are from Mars and women are from Venus."</code>");'
|
||||
- text: 'Ваше регулярное выражение должно найти 23 пробела в <code>"Space: the final frontier."</code>'
|
||||
testString: 'assert("Space: the final frontier.".match(countNonWhiteSpace).length == 23, "Your regex should find 23 non-spaces in <code>"Space: the final frontier."</code>");'
|
||||
- text: Ваше регулярное выражение должно найти 21 пробел в <code>"MindYourPersonalSpace"</code>
|
||||
testString: 'assert("MindYourPersonalSpace".match(countNonWhiteSpace).length == 21, "Your regex should find 21 non-spaces in <code>"MindYourPersonalSpace"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let sample = "Whitespace is important in separating words";
|
||||
let countNonWhiteSpace = /change/; // Change this line
|
||||
let result = sample.match(countNonWhiteSpace);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db5367417b2b2512b97
|
||||
title: Match Numbers and Letters of the Alphabet
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Спичечные номера и буквы алфавита
|
||||
---
|
||||
|
||||
## Description
|
||||
undefined
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Создайте одно регулярное выражение, соответствующее диапазону букв между <code>h</code> и <code>s</code> , и диапазон чисел от <code>2</code> до <code>6</code> . Не забудьте включить соответствующие флаги в регулярное выражение. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше regex <code>myRegex</code> должно соответствовать 17 элементам.
|
||||
testString: 'assert(result.length == 17, "Your regex <code>myRegex</code> should match 17 items.");'
|
||||
- text: ''
|
||||
testString: 'assert(myRegex.flags.match(/g/).length == 1, "Your regex <code>myRegex</code> should use the global flag.");'
|
||||
- text: ''
|
||||
testString: 'assert(myRegex.flags.match(/i/).length == 1, "Your regex <code>myRegex</code> should use the case insensitive flag.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "Blueberry 3.141592653s are delicious.";
|
||||
let myRegex = /change/; // Change this line
|
||||
let result = myRegex; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 587d7db5367417b2b2512b95
|
||||
title: Match Single Character with Multiple Possibilities
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совместный персонаж с несколькими возможностями
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы узнали, как сопоставить литералы ( <code>/literal/</code> ) и подстановочный знак ( <code>/./</code> ). Это крайности регулярных выражений, где вы найдете точные совпадения, а другие - все. Существуют варианты, которые являются балансом между двумя крайностями. Вы можете искать буквенный шаблон с некоторой гибкостью с <code>character classes</code> . Классы символов позволяют вам определять группу символов, которые вы хотите сопоставить, помещая их в квадратные ( <code>[</code> и <code>]</code> ) скобки. Например, вы хотите совместить <code>"bag"</code> , <code>"big"</code> и <code>"bug"</code> но не <code>"bog"</code> . Вы можете создать regex <code>/b[aiu]g/</code> для этого. <code>[aiu]</code> - это класс символов, который будет соответствовать только символам <code>"a"</code> , <code>"i"</code> или <code>"u"</code> . <blockquote> пусть bigStr = «большой»; <br> let bagStr = "bag"; <br> let bugStr = "ошибка"; <br> пусть bogStr = "болото"; <br> пусть bgRegex = / b [aiu] g /; <br> bigStr.match (bgRegex); // Возвращает ["большой"] <br> bagStr.match (bgRegex); // Возвращает ["bag"] <br> bugStr.match (bgRegex); // Возвращает ["bug"] <br> bogStr.match (bgRegex); // Возвращает значение null </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте класс символов с гласными ( <code>a</code> , <code>e</code> , <code>i</code> , <code>o</code> , <code>u</code> ) в вашем регулярном выражении <code>vowelRegex</code> чтобы найти все гласные в строке <code>quoteSample</code> . <strong>Заметка</strong> <br> Обязательно сопоставляйте гласные и нижние строчные гласные. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вы должны найти все 25 гласных.
|
||||
testString: 'assert(result.length == 25, "You should find all 25 vowels.");'
|
||||
- text: Ваш regex <code>vowelRegex</code> должен использовать класс символов.
|
||||
testString: 'assert(/\[.*\]/.test(vowelRegex.source), "Your regex <code>vowelRegex</code> should use a character class.");'
|
||||
- text: Ваш regex <code>vowelRegex</code> должен использовать глобальный флаг.
|
||||
testString: 'assert(vowelRegex.flags.match(/g/).length == 1, "Your regex <code>vowelRegex</code> should use the global flag.");'
|
||||
- text: 'В вашем регулярном выражении <code>vowelRegex</code> должен использоваться флаг, нечувствительный к регистру.'
|
||||
testString: 'assert(vowelRegex.flags.match(/i/).length == 1, "Your regex <code>vowelRegex</code> should use the case insensitive flag.");'
|
||||
- text: Ваше регулярное выражение не должно соответствовать согласным.
|
||||
testString: 'assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()), "Your regex should not match any consonants.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
|
||||
let vowelRegex = /change/; // Change this line
|
||||
let result = vowelRegex; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7db6367417b2b2512b98
|
||||
title: Match Single Characters Not Specified
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение отдельных символов не указано
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Пока вы создали набор символов, которые вы хотите сопоставить, но вы также можете создать набор символов, которые вы не хотите сопоставлять. Эти типы наборов символов называются <code>negated character sets</code> . Чтобы создать <code>negated character set</code> , вы поместите символ <code>caret</code> ( <code>^</code> ) после открывающей скобки и перед символами, которые вы не хотите сопоставлять. Например, <code>/[^aeiou]/gi</code> соответствует всем символам, которые не являются гласным. Обратите внимание, что символы вроде <code>.</code> , <code>!</code> , <code>[</code> , <code>@</code> , <code>/</code> и пробел совпадают - набор символов отрицательного гласного исключает только символы гласных. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Создайте одно регулярное выражение, соответствующее всем символам, которые не являются числом или гласным. Не забудьте включить соответствующие флаги в регулярное выражение. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение <code>myRegex</code> должно соответствовать 9 элементам.
|
||||
testString: 'assert(result.length == 9, "Your regex <code>myRegex</code> should match 9 items.");'
|
||||
- text: Ваш regex <code>myRegex</code> должен использовать глобальный флаг.
|
||||
testString: 'assert(myRegex.flags.match(/g/).length == 1, "Your regex <code>myRegex</code> should use the global flag.");'
|
||||
- text: 'В regex <code>myRegex</code> должен использоваться флаг, нечувствительный к регистру.'
|
||||
testString: 'assert(myRegex.flags.match(/i/).length == 1, "Your regex <code>myRegex</code> should use the case insensitive flag.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let quoteSample = "3 blind mice.";
|
||||
let myRegex = /change/; // Change this line
|
||||
let result = myRegex; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 587d7db8367417b2b2512ba3
|
||||
title: Match Whitespace
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Совпадение пробелов
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> На сегодняшний день проблемы охватывают соответствующие буквы алфавита и цифры. Вы также можете сопоставить пробелы или пробелы между буквами. Вы можете искать пробелы с помощью <code>\s</code> , которая является строчной <code>s</code> . Этот шаблон не только соответствует пробелу, но также возвращает карету, вкладку, форму и новые символы строки. Вы можете считать это похожим на класс символов <code>[ \r\t\f\n\v]</code> . <blockquote> let whiteSpace = "Пробел. Пробел везде!" <br> пусть пространство Regex = / \ s / g; <br> whiteSpace.match (spaceRegex); <br> // Возвращает ["", ""] <br></blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените регулярное выражение <code>countWhiteSpace</code> для поиска нескольких символов пробела в строке. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: В вашем регулярном выражении должен использоваться глобальный флаг.
|
||||
testString: 'assert(countWhiteSpace.global, "Your regex should use the global flag.");'
|
||||
- text: Вашему регулярному выражению следует использовать сокращенный символ
|
||||
testString: 'assert(/\\s/.test(countWhiteSpace.source), "Your regex should use the shorthand character <code>\s</code> to match all whitespace characters.");'
|
||||
- text: Ваше регулярное выражение должно найти восемь пробелов в <code>"Men are from Mars and women are from Venus."</code>
|
||||
testString: 'assert("Men are from Mars and women are from Venus.".match(countWhiteSpace).length == 8, "Your regex should find eight spaces in <code>"Men are from Mars and women are from Venus."</code>");'
|
||||
- text: 'Ваше регулярное выражение должно найти три пробела в <code>"Space: the final frontier."</code>'
|
||||
testString: 'assert("Space: the final frontier.".match(countWhiteSpace).length == 3, "Your regex should find three spaces in <code>"Space: the final frontier."</code>");'
|
||||
- text: Ваше регулярное выражение не должно <code>"MindYourPersonalSpace"</code> пробелов в <code>"MindYourPersonalSpace"</code>
|
||||
testString: 'assert("MindYourPersonalSpace".match(countWhiteSpace) == null, "Your regex should find no spaces in <code>"MindYourPersonalSpace"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let sample = "Whitespace is important in separating words";
|
||||
let countWhiteSpace = /change/; // Change this line
|
||||
let result = sample.match(countWhiteSpace);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 587d7dba367417b2b2512ba9
|
||||
title: Positive and Negative Lookahead
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Положительный и отрицательный Lookahead
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> <code>Lookaheads</code> - это шаблоны, которые говорят JavaScript для поиска в вашей строке, чтобы проверить шаблоны далее. Это может быть полезно, если вы хотите искать несколько шаблонов по одной и той же строке. Есть два вида <code>lookaheads</code> : <code>positive lookahead</code> и <code>negative lookahead</code> . <code>positive lookahead</code> взгляд будет выглядеть так, чтобы убедиться, что элемент в шаблоне поиска существует, но на самом деле не будет соответствовать ему. Положительный lookahead используется как <code>(?=...)</code> где <code>...</code> - искомая часть, которая не сопоставляется. С другой стороны, <code>negative lookahead</code> взгляд будет выглядеть так, чтобы убедиться, что элемент в шаблоне поиска отсутствует. Отрицательный lookahead используется как <code>(?!...)</code> где <code>...</code> это шаблон, который вы не хотите быть там. Остальная часть шаблона возвращается, если отрицательная обратная сторона отсутствует. Lookaheads немного запутывают, но некоторые примеры помогут. <blockquote> пусть quit = "qu"; <br> пусть noquit = "qt"; <br> пусть quRegex = / q (? = u) /; <br> пусть qRegex = / q (?! u) /; <br> quit.match (quRegex); // Возвращает ["q"] <br> noquit.match (qRegex); // Возвращает ["q"] </blockquote> Более практическое использование <code>lookaheads</code> - проверка двух или более шаблонов в одной строке. Вот (наивно) простая проверка пароля, которая ищет от 3 до 6 символов и по крайней мере одно число: <blockquote> пусть пароль = "abc123"; <br> пусть checkPass = / (? = \ w {3,6}) (? = \ D * \ d) /; <br> checkPass.test (пароль); // Возвращает true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Используйте <code>lookaheads</code> в <code>pwRegex</code> , чтобы соответствовать пароли, которые больше 5 символов и имеют две последовательные цифры. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение должно использовать два положительных <code>lookaheads</code> .
|
||||
testString: 'assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null, "Your regex should use two positive <code>lookaheads</code>.");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"astronaut"</code>
|
||||
testString: 'assert(!pwRegex.test("astronaut"), "Your regex should not match <code>"astronaut"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"airplanes"</code>
|
||||
testString: 'assert(!pwRegex.test("airplanes"), "Your regex should not match <code>"airplanes"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"banan1"</code>
|
||||
testString: 'assert(!pwRegex.test("banan1"), "Your regex should not match <code>"banan1"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"bana12"</code>
|
||||
testString: 'assert(pwRegex.test("bana12"), "Your regex should match <code>"bana12"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"abc123"</code>
|
||||
testString: 'assert(pwRegex.test("abc123"), "Your regex should match <code>"abc123"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"123"</code>
|
||||
testString: 'assert(!pwRegex.test("123"), "Your regex should not match <code>"123"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"1234"</code>
|
||||
testString: 'assert(!pwRegex.test("1234"), "Your regex should not match <code>"1234"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let sampleWord = "astronaut";
|
||||
let pwRegex = /change/; // Change this line
|
||||
let result = pwRegex.test(sampleWord);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7dbb367417b2b2512bac
|
||||
title: Remove Whitespace from Start and End
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Удаление пробелов от начала и конца
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Иногда пробельные символы вокруг строк не нужны, но есть. Типичная обработка строк - удаление пробелов в начале и в конце. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Напишите регулярное выражение и используйте соответствующие строковые методы для удаления пробелов в начале и в конце строк. <strong>Заметка</strong> <br> Здесь будет работать метод <code>.trim()</code> , но вам придется выполнить эту задачу, используя регулярные выражения. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>result</code> должен равняться <code>"Hello, World!"</code>'
|
||||
testString: 'assert(result == "Hello, World!", "<code>result</code> should equal to <code>"Hello, World!"</code>");'
|
||||
- text: Вы не должны использовать метод <code>.trim()</code> .
|
||||
testString: 'assert(!code.match(/\.trim\(.*?\)/), "You should not use the <code>.trim()</code> method.");'
|
||||
- text: <code>result</code> переменная не должна быть установлена равной строке.
|
||||
testString: 'assert(!code.match(/result\s*=\s*".*?"/), "The <code>result</code> variable should not be set equal to a string.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let hello = " Hello, World! ";
|
||||
let wsRegex = /change/; // Change this line
|
||||
let result = hello; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7db8367417b2b2512ba2
|
||||
title: Restrict Possible Usernames
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ограничить возможные имена пользователей
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Имена пользователей используются повсюду в Интернете. Это то, что дает пользователям уникальную идентификацию на своих любимых сайтах. Вам нужно проверить все имена пользователей в базе данных. Вот несколько простых правил, которым должны следовать пользователи при создании своего имени пользователя. 1) Единственные числа в имени пользователя должны быть в конце. В конце может быть ноль или более. 2) Буквы пользователя могут быть строчными и прописными. 3) Имена пользователей должны иметь длину не менее двух символов. Двухбуквенное имя пользователя может использовать только буквы алфавита. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените регулярное выражение <code>userCheck</code> чтобы он соответствовал ограничениям, перечисленным выше. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>JACK</code>
|
||||
testString: 'assert(userCheck.test("JACK"), "Your regex should match <code>JACK</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>J</code>
|
||||
testString: 'assert(!userCheck.test("J"), "Your regex should not match <code>J</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(userCheck.test("Oceans11"), "Your regex should match <code>Oceans11</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>RegexGuru</code>
|
||||
testString: 'assert(userCheck.test("RegexGuru"), "Your regex should match <code>RegexGuru</code>");'
|
||||
- text: ''
|
||||
testString: 'assert(!userCheck.test("007"), "Your regex should not match <code>007</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать <code>9</code>
|
||||
testString: 'assert(!userCheck.test("9"), "Your regex should not match <code>9</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let username = "JackOfAllTrades";
|
||||
let userCheck = /change/; // Change this line
|
||||
let result = userCheck.test(username);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: 587d7dbb367417b2b2512baa
|
||||
title: Reuse Patterns Using Capture Groups
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Повторное использование шаблонов с использованием групп захвата
|
||||
---
|
||||
|
||||
## Description
|
||||
undefined
|
||||
|
||||
## Instructions
|
||||
undefined
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать класс сокращенных символов для цифр.
|
||||
testString: 'assert(reRegex.source.match(/\\d/), "Your regex should use the shorthand character class for digits.");'
|
||||
- text: Ваше регулярное выражение должно повторно использовать группу захвата дважды.
|
||||
testString: 'assert(reRegex.source.match(/\\\d/g).length === 2, "Your regex should reuse the capture group twice.");'
|
||||
- text: 'У вашего регулярного выражения должно быть два пробела, разделяющих три числа.'
|
||||
testString: 'assert(reRegex.source.match(/\\s/g).length === 2, "Your regex should have two spaces separating the three numbers.");'
|
||||
- text: ''
|
||||
testString: 'assert(reRegex.test("42 42 42"), "Your regex should match <code>"42 42 42"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert(reRegex.test("100 100 100"), "Your regex should match <code>"100 100 100"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert.equal(("42 42 42 42").match(reRegex.source), null, "Your regex should not match <code>"42 42 42 42"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert.equal(("42 42").match(reRegex.source), null, "Your regex should not match <code>"42 42"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert(!reRegex.test("101 102 103"), "Your regex should not match <code>"101 102 103"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert(!reRegex.test("1 2 3"), "Your regex should not match <code>"1 2 3"</code>.");'
|
||||
- text: ''
|
||||
testString: 'assert(reRegex.test("10 10 10"), "Your regex should match <code>"10 10 10"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let repeatNum = "42 42 42";
|
||||
let reRegex = /change/; // Change this line
|
||||
let result = reRegex.test(repeatNum);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7db9367417b2b2512ba7
|
||||
title: Specify Exact Number of Matches
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Укажите точное количество совпадений
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы можете указать нижнее и верхнее число шаблонов с помощью <code>quantity specifiers</code> используя фигурные скобки. Иногда вам нужно только определенное количество совпадений. Чтобы указать определенное количество шаблонов, просто укажите это число между фигурными скобками. Например, чтобы соответствовать только слово <code>"hah"</code> с буквой <code>a</code> <code>3</code> раза, ваша регулярное выражение будет <code>/ha{3}h/</code> . <blockquote> пусть А4 = "хааах"; <br> пусть A3 = "haaah"; <br> пусть A100 = "h" + "a" .repeat (100) + "h"; <br> пусть multHA = / ha {3} h /; <br> multipleHA.test (А4); // Возвращает false <br> multipleHA.test (А3); // Возвращает true <br> multipleHA.test (А100); // Возвращает false </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените регулярное выражение <code>timRegex</code> в соответствии с словом <code>"Timber"</code> только тогда, когда оно имеет четыре буквы <code>m</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать фигурные скобки.
|
||||
testString: 'assert(timRegex.source.match(/{.*?}/).length > 0, "Your regex should use curly brackets.");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Timber"</code>
|
||||
testString: 'assert(!timRegex.test("Timber"), "Your regex should not match <code>"Timber"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Timmber"</code>
|
||||
testString: 'assert(!timRegex.test("Timmber"), "Your regex should not match <code>"Timmber"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Timmmber"</code>
|
||||
testString: 'assert(!timRegex.test("Timmmber"), "Your regex should not match <code>"Timmmber"</code>");'
|
||||
- text: Ваше регулярное выражение должно совпадать с <code>"Timmmmber"</code>
|
||||
testString: 'assert(timRegex.test("Timmmmber"), "Your regex should match <code>"Timmmmber"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Timber"</code> с 30 <code>m</code> в нем.
|
||||
testString: 'assert(!timRegex.test("Ti" + "m".repeat(30) + "ber"), "Your regex should not match <code>"Timber"</code> with 30 <code>m</code>\"s in it.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let timStr = "Timmmmber";
|
||||
let timRegex = /change/; // Change this line
|
||||
let result = timRegex.test(timStr);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 587d7db9367417b2b2512ba6
|
||||
title: Specify Only the Lower Number of Matches
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Укажите только меньшее число совпадений
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Вы можете указать нижнее и верхнее число шаблонов с помощью <code>quantity specifiers</code> используя фигурные скобки. Иногда вы хотите указать меньшее число шаблонов без верхнего предела. Чтобы указать только меньшее количество шаблонов, сохраните первое число, за которым следует запятая. Например, чтобы соответствовать только строке <code>"hah"</code> с буквой , появляющиеся по крайней мере <code>a</code> <code>3</code> раза, ваша регулярное выражение будет <code>/ha{3,}h/</code> . <blockquote> пусть А4 = "хааах"; <br> пусть А2 = «хаа»; <br> пусть A100 = "h" + "a" .repeat (100) + "h"; <br> пусть multA = / ha {3,} h /; <br> multipleA.test (А4); // Возвращает true <br> multipleA.test (А2); // Возвращает false <br> multipleA.test (А100); // Возвращает true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените regex <code>haRegex</code> чтобы он соответствовал слову <code>"Hazzah"</code> только если у него четыре или более букв <code>z</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать фигурные скобки.
|
||||
testString: 'assert(haRegex.source.match(/{.*?}/).length > 0, "Your regex should use curly brackets.");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Hazzah"</code>
|
||||
testString: 'assert(!haRegex.test("Hazzah"), "Your regex should not match <code>"Hazzah"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Hazzzah"</code>
|
||||
testString: 'assert(!haRegex.test("Hazzzah"), "Your regex should not match <code>"Hazzzah"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Hazzzzah"</code>
|
||||
testString: 'assert(haRegex.test("Hazzzzah"), "Your regex should match <code>"Hazzzzah"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Hazzzzzah"</code>
|
||||
testString: 'assert(haRegex.test("Hazzzzzah"), "Your regex should match <code>"Hazzzzzah"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Hazzzzzzah"</code>
|
||||
testString: 'assert(haRegex.test("Hazzzzzzah"), "Your regex should match <code>"Hazzzzzzah"</code>");'
|
||||
- text: 'Ваше регулярное выражение должно соответствовать <code>"Hazzah"</code> с 30 <code>z</code> 's в нем.'
|
||||
testString: 'assert(haRegex.test("Ha" + "z".repeat(30) + "ah"), "Your regex should match <code>"Hazzah"</code> with 30 <code>z</code>\"s in it.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let haStr = "Hazzzzah";
|
||||
let haRegex = /change/; // Change this line
|
||||
let result = haRegex.test(haStr);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 587d7db9367417b2b2512ba5
|
||||
title: Specify Upper and Lower Number of Matches
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Указать верхнее и нижнее число совпадений
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Напомним, что вы используете знак плюс <code>+</code> для поиска одного или нескольких символов и звездочки <code>*</code> для поиска нулевого или большего количества символов. Это удобно, но иногда вы хотите соответствовать определенному диапазону шаблонов. Вы можете указать нижнее и верхнее число шаблонов с <code>quantity specifiers</code> . Спецификаторы количества используются с фигурными скобками ( <code>{</code> и <code>}</code> ). Вы устанавливаете два числа между фигурными скобками - для нижнего и верхнего числа шаблонов. Например, чтобы соответствовать только букве <code>a</code> появляющейся между <code>3</code> и <code>5</code> раз в строке <code>"ah"</code> , ваше регулярное выражение будет <code>/a{3,5}h/</code> . <blockquote> пусть A4 = «aaaah»; <br> пусть A2 = "aah"; <br> пусть несколько А = / а {3,5} ч /; <br> multipleA.test (А4); // Возвращает true <br> multipleA.test (А2); // Возвращает false </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Измените regex <code>ohRegex</code> на соответствие только <code>3</code> - <code>6</code> буквам <code>h</code> в слове <code>"Oh no"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вашему регулярному выражению следует использовать фигурные скобки.
|
||||
testString: 'assert(ohRegex.source.match(/{.*?}/).length > 0, "Your regex should use curly brackets.");'
|
||||
- text: Ваше регулярное выражение не должно совпадать с <code>"Ohh no"</code>
|
||||
testString: 'assert(!ohRegex.test("Ohh no"), "Your regex should not match <code>"Ohh no"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Ohhh no"</code>
|
||||
testString: 'assert(ohRegex.test("Ohhh no"), "Your regex should match <code>"Ohhh no"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Ohhhh no"</code>
|
||||
testString: 'assert(ohRegex.test("Ohhhh no"), "Your regex should match <code>"Ohhhh no"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Ohhhhh no"</code>
|
||||
testString: 'assert(ohRegex.test("Ohhhhh no"), "Your regex should match <code>"Ohhhhh no"</code>");'
|
||||
- text: Ваше регулярное выражение должно соответствовать <code>"Ohhhhhh no"</code>
|
||||
testString: 'assert(ohRegex.test("Ohhhhhh no"), "Your regex should match <code>"Ohhhhhh no"</code>");'
|
||||
- text: Ваше регулярное выражение не должно совпадать <code>"Ohhhhhhh no"</code>
|
||||
testString: 'assert(!ohRegex.test("Ohhhhhhh no"), "Your regex should not match <code>"Ohhhhhhh no"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let ohStr = "Ohhh no";
|
||||
let ohRegex = /change/; // Change this line
|
||||
let result = ohRegex.test(ohStr);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 587d7dbb367417b2b2512bab
|
||||
title: Use Capture Groups to Search and Replace
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Использование групп захвата для поиска и замены
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Поиск полезен. Однако вы можете сделать поиск еще более мощным, когда он также изменяет (или заменяет) текст, который вы соответствуете. Вы можете искать и заменять текст в строке, используя <code>.replace()</code> в строке. Входы для <code>.replace()</code> - это сначала шаблон регулярного выражения, который вы хотите найти. Второй параметр - это строка, которая заменит совпадение или функцию, чтобы что-то сделать. <blockquote> пусть wrongText = «Небо серебристое»; <br> пусть сереброRegex = / серебро /; <br> wrongText.replace (silverRegex, «синий»); <br> // Возвращает «Небо синее». </blockquote> Вы также можете получить доступ к группам захвата в строке замены знаками доллара ( <code>$</code> ). <blockquote> «Кодовый лагерь» .replace (/ (\ w +) \ s (\ w +) /, '$ 2 $ 1'); <br> // Возвращает «Код лагеря» </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Напишите регулярное выражение так, чтобы он искал строку <code>"good"</code> . Затем обновите переменную <code>replaceText</code> чтобы заменить <code>"good"</code> на <code>"okey-dokey"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вы должны использовать <code>.replace()</code> для поиска и замены.
|
||||
testString: 'assert(code.match(/\.replace\(.*\)/), "You should use <code>.replace()</code> to search and replace.");'
|
||||
- text: 'Ваше регулярное выражение должно измениться: <code>"This sandwich is good."</code> <code>"This sandwich is okey-dokey."</code>'
|
||||
testString: 'assert(result == "This sandwich is okey-dokey." && replaceText === "okey-dokey", "Your regex should change <code>"This sandwich is good."</code> to <code>"This sandwich is okey-dokey."</code>");'
|
||||
- text: Вы не должны менять последнюю строку.
|
||||
testString: 'assert(code.match(/result\s*=\s*huhText\.replace\(.*?\)/), "You should not change the last line.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let huhText = "This sandwich is good.";
|
||||
let fixRegex = /change/; // Change this line
|
||||
let replaceText = ""; // Change this line
|
||||
let result = huhText.replace(fixRegex, replaceText);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,53 @@
|
||||
---
|
||||
id: 587d7db3367417b2b2512b8e
|
||||
title: Using the Test Method
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Использование метода испытаний
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Регулярные выражения используются в языках программирования для соответствия частям строк. Вы создаете шаблоны, которые помогут вам выполнить это сопоставление. Если вы хотите найти слово <code>"the"</code> в строке <code>"The dog chased the cat"</code> , вы можете использовать следующее регулярное выражение: <code>/the/</code> . Обратите внимание, что кавычки не требуются в регулярном выражении. JavaScript имеет несколько способов использования регулярных выражений. Один из способов проверки регулярного выражения - использовать метод <code>.test()</code> . Метод <code>.test()</code> принимает регулярное выражение, применяет его к строке (которая помещается внутри круглых скобок) и возвращает <code>true</code> или <code>false</code> если ваш шаблон что-то находит или нет. <blockquote> пусть testStr = "freeCodeCamp"; <br> пусть testRegex = / Code /; <br> testRegex.test (testStr); <br> // Возвращает true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Примените regex <code>myRegex</code> к строке <code>myString</code> используя метод <code>.test()</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Вы должны использовать <code>.test()</code> для проверки регулярного выражения.
|
||||
testString: 'assert(code.match(/myRegex.test\(\s*myString\s*\)/), "You should use <code>.test()</code> to test the regex.");'
|
||||
- text: Ваш результат должен возвращать <code>true</code> .
|
||||
testString: 'assert(result === true, "Your result should return <code>true</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let myString = "Hello, World!";
|
||||
let myRegex = /Hello/;
|
||||
let result = myRegex; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
Reference in New Issue
Block a user