Merge branch 'master' of github.com:javascript-tutorial/en.javascript.info into sync-19223ae7

Author: iliakan

1-js/02-first-steps/04-variables/article.md

@@ -157,7 +157,7 @@ let userName;
 let test123;
 ```
 
-When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word starting with a capital letter: `myVeryLongName`.
+When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word except first starting with a capital letter: `myVeryLongName`.
 
 What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning.
 

1-js/02-first-steps/06-type-conversions/article.md

@@ -1,6 +1,6 @@
 # Type Conversions
 
-Most of the time, operators and functions automatically convert the values given to them to the right type. This is called "type conversion".
+Most of the time, operators and functions automatically convert the values given to them to the right type. 
 
 For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
 

1-js/02-first-steps/14-function-basics/article.md

@@ -382,7 +382,7 @@ These examples assume common meanings of prefixes. What they mean for you is det
 ```smart header="Ultrashort function names"
 Functions that are used *very often* sometimes have ultrashort names.
 
-For example, the [jQuery](http://jquery.com) framework defines a function with `$`. The [LoDash](http://lodash.com/) library has its core function named `_`.
+For example, the [jQuery](http://jquery.com) framework defines a function with `$`. The [Lodash](http://lodash.com/) library has its core function named `_`.
 
 These are exceptions. Generally functions names should be concise and descriptive.
 ```

1-js/08-prototypes/02-function-prototype/article.md

@@ -43,7 +43,7 @@ On the picture, `"prototype"` is a horizontal arrow, meaning a regular property,
 ```smart header="`F.prototype` only used at `new F` time"
 `F.prototype` property is only used when `new F` is called, it assigns `[[Prototype]]` of the new object. After that, there's no connection between `F.prototype` and the new object. Think of it as a "one-time gift".
 
-If, after the creation, `F.prototype` property changes (`F.property = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
+If, after the creation, `F.prototype` property changes (`F.prototype = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
 ```
 
 ## Default F.prototype, constructor property

1-js/09-classes/01-class/article.md

@@ -86,7 +86,7 @@ alert(typeof User); // function
 
 What `class User {...}` construct really does is:
 1. Creates a function named `User`, that becomes the result of the class declaration.
-    - The function code is taken from the `constructor` method (assumed empty is we don't write such method).
+    - The function code is taken from the `constructor` method (assumed empty if we don't write such method).
 3. Stores all methods, such as `sayHi`, in `User.prototype`.
 
 Afterwards, for new objects, when we call a method, it's taken from the prototype, just as  described in the chapter <info:function-prototype>. So `new User` object has access to class methods.

8-web-components/1-webcomponents-intro/article.md

@@ -56,7 +56,8 @@ Components may have subcomponents, e.g. messages may be parts of a higher-level
 
 How do we decide, what is a component? That comes from intuition, experience and common sense. Usually it's a separate visual entity that we can describe in terms of what it does and how it interacts with the page. In the case above, the page has blocks, each of them plays its own role, it's logical to make these components.
 
-- A component has its own JavaScript class.
+A component has:
+- its own JavaScript class.
 - DOM structure, managed solely by its class, outside code doesn't access it ("encapsulation" principle).
 - CSS styles, applied to the component.
 - API: events, class methods etc, to interact with other components.

9-regular-expressions/02-regexp-methods/article.md

@@ -10,7 +10,9 @@ There are two sets of methods to deal with regular expressions.
 
 Which method to use depends on what we'd like to do.
 
-Methods become much easier to understand if we separate them by their use in real-life tasks:
+Methods become much easier to understand if we separate them by their use in real-life tasks.
+
+So, here are general recipes, the details to follow:
 
 **To search for all matches:**
 
@@ -30,9 +32,7 @@ Use regexp `g` flag and:
 **To split the string by a separator:**
 - `str.split(str|reg)`
 
-Now you get the details about every method in this chapter... But if you're reading for the first time, and want to know more about regexps - go ahead!
-
-You may want to skip methods for now, move on to the next chapter, and then return here if something about a method is unclear.
+Now you can continue reading this chapter to get the details about every method... But if you're reading for the first time, then you probably want to know more about regexps. So you can move to the next chapter, and then return here if something about a method is unclear.
 
 ## str.search(reg)
 
@@ -41,12 +41,12 @@ We've seen this method already. It returns the position of the first match or `-
 ```js run
 let str = "A drop of ink may make a million think";
 
-alert( str.search( *!*/a/i*/!* ) ); // 0 (the first position)
+alert( str.search( *!*/a/i*/!* ) ); // 0 (first match at zero position)
 ```
 
 **The important limitation: `search` only finds  the first match.**
 
-We can't find next positions using `search`, there's just no syntax for that. But there are other methods that can.
+We can't find next matches using `search`, there's just no syntax for that. But there are other methods that can.
 
 ## str.match(reg), no "g" flag
 
@@ -215,9 +215,9 @@ alert('12-34-56'.split(/-/)) // array of [12, 34, 56]
 
 ## str.replace(str|reg, str|func)
 
-That's actually a great method, one of most useful ones. The swiss army knife for searching and replacing.
+This is a generic method for searching and replacing, one of most useful ones. The swiss army knife for searching and replacing.  
 
-The simplest use -- searching and replacing a substring, like this:
+We can use it without regexps, to search and replace a substring:
 
 ```js run
 // replace a dash by a colon
@@ -263,7 +263,7 @@ Quite often we'd like to reuse parts of the source string, recombine them in the
 
 To do so, we should:
 1. First, mark the parts by parentheses in regexp.
-2. Use `$1`, `$2` (and so on) in the replacement string to get the content matched by parentheses.
+2. Use `$1`, `$2` (and so on) in the replacement string to get the content matched by 1st, 2nd and so on parentheses.
 
 For instance:
 
@@ -433,7 +433,7 @@ alert( regexp.test(str) ); // false (no match)
 
 
 ````warn header="Same global regexp tested repeatedly may fail to match"
-If we apply the same global regexp to different inputs, it may lead to wrong result, because `regexp.test` call advances `regexp.lastIndex` property, so next matches start from non-zero position.
+If we apply the same global regexp to different inputs, it may lead to wrong result, because `regexp.test` call advances `regexp.lastIndex` property, so the search in another string may start from non-zero position.
 
 For instance, here we call `regexp.test` twice on the same text, and the second time fails: