Merge branch 'master' of https://github.com/javascript-tutorial/en.javascript.info

# Conflicts:
#	1-js/05-data-types/02-number/article.md

Author: mehradsadeghi

1-js/09-classes/03-static-properties-methods/article.md

@@ -20,7 +20,7 @@ User.staticMethod(); // true
 That actually does the same as assigning it as a property directly:
 
 ```js run
-class User() { }
+class User { }
 
 User.staticMethod = function() {
   alert(this === User);

1-js/12-generators-iterators/1-generators/article.md

@@ -343,7 +343,7 @@ generator.next(4); // --> pass the result into the generator
 
 ![](genYield2.svg)
 
-1. The first call `generator.next()` is always without an argument. It starts the execution and returns the result of the first `yield "2+2=?"`. At this point the generator pauses the execution (still on that line).
+1. The first call `generator.next()` should be always made without an argument (the argument is ignored if passed). It starts the execution and returns the result of the first `yield "2+2=?"`. At this point the generator pauses the execution, while staying on the line `(*)`.
 2. Then, as shown at the picture above, the result of `yield` gets into the `question` variable in the calling code.
 3. On `generator.next(4)`, the generator resumes, and `4` gets in as the result: `let result = 4`.
 

2-ui/1-document/07-modifying-document/article.md

@@ -540,7 +540,7 @@ So if we need to add a lot of text into HTML dynamically, and we're at page load
     - `"beforeend"` -- insert `html` into `elem`, at the end,
     - `"afterend"` -- insert `html` right after `elem`.
 
-    Also there are also similar methods, `elem.insertAdjacentText` and `elem.insertAdjacentElement`, that insert text strings and elements, but they are rarely used.
+    Also there are similar methods, `elem.insertAdjacentText` and `elem.insertAdjacentElement`, that insert text strings and elements, but they are rarely used.
 
 - To append HTML to the page before it has finished loading:
     - `document.write(html)`

2-ui/2-events/01-introduction-browser-events/07-carousel/solution.md

@@ -1,6 +1,6 @@
 The images ribbon can be represented as `ul/li` list of images `<img>`.
 
-Normally, such a ribbon is wide, but we put a fixed-size `<div>` around to "cut" it, so that only a part of the ribbon is visibble:
+Normally, such a ribbon is wide, but we put a fixed-size `<div>` around to "cut" it, so that only a part of the ribbon is visible:
 
 ![](carousel1.svg)
 

2-ui/2-events/02-bubbling-and-capturing/article.md

@@ -68,7 +68,7 @@ For instance, if we have a single handler `form.onclick`, then it can "catch" al
 
 In `form.onclick` handler:
 
-- `this` (`=event.currentTarget`) is the `<form>` element, because the handler runs on it.
+- `this` (=`event.currentTarget`) is the `<form>` element, because the handler runs on it.
 - `event.target` is the actual element inside the form that was clicked.
 
 Check it out:
@@ -102,7 +102,7 @@ To stop the bubbling and prevent handlers on the current element from running, t
 ```
 
 ```warn header="Don't stop bubbling without a need!"
-Bubbling is convenient. Don't stop it without a real need: obvious and architecturally well-thought.
+Bubbling is convenient. Don't stop it without a real need: obvious and architecturally well thought out.
 
 Sometimes `event.stopPropagation()` creates hidden pitfalls that later may become problems.
 

2-ui/2-events/03-event-delegation/article.md

@@ -163,7 +163,7 @@ The handler reads the attribute and executes the method. Take a look at the work
 
 Please note that `this.onClick` is bound to `this` in `(*)`. That's important, because otherwise `this` inside it would reference the DOM element (`elem`), not the `Menu` object, and `this[action]` would not be what we need.
 
-So, what the delegation gives us here?
+So, what advantages does delegation give us here?
 
 ```compare
 + We don't need to write the code to assign a handler to each button. Just make a method and put it in the markup.
@@ -242,13 +242,13 @@ That may become really convenient -- no need to write JavaScript for every such
 
 We can combine multiple behaviors on a single element as well.
 
-The "behavior" pattern can be an alternative of mini-fragments of JavaScript.
+The "behavior" pattern can be an alternative to mini-fragments of JavaScript.
 
 ## Summary
 
 Event delegation is really cool! It's one of the most helpful patterns for DOM events.
 
-It's often used to add same handling for many similar elements, but not only for that.
+It's often used to add the same handling for many similar elements, but not only for that.
 
 The algorithm:
 
@@ -261,12 +261,12 @@ Benefits:
 ```compare
 + Simplifies initialization and saves memory: no need to add many handlers.
 + Less code: when adding or removing elements, no need to add/remove handlers.
-+ DOM modifications: we can mass add/remove elements with `innerHTML` and alike.
++ DOM modifications: we can mass add/remove elements with `innerHTML` and the like.
 ```
 
 The delegation has its limitations of course:
 
 ```compare
 - First, the event must be bubbling. Some events do not bubble. Also, low-level handlers should not use `event.stopPropagation()`.
-- Second, the delegation may add CPU load, because the container-level handler reacts on events in any place of the container, no matter if they interest us or not. But usually the load is negligible, so we don't take it into account.
+- Second, the delegation may add CPU load, because the container-level handler reacts on events in any place of the container, no matter whether they interest us or not. But usually the load is negligible, so we don't take it into account.
 ```

2-ui/3-event-details/1-mouse-events-basics/article.md

@@ -110,7 +110,7 @@ So if we want to support combinations like `key:Ctrl`+click, then for Mac it mak
 
 Even if we'd like to force Mac users to `key:Ctrl`+click -- that's kind of difficult. The problem is: a left-click with `key:Ctrl` is interpreted as a *right-click* on MacOS, and it generates the `contextmenu` event, not `click` like Windows/Linux.
 
-So if we want users of all operational systems to feel comfortable, then together with `ctrlKey` we should check `metaKey`.
+So if we want users of all operating systems to feel comfortable, then together with `ctrlKey` we should check `metaKey`.
 
 For JS-code it means that we should check `if (event.ctrlKey || event.metaKey)`.
 ```

2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md

@@ -145,7 +145,7 @@ When the pointer leaves an element -- `mouseleave` triggers.
 ```online
 This example is similar to the one above, but now the top element has `mouseenter/mouseleave` instead of `mouseover/mouseout`.
 
-As you can see, the only generated events are the ones related to moving the pointer in and out of the top element. Nothing happens when the pointer goes to the child and back. Transitions between descendants are ignores
+As you can see, the only generated events are the ones related to moving the pointer in and out of the top element. Nothing happens when the pointer goes to the child and back. Transitions between descendants are ignored
 
 [codetabs height=340 src="mouseleave"]
 ```

2-ui/99-ui-misc/02-selection-range/article.md

@@ -428,7 +428,7 @@ Form elements, such as `input` and `textarea` provide [special API for selection
 
 Properties:
 - `input.selectionStart` -- position of selection start (writeable),
-- `input.selectionEnd` -- position of selection start (writeable),
+- `input.selectionEnd` -- position of selection end (writeable),
 - `input.selectionDirection` -- selection direction, one of: "forward", "backward" or "none" (if e.g. selected with a double mouse click),
 
 Events:

5-network/02-formdata/article.md

@@ -54,14 +54,14 @@ In this example, the server code is not presented, as it's beyound our scope. Th
 We can modify fields in `FormData` with methods:
 
 - `formData.append(name, value)` - add a form field with the given `name` and `value`,
-- `formData.append(name, blob, fileName)` - add a field as if it were `<input type="file">`, the third argument `fileName` sets file name (not form field name), as it it were a name of the file in user's filesystem,
+- `formData.append(name, blob, fileName)` - add a field as if it were `<input type="file">`, the third argument `fileName` sets file name (not form field name), as it were a name of the file in user's filesystem,
 - `formData.delete(name)` - remove the field with the given `name`,
 - `formData.get(name)` - get the value of the field with the given `name`,
 - `formData.has(name)` - if there exists a field with the given `name`, returns `true`, otherwise `false`
 
 A form is technically allowed to have many fields with the same `name`, so multiple calls to `append` add more same-named fields.
 
-There's also method `set`, with the same syntax as `append`. The difference is that `.set` removes all fields with the given `name`, and then appends a new field. So it makes sure there's only field with such `name`, the rest is just like `append`:
+There's also method `set`, with the same syntax as `append`. The difference is that `.set` removes all fields with the given `name`, and then appends a new field. So it makes sure there's only one field with such `name`, the rest is just like `append`:
 
 - `formData.set(name, value)`,
 - `formData.set(name, blob, fileName)`.