Dec 31, 2021 · Dec 30, 2021 · Dec 31, 2021
diff --git a/1-js/99-js-misc/01-proxy/01-error-nonexisting/solution.md b/1-js/99-js-misc/01-proxy/01-error-nonexisting/solution.md
      if (prop in target) {
        return Reflect.get(target, prop, receiver);
      } else {
        throw new ReferenceError(`Property doesn't exist: "${prop}"`)
        throw new ReferenceError(`Властивість не існує: "${prop}"`)
      }
    }
  });
 }

 user = wrap(user);

 alert(user.name); //John
 alert(user.age); // ReferenceError:Property doesn't exist: "age"
 alert(user.name); //Іван
 alert(user.age); // ReferenceError:Властивість не існує: "age"
 ```
diff --git a/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md b/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md
 #Error on reading non-existent property
 #Помилка під час зчитування неіснуючої властивості

 Usually, an attempt to read a non-existent property returns `undefined`.
 Зазвичай при спробі прочитати неіснуючу властивість повертається `undefined`.

 Create a proxy that throws an error for an attempt to read of a non-existent property instead.
 Створіть проксі, що видає помилку при спробі зчитування неіснуючої властивості.

 That can help to detect programming mistakes early.
 Це може допомогти виявити помилки програмування раніше.

 Write a function`wrap(target)` that takes an object`target`and return a proxy that adds this functionality aspect.
 Напишіть функцію`wrap(target)`, яка приймає об’єкт`target`і повертає проксі, що додає цей аспект функціональності.

 That's how it should work:
 Ось як це має працювати:

 ```js
 let user = {
  name: "John"
  name: "Іван"
 };

 function wrap(target) {
  return new Proxy(target, {
 *!*
      /*your code */
      /*ваш код */
 */!*
  });
 }

 user = wrap(user);

 alert(user.name); //John
 alert(user.name); //Іван
 *!*
 alert(user.age); // ReferenceError:Property doesn't exist: "age"
 alert(user.age); // ReferenceError:Властивість не існує: "age"
 */!*
 ```
diff --git a/1-js/99-js-misc/01-proxy/02-array-negative/solution.md b/1-js/99-js-misc/01-proxy/02-array-negative/solution.md
 array = new Proxy(array, {
  get(target, prop, receiver) {
    if (prop < 0) {
      //even if we access it like arr[1]
      // propis a string, so need to convert it to number
      //навіть якщо ми намагаємося отримати доступ як arr[1]
      // propє рядком, тому його потрібно перетворити на число
      prop = +prop + target.length;
    }
    return Reflect.get(target, prop, receiver);
diff --git a/1-js/99-js-misc/01-proxy/02-array-negative/task.md b/1-js/99-js-misc/01-proxy/02-array-negative/task.md

 #Accessing array[-1]
 #Доступ до масиву[-1]

 In some programming languages, we can access array elements using negative indexes, counted from the end.
 У деяких мовах програмування ми можемо отримати доступ до елементів масиву за допомогою негативних індексів, відрахованих з кінця.

 Like this:
 Наприклад ось так:

 ```js
 let array = [1, 2, 3];

 array[-1]; // 3,the last element
 array[-2]; // 2,one step from the end
 array[-3]; // 1,two steps from the end
 array[-1]; // 3,останній елемент
 array[-2]; // 2,за крок від кінця
 array[-3]; // 1,за два кроки від кінця
 ```

 In other words, `array[-N]`is the same as `array[array.length - N]`.
 Іншими словами, `array[-N]`це те саме, що `array[array.length - N]`.

 Create a proxy to implement that behavior.
 Створіть проксі для реалізації такої поведінки.

 That's how it should work:
 Ось як це має працювати:

 ```js
 let array = [1, 2, 3];

 array = new Proxy(array, {
  /*your code */
  /*ваш код */
 });

 alert( array[-1] ); // 3
 alert( array[-2] ); // 2

 //Other array functionality should be kept "as is"
 //Іншу функціональність масиву слід зберегти "як є"
 ```
diff --git a/1-js/99-js-misc/01-proxy/03-observable/solution.md b/1-js/99-js-misc/01-proxy/03-observable/solution.md
 The solution consists of two parts:
 Рішення складається з двох частин:

 1.Whenever`.observe(handler)` is called, we need to remember the handler somewhere, to be able to call it later. We can store handlers right in the object, using our symbol as the property key.
 2.We need a proxy with `set`trap to call handlers in case of any change.
 1.Щоразу, коли викликається`.observe(handler)`, нам потрібно десь запам’ятати обробник, щоб мати можливість викликати його пізніше. Ми можемо зберігати обробники прямо в об’єкті, використовуючи наш символ як ключ властивості.
 2.Нам потрібен проксі з пасткою `set`для виклику обробників у разі будь-яких змін.

 ```js run
 let handlers = Symbol('handlers');

 function makeObservable(target) {
  // 1.Initialize handlers store
  // 1.Ініціалізуємо сховище обробників
  target[handlers] = [];

  //Store the handler function in array for future calls
  //Збережемо функцію-обробник в масиві для майбутніх викликів
  target.observe = function(handler) {
    this[handlers].push(handler);
  };

  // 2.Create a proxy to handle changes
  // 2.Створимо проксі для обробки змін
  return new Proxy(target, {
    set(target, property, value, receiver) {
      let success = Reflect.set(...arguments); //forward the operation to object
      if (success) { //if there were no error while setting the property
        //call all handlers
      let success = Reflect.set(...arguments); //перенаправимо операцію на об’єкт
      if (success) { //якщо під час запису властивості не було помилок
        //викличемо всі обробники
        target[handlers].forEach(handler => handler(property, value));
      }
      return success;
  alert(`SET ${key}=${value}`);
 });

 user.name = "John";
 user.name = "Іван";
 ```
diff --git a/1-js/99-js-misc/01-proxy/03-observable/task.md b/1-js/99-js-misc/01-proxy/03-observable/task.md

 # Observable

 Create a function`makeObservable(target)` that "makes the object observable" by returning a proxy.
 Створіть функцію`makeObservable(target)`, яка "робить об’єкт доступним для спостереження", повертаючи проксі.

 Here's how it should work:
 Ось як це має працювати:

 ```js run
 function makeObservable(target) {
  /*your code */
  /*ваш код */
 }

 let user = {};
  alert(`SET ${key}=${value}`);
 });

 user.name = "John"; //alerts: SET name=John
 user.name = "Іван"; //сповіщає: SET name=Іван
 ```

 In other words, an object returned by`makeObservable` is just like the original one, but also has the method`observe(handler)` that sets`handler`function to be called on any property change.
 Іншими словами, об’єкт, повернутий`makeObservable`, такий же, як оригінальний, але також має метод`observe(handler)`, який встановлює функцію`handler`для виклику при будь-якій зміні властивості.

 Whenever a property changes,`handler(key, value)`is called with the name and value of the property.
 Щоразу, коли властивість змінюється, викликається`handler(key, value)`з назвою та значенням властивості.

 P.S.In this task, please only take care about writing to a property. Other operations can be implemented in a similar way.
 P.S.У цьому завданні подбайте лише про запис у властивість. Подібним чином можна реалізувати й інші операції.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -10,14 +10,14 @@ function wrap(target) {
		if (prop in target) {
		return Reflect.get(target, prop, receiver);
		} else {
		throw new ReferenceError(`Property doesn't exist: "${prop}"`)
		throw new ReferenceError(`Властивість не існує: "${prop}"`)
		}
		}
		});
		}

		user = wrap(user);

		alert(user.name); //John
		alert(user.age); // ReferenceError:Property doesn't exist: "age"
		alert(user.name); //Іван
		alert(user.age); // ReferenceError:Властивість не існує: "age"
		```
Original file line number	Diff line number	Diff line change
		@@ -1,32 +1,32 @@
		#Error on reading non-existent property
		#Помилка під час зчитування неіснуючої властивості

		Usually, an attempt to read a non-existent property returns `undefined`.
		Зазвичай при спробі прочитати неіснуючу властивість повертається `undefined`.

		Create a proxy that throws an error for an attempt to read of a non-existent property instead.
		Створіть проксі, що видає помилку при спробі зчитування неіснуючої властивості.

		That can help to detect programming mistakes early.
		Це може допомогти виявити помилки програмування раніше.

		Write a function`wrap(target)` that takes an object`target`and return a proxy that adds this functionality aspect.
		Напишіть функцію`wrap(target)`, яка приймає об’єкт`target`і повертає проксі, що додає цей аспект функціональності.

		That's how it should work:
		Ось як це має працювати:

		```js
		let user = {
		name: "John"
		name: "Іван"
		};

		function wrap(target) {
		return new Proxy(target, {
		!
		/your code /
		/ваш код /
		/!
		});
		}

		user = wrap(user);

		alert(user.name); //John
		alert(user.name); //Іван
		!
		alert(user.age); // ReferenceError:Property doesn't exist: "age"
		alert(user.age); // ReferenceError:Властивість не існує: "age"
		/!
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5,8 +5,8 @@ let array = [1, 2, 3];
		array = new Proxy(array, {
		get(target, prop, receiver) {
		if (prop < 0) {
		//even if we access it like arr[1]
		// propis a string, so need to convert it to number
		//навіть якщо ми намагаємося отримати доступ як arr[1]
		// propє рядком, тому його потрібно перетворити на число
		prop = +prop + target.length;
		}
		return Reflect.get(target, prop, receiver);
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,33 +1,33 @@

		#Accessing array[-1]
		#Доступ до масиву[-1]

		In some programming languages, we can access array elements using negative indexes, counted from the end.
		У деяких мовах програмування ми можемо отримати доступ до елементів масиву за допомогою негативних індексів, відрахованих з кінця.

		Like this:
		Наприклад ось так:

		```js
		let array = [1, 2, 3];

		array[-1]; // 3,the last element
		array[-2]; // 2,one step from the end
		array[-3]; // 1,two steps from the end
		array[-1]; // 3,останній елемент
		array[-2]; // 2,за крок від кінця
		array[-3]; // 1,за два кроки від кінця
		```

		In other words, `array[-N]`is the same as `array[array.length - N]`.
		Іншими словами, `array[-N]`це те саме, що `array[array.length - N]`.

		Create a proxy to implement that behavior.
		Створіть проксі для реалізації такої поведінки.

		That's how it should work:
		Ось як це має працювати:

		```js
		let array = [1, 2, 3];

		array = new Proxy(array, {
		/your code /
		/ваш код /
		});

		alert( array[-1] ); // 3
		alert( array[-2] ); // 2

		//Other array functionality should be kept "as is"
		//Іншу функціональність масиву слід зберегти "як є"
		```
Original file line number	Diff line number	Diff line change
		@@ -1,26 +1,26 @@
		The solution consists of two parts:
		Рішення складається з двох частин:

		1.Whenever`.observe(handler)` is called, we need to remember the handler somewhere, to be able to call it later. We can store handlers right in the object, using our symbol as the property key.
		2.We need a proxy with `set`trap to call handlers in case of any change.
		1.Щоразу, коли викликається`.observe(handler)`, нам потрібно десь запам’ятати обробник, щоб мати можливість викликати його пізніше. Ми можемо зберігати обробники прямо в об’єкті, використовуючи наш символ як ключ властивості.
		2.Нам потрібен проксі з пасткою `set`для виклику обробників у разі будь-яких змін.

		```js run
		let handlers = Symbol('handlers');

		function makeObservable(target) {
		// 1.Initialize handlers store
		// 1.Ініціалізуємо сховище обробників
		target[handlers] = [];

		//Store the handler function in array for future calls
		//Збережемо функцію-обробник в масиві для майбутніх викликів
		target.observe = function(handler) {
		this[handlers].push(handler);
		};

		// 2.Create a proxy to handle changes
		// 2.Створимо проксі для обробки змін
		return new Proxy(target, {
		set(target, property, value, receiver) {
		let success = Reflect.set(...arguments); //forward the operation to object
		if (success) { //if there were no error while setting the property
		//call all handlers
		let success = Reflect.set(...arguments); //перенаправимо операцію на об’єкт
		if (success) { //якщо під час запису властивості не було помилок
		//викличемо всі обробники
		target[handlers].forEach(handler => handler(property, value));
		}
		return success;
Expand All		@@ -36,5 +36,5 @@ user.observe((key, value) => {
		alert(`SET ${key}=${value}`);
		});

		user.name = "John";
		user.name = "Іван";
		```
Original file line number	Diff line number	Diff line change
		@@ -1,13 +1,13 @@

		# Observable

		Create a function`makeObservable(target)` that "makes the object observable" by returning a proxy.
		Створіть функцію`makeObservable(target)`, яка "робить об’єкт доступним для спостереження", повертаючи проксі.

		Here's how it should work:
		Ось як це має працювати:

		```js run
		function makeObservable(target) {
		/your code /
		/ваш код /
		}

		let user = {};
Expand All		@@ -17,11 +17,11 @@ user.observe((key, value) => {
		alert(`SET ${key}=${value}`);
		});

		user.name = "John"; //alerts: SET name=John
		user.name = "Іван"; //сповіщає: SET name=Іван
		```

		In other words, an object returned by`makeObservable` is just like the original one, but also has the method`observe(handler)` that sets`handler`function to be called on any property change.
		Іншими словами, об’єкт, повернутий`makeObservable`, такий же, як оригінальний, але також має метод`observe(handler)`, який встановлює функцію`handler`для виклику при будь-якій зміні властивості.

		Whenever a property changes,`handler(key, value)`is called with the name and value of the property.
		Щоразу, коли властивість змінюється, викликається`handler(key, value)`з назвою та значенням властивості.

		P.S.In this task, please only take care about writing to a property. Other operations can be implemented in a similar way.
		P.S.У цьому завданні подбайте лише про запис у властивість. Подібним чином можна реалізувати й інші операції.