Jak działa plik function.apply.bind w poniższym kodzie?

Question

Więc dostaję, że tablica [200.599] jest zwracana z obietnicy, a funkcja wywołania zwrotnego wewnątrz rozprzestrzeniania jest przekazywana do Function.apply.bind, ale teraz jestem zagubiony. W jaki sposób tablica [200,599] podzielona na x i y? Jak dokładnie działa aplikacja apply.bind?

function getY(x) { 
     return new Promise(function(resolve,reject){ 
      setTimeout(function(){ 
       resolve((3 * x) - 1); 
      }, 100); 
     }); 
    } 

function foo(bar,baz) { 
    var x = bar * baz; 

    // return both promises 
    return [ 
     Promise.resolve(x), 
     getY(x) 
    ]; 
} 

function spread(fn) { 
    return Function.apply.bind(fn, null); 
} 

Promise.all(
    foo(10, 20) 
) 
.then(
    spread(function(x,y){ 
     console.log(x, y); // 200 599 
    }) 
) 

Answer 1

Funkcja rozproszonym prostu funkcja Narzędzie do konwertowania tablicę, na parametry przekazywane do funkcji. Stosuje się konwersję, a powiązanie wiąże ją z funkcją wywołującą, dzięki czemu kontekst "ten" jest połączony z tą samą funkcją.

Aby zobaczyć, jak spread pracuje w prostszej postaci ->

spread(function (x,y){console.log(x,y);})([1,2]) 

Dostaniesz odpowiedź, 1: 2, a 1 jest przekazywana do x i 2 są przekazywane do y.

Tak więc w twoim przykładzie obietnica .all zwraca wiele rozstrzygniętych obietnic. Są one następnie mapowane do parametrów do funkcji (x, y).

Answer 2

Spread przyjmuje funkcję i binds z apply method na, częściowo stosując argument null. Tak w skrócie,

spread(fn) 

przekształca się

args => fn.apply(null, args) 

która jest taka sama jak przy użyciu ES6 rozprzestrzeniać składni

gdzie funkcja ma swoją nazwę.

---

Jeśli chcesz długiej odpowiedzi, pamiętaj co bind robi:

method.bind(context, ...args1) 

zwraca funkcję, która działa jak

(...args2) => method.call(context, ...args1, ...args2) 

w naszym przypadku method jest apply The context jest fn a pierwsze argumenty to null, więc wywołanie

Function.apply.bind(fn, null) 

tworzy funkcję, która działa jak

(...args2) => (Function.apply).call(fn, null, ...args2) 

, która jest równoważna do połączenia fn.apply(…) powyżej, ponieważ apply jest sposób odziedziczone Function.prototype obu wejściach.

Answer 3

.apply() to metoda na obiektach funkcyjnych.Tak:

console.log(Math.max.apply(null, [1, 2, 3])); // 3

.apply() przyjmuje dwa argumenty, kontekst (co stanie się this wewnątrz funkcji docelowej) oraz iterable argumentów (zwykle tablicę, ale tablicę jak również arguments Prace).

---

.bind() to metoda na obiektach funkcyjnych. Tak:

const x = { 
 
    foo: function() { 
 
    console.log(this.x); 
 
    }, 
 
    x: 42 
 
} 
 

 
var myFoo = x.foo.bind({x: 5}); 
 

 
x.foo(); // 42 
 
myFoo(); // 5

.bind() zajmuje kontekstu (co by stać this) i ewentualnie dodatkowe argumenty i zwraca nową funkcję z kontekstu związany i dodatkowe argumenty zablokowane

---

od .apply() jest funkcją w sobie, może to być związane z .bind(), tak:

Function.prototype.apply.bind(fn, null); 

ten sposób, że this z .apply() byłoby fn a pierwszy argument .apply() byłoby null. Oznacza to, że będzie wyglądać następująco:

fn.apply(null, args) 

Który rozłożyłby parametry z tablicy.