From 3625d947626055f4338744281af3c9edcb23d2ea Mon Sep 17 00:00:00 2001 From: pasor1 Date: Sun, 21 Feb 2021 11:57:47 +0100 Subject: [PATCH 1/5] traduzione Function binding --- .../2-write-to-object-after-bind/solution.md | 6 +- .../2-write-to-object-after-bind/task.md | 4 +- .../10-bind/3-second-bind/solution.md | 6 +- .../10-bind/3-second-bind/task.md | 6 +- .../solution.md | 4 +- .../4-function-property-after-bind/task.md | 6 +- .../10-bind/5-question-use-bind/solution.md | 14 +- .../10-bind/5-question-use-bind/task.md | 8 +- .../10-bind/6-ask-partial/solution.md | 6 +- .../10-bind/6-ask-partial/task.md | 11 +- 1-js/06-advanced-functions/10-bind/article.md | 153 +++++++++--------- 11 files changed, 111 insertions(+), 113 deletions(-) diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md index 737a14481..5aec90ed2 100644 --- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md +++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md @@ -1,4 +1,4 @@ -The answer: `null`. +Risposta: `null`. ```js run @@ -13,6 +13,6 @@ let user = { user.g(); ``` -The context of a bound function is hard-fixed. There's just no way to further change it. +Il contesto di una funzione associata e fisso. Non esiste alcun modo di cambiarlo successivamente. -So even while we run `user.g()`, the original function is called with `this=null`. +Quindi, anche se eseguiamo `user.g()`, la funzione originale verrà chiamata con `this=null`. diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md index 6d7e1fb24..2b17ebc5d 100644 --- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md +++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Bound function as a method +# Funzione associata come metodo -What will be the output? +Quale sarà l'output? ```js function f() { diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md index 97e1c2809..f3c8853b2 100644 --- a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md +++ b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md @@ -1,4 +1,4 @@ -The answer: **John**. +Risposta: **John**. ```js run no-beautify function f() { @@ -10,6 +10,6 @@ f = f.bind( {name: "John"} ).bind( {name: "Pete"} ); f(); // John ``` -The exotic [bound function](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) object returned by `f.bind(...)` remembers the context (and arguments if provided) only at creation time. +L' *exotic object* [bound function](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) restituito da `f.bind(...)` memorizza il contesto (e gli argomenti, se forniti) solo in fase di creazione. -A function cannot be re-bound. +Una funzione non può essere riassegnata. diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md index 5daf053c6..312ed1fe7 100644 --- a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md +++ b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md @@ -2,11 +2,11 @@ importance: 5 --- -# Second bind +# Second0 bind -Can we change `this` by additional binding? +Possiamo cambiare `this` con una associazione addizionale? -What will be the output? +Quale sarà l'output? ```js no-beautify function f() { diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md index 181555d95..0ea5a002b 100644 --- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md +++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md @@ -1,4 +1,4 @@ -The answer: `undefined`. +Risposta: `undefined`. -The result of `bind` is another object. It does not have the `test` property. +Il risultato di `bind` è un altro oggetto, che non ha la proprietà `test`. diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md index d6cfb44bf..2ab094a03 100644 --- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md +++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Function property after bind +# Proprietà della funzione dopo il bind -There's a value in the property of a function. Will it change after `bind`? Why, or why not? +C'è un valore nella proprietà di una funzione. Cambierà dopo `bind`? Perché, o perché no? ```js run function sayHi() { @@ -17,7 +17,7 @@ let bound = sayHi.bind({ name: "John" }); -alert( bound.test ); // what will be the output? why? +alert( bound.test ); // quale sarà l'output? Perché? */!* ``` diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md index 403107ca6..416e77a9a 100644 --- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md +++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md @@ -1,9 +1,9 @@ -The error occurs because `ask` gets functions `loginOk/loginFail` without the object. +L'errore si verifica perché `askPassword` riceve le funzioni `loginOk/loginFail` senza l'oggetto. -When it calls them, they naturally assume `this=undefined`. +Quando le chiamiamo, naturalmente assumono `this=undefined`. -Let's `bind` the context: +Usiamo `bind` per associare il contesto: ```js run function askPassword(ok, fail) { @@ -30,14 +30,14 @@ askPassword(user.loginOk.bind(user), user.loginFail.bind(user)); */!* ``` -Now it works. +Ora funziona. -An alternative solution could be: +Una soluzione alternativa potrebbe essere: ```js //... askPassword(() => user.loginOk(), () => user.loginFail()); ``` -Usually that also works and looks good. +Di solito anche questo funziona e appare come una buona soluzione. -It's a bit less reliable though in more complex situations where `user` variable might change *after* `askPassword` is called, but *before* the visitor answers and calls `() => user.loginOk()`. +Tuttavia è un po' meno affidabile in situazioni più complesse, in cui la variabile `user` potrebbe cambiare *dopo* la chiamata di `askPassword`, ma *prima* che il visitatore risponda e venga chiamata `() => user.loginOk()`. diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md index fe6a9b4eb..fd41e46c5 100644 --- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md +++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md @@ -2,13 +2,13 @@ importance: 5 --- -# Fix a function that loses "this" +# Correggi una funzione che ha perso "this" -The call to `askPassword()` in the code below should check the password and then call `user.loginOk/loginFail` depending on the answer. +La chiamata di `askPassword()` nel codice sottostante dovrebbe controllare la password e quindi chiamare `user.loginOk/loginFail` a seconda della risposta. -But it leads to an error. Why? +Ma porta a un errore. Perché? -Fix the highlighted line for everything to start working right (other lines are not to be changed). +Correggi la riga evidenziata affinché tutto funzioni correttamente (le altre righe non devono essere modificate). ```js run function askPassword(ok, fail) { diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md index 3284c943b..d9e8f9e65 100644 --- a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md +++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md @@ -1,14 +1,14 @@ -1. Either use a wrapper function, an arrow to be concise: +1. Puoi sia utilizzare una funzione wrapper, una arrow per essere concisi: ```js askPassword(() => user.login(true), () => user.login(false)); ``` - Now it gets `user` from outer variables and runs it the normal way. + Ora riceve `user` dalla variabile esterna ed esegue la funzione in maniera corretta. -2. Or create a partial function from `user.login` that uses `user` as the context and has the correct first argument: +2. Oppure creare una funzione parziale da `user.login` che utilizzi `user` come contesto ed abbia il giusto primo argomento: ```js diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md index c90851c2b..ecd5ac605 100644 --- a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md +++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md @@ -2,13 +2,13 @@ importance: 5 --- -# Partial application for login +# Applicazione parziale per login -The task is a little more complex variant of . +Il compito è una variante leggermente più complessa di . -The `user` object was modified. Now instead of two functions `loginOk/loginFail`, it has a single function `user.login(true/false)`. +L'oggetto `user` è stato modificato. Ora al posto delle due funzioni `loginOk/loginFail`, ha una sola funzione `user.login(true/false)`. -What should we pass `askPassword` in the code below, so that it calls `user.login(true)` as `ok` and `user.login(false)` as `fail`? +Cosa dovremmo passare a `askPassword` nel codice qui sotto, in modo che chiami `user.login(true)` come `ok` e `user.login(false)` come `fail`? ```js function askPassword(ok, fail) { @@ -30,5 +30,4 @@ askPassword(?, ?); // ? */!* ``` -Your changes should only modify the highlighted fragment. - +Le tue modifiche dovrebbero solo interessare la porzione di codice evidenziata. diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md index 3cee4fe83..42b4dc33c 100644 --- a/1-js/06-advanced-functions/10-bind/article.md +++ b/1-js/06-advanced-functions/10-bind/article.md @@ -5,15 +5,15 @@ libs: # Function binding -When passing object methods as callbacks, for instance to `setTimeout`, there's a known problem: "losing `this`". +Quando passiamo i metodi di un oggetto tramite callback, ad esempio con `setTimeout`, c'è un problema ben conosciuto: "la perdita di `this`". -In this chapter we'll see the ways to fix it. +In questo capitolo vedremo i modi per risolverlo. -## Losing "this" +## "this" perso -We've already seen examples of losing `this`. Once a method is passed somewhere separately from the object -- `this` is lost. +Abbiamo già visto esempi di `this` perso. Quando un metodo viene passato separatamente dall'oggetto che lo contiene -- `this` viene perso. -Here's how it may happen with `setTimeout`: +Ecco quello che accade con `setTimeout`: ```js run let user = { @@ -28,22 +28,22 @@ setTimeout(user.sayHi, 1000); // Hello, undefined! */!* ``` -As we can see, the output shows not "John" as `this.firstName`, but `undefined`! +Come possiamo vedere, l'output non mostra "John" come `this.firstName`, ma `undefined`! -That's because `setTimeout` got the function `user.sayHi`, separately from the object. The last line can be rewritten as: +Questo perché `setTimeout` ha ricevuto `user.sayHi` separatamente dall'oggetto. L'ultima riga può essere riscritta così: ```js let f = user.sayHi; -setTimeout(f, 1000); // lost user context +setTimeout(f, 1000); // il contesto user è stato perso ``` -The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.js, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases, usually `this` just becomes `undefined`. +Nei browser, il metodo `setTimeout` è un po' speciale: per la chiamata della funzione imposta `this=window` (in Node.js, invece, `this` è l'oggetto timer, ma qui non ci interessa). Quindi per `this.firstName` prova a recuperare `window.firstName`, il quale non esiste. In altri casi simili, di solito `this` diventa semplicemente `undefined`. -The task is quite typical -- we want to pass an object method somewhere else (here -- to the scheduler) where it will be called. How to make sure that it will be called in the right context? +Il problema è abbastanza tipico: vogliamo passare un metodo di un oggetto da qualche parte (qui, allo scheduler), dove verrà chiamato. Come assicurarsi che venga chiamato nel giusto contesto? -## Solution 1: a wrapper +## Soluzione 1: un wrapper -The simplest solution is to use a wrapping function: +La soluzione più semplice consiste nell'usare una funzione wrapper: ```js run let user = { @@ -60,17 +60,17 @@ setTimeout(function() { */!* ``` -Now it works, because it receives `user` from the outer lexical environment, and then calls the method normally. +Ora funziona, perché riceve `user` dal *lexical environment* esterno, e quindi chiama il metodo normalmente. -The same, but shorter: +Lo stesso, ma più conciso: ```js setTimeout(() => user.sayHi(), 1000); // Hello, John! ``` -Looks fine, but a slight vulnerability appears in our code structure. +Sembra ok, ma nella struttura del nostro codice appare una piccola vulnerabilità. -What if before `setTimeout` triggers (there's one second delay!) `user` changes value? Then, suddenly, it will call the wrong object! +Cosa succederebbe se prima che `setTimeout` "scada" (c'è un secondo di ritardo!) `user` cambiasse valore? All'improvviso ci ritroveremmo con l'oggetto sbagliato! ```js run @@ -83,32 +83,32 @@ let user = { setTimeout(() => user.sayHi(), 1000); -// ...the value of user changes within 1 second +// ...il valore di user cambia entro 1 secondo user = { sayHi() { alert("Another user in setTimeout!"); } }; -// Another user in setTimeout! +// Un altro user in setTimeout! ``` -The next solution guarantees that such thing won't happen. +La prossima soluzione garantisce che questo genere di cose non accada. -## Solution 2: bind +## Soluzione 2: bind -Functions provide a built-in method [bind](mdn:js/Function/bind) that allows to fix `this`. +Function fornisce il metodo nativo [bind](mdn:js/Function/bind) che permette di "fissare" `this`. -The basic syntax is: +La sintassi di base è la seguente: ```js -// more complex syntax will come a little later +// più avanti vedremo una sintassi più complessa let boundFunc = func.bind(context); ``` -The result of `func.bind(context)` is a special function-like "exotic object", that is callable as function and transparently passes the call to `func` setting `this=context`. +Il risultato di `func.bind(context)` è un "exotic object", una particolare simil-funzione richiamabile come una normale funzione e che passa in maniera trasparente la chiamata a `func` impostando `this=context`. -In other words, calling `boundFunc` is like `func` with fixed `this`. +In altre parole, chiamare `boundFunc` è come chiamare `func` con `this` fisso. -For instance, here `funcUser` passes a call to `func` with `this=user`: +Ad esempio, qui `funcUser` passa la chiamata a `func` con `this=user`: ```js run let user = { @@ -125,9 +125,9 @@ funcUser(); // John */!* ``` -Here `func.bind(user)` as a "bound variant" of `func`, with fixed `this=user`. +Qui `func.bind(user)` è come una "variante" di `func`, con `this=user` fisso. -All arguments are passed to the original `func` "as is", for instance: +Tutti gli argomenti vengono passati così come sono a `func` originale, ad esempio: ```js run let user = { @@ -138,15 +138,15 @@ function func(phrase) { alert(phrase + ', ' + this.firstName); } -// bind this to user +// bind this a user let funcUser = func.bind(user); *!* -funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user) +funcUser("Hello"); // Hello, John (l'argomento "Hello" viene passato, e this=user) */!* ``` -Now let's try with an object method: +Ora proviamo con il metodo di un oggetto: ```js run @@ -161,21 +161,21 @@ let user = { let sayHi = user.sayHi.bind(user); // (*) */!* -// can run it without an object +// puo' funzionare senza un oggetto sayHi(); // Hello, John! setTimeout(sayHi, 1000); // Hello, John! -// even if the value of user changes within 1 second -// sayHi uses the pre-bound value which is reference to the old user object +// anche se il valore di user cambia entro 1 secondo +// sayHi utilizza il valore pre-associato che fa riferimento al vecchio oggetto user user = { - sayHi() { alert("Another user in setTimeout!"); } + sayHi() { alert("Un utente differente in setTimeout!"); } }; ``` -In the line `(*)` we take the method `user.sayHi` and bind it to `user`. The `sayHi` is a "bound" function, that can be called alone or passed to `setTimeout` -- doesn't matter, the context will be right. +Alla linea `(*)` prendiamo il metodo `user.sayHi` e lo leghiamo a `user`. `sayHi` è una funzione "associata", che può essere chiamata da sola, o passata a `setTimeout` -- non importa, il contesto sarà sempre esatto. -Here we can see that arguments are passed "as is", only `this` is fixed by `bind`: +Qui possiamo vedere che gli argomenti vengono passati "così come sono", solo `this` viene fissato da `bind`: ```js run let user = { @@ -187,12 +187,12 @@ let user = { let say = user.say.bind(user); -say("Hello"); // Hello, John ("Hello" argument is passed to say) -say("Bye"); // Bye, John ("Bye" is passed to say) +say("Hello"); // Hello, John (l'argomento "Hello" viene passato a say) +say("Bye"); // Bye, John ("Bye" viene passato a say) ``` -````smart header="Convenience method: `bindAll`" -If an object has many methods and we plan to actively pass it around, then we could bind them all in a loop: +````smart header="Un metodo comodo: `bindAll`" +Se un oggetto possiede molti metodi che abbiamo bisogno di passare, allora potremmo eseguire un ciclo per usare `bind` su tutti: ```js for (let key in user) { @@ -202,24 +202,24 @@ for (let key in user) { } ``` -JavaScript libraries also provide functions for convenient mass binding , e.g. [_.bindAll(object, methodNames)](http://lodash.com/docs#bindAll) in lodash. +Alcune librerie JavaScript forniscono utili funzioni per il *binding* di massa, ad esempio [_.bindAll(object, methodNames)](http://lodash.com/docs#bindAll) in lodash. ```` -## Partial functions +## Funzioni parziali -Until now we have only been talking about binding `this`. Let's take it a step further. +Finora abbiamo solo parlato di come legare `this`. Portiamo il concetto ad un livello successivo. -We can bind not only `this`, but also arguments. That's rarely done, but sometimes can be handy. +Possiamo legare non solo `this`, ma anche argomenti. Questo viene fatto raramente, ma a volte può rivelarsi utile. -The full syntax of `bind`: +La sintassi completa di `bind`: ```js let bound = func.bind(context, [arg1], [arg2], ...); ``` -It allows to bind context as `this` and starting arguments of the function. +Questo permette di legare alla funzione un contesto come `this`, e degli argomenti di partenza. -For instance, we have a multiplication function `mul(a, b)`: +Ad esempio, abbiamo la funzione di moltiplicazione `mul(a, b)`: ```js function mul(a, b) { @@ -227,7 +227,7 @@ function mul(a, b) { } ``` -Let's use `bind` to create a function `double` on its base: +Usiamo `bind` per creare una funzione `double` che si basi su di essa: ```js run function mul(a, b) { @@ -242,14 +242,13 @@ alert( double(3) ); // = mul(2, 3) = 6 alert( double(4) ); // = mul(2, 4) = 8 alert( double(5) ); // = mul(2, 5) = 10 ``` +La chiamata a `mul.bind(null, 2)` crea una nuova funzione `double` che passa la chiamata a `mul`, fissa `null` come contesto e `2` come primo argomento. I seguenti argomenti vengono passati "così come sono". -The call to `mul.bind(null, 2)` creates a new function `double` that passes calls to `mul`, fixing `null` as the context and `2` as the first argument. Further arguments are passed "as is". - -That's called [partial function application](https://en.wikipedia.org/wiki/Partial_application) -- we create a new function by fixing some parameters of the existing one. +Questa pratica è chiamata "applicazione parziale di funzione" [partial function application](https://en.wikipedia.org/wiki/Partial_application) -- creiamo una nuova funzione fissando alcuni parametri di quella esistente. -Please note that we actually don't use `this` here. But `bind` requires it, so we must put in something like `null`. +Nota che in realtà qui non usiamo `this`, ma `bind` lo richiede, quindi dobbiamo mettere al suo posto qualcosa tipo `null`. -The function `triple` in the code below triples the value: +La funzione `triple` nel codice che segue, triplica il valore: ```js run function mul(a, b) { @@ -265,23 +264,23 @@ alert( triple(4) ); // = mul(3, 4) = 12 alert( triple(5) ); // = mul(3, 5) = 15 ``` -Why do we usually make a partial function? +Perché dovremmo aver bisogno di una funzione parziale? -The benefit is that we can create an independent function with a readable name (`double`, `triple`). We can use it and not provide the first argument every time as it's fixed with `bind`. +Il vantaggio è che possiamo creare una funzione indipendente con un nome leggibile (`double`,` triple`). Possiamo usarla senza fornire tutte le volte il primo argomento, poiché è stato associato con `bind`. -In other cases, partial application is useful when we have a very generic function and want a less universal variant of it for convenience. +In altri casi, l'applicazione parziale è utile quando abbiamo una funzione molto generica e per comodità ne vogliamo una variante meno universale. -For instance, we have a function `send(from, to, text)`. Then, inside a `user` object we may want to use a partial variant of it: `sendTo(to, text)` that sends from the current user. +Ad esempio, abbiamo una funzione `send(from, to, text)`. Ma nell'oggetto `user` potremmo volerne usare una parziale variante: `sendTo(to, text)` che invia dallo user corrente. -## Going partial without context +## Utilizzo parziale senza contesto -What if we'd like to fix some arguments, but not the context `this`? For example, for an object method. +E se volessimo fissare alcuni argomenti, ma non il contesto `this`? Ad esempio, per un metodo in un oggetto. -The native `bind` does not allow that. We can't just omit the context and jump to arguments. +Il `bind` nativo non lo permette. Non possiamo semplicemente omettere il contesto e saltare agli argomenti. -Fortunately, a function `partial` for binding only arguments can be easily implemented. +Fortunatamente una funzione `partial` per legare solo gli argomenti, può essere implementata con facilità. -Like this: +Così: ```js run *!* @@ -292,7 +291,7 @@ function partial(func, ...argsBound) { } */!* -// Usage: +// Uso: let user = { firstName: "John", say(time, phrase) { @@ -300,29 +299,29 @@ let user = { } }; -// add a partial method with fixed time +// aggiunge un metodo parziale con un orario fisso user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes()); user.sayNow("Hello"); -// Something like: +// Qualcosa tipo: // [10:00] John: Hello! ``` -The result of `partial(func[, arg1, arg2...])` call is a wrapper `(*)` that calls `func` with: -- Same `this` as it gets (for `user.sayNow` call it's `user`) -- Then gives it `...argsBound` -- arguments from the `partial` call (`"10:00"`) -- Then gives it `...args` -- arguments given to the wrapper (`"Hello"`) +Il risultato della chiamata di `partial(func[, arg1, arg2...])` è un wrapper `(*)` che chiama `func` con: +- Lo stesso `this` (per la chiamata di `user.sayNow` è `user`) +- quindi passa `...argsBound` -- argomenti dalla chiamata di `partial` (`"10:00"`) +- quindi passa `...args` -- argomenti passati al wrapper (`"Hello"`) -So easy to do it with the spread syntax, right? +E' molto facile da fare con la sintassi *spread* vero? -Also there's a ready [_.partial](https://lodash.com/docs#partial) implementation from lodash library. +Esiste anche un'implementazione già pronta, [_.partial](https://lodash.com/docs#partial) dalla libreria lodash. -## Summary +## Riepilogo -Method `func.bind(context, ...args)` returns a "bound variant" of function `func` that fixes the context `this` and first arguments if given. +Il metodo `func.bind(context, ...args)` ritorna una "variante associata" della funzione `func` con il contesto `this` fisso, ed i primi argomenti, se impostati. -Usually we apply `bind` to fix `this` for an object method, so that we can pass it somewhere. For example, to `setTimeout`. +Di solito usiamo `bind` per fissare `this` in un metodo di un oggetto, in modo da poterlo passare senza problemi. Ad esempio a `setTimeout`. -When we fix some arguments of an existing function, the resulting (less universal) function is called *partially applied* or *partial*. +Quando leghiamo alcuni argomenti ad una funzione esistente, la funzione risultante (meno universale) è chiamata *parzialmente applicata* o *parziale*. -Partials are convenient when we don't want to repeat the same argument over and over again. Like if we have a `send(from, to)` function, and `from` should always be the same for our task, we can get a partial and go on with it. +Le parziali sono utili quando non vogliamo ripetere lo stesso argomento più e più volte. Ad esempio, se abbiamo una funzione `send (from, to)`, e `from` dovrebbe essere sempre lo stesso. From e3ac2829b2b5562317a233a5f815ec4f1b29839b Mon Sep 17 00:00:00 2001 From: Simone Pasini <66781510+pasor1@users.noreply.github.com> Date: Fri, 26 Feb 2021 13:50:56 +0100 Subject: [PATCH 2/5] Update 1-js/06-advanced-functions/10-bind/3-second-bind/task.md Co-authored-by: Andrea <45577511+longo-andrea@users.noreply.github.com> --- 1-js/06-advanced-functions/10-bind/3-second-bind/task.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md index 312ed1fe7..edabe17b4 100644 --- a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md +++ b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md @@ -2,7 +2,7 @@ importance: 5 --- -# Second0 bind +# Secondo bind Possiamo cambiare `this` con una associazione addizionale? @@ -17,4 +17,3 @@ f = f.bind( {name: "John"} ).bind( {name: "Ann" } ); f(); ``` - From 170fb145506c04d86285008cef1fdc6f98081747 Mon Sep 17 00:00:00 2001 From: Simone Pasini <66781510+pasor1@users.noreply.github.com> Date: Fri, 26 Feb 2021 13:52:19 +0100 Subject: [PATCH 3/5] Update 1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md Co-authored-by: Dorin-David <70648503+Dorin-David@users.noreply.github.com> --- .../10-bind/2-write-to-object-after-bind/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md index 5aec90ed2..727eb8a08 100644 --- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md +++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md @@ -13,6 +13,6 @@ let user = { user.g(); ``` -Il contesto di una funzione associata e fisso. Non esiste alcun modo di cambiarlo successivamente. +Il contesto di una funzione associata è fisso. Non esiste alcun modo di cambiarlo successivamente. Quindi, anche se eseguiamo `user.g()`, la funzione originale verrà chiamata con `this=null`. From 345dffc2167fa31c9d0ced247a5c5d32f6a827bd Mon Sep 17 00:00:00 2001 From: Simone Pasini <66781510+pasor1@users.noreply.github.com> Date: Fri, 26 Feb 2021 13:52:36 +0100 Subject: [PATCH 4/5] Update 1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md Co-authored-by: Dorin-David <70648503+Dorin-David@users.noreply.github.com> --- 1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md index d9e8f9e65..be69a82d4 100644 --- a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md +++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md @@ -1,6 +1,6 @@ -1. Puoi sia utilizzare una funzione wrapper, una arrow per essere concisi: +1. Puoi sia utilizzare una funzione wrapper, che una arrow per essere concisi: ```js askPassword(() => user.login(true), () => user.login(false)); From 7aed099bfb24917c1459ba3c918201be55a2e166 Mon Sep 17 00:00:00 2001 From: Simone Pasini <66781510+pasor1@users.noreply.github.com> Date: Fri, 26 Feb 2021 13:54:04 +0100 Subject: [PATCH 5/5] Update 1-js/06-advanced-functions/10-bind/article.md Co-authored-by: Dorin-David <70648503+Dorin-David@users.noreply.github.com> --- 1-js/06-advanced-functions/10-bind/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md index 42b4dc33c..58e121006 100644 --- a/1-js/06-advanced-functions/10-bind/article.md +++ b/1-js/06-advanced-functions/10-bind/article.md @@ -104,7 +104,7 @@ La sintassi di base è la seguente: let boundFunc = func.bind(context); ``` -Il risultato di `func.bind(context)` è un "exotic object", una particolare simil-funzione richiamabile come una normale funzione e che passa in maniera trasparente la chiamata a `func` impostando `this=context`. +Il risultato di `func.bind(context)` è un "exotic object", una particolare funzione richiamabile come una normale funzione e che passa in maniera trasparente la chiamata a `func` impostando `this=context`. In altre parole, chiamare `boundFunc` è come chiamare `func` con `this` fisso. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy