Lösen Sie JavaScript Promise außerhalb des Funktionsumfangs auf

Ich habe mit ES6 Versprechen.

Normalerweise ein Versprechen ist gebaut und genutzt, wie dies

new Promise(function(resolve, reject){
    if (someCondition){
        resolve();
    } else {
        reject();
    } 
});

Aber ich habe dabei so etwas wie unten nehmen beheben außerhalb aus Gründen der Flexibilität.

var outsideResolve;
var outsideReject;
new Promise(function(resolve, reject) { 
    outsideResolve = resolve; 
    outsideReject = reject; 
});

Und später

onClick = function(){
    outsideResolve();
}

Dies funktioniert gut, aber es ist ein einfacher Weg, dies zu tun? Wenn nicht, ist das eine gute Praxis?

InformationsquelleAutor der Frage Morio | 2014-10-01

52

Nein, es gibt keinen anderen Weg, dies zu tun - das einzige was ich sagen kann ist, dass dieser Anwendungsfall ist nicht sehr Häufig. Wie Felix sagte in der Kommentar - was Sie tun wird konsequent arbeiten.

Es ist erwähnenswert, dass der Grund, das Versprechen Konstruktor verhält sich dieser Weg werfen Sicherheit - wenn eine Ausnahme nicht geplant passiert, während Ihr code ausgeführt wird, innerhalb der promise-Konstruktor wird daraus eine Ablehnung, die diese form der Sicherheit werfen - converting-Fehler geworfen zu Ablehnungen ist wichtig und hilft bei der Erhaltung vorhersagbaren code.

Für das werfen der Sicherheit Grund, das Versprechen Konstruktor gewählt wurde, über deferreds (die eine alternative Versprechen Konstruktion so, dass tun lassen, was Sie tun) - wie für "best practices" - ich würde übergeben Sie das element und verwenden Sie die Versprechen Konstruktor statt:
```
var p = new Promise(function(resolve, reject){
    this.onclick = resolve;
}.bind(this));
```
Deshalb - Wann immer Sie kann Verwendung des promise-Konstruktor über den Export die Funktionen - ich empfehle Ihnen, verwenden Sie es zu tun. Wann immer Sie können, vermeiden, - vermeiden und Kette.

Beachten Sie, dass Sie sollten verwenden Sie niemals das Versprechen Konstruktor für Dinge wie if(condition)das erste Beispiel könnte auch geschrieben werden als:
```
var p = Promise[(someCondition)?"resolve":"reject"]();
```
InformationsquelleAutor der Antwort Benjamin Gruenbaum

einfach:

var promiseResolve, promiseReject;

var promise = new Promise(function(resolve, reject){
  promiseResolve = resolve;
  promiseReject = reject;
});

promiseResolve();

InformationsquelleAutor der Antwort carter

Wenig spät zur party hier, aber einen anderen Weg, es zu tun wäre, um eine Latente Objekt. Sie müssen im wesentlichen die gleiche Menge an boilerplate, aber es ist praktisch, wenn Sie möchten, übergeben Sie herum und möglicherweise zu lösen, die außerhalb Ihrer definition.

Naive Implementierung:

class Deferred {
  constructor() {
    this.promise = new Promise((resolve, reject)=> {
      this.reject = reject
      this.resolve = resolve
    })
  }
}

function asyncAction() {
  var dfd = new Deferred()

  setTimeout(()=> {
    dfd.resolve(42)
  }, 500)

  return dfd.promise
}

asyncAction().then(result => {
  console.log(result) //42
})

ES5 Version:

function Deferred() {
  var self = this;
  this.promise = new Promise(function(resolve, reject) {
    self.reject = reject
    self.resolve = resolve
  })
}

function asyncAction() {
  var dfd = new Deferred()

  setTimeout(function() {
    dfd.resolve(42)
  }, 500)

  return dfd.promise
}

asyncAction().then(function(result) {
  console.log(result) //42
})

InformationsquelleAutor der Antwort Jon Jaques

Einer Lösung kam ich mit im Jahr 2015 für meine Rahmen. Ich rief diese Art von Versprechungen Aufgabe

function createPromise(handler){
  var _resolve, _reject;

  var promise = new Promise(function(resolve, reject){
    _resolve = resolve; 
    _reject = reject;

    handler(resolve, reject);
  })

  promise.resolve = _resolve;
  promise.reject = _reject;

  return promise;
}

var promise = createPromise()
promise.then(function(data){ alert(data) })

promise.resolve(200) //resolve from outside

InformationsquelleAutor der Antwort Maxmaxmaximus

Ein-Helfer-Methode lindern würde dies zusätzlichen Aufwand, und geben Sie die gleiche jQuery fühlen.

function Deferred() {
    let resolve;
    let reject;
    const promise = new Promise((res, rej) => {
        resolve = res;
        reject = rej;
    });
    return { promise, resolve, reject };
}

Verwendung wäre

const { promise, resolve, reject } = Deferred();
displayConfirmationDialog({
    confirm: resolve,
    cancel: reject
});
return promise;

Ähnlich zu jQuery

const dfd = $.Deferred();
displayConfirmationDialog({
    confirm: dfd.resolve,
    cancel: dfd.reject
});
return dfd.promise();

Obwohl, in einem Fall verwenden Sie diese einfache, native syntax ist in Ordnung

return new Promise((resolve, reject) => {
    displayConfirmationDialog({
        confirm: resolve,
        cancel: reject
    });
});

InformationsquelleAutor der Antwort Cory Danielson

Unsere Lösung zu nutzen, um die Verschlüsse zu speichern beheben/reject Funktionen und zusätzlich befestigen, eine Funktion zu erweitern, das Versprechen selbst.

Hier ist das Muster:

function getPromise() {

    var _resolve, _reject;

    var promise = new Promise((resolve, reject) => {
        _reject = reject;
        _resolve = resolve;
    });

    promise.resolve_ex = (value) => {
       _resolve(value);
    };

    promise.reject_ex = (value) => {
       _reject(value);
    };

    return promise;
}

Und die, die es verwenden:

var promise = getPromise();

promise.then(value => {
    console.info('The promise has been fulfilled: ' + value);
});

promise.resolve_ex('hello');  
//or the reject version 
//promise.reject_ex('goodbye');

InformationsquelleAutor der Antwort Steven Spungin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.