merge

Author: iliakan

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

@@ -340,9 +340,15 @@ return*!*;*/!*
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
 
+<<<<<<< HEAD
 Таким образом, это фактически стало пустым `return`.
 
 Если мы хотим, чтобы возвращаемое выражение занимало несколько строк, нужно начать его на той же строке, что и `return`. Или, хотя бы, поставить там открывающую скобку, вот так:
+=======
+So, it effectively becomes an empty return.
+
+If we want the returned expression to wrap across multiple lines, we should start it at the same line as `return`. Or at least put the opening parentheses there as follows:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js
 return (
@@ -351,7 +357,11 @@ return (
   whatever * f(a) + f(b)
   )
 ```
+<<<<<<< HEAD
 И тогда всё сработает как задумано.
+=======
+And it will work just as we expect it to.
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 ````
 
 ## Выбор имени функции [#function-naming]

1-js/02-first-steps/15-function-expressions-arrows/article.md

@@ -132,7 +132,11 @@ ask("Вы согласны?", showOk, showCancel);
 
 Перед тем, как мы рассмотрим, как можно записать это гораздо короче, давайте обратим внимание, что в браузере (и в отдельных случаях на стороне сервера) подобное использование функций очень распространено. Основным отличием между реализацией таких функций в реальном проекте и примером выше является то, что в реальности функции используют более сложные способы взаимодействия с пользователем, чем простой вызов `confirm`. В браузерах такие функции обычно отображают красивые диалоговые окна. Но это уже другая история.
 
+<<<<<<< HEAD
 **Аргументы функции `ask` ещё называют *функциями-колбэками* или просто *колбэками*.**
+=======
+**The arguments `showOk` and `showCancel` of `ask` are called *callback functions* or just *callbacks*.**
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 Ключевая идея в том, что мы передаём функцию и ожидаем, что она вызовется обратно (от англ. "call back" - обратный вызов) когда-нибудь позже, если это будет необходимо. В нашем случае, `showOk` становится *колбэком*' для ответа "yes", а `showCancel` -- для ответа "no".
 

1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md

@@ -1,14 +1,14 @@
 
 
-1. Либо для краткости используйте стрелочную функцию-обёртку:
+1. Either use a wrapper function, an arrow to be concise:
 
     ```js 
     askPassword(() => user.login(true), () => user.login(false)); 
     ```
 
-    Теперь `user` берётся из внешних переменных, и всё выполняется правильно.
+    Now it gets `user` from outer variables and runs it the normal way.
 
-2. Либо сделайте из `user.login` функцию частичного применения, которая использует `user` как контекст, и которой передан корректный первый аргумент:
+2. Or create a partial function from `user.login` that uses `user` as the context and has the correct first argument:
 
 
     ```js 

1-js/06-advanced-functions/10-bind/6-ask-partial/task.md

@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Частичное применение для логина
+# Partial application for login
 
-Эта задача -- немного более усложнённый вариант <info:task/question-use-bind>.
+The task is a little more complex variant of <info:task/question-use-bind>. 
 
-Объект `user` был изменён. Теперь вместо двух функций `loginOk/loginFail`, у него одна функция: `user.login(true/false)`.
+The `user` object was modified. Now instead of two functions `loginOk/loginFail`, it has a single function `user.login(true/false)`.
 
-Что нужно передать функции `askPassword` в коде ниже, чтобы она вызывала `user.login(true)` как `ok` и `user.login(false)` как `fail`?
+What to pass `askPassword` in the code below, so that it calls `user.login(true)` as `ok` and `user.login(false)` as `fail`?
 
 ```js
 function askPassword(ok, fail) {
@@ -30,5 +30,5 @@ askPassword(?, ?); // ?
 */!*
 ```
 
-Вы можете изменять только подсвеченные фрагменты кода.
+Your changes should only modify the highlighted fragment.
 

1-js/06-advanced-functions/10-bind/article.md

@@ -194,28 +194,49 @@ for (let key in user) {
 Некоторые JS-библиотеки предоставляют встроенные функции для удобной массовой привязки контекста, например [_.bindAll(obj)](http://lodash.com/docs#bindAll) в lodash.
 ````
 
+<<<<<<< HEAD
 ## Частичное применение
 
 До сих пор мы говорили только о привязывании `this`. Давайте шагнём дальше.
 
 Мы можем привязать не только `this`, но и аргументы. Это делается редко, но иногда может быть полезно.
 
 Полный синтаксис `bind`:
+=======
+## Partial functions
+
+Until now we have only been talking about binding `this`. Let's take it a step further.
+
+We can bind not only `this`, but also arguments. That's rarely done, but sometimes can be handy.
+
+The full syntax of `bind`:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js
 let bound = func.bind(context, [arg1], [arg2], ...);
 ```
+<<<<<<< HEAD
 Это позволяет привязать контекст `this` и начальные аргументы функции.
 
 Например, у нас есть функция умножения `mul(a, b)`:
+=======
+
+It allows to bind context as `this` and starting arguments of the function.
+
+For instance, we have a multiplication function `mul(a, b)`:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js
 function mul(a, b) {
   return a * b;
 }
 ```
 
+<<<<<<< HEAD
 Давайте воспользуемся `bind`, чтобы создать функцию `double` на её основе:
+=======
+Let's use `bind` to create a function `double` on its base:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js run
 function mul(a, b) {
@@ -231,13 +252,23 @@ alert( double(4) ); // = mul(2, 4) = 8
 alert( double(5) ); // = mul(2, 5) = 10
 ```
 
+<<<<<<< HEAD
 Вызов `mul.bind(null, 2)` создаёт новую функцию `double`, которая передаёт вызов `mul`, фиксируя `null` как контекст и `2` -- как первый аргумент. Следующие аргументы передаются "как есть".
 
 Это называется [частичное применение](https://ru.wikipedia.org/wiki/Частичное_применение) -- мы создаём новую функцию, фиксируя некоторые из существующих параметров.
 
 Обратите внимание, что в данном случае мы на самом деле не используем `this`. Но для `bind` это обязательный параметр, так что мы должны передать туда что-нибудь вроде `null`.
 
 В следующем коде функция `triple` умножает значение на три:
+=======
+The call to `mul.bind(null, 2)` creates a new function `double` that passes calls to `mul`, fixing `null` as the context and `2` as the first argument. Further arguments are passed "as is".
+
+That's called [partial function application](https://en.wikipedia.org/wiki/Partial_application) -- we create a new function by fixing some parameters of the existing one.
+
+Please note that here we actually don't use `this` here. But `bind` requires it, so we must put in something like `null`.
+
+The function `triple` in the code below triples the value:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js run
 function mul(a, b) {
@@ -253,6 +284,7 @@ alert( triple(4) ); // = mul(3, 4) = 12
 alert( triple(5) ); // = mul(3, 5) = 15
 ```
 
+<<<<<<< HEAD
 Для чего мы обычно создаём частично применённую функцию?
 
 Польза от этого в том, что возможно создать независимую функцию с понятным названием (`double`, `triple`). Мы можем использовать её и не передавать каждый раз первый аргумент, т.к. он зафиксирован с помощью `bind`.
@@ -270,6 +302,25 @@ alert( triple(5) ); // = mul(3, 5) = 15
 К счастью, лекго создать вспомогательную функцию `partial`, которая привязывает только аргументы.
 
 Вот так:
+=======
+Why do we usually make a partial function?
+
+The benefit is that we can create an independent function with a readable name (`double`, `triple`). We can use it and not provide first argument of every time as it's fixed with `bind`.
+
+In other cases, partial application is useful when we have a very generic function and want a less universal variant of it for convenience.
+
+For instance, we have a function `send(from, to, text)`. Then, inside a `user` object we may want to use a partial variant of it: `sendTo(to, text)` that sends from the current user.
+
+## Going partial without context
+
+What if we'd like to fix some arguments, but not the context `this`? For example, for an object method.
+
+The native `bind` does not allow that. We can't just omit the context and jump to arguments.
+
+Fortunately, a helper function `partial` for binding only arguments can be easily implemented.
+
+Like this:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js run
 *!*
@@ -280,14 +331,19 @@ function partial(func, ...argsBound) {
 }
 */!*
 
+<<<<<<< HEAD
 // использование:
+=======
+// Usage:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 let user = {
   firstName: "John",
   say(time, phrase) {
     alert(`[${time}] ${this.firstName}: ${phrase}!`);
   }
 };
 
+<<<<<<< HEAD
 // добавляем частично применённый метод с фиксированным временем
 user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes());
 
@@ -310,7 +366,35 @@ user.sayNow("Hello");
 Метод `bind` возвращает "привязанный вариант" функции `func`, фиксируя контекст `this` и первые аргументы `arg1`, `arg2`..., если они заданы.
 
 Обычно `bind` применяется для фиксации `this` в методе объекта, чтобы передать его в качестве колбэка. Например, для `setTimeout`.
+=======
+// add a partial method with fixed time
+user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes());
+
+user.sayNow("Hello");
+// Something like:
+// [10:00] John: Hello!
+```
+
+The result of `partial(func[, arg1, arg2...])` call is a wrapper `(*)` that calls `func` with:
+- Same `this` as it gets (for `user.sayNow` call it's `user`)
+- Then gives it `...argsBound` -- arguments from the `partial` call (`"10:00"`)
+- Then gives it `...args` -- arguments given to the wrapper (`"Hello"`)
+
+So easy to do it with the spread operator, right?
+
+Also there's a ready [_.partial](https://lodash.com/docs#partial) implementation from lodash library.
+
+## Summary
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 Когда мы привязываем аргументы, такая функция называется "частично применённой" или "частичной".
 
+<<<<<<< HEAD
 Частичное применение удобно, когда мы не хотим повторять один и тот же аргумент много раз. Например, когда у нас есть функция `send(from, to)`, и `from` всё время будет одинаков для нашей задачи, мы можем создать частично применённую функцию и дальше работать с ней.
+=======
+Usually we apply `bind` to fix `this` for an object method, so that we can pass it somewhere. For example, to `setTimeout`.
+
+When we fix some arguments of an existing function, the resulting (less universal) function is called *partially applied* or *partial*.
+
+Partials are convenient when we don't want to repeat the same argument over and over again. Like if we have a `send(from, to)` function, and `from` should always be the same for our task, we can get a partial and go on with it.
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515

1-js/07-object-properties/01-property-descriptors/article.md

@@ -63,7 +63,11 @@ Object.defineProperty(obj, propertyName, descriptor)
 ```
 
 `obj`, `propertyName`
+<<<<<<< HEAD
 : Объект и его свойство, для которого нужно применить дескриптор.
+=======
+: The object and its property to apply the descriptor.
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 `descriptor`
 : Применяемый дескриптор.
@@ -116,7 +120,11 @@ Object.defineProperty(user, "name", {
 });
 
 *!*
+<<<<<<< HEAD
 user.name = "Pete"; // Ошибка: Невозможно изменить доступное только для чтения свойство 'name'
+=======
+user.name = "Pete"; // Error: Cannot assign to read only property 'name'
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 */!*
 ```
 
@@ -126,27 +134,44 @@ user.name = "Pete"; // Ошибка: Невозможно изменить до
 В нестрогом режиме, без `use strict`, мы не увидим никаких ошибок при записи в свойства "только для чтения" и т.п. Но эти операции всё равно не будут выполнены успешно. Действия, нарушающие ограничения флагов, в нестрогом режиме просто молча игнорируются.
 ```
 
+<<<<<<< HEAD
 Вот тот же пример, но свойство создано "с нуля":
+=======
+Here's the same example, but the property is created from scratch:
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 ```js run
 let user = { };
 
 Object.defineProperty(user, "name", {
 *!*
   value: "John",
+<<<<<<< HEAD
   // для нового свойства необходимо явно указывать все флаги, для которых значение true
+=======
+  // for new properties need to explicitly list what's true
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
   enumerable: true,
   configurable: true
 */!*
 });
 
 alert(user.name); // John
+<<<<<<< HEAD
 user.name = "Pete"; // Ошибка
 ```
 
 ## Неперечислимое свойство
 
 Теперь добавим собственный метод `toString` к объекту `user`.
+=======
+user.name = "Pete"; // Error
+```
+
+## Non-enumerable
+
+Now let's add a custom `toString` to `user`.
+>>>>>>> e50185af4b4df7dbe1870215e382a206241c8515
 
 Встроенный метод `toString` в объектах - неперечислимый, его не видно в цикле `for..in`. Но если мы напишем свой собственный метод `toString`, цикл `for..in` будет выводить его по умолчанию: