Jan 12, 2022 · Jan 11, 2022
diff --git a/1-js/99-js-misc/04-reference-type/2-check-syntax/solution.md b/1-js/99-js-misc/04-reference-type/2-check-syntax/solution.md
 **Error**!
 **Помилка**!

 Try it:
 Спробуйте:

 ```js run
 let user = {
  name: "John",
  name: "Іван",
  go: function() { alert(this.name) }
 }

 (user.go)() //error!
 (user.go)() //помилка!
 ```

 The error message in most browsers does not give us much of a clue about what went wrong.
 Повідомлення про помилку в більшості браузерів не дає нам велику кількість підказок про те, що пішло не так.

 **The error appears because a semicolon is missing after `user = {...}`.**
 **Помилка з'являється, оскільки крапка з комою відсутня після `user = {...}`.**

 JavaScriptdoes not auto-insert a semicolon before a bracket `(user.go)()`, so it reads the code like:
 JavaScriptне вставляэ автоматично крапку з комою перед дужками `(user.go)()` тому, що він читає код, як:

 ```js no-beautify
 let user = { go:... }(user.go)()
 ```

 Then we can also see that such a joint expression is syntactically a call of the object`{ go: ... }`as a function with the argument`(user.go)`.And that also happens on the same line with `let user`,so the`user`object has not yet even been defined, hence the error.
 Тоді ми також можемо побачити, що такий спільний вираз синтаксично є викликом об'єкта`{ go: ... }`як функція з аргументом`(user.go)`.І це також відбувається на тій же лінії, з `let user`,тому, оскільки об'єкт`user`ще не визначений, виникає помилка.

 If we insert the semicolon, all is fine:
 Якщо ми вставляємо крапку з комою, все добре:

 ```js run
 let user = {
  name: "John",
  name: "Іван",
  go: function() { alert(this.name) }
 }*!*;*/!*

 (user.go)() //John
 (user.go)() //Іван
 ```

 Please note that parentheses around `(user.go)`do nothing here. Usually they setup the order of operations, but here the dot `.` works first anyway, so there's no effect. Only the semicolon thing matters.
 Зверніть увагу, що дужки навколо `(user.go)`нічого не роблять тут. Зазвичай вони встановлюють порядок операцій, але тут крапка спрацьовує спочатку в будь-якому випадку, тому немає ефекту. Тільки грає роль лише крапка з комою вкінці.
diff --git a/1-js/99-js-misc/04-reference-type/2-check-syntax/task.md b/1-js/99-js-misc/04-reference-type/2-check-syntax/task.md

 ---

 #Syntax check
 #Перевірка синтаксису

 What is the result of this code?
 Який результат цього коду?


 ```js no-beautify
 let user = {
  name: "John",
  name: "Іван",
  go: function() { alert(this.name) }
 }

 (user.go)()
 ```

 P.S. There's a pitfall :)
 П.С. Тут є пастка :)
diff --git a/1-js/99-js-misc/04-reference-type/3-why-this/solution.md b/1-js/99-js-misc/04-reference-type/3-why-this/solution.md

 Here's the explanations.
 Ось пояснення.

 1.That's a regular object method call.
 1.Це звичайний виклик методу об'єкта.

 2.The same, parentheses do not change the order of operations here, the dot is first anyway.
 2.Те ж саме, дужки не змінюють порядок операцій тут, крапка спрацьовує спочатку в будь-якому випадку.

 3.Here we have a more complex call `(expression)()`.The call works as if it were split into two lines:
 3.Тут у нас є більш складний виклик `(вираз)()`.Виклик працює так, ніби він був розділений на два рядки:

    ```js no-beautify
    f = obj.go; //calculate the expression
    f();        //call what we have
    f = obj.go; //обчислити вираз
    f();        //викликати те, що ми маємо
    ```

 Here `f()`is executed as a function, without `this`.
 Тут `f()`виконується як функція, без `this`.

 4.The similar thing as`(3)`,to the left of the parentheses`()` we have an expression.
 4.Ми маємо вираз подібну річ, як в`(3)`,ліворуч від дужок`()`.

 To explain the behavior of`(3)`and `(4)` we need to recall that property accessors (dot or square brackets) return a value of the Reference Type.
 Щоб пояснити поведінку`(3)`та `(4)`, ми повинні нагадати, що аксесори властивостей (крапка або квадратні дужки) повертають значення посисального типу.

 Any operation on it except a method call (like assignment `=`or `||`)turns it into an ordinary value, which does not carry the information allowing to set `this`.
 Будь-яка операція на цьому, крім виклику методу (наприклад, присвоєння `=`або `||`)перетворює його в звичайне значення, яке не носить інформацію, яка дозволяє встановити `this`.

diff --git a/1-js/99-js-misc/04-reference-type/3-why-this/task.md b/1-js/99-js-misc/04-reference-type/3-why-this/task.md

 ---

 #Explain the value of "this"
 #Поясніть значення "this"

 In the code below we intend to call `obj.go()`method 4 times in a row.
 У коді нижче ми маємо намір викликати метод `obj.go()`4 рази поспіль.

 But calls `(1)`and `(2)`works differently from `(3)`and `(4)`.Why?
 Але виклики `(1)`та `(2)`працюють по-різному ніж `(3)`і `(4)`.Чому?

 ```js run no-beautify
 let obj, method;
diff --git a/1-js/99-js-misc/04-reference-type/article.md b/1-js/99-js-misc/04-reference-type/article.md

 #Reference Type
 #Посилальний Тип

 ```warn header="In-depth language feature"
 This article covers an advanced topic, to understand certain edge-cases better.
 ```warn header="Поглиблений функціонал мови"
 Ця стаття охоплює складну тему, щоб краще зрозуміти певні крайні випадки.

 It's not important. Many experienced developers live fine without knowing it. Read on if you want to know how things work under the hood.
 Це не є важливим. Багато досвідчених розробників живуть добре, не знаючи цього. Прочитайте, якщо ви хочете знати, як певні речі працюють під капотом.
 ```

 A dynamically evaluated method call can lose `this`.
 Динамічно оцінений виклик методу може втратити `this`.

 For instance:
 Наприклад:

 ```js run
 let user = {
  name: "John",
  name: "Іван",
  hi() { alert(this.name); },
  bye() { alert("Bye"); }
  bye() { alert("До побачення"); }
 };

 user.hi(); //works
 user.hi(); //працює

 //now let's calluser.hior user.byedepending on the name
 //тепер викличмоuser.hiабо user.byeзалежно від назви
 *!*
 (user.name == "John" ? user.hi : user.bye)(); //Error!
 (user.name == "John" ? user.hi : user.bye)(); //Помилка!
 */!*
 ```

 On the last line there is a conditional operator that chooses either`user.hi`or `user.bye`.In this case the result is `user.hi`.
 На останньому рядку є умовний оператор, який вибирає або`user.hi`або `user.bye`.У цьому випадку результат -- `user.hi`.

 Then the method is immediately called with parentheses`()`.But it doesn't work correctly!
 Потім метод негайно викликається за допомогою дужок`()`.Але це працює неправильно!

 As you can see, the call results in an error, because the value of`"this"`inside the call becomes `undefined`.
 Як ви бачите, виклик призводить до помилки, тому що значення`"this"`всередині виклику стає `undefined`.

 This works (object dot method):
 Це працює (метод об’єкта через крапку):
 ```js
 user.hi();
 ```

 This doesn't (evaluated method):
 Це ні (динамічно оцінений метод):
 ```js
 (user.name == "John" ? user.hi : user.bye)(); //Error!
 (user.name == "John" ? user.hi : user.bye)(); //Помилка!
 ```

 Why? If we want to understand why it happens, let's get under the hood of how`obj.method()` call works.
 Чому? Якщо ми хочемо зрозуміти, чому це трапляється, загляньмо під капот, як працює виклик`obj.method()`.

 ##Reference type explained
 ##Пояснення Посилального Типу

 Looking closely, we may notice two operations in`obj.method()` statement:
 Дивлячись уважно, ми можемо помітити дві операції в інструкції`obj.method()`:

 1.First, the dot`'.'`retrieves the property `obj.method`.
 2.Then parentheses `()`execute it.
 1.По-перше, крапка`'.'`витягує властивість `obj.method`.
 2.Потім дужки `()`виконуйте її.

 So, how does the information about`this`get passed from the first part to the second one?
 Отже, як інформація про`this`передається з першої частини до другої?

 If we put these operations on separate lines, then `this`will be lost for sure:
 Якщо ми поставимо ці операції на окремі рядки, то `this`напевно буде втрачено:

 ```js run
 let user = {
 }

 *!*
 //split getting and calling the method in two lines
 //розділимо отримання та виклик методу на два рядки
 let hi = user.hi;
 hi(); //Error, becausethisis undefined
 hi(); //Помилка, тому щоthis-- це undefined
 */!*
 ```

 Here `hi = user.hi`puts the function into the variable, and then on the last line it is completely standalone, and so there's no `this`.
 Тут `hi = user.hi`поміщає функцію в змінну, а потім на останньому рядку, ця змінна повністю автономна, і тому не має `this`.

 **To make`user.hi()`calls work, JavaScriptuses a trick--the dot`'.'`returns not a function, but a value of the special [Reference Type](https://tc39.github.io/ecma262/#sec-reference-specification-type).**
 **Щоб зробити виклик`user.hi()`робочим, JavaScriptвикористовує трюк--крапка`'.'`повертає не функцію, а значення спеціального [посилальний типу](https://tc39.github.io/ecma262/#sec-reference-specification-type).**

 The Reference Type is a "specification type".We can't explicitly use it, but it is used internally by the language.
 Посилальний тип -- це "тип специфікації".Ми не можемо явно використовувати його, але він використовується всередині мови.

 The value of Reference Type is a three-value combination`(base, name, strict)`,where:
 Значення посилального типу -- це комбінація трьох значення`(base, name, strict)`,де:

 - `base`is the object.
 - `name`is the property name.
 - `strict`istrueif`use strict` is in effect.
 - `base`-- це об’єкт.
 - `name`-- це назва властивості.
 - `strict`-- цеtrueякщо діє`use strict`.

 The result of a property access`user.hi`is not a function, but a value of Reference Type. For `user.hi`in strict mode it is:
 Результат доступу до властивості`user.hi`є не функцією, а значенням посилального типу. Для `user.hi`у суворому режимі це:

 ```js
 //Reference Type value
 //Значення посилального типу
 (user, "hi", true)
 ```

 When parentheses `()`are called on the Reference Type, they receive the full information about the object and its method, and can set the right`this` (`=user`in this case).
 Коли дужки `()`викликаються з посилальним типом, вони отримують повну інформацію про об’єкт та його метод, і можуть встановити правильний`this` (`=user`у даному випадку).

 Reference type is a special "intermediary" internal type, with the purpose to pass information from dot `.`to calling parentheses `()`.
 Посилальний тип -- це особливий "посередницький" внутрішній тип, який використовується з метою передачі інформації від крапки `.`до дужок виклику `()`.

 Any other operation like assignment `hi = user.hi`discards the reference type as a whole, takes the value of`user.hi` (a function) and passes it on. So any further operation "loses" `this`.
 Будь-яка інша операція, наприклад присвоєння `hi = user.hi`в цілому відкидає посилальний тип та приймає значення`user.hi` (функції) і передає його. Отже, будь-яка подальша операція "втрачає" `this`.

 So, as the result, the value of`this`is only passed the right way if the function is called directly using a dot`obj.method()`or square brackets`obj['method']()`syntax (they do the same here).There are various ways to solve this problem such as [func.bind()](/bind#solution-2-bind).
 Отже, як результат, значення`this`передається правильно тільки тоді, якщо функція викликається безпосередньо за допомогою крапки`obj.method()`або синтаксису квадратних дужок`obj['method']()`(вони роблять одне й те ж саме).Існують різні способи розв’язання цієї проблеми, як [func.bind()](/bind#solution-2-bind).

 ##Summary
 ##Підсумки

 Reference Type is an internal type of the language.
 Посилальний тип -- це внутрішній тип мови.

 Reading a property, such as with dot`.`in `obj.method()`returns not exactly the property value, but a special "reference type" value that stores both the property value and the object it was taken from.
 Читання властивості, наприклад, крапкою`.`в `obj.method()`повертає не саме значення властивості, але спеціальне значення "посилального типу", яке зберігає як значення властивості, так і об’єкт, з якою він був взятий.

 That's for the subsequent method call`()` to get the object and set`this`to it.
 Це використовується для подальшого виклику методу за допомогою`()`, щоб отримати об’єкт і встановити`this`до цього.

 For all other operations, the reference type automatically becomes the property value (a function in our case).
 Для всіх інших операцій, посилальний тип автоматично стає значенням властивості (функцією у нашому випадку).

 The whole mechanics is hidden from our eyes. It only matters in subtle cases, such as when a method is obtained dynamically from the object, using an expression.
 Вся ця механіка прихована від наших очей. Це лише важливо в тонких випадках, наприклад, коли метод отримується динамічно з об’єкта, використовуючи вираз.
Original file line number	Diff line number	Diff line change
		@@ -1,37 +1,37 @@
		Error!
		Помилка!

		Try it:
		Спробуйте:

		```js run
		let user = {
		name: "John",
		name: "Іван",
		go: function() { alert(this.name) }
		}

		(user.go)() //error!
		(user.go)() //помилка!
		```

		The error message in most browsers does not give us much of a clue about what went wrong.
		Повідомлення про помилку в більшості браузерів не дає нам велику кількість підказок про те, що пішло не так.

		The error appears because a semicolon is missing after `user = {...}`.
		Помилка з'являється, оскільки крапка з комою відсутня після `user = {...}`.

		JavaScriptdoes not auto-insert a semicolon before a bracket `(user.go)()`, so it reads the code like:
		JavaScriptне вставляэ автоматично крапку з комою перед дужками `(user.go)()` тому, що він читає код, як:

		```js no-beautify
		let user = { go:... }(user.go)()
		```

		Then we can also see that such a joint expression is syntactically a call of the object`{ go: ... }`as a function with the argument`(user.go)`.And that also happens on the same line with `let user`,so the`user`object has not yet even been defined, hence the error.
		Тоді ми також можемо побачити, що такий спільний вираз синтаксично є викликом об'єкта`{ go: ... }`як функція з аргументом`(user.go)`.І це також відбувається на тій же лінії, з `let user`,тому, оскільки об'єкт`user`ще не визначений, виникає помилка.

		If we insert the semicolon, all is fine:
		Якщо ми вставляємо крапку з комою, все добре:

		```js run
		let user = {
		name: "John",
		name: "Іван",
		go: function() { alert(this.name) }
		}!;/!

		(user.go)() //John
		(user.go)() //Іван
		```

		Please note that parentheses around `(user.go)`do nothing here. Usually they setup the order of operations, but here the dot `.` works first anyway, so there's no effect. Only the semicolon thing matters.
		Зверніть увагу, що дужки навколо `(user.go)`нічого не роблять тут. Зазвичай вони встановлюють порядок операцій, але тут крапка спрацьовує спочатку в будь-якому випадку, тому немає ефекту. Тільки грає роль лише крапка з комою вкінці.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,18 +2,18 @@ importance: 2

		---

		#Syntax check
		#Перевірка синтаксису

		What is the result of this code?
		Який результат цього коду?


		```js no-beautify
		let user = {
		name: "John",
		name: "Іван",
		go: function() { alert(this.name) }
		}

		(user.go)()
		```

		P.S. There's a pitfall :)
		П.С. Тут є пастка :)
Original file line number	Diff line number	Diff line change
		@@ -1,22 +1,22 @@

		Here's the explanations.
		Ось пояснення.

		1.That's a regular object method call.
		1.Це звичайний виклик методу об'єкта.

		2.The same, parentheses do not change the order of operations here, the dot is first anyway.
		2.Те ж саме, дужки не змінюють порядок операцій тут, крапка спрацьовує спочатку в будь-якому випадку.

		3.Here we have a more complex call `(expression)()`.The call works as if it were split into two lines:
		3.Тут у нас є більш складний виклик `(вираз)()`.Виклик працює так, ніби він був розділений на два рядки:

		```js no-beautify
		f = obj.go; //calculate the expression
		f(); //call what we have
		f = obj.go; //обчислити вираз
		f(); //викликати те, що ми маємо
		```

		Here `f()`is executed as a function, without `this`.
		Тут `f()`виконується як функція, без `this`.

		4.The similar thing as`(3)`,to the left of the parentheses`()` we have an expression.
		4.Ми маємо вираз подібну річ, як в`(3)`,ліворуч від дужок`()`.

		To explain the behavior of`(3)`and `(4)` we need to recall that property accessors (dot or square brackets) return a value of the Reference Type.
		Щоб пояснити поведінку`(3)`та `(4)`, ми повинні нагадати, що аксесори властивостей (крапка або квадратні дужки) повертають значення посисального типу.

		Any operation on it except a method call (like assignment `=`or `\|\|`)turns it into an ordinary value, which does not carry the information allowing to set `this`.
		Будь-яка операція на цьому, крім виклику методу (наприклад, присвоєння `=`або `\|\|`)перетворює його в звичайне значення, яке не носить інформацію, яка дозволяє встановити `this`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,11 +2,11 @@ importance: 3

		---

		#Explain the value of "this"
		#Поясніть значення "this"

		In the code below we intend to call `obj.go()`method 4 times in a row.
		У коді нижче ми маємо намір викликати метод `obj.go()`4 рази поспіль.

		But calls `(1)`and `(2)`works differently from `(3)`and `(4)`.Why?
		Але виклики `(1)`та `(2)`працюють по-різному ніж `(3)`і `(4)`.Чому?

		```js run no-beautify
		let obj, method;
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,59 +1,59 @@

		#Reference Type
		#Посилальний Тип

		```warn header="In-depth language feature"
		This article covers an advanced topic, to understand certain edge-cases better.
		```warn header="Поглиблений функціонал мови"
		Ця стаття охоплює складну тему, щоб краще зрозуміти певні крайні випадки.

		It's not important. Many experienced developers live fine without knowing it. Read on if you want to know how things work under the hood.
		Це не є важливим. Багато досвідчених розробників живуть добре, не знаючи цього. Прочитайте, якщо ви хочете знати, як певні речі працюють під капотом.
		```

		A dynamically evaluated method call can lose `this`.
		Динамічно оцінений виклик методу може втратити `this`.

		For instance:
		Наприклад:

		```js run
		let user = {
		name: "John",
		name: "Іван",
		hi() { alert(this.name); },
		bye() { alert("Bye"); }
		bye() { alert("До побачення"); }
		};

		user.hi(); //works
		user.hi(); //працює

		//now let's calluser.hior user.byedepending on the name
		//тепер викличмоuser.hiабо user.byeзалежно від назви
		!
		(user.name == "John" ? user.hi : user.bye)(); //Error!
		(user.name == "John" ? user.hi : user.bye)(); //Помилка!
		/!
		```

		On the last line there is a conditional operator that chooses either`user.hi`or `user.bye`.In this case the result is `user.hi`.
		На останньому рядку є умовний оператор, який вибирає або`user.hi`або `user.bye`.У цьому випадку результат -- `user.hi`.

		Then the method is immediately called with parentheses`()`.But it doesn't work correctly!
		Потім метод негайно викликається за допомогою дужок`()`.Але це працює неправильно!

		As you can see, the call results in an error, because the value of`"this"`inside the call becomes `undefined`.
		Як ви бачите, виклик призводить до помилки, тому що значення`"this"`всередині виклику стає `undefined`.

		This works (object dot method):
		Це працює (метод об’єкта через крапку):
		```js
		user.hi();
		```

		This doesn't (evaluated method):
		Це ні (динамічно оцінений метод):
		```js
		(user.name == "John" ? user.hi : user.bye)(); //Error!
		(user.name == "John" ? user.hi : user.bye)(); //Помилка!
		```

		Why? If we want to understand why it happens, let's get under the hood of how`obj.method()` call works.
		Чому? Якщо ми хочемо зрозуміти, чому це трапляється, загляньмо під капот, як працює виклик`obj.method()`.

		##Reference type explained
		##Пояснення Посилального Типу

		Looking closely, we may notice two operations in`obj.method()` statement:
		Дивлячись уважно, ми можемо помітити дві операції в інструкції`obj.method()`:

		1.First, the dot`'.'`retrieves the property `obj.method`.
		2.Then parentheses `()`execute it.
		1.По-перше, крапка`'.'`витягує властивість `obj.method`.
		2.Потім дужки `()`виконуйте її.

		So, how does the information about`this`get passed from the first part to the second one?
		Отже, як інформація про`this`передається з першої частини до другої?

		If we put these operations on separate lines, then `this`will be lost for sure:
		Якщо ми поставимо ці операції на окремі рядки, то `this`напевно буде втрачено:

		```js run
		let user = {
Expand All		@@ -62,47 +62,47 @@ let user = {
		}

		!
		//split getting and calling the method in two lines
		//розділимо отримання та виклик методу на два рядки
		let hi = user.hi;
		hi(); //Error, becausethisis undefined
		hi(); //Помилка, тому щоthis-- це undefined
		/!
		```

		Here `hi = user.hi`puts the function into the variable, and then on the last line it is completely standalone, and so there's no `this`.
		Тут `hi = user.hi`поміщає функцію в змінну, а потім на останньому рядку, ця змінна повністю автономна, і тому не має `this`.

		To make`user.hi()`calls work, JavaScriptuses a trick--the dot`'.'`returns not a function, but a value of the special [Reference Type](https://tc39.github.io/ecma262/#sec-reference-specification-type).
		Щоб зробити виклик`user.hi()`робочим, JavaScriptвикористовує трюк--крапка`'.'`повертає не функцію, а значення спеціального [посилальний типу](https://tc39.github.io/ecma262/#sec-reference-specification-type).

		The Reference Type is a "specification type".We can't explicitly use it, but it is used internally by the language.
		Посилальний тип -- це "тип специфікації".Ми не можемо явно використовувати його, але він використовується всередині мови.

		The value of Reference Type is a three-value combination`(base, name, strict)`,where:
		Значення посилального типу -- це комбінація трьох значення`(base, name, strict)`,де:

		- `base`is the object.
		- `name`is the property name.
		- `strict`istrueif`use strict` is in effect.
		- `base`-- це об’єкт.
		- `name`-- це назва властивості.
		- `strict`-- цеtrueякщо діє`use strict`.

		The result of a property access`user.hi`is not a function, but a value of Reference Type. For `user.hi`in strict mode it is:
		Результат доступу до властивості`user.hi`є не функцією, а значенням посилального типу. Для `user.hi`у суворому режимі це:

		```js
		//Reference Type value
		//Значення посилального типу
		(user, "hi", true)
		```

		When parentheses `()`are called on the Reference Type, they receive the full information about the object and its method, and can set the right`this` (`=user`in this case).
		Коли дужки `()`викликаються з посилальним типом, вони отримують повну інформацію про об’єкт та його метод, і можуть встановити правильний`this` (`=user`у даному випадку).

		Reference type is a special "intermediary" internal type, with the purpose to pass information from dot `.`to calling parentheses `()`.
		Посилальний тип -- це особливий "посередницький" внутрішній тип, який використовується з метою передачі інформації від крапки `.`до дужок виклику `()`.

		Any other operation like assignment `hi = user.hi`discards the reference type as a whole, takes the value of`user.hi` (a function) and passes it on. So any further operation "loses" `this`.
		Будь-яка інша операція, наприклад присвоєння `hi = user.hi`в цілому відкидає посилальний тип та приймає значення`user.hi` (функції) і передає його. Отже, будь-яка подальша операція "втрачає" `this`.

		So, as the result, the value of`this`is only passed the right way if the function is called directly using a dot`obj.method()`or square brackets`obj['method']()`syntax (they do the same here).There are various ways to solve this problem such as [func.bind()](/bind#solution-2-bind).
		Отже, як результат, значення`this`передається правильно тільки тоді, якщо функція викликається безпосередньо за допомогою крапки`obj.method()`або синтаксису квадратних дужок`obj['method']()`(вони роблять одне й те ж саме).Існують різні способи розв’язання цієї проблеми, як [func.bind()](/bind#solution-2-bind).

		##Summary
		##Підсумки

		Reference Type is an internal type of the language.
		Посилальний тип -- це внутрішній тип мови.

		Reading a property, such as with dot`.`in `obj.method()`returns not exactly the property value, but a special "reference type" value that stores both the property value and the object it was taken from.
		Читання властивості, наприклад, крапкою`.`в `obj.method()`повертає не саме значення властивості, але спеціальне значення "посилального типу", яке зберігає як значення властивості, так і об’єкт, з якою він був взятий.

		That's for the subsequent method call`()` to get the object and set`this`to it.
		Це використовується для подальшого виклику методу за допомогою`()`, щоб отримати об’єкт і встановити`this`до цього.

		For all other operations, the reference type automatically becomes the property value (a function in our case).
		Для всіх інших операцій, посилальний тип автоматично стає значенням властивості (функцією у нашому випадку).

		The whole mechanics is hidden from our eyes. It only matters in subtle cases, such as when a method is obtained dynamically from the object, using an expression.
		Вся ця механіка прихована від наших очей. Це лише важливо в тонких випадках, наприклад, коли метод отримується динамічно з об’єкта, використовуючи вираз.