Oct 17, 2023 · Oct 17, 2023
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/_js.view/test.js b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/_js.view/test.js
    const debounced = debounce(f, 1000);

    debounced('a');
    setTimeout(() => debounced('b'), 200); // ignored (too early)
    setTimeout(() => debounced('c'), 500); // runs (1000 ms passed)
    setTimeout(() => debounced('b'), 200);
    setTimeout(() => debounced('c'), 500);
    this.clock.tick(1000);

    assert(f.notCalled, 'not called after 1000ms');
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
 In a browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).
 **We'd like to update some information on the web-page when the pointer moves.**

 ...But updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in updating more often than once per100ms.
 ...But updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in updating more often than once per1000ms.

 So we'll wrap it into the decorator: use `throttle(update,100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but forward the call to `update()` at maximum once per100ms.
 So we'll wrap it into the decorator: use `throttle(update,1000)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but forward the call to `update()` at maximum once per1000ms.

 Visually, it will look like this:

 1. For the first mouse movement the decorated variant immediately passes the call to `update`. That's important, the user sees our reaction to their move immediately.
 2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
 3. At the end of `100ms` -- one more `update` happens with the last coordinates.
 4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, quite important, the final mouse coordinates are processed.
 2. Then as the mouse moves on, until `1000ms` nothing happens. The decorated variant ignores calls.
 3. At the end of `1000ms` -- one more `update` happens with the last coordinates.
 4. Then, finally, the mouse stops somewhere. The decorated variant waits until `1000ms` expire and then runs `update` with last coordinates. So, quite important, the final mouse coordinates are processed.

 A code example:
Original file line number	Diff line number	Diff line change
Expand Up		@@ -22,8 +22,8 @@ describe('debounce', function () {
		const debounced = debounce(f, 1000);

		debounced('a');
		setTimeout(() => debounced('b'), 200); // ignored (too early)
		setTimeout(() => debounced('c'), 500); // runs (1000 ms passed)
		setTimeout(() => debounced('b'), 200);
		setTimeout(() => debounced('c'), 500);
		this.clock.tick(1000);

		assert(f.notCalled, 'not called after 1000ms');
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,16 +21,16 @@ Let's check the real-life application to better understand that requirement and
		In a browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).
		We'd like to update some information on the web-page when the pointer moves.

		...But updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in updating more often than once per100ms.
		...But updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in updating more often than once per1000ms.

		So we'll wrap it into the decorator: use `throttle(update,100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but forward the call to `update()` at maximum once per100ms.
		So we'll wrap it into the decorator: use `throttle(update,1000)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but forward the call to `update()` at maximum once per1000ms.

		Visually, it will look like this:

		1. For the first mouse movement the decorated variant immediately passes the call to `update`. That's important, the user sees our reaction to their move immediately.
		2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
		3. At the end of `100ms` -- one more `update` happens with the last coordinates.
		4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, quite important, the final mouse coordinates are processed.
		2. Then as the mouse moves on, until `1000ms` nothing happens. The decorated variant ignores calls.
		3. At the end of `1000ms` -- one more `update` happens with the last coordinates.
		4. Then, finally, the mouse stops somewhere. The decorated variant waits until `1000ms` expire and then runs `update` with last coordinates. So, quite important, the final mouse coordinates are processed.

		A code example:

Expand Down