Merge pull request #1094 from dyslexicon/master

Correct spelling

9-regular-expressions/14-regexp-lookahead-lookbehind/article.md

@@ -40,7 +40,7 @@ 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+` -- an amount preceeded by `subject:$`:
+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+` -- an amount preceded by `subject:$`:
 
 ```js run
 let str = "1 turkey costs $30";
@@ -48,7 +48,7 @@ let str = "1 turkey costs $30";
 alert( str.match(/(?<=\$)\d+/) ); // 30 (skipped the sole number)
 ```
 
-And, to find the quantity -- a number, not preceeded by `subject:$`, we can use a negative lookbehind `pattern:(?<!\$)\d+`:
+And, to find the quantity -- a number, not preceded by `subject:$`, we can use a negative lookbehind `pattern:(?<!\$)\d+`:
 
 ```js run
 let str = "2 turkeys cost $60";

9-regular-expressions/15-regexp-infinite-backtracking-problem/article.md

@@ -112,7 +112,7 @@ First, one may notice that the regexp is a little bit strange. The quantifier `p
 
 Indeed, the regexp is artificial. But the reason why it is slow is the same as those we saw above. So let's understand it, and then the previous example will become obvious.
 
-What happen during the search of `pattern:(\d+)*$` in the line `subject:123456789z`?
+What happened during the search of `pattern:(\d+)*$` in the line `subject:123456789z`?
 
 1. First, the regexp engine tries to find a number `pattern:\d+`. The plus `pattern:+` is greedy by default, so it consumes all digits:
 
@@ -264,7 +264,9 @@ In other words:
 - The lookahead `pattern:?=` looks for the maximal count `pattern:a+` from the current position.
 - And then they are "consumed into the result" by the backreference `pattern:\1` (`pattern:\1` corresponds to the content of the second parentheses, that is `pattern:a+`).
 
-There will be no backtracking, because lookahead does not backtrack. If it found like 5 times of `pattern:a+` and the further match failed, then it doesn't go back to 4.
+There will be no backtracking, because lookahead does not backtrack. If, for
+example, it found 5 instances of `pattern:a+` and the further match failed,
+it won't go back to the 4th instance.
 
 ```smart
 There's more about the relation between possessive quantifiers and lookahead in articles [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) and [Mimicking Atomic Groups](http://blog.stevenlevithan.com/archives/mimic-atomic-groups).

9-regular-expressions/20-regexp-unicode/article.md

@@ -5,7 +5,7 @@ The unicode flag `/.../u` enables the correct support of surrogate pairs.
 
 Surrogate pairs are explained in the chapter <info:string>.
 
-Let's briefly remind them here. In short, normally characters are encoded with 2 bytes. That gives us 65536 characters maximum. But there are more characters in the world.
+Let's briefly review them here. In short, normally characters are encoded with 2 bytes. That gives us 65536 characters maximum. But there are more characters in the world.
 
 So certain rare characters are encoded with 4 bytes, like `𝒳` (mathematical X) or `😄` (a smile).