merge prs

Author: iliakan

1-js/06-advanced-functions/03-closure/article.md

@@ -275,7 +275,7 @@ In this example `count` is found on  step `2`. When an outer variable is modifie
 
 Here are two questions to consider:
 
-1. Can we somehow reset the `counter` from the code that doesn't belong to `makeCounter`? E.g. after `alert` calls in the example above.
+1. Can we somehow reset the counter `count` from the code that doesn't belong to `makeCounter`? E.g. after `alert` calls in the example above.
 2. If we call `makeCounter()` multiple times -- it returns many `counter` functions. Are they independent or do they share the same `count`?
 
 Try to answer them before you continue reading.
@@ -286,8 +286,8 @@ All done?
 
 Okay, let's go over the answers.
 
-1. There is no way. The `counter` is a local function variable, we can't access it from the outside.
-2. For every call to `makeCounter()` a new function Lexical Environment is created, with its own `counter`. So the resulting `counter` functions are independent.
+1. There is no way: `count` is a local function variable, we can't access it from the outside.
+2. For every call to `makeCounter()` a new function Lexical Environment is created, with its own `count`. So the resulting `counter` functions are independent.
 
 Here's the demo:
 

1-js/99-js-miscellaneous/index.md

@@ -103,7 +103,7 @@ There are only 5 of them in JavaScript:
 : Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter <info:regexp-unicode>.
 
 `y`
-: Sticky mode (covered in the [next chapter](info:regexp-methods#y-flag))
+: Sticky mode (covered in the chapter <info:regexp-sticky>)
 
 We'll cover all these flags further in the tutorial.
 

2-ui/99-ui-miscellaneous/index.md

@@ -0,0 +1,99 @@
+# Lookahead and lookbehind
+
+Sometimes we need to match a pattern only if followed by another pattern. For instance, we'd like to get the price from a string like `subject:1 turkey costs 30€`.
+
+We need a number (let's say a price has no decimal point) followed by `subject:€` sign.
+
+That's what lookahead is for.
+
+## Lookahead
+
+The syntax is: `pattern:x(?=y)`, it means "match `pattern:x` only if followed by `pattern:y`".
+
+The euro sign is often written after the amount, so the regexp will be `pattern:\d+(?=€)` (assuming the price has no decimal point):
+
+```js run
+let str = "1 turkey costs 30€";
+
+alert( str.match(/\d+(?=€)/) ); // 30 (correctly skipped the sole number 1)
+```
+
+Or, if we wanted a quantity, then a negative lookahead can be applied.
+
+The syntax is: `pattern:x(?!y)`, it means "match `pattern:x` only if not followed by `pattern:y`".
+
+```js run
+let str = "2 turkeys cost 60€";
+
+alert( str.match(/\d+(?!€)/) ); // 2 (correctly skipped the price)
+```
+
+## Lookbehind
+
+Lookbehind allows to match a pattern only if there's something before.
+
+The syntax is:
+- Positive lookbehind: `pattern:(?<=y)x`, matches `pattern:x`, but only if it follows after `pattern:y`.
+- Negative lookbehind: `pattern:(?<!y)x`, matches `pattern:x`, but only if there's no `pattern:y` before.
+
+For example, let's change the price to US dollars. The dollar sign is usually before the number, so to look for `$30` we'll use `pattern:(?<=\$)\d+`:
+
+```js run
+let str = "1 turkey costs $30";
+
+alert( str.match(/(?<=\$)\d+/) ); // 30 (correctly skipped the sole number 1)
+```
+
+And for the quantity let's use a negative lookbehind `pattern:(?<!\$)\d+`:
+
+```js run
+let str = "2 turkeys cost $60";
+
+alert( str.match(/(?<!\$)\d+/) ); // 2 (correctly skipped the price)
+```
+
+## Capture groups
+
+Generally, what's inside the lookaround (a common name for both lookahead and lookbehind) parentheses does not become a part of the match.
+
+But if we want to capture something, that's doable. Just need to wrap that into additional parentheses.
+
+For instance, here the currency `pattern:(€|kr)` is captured, along with the amount:
+
+```js run
+let str = "1 turkey costs 30€";
+let reg = /\d+(?=(€|kr))/;
+
+alert( str.match(reg) ); // 30, €
+```
+
+And here's the same for lookbehind:
+
+```js run
+let str = "1 turkey costs $30";
+let reg = /(?<=(\$|£))\d+/;
+
+alert( str.match(reg) ); // 30, $
+```
+
+Please note that for lookbehind the order stays be same, even though lookahead parentheses are before the main pattern.
+
+Usually parentheses are numbered left-to-right, but lookbehind is an exception, it is always captured after the main pattern. So the match for `pattern:\d+` goes in the result first, and then for `pattern:(\$|£)`.
+
+
+## Summary
+
+Lookahead and lookbehind (commonly referred to as "lookaround") are useful for simple regular expressions, when we'd like not to take something into the match depending on the context before/after it.
+
+Sometimes we can do the same manually, that is: match all and filter by context in the loop. Remember, `str.matchAll` and `reg.exec` return matches with `.index` property, so we know where exactly in the text it is. But generally regular expressions can do it better.
+
+Lookaround types:
+
+| Pattern            | type             | matches |
+|--------------------|------------------|---------|
+| `pattern:x(?=y)`   | Positive lookahead | `x` if followed by `y` |
+| `pattern:x(?!y)`   | Negative lookahead | `x` if not followed by `y` |
+| `pattern:(?<=y)x` |  Positive lookbehind | `x` if after `y` |
+| `pattern:(?<!y)x` | Negative lookbehind | `x` if not after `y` |
+
+Lookahead can also used to disable backtracking. Why that may be needed -- see in the next chapter.