So übergeben Sie Parameter an eine Promise-Funktion

Lesezeit: 7 Minuten

Kundante

das mag eine dumme Frage erscheinen, aber ich bin ein Neuling in diesem Thema. Ich arbeite an Versprechungen auf Knoten js. Und ich möchte Parameter an eine Promise-Funktion übergeben. Allerdings konnte ich es nicht herausfinden.

someModule.someFunction.then(username, password,function(uid) {
  /*stuff */
}

und die Funktion ist so etwas wie

var someFunction = new Promise(username, password, function(resolve, reject) {
  /*stuff using username, password*/
  if ( /* everything turned out fine */ ) {
    resolve("Stuff worked!");
  } else {
    reject(Error("It broke"));
  }
});

Dafür gibt es keinen Grund, man kann es einfach definieren username und password in höherem Umfang

– adeneo

10. Februar 2016 um 14:56 Uhr
Aber ich rufe das Versprechen von einem anderen Modul auf, und auch Benutzername und Passwort sind nicht statisch, sondern kommen von der Client-Seite. Ist es sicher, eine Art globale Variable zu definieren, die eine Funktion setzt und die andere verwendet? Besteht die Gefahr, dass die Variable von einem anderen Client geändert wird?

– Kundante

10. Februar 2016 um 15:00 Uhr
@kundante Du brauchst keine Globals. Informieren Sie sich über Schließungen.

– SLaks

10. Februar 2016 um 15:03 Uhr
@adeneo das Versprechen ist asynchron – was ist, wenn er die Funktion ein zweites Mal aufruft, bevor das erste Versprechen aufgelöst wird?

– Mawg sagt, Monica wieder einzusetzen

5. April 2019 um 10:08 Uhr
@adeneo – Bitte beantworte keine Fragen mit “Dazu gibt es keinen Grund”. Das wissen Sie nicht, und es ist eine wirklich ärgerliche Antwort. Die Person könnte bestimmte Gründe haben, warum sie etwas auf eine bestimmte Weise tun möchte, die sie nicht unbedingt erklären sollte. Entweder es ist machbar oder nicht, und wenn es eine schlechte Idee ist, können Sie die Gründe auflisten. Wie die Antwort mit 248 positiven Stimmen unten zeigt, ist dies eindeutig machbar, und es gibt viele Gründe dafür.

– hannodb

23. September 2020 um 11:21 Uhr

Shanuor

Wickeln Sie Ihr Promise in eine Funktion ein, oder es beginnt sofort mit seiner Arbeit. Außerdem können Sie Parameter an die Funktion übergeben:

var some_function = function(username, password)
{
 return new Promise(function(resolve, reject)
 {
  /*stuff using username, password*/
  if ( /* everything turned out fine */ )
  {
   resolve("Stuff worked!");
  }
  else
  {
   reject(Error("It broke"));
  }
 });
}

Dann verwenden Sie es:

some_module.some_function(username, password).then(function(uid)
{
 // stuff
})

ES6:

const some_function = (username, password) =>
{
 return new Promise((resolve, reject) =>
 {
  /*stuff using username, password*/

  if ( /* everything turned out fine */ )
  {
   resolve("Stuff worked!");
  }
  else
  {
   reject(Error("It broke"));
  }
 });
};

Verwenden:

some_module.some_function(username, password).then(uid =>
{
 // stuff
});

was ist someModule?

– Si8

9. Oktober 2018 um 18:06 Uhr
Es ist nur ein Beispiel aus dem OP

– Shanuor

13. Oktober 2018 um 11:09 Uhr
@Shanoor Was ist uid? Ist es der String „Stuff hat funktioniert!“?

– Alte Knacker

16. Juli 2019 um 16:34 Uhr
@OldGeezer, es ist nur eine Variable, die die Rückgabe des Versprechens enthält. In diesem Fall, ja, das wäre „Zeug funktioniert!“.

– Shanuor

19. Juli 2019 um 8:06 Uhr
Wissen Sie, wie Sie eine Funktion aus der übergeordneten Klasse innerhalb des neuen Promise aufrufen?

– Zeitliches Paradox

16. Juli 2020 um 13:44 Uhr

sadiq

Ein anderer Weg(Müssen versuchen):

var promise1 = new Promise(function(resolve, reject) {
  resolve('Success!');
});
var extraData="ImExtraData";
promise1.then(function(value) {
  console.log(value, extraData);
  // expected output: "Success!" "ImExtraData"
}, extraData);

Ihr Beispiel wäre besser, wenn Sie mit einem Array oder Objekt auflösen, das Sie dekonstruieren, sodass mehrere Argumente angezeigt werden und das ausführliche Versprechen bereits wie folgt aufgelöst erstellt wird: Promise.resolve([arg1, arg2, arg3]);

– Benutzer5389726598465

12. März 2018 um 8:36 Uhr
Ich denke, es ist falsch, da der zweite Parameter übergeben wird then ist ein Callback zum Verarbeiten des Rückgabewerts von ablehnen Funktion. Anstatt von resolve('Success!'); Versuchen reject('Error'); Wir erhalten Fehler: Unhandled promise rejection Hier sehen wir die Ausgabe, weil var extraData = 'ImExtraData'; ist ein global Variable und NICHT, weil sie mit übergeben wird then

– Shakiba Moshiri

11. Mai 2019 um 14:38 Uhr
Wenn Sie es nicht bestehen, können Sie nicht darauf zugreifen, da es keinen versprochenen Bereich hat / dann, wenn Sie es nicht bestehen.

– sadiq

12. Mai 2019 um 4:03 Uhr
Versuchen Sie es zu entfernen und sehen Sie, ob es funktioniert oder nicht? codepen.io/k-five/pen/ZNOvKG Sehen Sie sich das Konsolenprotokoll in Ihrem Browser an

– Shakiba Moshiri

12. Mai 2019 um 4:50 Uhr
Ich schätze Ihren Codepen, aber verwenden Sie zwei verschiedene Variablen und sehen Sie dann den wahren Faktor! VERMEIDEN SIE DIESELBE VARIABLE. Wenn nur die globale Variable gut funktionierte, mussten wir keinen zusätzlichen Parameter übergeben.

– sadiq

12. Mai 2019 um 12:02 Uhr

Noch kürzer

var foo = (user, pass) =>
  new Promise((resolve, reject) => {
    if (/* condition */) {
      resolve("Fine");
    } else {
      reject("Error message");
    }
  });

foo(user, pass).then(result => {
  /* process */
});

Jermaine Antwi

Sie können Ihr Versprechen in einer Funktion mit Argumenten zurückgeben. So was:

function someFunction(username, password) {
    return new Promise((resolve, reject) => {
        // Do something with the params username and password...
        if ( /* everything turned out fine */ ) {
            resolve("Stuff worked!");
        } else {
            reject(Error("It didn't work!"));
        }
    });
}
    
someFunction(username, password)
    .then((result) => {
        // Do something...
    })
    .catch((err) => {
        // Handle the error...
    });

Sie können .bind() verwenden, um den Parameter zu übergeben (Dies) zur Funktion.

var someFunction =function(resolve, reject) {
  /* get username, password*/
  var username=this.username;
  var password=this.password;
  if ( /* everything turned out fine */ ) {
    resolve("Stuff worked!");
  } else {
    reject(Error("It broke"));
  }
}
var promise=new Promise(someFunction.bind({username:"your username",password:"your password"}));

Ich habe diese Funktion, wie man es bearbeitet, zu akzeptieren .then() wenn ich es in einem Button aufrufe ` SaveImagesToFirebase = () => {const uid = firebase.auth().currentUser.uid; // Anbieter const { images } = this.state; images.map(image => {let file = image.uri; console.log(file); const path = “Img” + Math.floor(Math.random() * 1500); console.log(“@IMAGE”, path); const ref = firebase .storage() .ref(provider/${uid}/ProviderGalary/${path}); ref.put (Datei); }); };` @gogog

– DevAS

14. Juli 2019 um 23:20 Uhr
@DevAS Skript ist ` var then_function=function(promise){new Promise(promise).then(function(e){/*code* /})}; function SaveImagesToFirebase(resolve,reject){/*code*/resolve(/*???*/);}`

– guck

16. Juli 2019 um 12:11 Uhr
Genau das, wonach ich gesucht habe: meine Funktionen zu trennen, damit Sie keine anonyme Funktion in Ihr Versprechen einschließen müssen function f2(resolve, reject){ console.log('executing with params : ', this); setTimeout(() => resolve("done!"), this.delay) }; async function f1(data) { // process data here console.log('before'); let promise = new Promise(f2.bind(data)); let result = await promise; // wait until the promise resolves console.log('after'); // process result here alert(result); // "done!" } const data = {delay: 1000}; f1(data);

– Daweb

29. Oktober 2020 um 10:12 Uhr

Langsames_Schaf_

Nicht sicher, ob Sie es richtig verstanden haben, aber um das Argument von Promise an eine andere Funktion zu senden, können Sie so etwas tun:

function logUser(username, password){
    return new Promise((resolve, reject) => {
        let response="user logged in"
        resolve(response)
    })
}

function showMessage(msg){
    console.log(msg)
}

logUser('user', 'pass').then((respFromLogUser) => {
    showMessage(respFromLogUser)
})

Ich habe diese Funktion, wie man es bearbeitet, zu akzeptieren .then() wenn ich es in einem Button aufrufe ` SaveImagesToFirebase = () => {const uid = firebase.auth().currentUser.uid; // Anbieter const { images } = this.state; images.map(image => {let file = image.uri; console.log(file); const path = “Img” + Math.floor(Math.random() * 1500); console.log(“@IMAGE”, path); const ref = firebase .storage() .ref(provider/${uid}/ProviderGalary/${path}); ref.put (Datei); }); };` @gogog

– DevAS

14. Juli 2019 um 23:20 Uhr
@DevAS Skript ist ` var then_function=function(promise){new Promise(promise).then(function(e){/*code* /})}; function SaveImagesToFirebase(resolve,reject){/*code*/resolve(/*???*/);}`

– guck

16. Juli 2019 um 12:11 Uhr
Genau das, wonach ich gesucht habe: meine Funktionen zu trennen, damit Sie keine anonyme Funktion in Ihr Versprechen einschließen müssen function f2(resolve, reject){ console.log('executing with params : ', this); setTimeout(() => resolve("done!"), this.delay) }; async function f1(data) { // process data here console.log('before'); let promise = new Promise(f2.bind(data)); let result = await promise; // wait until the promise resolves console.log('after'); // process result here alert(result); // "done!" } const data = {delay: 1000}; f1(data);

– Daweb

29. Oktober 2020 um 10:12 Uhr

sancons

Ich weiß, das ist alt, aber das kann jemandem helfen, der durch Google gräbt. Dies ist ein praktischeres Beispiel, bei dem ich einfach 2 Parameter an eine Promise-Funktion übergebe und darauf warte, dass sie aufgelöst wird. Hoffentlich hilft das. Das setTimeout simuliert “Bearbeitungszeit”. Nach 3 Sekunden wird der Wert vom Promise zurückgegeben und auf dem Bildschirm ausgegeben.

const addNumbers = (a, b) => {
    
  return new Promise((resolve, reject) => {
    
    setTimeout(() => {
      resolve(a + b);
    }, 3000);
  
  });
  
  
};

let getResult = async (a, b) => {
    let value = await addNumbers(a, b);
    console.log(value);
};

getResult(1, 3);

12874400cookie-checkSo übergeben Sie Parameter an eine Promise-Funktion

#es6-versprechen #Javascript #node.js #Parameterübergabe #Versprechen