Merge pull request #204 from pasor1/article/09-call-apply-decorators

Decorators and forwarding, call/apply

Author: pasor1

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js

@@ -1,7 +1,7 @@
 function spy(func) {
 
   function wrapper(...args) {
-    // using ...args instead of arguments to store "real" array in wrapper.calls
+    // usiamo ...args invece di arguments per memorizzare un vero array in wrapper.calls
     wrapper.calls.push(args);
     return func.apply(this, args);
   }

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js

@@ -1,5 +1,5 @@
 function spy(func) {
-  // your code
+  // il tuo codice
 }
 
 

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md

@@ -1 +1 @@
-The wrapper returned by `spy(f)` should store all arguments and then use `f.apply` to forward the call.
+Il wrapper restituito da `spy (f)` dovrebbe memorizzare tutti gli argomenti e quindi usare `f.apply` per inoltrare la chiamata.

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Spy decorator
+# decorator spia
 
-Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.
+Crea un decorator `spy(func)` che restituisca un wrapper che salva tutte le chiamate alla funzione nella sua proprietà `calls`.
 
-Every call is saved as an array of arguments.
+Ogni chiamata viene salvata come un array di argomenti.
 
-For instance:
+Ad esempio:
 
 ```js
 function work(a, b) {
-  alert( a + b ); // work is an arbitrary function or method
+  alert( a + b ); // work è una funzione o un metodo arbitrario
 }
 
 *!*
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
+P.S. Questo decorator a volte è utile per fare *unit-testing*. La sua forma avanzata è `sinon.spy` nella libreria [Sinon.JS](http://sinonjs.org/).

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/_js.view/test.js

@@ -1,13 +1,13 @@
-describe("delay", function() {
-  before(function() {
+describe("delay", function () {
+  before(function () {
     this.clock = sinon.useFakeTimers();
   });
 
-  after(function() {
+  after(function () {
     this.clock.restore();
   });
 
-  it("calls the function after the specified timeout", function() {
+  it("chiama la funzione dopo il timeout specificato", function () {
     let start = Date.now();
 
     function f(x) {
@@ -18,13 +18,13 @@ describe("delay", function() {
     let f1000 = delay(f, 1000);
     f1000("test");
     this.clock.tick(2000);
-    assert(f.calledOnce, 'calledOnce check fails');
+    assert(f.calledOnce, 'controllo di calledOnce fallito');
   });
 
-  it("passes arguments and this", function() {
+  it("passa argomenti e this", function () {
     let start = Date.now();
     let user = {
-      sayHi: function(phrase, who) {
+      sayHi: function (phrase, who) {
         assert.equal(this, user);
         assert.equal(phrase, "Hello");
         assert.equal(who, "John");
@@ -41,6 +41,6 @@ describe("delay", function() {
 
     this.clock.tick(2000);
 
-    assert(spy.calledOnce, 'calledOnce check failed');
+    assert(spy.calledOnce, 'controllo di calledOnce fallito');
   });
 });

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md

@@ -1,4 +1,4 @@
-The solution:
+La soluzione:
 
 ```js run demo
 function delay(f, ms) {
@@ -11,22 +11,22 @@ function delay(f, ms) {
 
 let f1000 = delay(alert, 1000);
 
-f1000("test"); // shows "test" after 1000ms
+f1000("test"); // mostra "test" dopo 1000ms
 ```
 
-Please note how an arrow function is used here. As we know, arrow functions do not have own `this` and `arguments`, so `f.apply(this, arguments)` takes `this` and `arguments` from the wrapper.
+Qui, nota come viene utilizzata un arrow function. come sappiamo le arrow functions non hanno un proprio `this` nè `arguments`, quindi `f.apply(this, arguments)` prende `this` e `arguments` dal wrapper.
 
-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
+Se passassimo una funzione regolare, `setTimeout` la chiamerebbe senza argomenti e` this = window` (supponendo essere in un browser). 
 
-We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
+Possiamo anche passare il `this` corretto usando una variabile intermedia, ma è un po' più complicato:
 
 ```js
 function delay(f, ms) {
 
   return function(...args) {
-    let savedThis = this; // store this into an intermediate variable
+    let savedThis = this; // memorizzalo in una variabile intermedia
     setTimeout(function() {
-      f.apply(savedThis, args); // use it here
+      f.apply(savedThis, args); // usalo qui
     }, ms);
   };
 

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md

@@ -2,25 +2,25 @@ importance: 5
 
 ---
 
-# Delaying decorator
+# decorator ritardante
 
-Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.
+Crea il decorator `delay(f, ms)` che ritarda ogni chiamata ad `f` di `ms` millisecondi.
 
-For instance:
+Ad esempio:
 
 ```js
 function f(x) {
   alert(x);
 }
 
-// create wrappers
+// crea i wrappers
 let f1000 = delay(f, 1000);
 let f1500 = delay(f, 1500);
 
-f1000("test"); // shows "test" after 1000ms
-f1500("test"); // shows "test" after 1500ms
+f1000("test"); // visualizza "test" dopo 1000ms
+f1500("test"); // visualizza "test" dopo 1500ms
 ```
 
-In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.
+In altre parole, `delay(f, ms)` ritorna una variante di `f` ritardata di `ms`.
 
-In the code above, `f` is a function of a single argument, but your solution should pass all arguments and the context `this`.
+Nel codice sopra, `f` è una funzione con un solo argomento, ma la tua soluzione potrebbe passare molti argomenti ed il contesto `this`.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/_js.view/test.js

@@ -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); // ignorato (tropo presto)
+    setTimeout(() => debounced('c'), 500); // eseguito (1000 ms passati)
     this.clock.tick(1000);
 
     assert(f.notCalled, 'not called after 1000ms');
@@ -44,5 +44,5 @@ describe('debounce', function () {
     obj.f('test');
     this.clock.tick(5000);
   });
-  
+
 });

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html

@@ -1,24 +1,24 @@
 <!doctype html>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 
-Function <code>handler</code> is called on this input:
+Function <code>handler</code> viene chiamata su questo input:
 <br>
 <input id="input1" placeholder="type here">
 
 <p>
 
-Debounced function <code>debounce(handler, 1000)</code> is called on this input:
-<br>
-<input id="input2" placeholder="type here">
+  Debounced function <code>debounce(handler, 1000)</code> viene chiamata su questo input:
+  <br>
+  <input id="input2" placeholder="type here">
 
 <p>
-<button id="result">The <code>handler</code> puts the result here</button>
+  <button id="result">L' <code>handler</code> mette il risultato qui</button>
 
-<script>
-  function handler(event) {
-    result.innerHTML = event.target.value;
-  }
+  <script>
+    function handler(event) {
+      result.innerHTML = event.target.value;
+    }
 
-  input1.oninput = handler;
-  input2.oninput = _.debounce(handler, 1000);
-</script>
+    input1.oninput = handler;
+    input2.oninput = _.debounce(handler, 1000);
+  </script>

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md

@@ -9,5 +9,5 @@ function debounce(func, ms) {
 
 ```
 
-A call to `debounce` returns a wrapper. When called, it schedules the original function call after given `ms` and cancels the previous such timeout.
+Una chiamata a `debounce` restituisce un wrapper. Quando viene chiamato, pianifica la chiamata della funzione originale dopo tot `ms` e annulla il precedente timeout.