Mar 25, 2024 · Jul 20, 2021 · Jul 24, 2021 · Jul 24, 2021 · Jul 24, 2021 · Jul 24, 2021
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js
 function spy(func) {

  function wrapper(...args) {
    // using ...args instead of arguments to store "real" array in wrapper.calls
    // usar `...args` ao invés de `arguments`
    // para armazenar o vetor "real" no `wrapper.calls`
    wrapper.calls.push(args);
    return func.apply(this, args);
  }
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
 function spy(func) {
  //your code
  //o teu código
 }


diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js
  });

  it("transparently wraps functions", function() {


    let sum = sinon.spy((a, b) => a + b);

    let wrappedSum = spy(sum);

    assert.equal(wrappedSum(1, 2), 3);
    assert(sum.calledWith(1, 2));
    assert(sum.calledWidth(1, 2));
  });


  it("transparently wraps methods", function() {


    let calc = {
      sum: sinon.spy((a, b) => a + b)
    };
    assert(calc.sum.calledWith(1, 2));
    assert(calc.sum.calledOn(calc));
  });

 });
 });
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
 The wrapper returned by `spy(f)`should store all arguments and then use`f.apply`to forward the call.
 O embrulhador retornado pela `spy(f)`deve armazenar todos os argumentos e então usar`f.apply`para encaminhar a chamada.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md

 ---

 #Spy decorator
 #Decorador de Espionagem

 Create a decorator `spy(func)`that should return a wrapper that saves all calls to function in its`calls` property.
 Cria um decorador `spy(func)`que retorna um embrulhador que guarda todas as chamadas à função na sua propriedade`calls`.

 Every call is saved as an array of arguments.
 Toda chamada é guardada num vetor de argumentos.

 For instance:
 Por exemplo:

 ```js
 function work(a, b) {
  alert( a + b ); // work is an arbitrary function or method
  alert( a + b ); //`work` é uma função ou método arbitrário
 }

 *!*
 }
 ```

 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-escrito: Este decorador pode ser útil para testes unitários. Sua forma avançada é `sinon.spy`na biblioteca[Sinon.JS](http://sinonjs.org).
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/_js.view/test.js b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/_js.view/test.js
    this.clock.restore();
  });

  it("calls the function after the specified timeout", function() {
  it("chama a função após o tempo de espera especificado", function() {
    let start = Date.now();

    function f(x) {
    f = sinon.spy(f);

    let f1000 = delay(f, 1000);
    f1000("test");
    f1000("teste");
    this.clock.tick(2000);
    assert(f.calledOnce, 'calledOnce check fails');
    assert(f.calledOnce, 'a verificação de calledOnce falha');
  });

  it("passes arguments and this", function() {
  it("passa os argumentos e o contexto de this", function() {
    let start = Date.now();
    let user = {
      sayHi: function(phrase, who) {
    let spy = user.sayHi;
    user.sayHi = delay(user.sayHi, 1500);

    user.sayHi("Hello", "John");
    user.sayHi("Olá", "John");

    this.clock.tick(2000);

    assert(spy.calledOnce, 'calledOnce check failed');
    assert(spy.calledOnce, 'a verificação de calledOnce falhou');
  });
 });
 });
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
 The solution:
 A solução:

 ```js run demo
 function delay(f, ms) {

 let f1000 = delay(alert, 1000);

 f1000("test"); //shows "test" after 1000ms
 f1000("teste"); //exibe "teste" após 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.
 Notemos como usamos uma função de seta neste exemplo de código. Como sabemos, as funções de seta não possuem `this`e `arguments` próprios, então `f.apply(this, arguments)`recebe o`this`e `arguments`da função envolvente.

 If we pass a regular function, `setTimeout`would call it without arguments and`this=window` (assuming we're in the browser).
 Se passarmos uma função normal, `setTimeout`a chamaria sem argumentos e`this=window` (assumindo que estamos no navegador).

 We still can pass the right`this`by using an intermediate variable, but that's a little bit more cumbersome:
 Nós podemos ainda passar o`this`correto utilizando uma variável intermediária, mas isso é um pouco mais complicado:

 ```js
 function delay(f, ms) {

  return function(...args) {
    let savedThis = this; //store this into an intermediate variable
    let savedThis = this; //armazenar isto numa variável intermédia
    setTimeout(function() {
      f.apply(savedThis, args); //use it here
      f.apply(savedThis, args); //utilizá-lo aqui
    }, ms);
  };

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

 ---

 #Delaying decorator
 #Decorador de Atraso

 Create a decorator `delay(f, ms)`that delays each call of `f`by `ms`milliseconds.
 Crie um decorador `delay(f, ms)`que atrasa cada chamada de `f`por `ms`milissegundos.

 For instance:
 Por exemplo:

 ```js
 function f(x) {
  alert(x);
 }

 //create wrappers
 //criar funções envolventes
 let f1000 = delay(f, 1000);
 let f1500 = delay(f, 1500);

 f1000("test"); //shows "test" after 1000ms
 f1500("test"); //shows "test" after 1500ms
 f1000("teste"); //exibe "teste" após 1000ms
 f1500("teste"); //exibe "teste" após 1500ms
 ```

 In other words, `delay(f, ms)`returns a "delayed by `ms`"variant of `f`.
 Por outras palavras, `delay(f, ms)`retorna uma variante "atrasada por `ms`"de `f`.

 In the code above, `f`is a function of a single argument, but your solution should pass all arguments and the context `this`.
 No código acima, `f`é uma função de um único argumento, mas a sua solução deve passar todos os argumentos e o contexto de `this`.
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
    this.clock.restore();
  });

  it('for one call -runs it after given ms', function () {
  it('para uma chamada -execute-a após um determinado ms', function () {
    const f = sinon.spy();
    const debounced = debounce(f, 1000);

    debounced('test');
    assert(f.notCalled, 'not called immediately');
    assert(f.notCalled, 'não é chamada imediatamente');
    this.clock.tick(1000);
    assert(f.calledOnceWith('test'), 'called after 1000ms');
    assert(f.calledOnceWith('test'), 'chamada após 1000ms');
  });

  it('for 3calls -runs the last one after given ms', function () {
  it('para 3chamadas -executa a última após determinados ms', function () {
    const f = sinon.spy();
    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); //ignorada (demasiado cedo)
    setTimeout(() => debounced('c'), 500); //executar (1000ms passados)
    this.clock.tick(1000);

    assert(f.notCalled, 'not called after 1000ms');
    assert(f.notCalled, 'não é chamada após 1000ms');

    this.clock.tick(500);

    assert(f.calledOnceWith('c'), 'called after 1500ms');
    assert(f.calledOnceWith('c'), 'chamada após 1500ms');
  });

  it('keeps the context of the call', function () {
  it('mantém o contexto da chamada', function () {
    let obj = {
      f() {
        assert.equal(this, obj);
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.svg b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.svg
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html
 <!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:
 A função<code>handler</code>é chamada nesta entrada:
 <br>
 <input id="input1" placeholder="type here">

 <p>

 Debounced function <code>debounce(handler, 1000)</code>is called on this input:
 A função <code>debounce(handler, 1000)</code>reduzida é chamada nesta entrada:
 <br>
 <input id="input2" placeholder="type here">

 <p>
 <button id="result">The <code>handler</code>puts the result here</button>
 <button id="result">A <code>handler</code>coloca o resultado aqui</button>

 <script>
  function handler(event) {

  input1.oninput = handler;
  input2.oninput = _.debounce(handler, 1000);
 </script>
 </script>
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md

 ```

 A call to `debounce` returns a wrapper. When called, it schedules the original function call after given `ms` and cancels the previous such timeout.

 Uma chamada à `debounce` retorna um embrulhador. Quando chamado, este agenda a chamada da função original depois de dados `ms` e cancela o tempo de espera anterior.
Original file line number	Diff line number	Diff line change
		@@ -1,7 +1,8 @@
		function spy(func) {

		function wrapper(...args) {
		// using ...args instead of arguments to store "real" array in wrapper.calls
		// usar `...args` ao invés de `arguments`
		// para armazenar o vetor "real" no `wrapper.calls`
		wrapper.calls.push(args);
		return func.apply(this, args);
		}
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,5 +1,4 @@
		function spy(func) {
		//your code
		//o teu código
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -18,18 +18,17 @@ describe("spy", function() {
		});

		it("transparently wraps functions", function() {


		let sum = sinon.spy((a, b) => a + b);

		let wrappedSum = spy(sum);

		assert.equal(wrappedSum(1, 2), 3);
		assert(sum.calledWith(1, 2));
		assert(sum.calledWidth(1, 2));
		});


		it("transparently wraps methods", function() {


		let calc = {
		sum: sinon.spy((a, b) => a + b)
		};
Expand All		@@ -40,5 +39,4 @@ describe("spy", function() {
		assert(calc.sum.calledWith(1, 2));
		assert(calc.sum.calledOn(calc));
		});

		});
		});
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		The wrapper returned by `spy(f)`should store all arguments and then use`f.apply`to forward the call.
		O embrulhador retornado pela `spy(f)`deve armazenar todos os argumentos e então usar`f.apply`para encaminhar a chamada.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,17 +2,17 @@ importance: 5

		---

		#Spy decorator
		#Decorador de Espionagem

		Create a decorator `spy(func)`that should return a wrapper that saves all calls to function in its`calls` property.
		Cria um decorador `spy(func)`que retorna um embrulhador que guarda todas as chamadas à função na sua propriedade`calls`.

		Every call is saved as an array of arguments.
		Toda chamada é guardada num vetor de argumentos.

		For instance:
		Por exemplo:

		```js
		function work(a, b) {
		alert( a + b ); // work is an arbitrary function or method
		alert( a + b ); //`work` é uma função ou método arbitrário
		}

		!
Expand All		@@ -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-escrito: Este decorador pode ser útil para testes unitários. Sua forma avançada é `sinon.spy`na biblioteca[Sinon.JS](http://sinonjs.org).
Original file line number	Diff line number	Diff line change
Expand Up		@@ -7,7 +7,7 @@ describe("delay", function() {
		this.clock.restore();
		});

		it("calls the function after the specified timeout", function() {
		it("chama a função após o tempo de espera especificado", function() {
		let start = Date.now();

		function f(x) {
Expand All		@@ -16,12 +16,12 @@ describe("delay", function() {
		f = sinon.spy(f);

		let f1000 = delay(f, 1000);
		f1000("test");
		f1000("teste");
		this.clock.tick(2000);
		assert(f.calledOnce, 'calledOnce check fails');
		assert(f.calledOnce, 'a verificação de calledOnce falha');
		});

		it("passes arguments and this", function() {
		it("passa os argumentos e o contexto de this", function() {
		let start = Date.now();
		let user = {
		sayHi: function(phrase, who) {
Expand All		@@ -37,10 +37,10 @@ describe("delay", function() {
		let spy = user.sayHi;
		user.sayHi = delay(user.sayHi, 1500);

		user.sayHi("Hello", "John");
		user.sayHi("Olá", "John");

		this.clock.tick(2000);

		assert(spy.calledOnce, 'calledOnce check failed');
		assert(spy.calledOnce, 'a verificação de calledOnce falhou');
		});
		});
		});
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		The solution:
		A solução:

		```js run demo
		function delay(f, ms) {
Expand All		@@ -11,22 +11,22 @@ function delay(f, ms) {

		let f1000 = delay(alert, 1000);

		f1000("test"); //shows "test" after 1000ms
		f1000("teste"); //exibe "teste" após 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.
		Notemos como usamos uma função de seta neste exemplo de código. Como sabemos, as funções de seta não possuem `this`e `arguments` próprios, então `f.apply(this, arguments)`recebe o`this`e `arguments`da função envolvente.

		If we pass a regular function, `setTimeout`would call it without arguments and`this=window` (assuming we're in the browser).
		Se passarmos uma função normal, `setTimeout`a chamaria sem argumentos e`this=window` (assumindo que estamos no navegador).

		We still can pass the right`this`by using an intermediate variable, but that's a little bit more cumbersome:
		Nós podemos ainda passar o`this`correto utilizando uma variável intermediária, mas isso é um pouco mais complicado:

		```js
		function delay(f, ms) {

		return function(...args) {
		let savedThis = this; //store this into an intermediate variable
		let savedThis = this; //armazenar isto numa variável intermédia
		setTimeout(function() {
		f.apply(savedThis, args); //use it here
		f.apply(savedThis, args); //utilizá-lo aqui
		}, ms);
		};

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,25 +2,25 @@ importance: 5

		---

		#Delaying decorator
		#Decorador de Atraso

		Create a decorator `delay(f, ms)`that delays each call of `f`by `ms`milliseconds.
		Crie um decorador `delay(f, ms)`que atrasa cada chamada de `f`por `ms`milissegundos.

		For instance:
		Por exemplo:

		```js
		function f(x) {
		alert(x);
		}

		//create wrappers
		//criar funções envolventes
		let f1000 = delay(f, 1000);
		let f1500 = delay(f, 1500);

		f1000("test"); //shows "test" after 1000ms
		f1500("test"); //shows "test" after 1500ms
		f1000("teste"); //exibe "teste" após 1000ms
		f1500("teste"); //exibe "teste" após 1500ms
		```

		In other words, `delay(f, ms)`returns a "delayed by `ms`"variant of `f`.
		Por outras palavras, `delay(f, ms)`retorna uma variante "atrasada por `ms`"de `f`.

		In the code above, `f`is a function of a single argument, but your solution should pass all arguments and the context `this`.
		No código acima, `f`é uma função de um único argumento, mas a sua solução deve passar todos os argumentos e o contexto de `this`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -7,33 +7,33 @@ describe('debounce', function () {
		this.clock.restore();
		});

		it('for one call -runs it after given ms', function () {
		it('para uma chamada -execute-a após um determinado ms', function () {
		const f = sinon.spy();
		const debounced = debounce(f, 1000);

		debounced('test');
		assert(f.notCalled, 'not called immediately');
		assert(f.notCalled, 'não é chamada imediatamente');
		this.clock.tick(1000);
		assert(f.calledOnceWith('test'), 'called after 1000ms');
		assert(f.calledOnceWith('test'), 'chamada após 1000ms');
		});

		it('for 3calls -runs the last one after given ms', function () {
		it('para 3chamadas -executa a última após determinados ms', function () {
		const f = sinon.spy();
		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); //ignorada (demasiado cedo)
		setTimeout(() => debounced('c'), 500); //executar (1000ms passados)
		this.clock.tick(1000);

		assert(f.notCalled, 'not called after 1000ms');
		assert(f.notCalled, 'não é chamada após 1000ms');

		this.clock.tick(500);

		assert(f.calledOnceWith('c'), 'called after 1500ms');
		assert(f.calledOnceWith('c'), 'chamada após 1500ms');
		});

		it('keeps the context of the call', function () {
		it('mantém o contexto da chamada', function () {
		let obj = {
		f() {
		assert.equal(this, obj);
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,18 +1,18 @@
		<!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:
		A função<code>handler</code>é chamada nesta entrada:
		<br>
		<input id="input1" placeholder="type here">

		<p>

		Debounced function <code>debounce(handler, 1000)</code>is called on this input:
		A função <code>debounce(handler, 1000)</code>reduzida é chamada nesta entrada:
		<br>
		<input id="input2" placeholder="type here">

		<p>
		<button id="result">The <code>handler</code>puts the result here</button>
		<button id="result">A <code>handler</code>coloca o resultado aqui</button>

		<script>
		function handler(event) {
Expand All		@@ -21,4 +21,4 @@

		input1.oninput = handler;
		input2.oninput = _.debounce(handler, 1000);
		</script>
		</script>