Cách tạo một hàm chờ cho đến khi một cuộc gọi lại được gọi bằng node.js

Tôi có một chức năng đơn giản hóa trông như thế này:

function(query) {
  myApi.exec('SomeCommand', function(response) {
    return response;
  });
}

Về cơ bản tôi muốn nó gọi myApi.execvà trả về phản hồi được đưa ra trong lambda gọi lại. Tuy nhiên, đoạn mã trên không hoạt động và chỉ cần trả về ngay lập tức.

Chỉ với một nỗ lực rất hóc búa, tôi đã thử những cách dưới đây không hiệu quả, nhưng ít nhất bạn cũng hiểu được những gì tôi đang cố gắng đạt được:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  while (!r) {}
  return r;
}

Về cơ bản, cách tốt nhất "node.js / hướng sự kiện" sẽ diễn ra như thế nào? Tôi muốn chức năng của mình đợi cho đến khi gọi lại được gọi, sau đó trả về giá trị được truyền cho nó.

Cách "tốt node.js / hướng sự kiện" để làm điều này là không chờ đợi .

Giống như hầu hết mọi thứ khác khi làm việc với các hệ thống điều khiển sự kiện như nút, hàm của bạn sẽ chấp nhận tham số gọi lại sẽ được gọi khi hoàn thành tính toán. Người gọi không nên đợi giá trị được "trả về" theo nghĩa thông thường, mà nên gửi thói quen sẽ xử lý giá trị kết quả:

function(query, callback) {
  myApi.exec('SomeCommand', function(response) {
    // other stuff here...
    // bla bla..
    callback(response); // this will "return" your value to the original caller
  });
}

Vì vậy, bạn không sử dụng nó như thế này:

var returnValue = myFunction(query);

Nhưng như thế này:

myFunction(query, function(returnValue) {
  // use the return value here instead of like a regular (non-evented) return value
});

Một cách để đạt được điều này là kết thúc lệnh gọi API thành một lời hứa và sau đó sử dụng awaitđể chờ kết quả.

// let's say this is the API function with two callbacks,
// one for success and the other for error
function apiFunction(query, successCallback, errorCallback) {
    if (query == "bad query") {
        errorCallback("problem with the query");
    }
    successCallback("Your query was <" + query + ">");
}

// myFunction wraps the above API call into a Promise
// and handles the callbacks with resolve and reject
function apiFunctionWrapper(query) {
    return new Promise((resolve, reject) => {
        apiFunction(query,(successResponse) => {
            resolve(successResponse);
        }, (errorResponse) => {
            reject(errorResponse)
        });
    });
}

// now you can use await to get the result from the wrapped api function
// and you can use standard try-catch to handle the errors
async function businessLogic() {
    try {
        const result = await apiFunctionWrapper("query all users");
        console.log(result);

        // the next line will fail
        const result2 = await apiFunctionWrapper("bad query");
    } catch(error) {
        console.error("ERROR:" + error);
    }
}

// call the main function
businessLogic();

Đầu ra:

Your query was <query all users>
ERROR:problem with the query

kiểm tra điều này: https://github.com/luciotato/waitfor-ES6

mã của bạn với Wait.for: (yêu cầu trình tạo, cờ --harmony)

function* (query) {
  var r = yield wait.for( myApi.exec, 'SomeCommand');
  return r;
}

Nếu bạn không muốn sử dụng gọi lại thì bạn có thể sử dụng mô-đun "Q".

Ví dụ:

function getdb() {
    var deferred = Q.defer();
    MongoClient.connect(databaseUrl, function(err, db) {
        if (err) {
            console.log("Problem connecting database");
            deferred.reject(new Error(err));
        } else {
            var collection = db.collection("url");
            deferred.resolve(collection);
        }
    });
    return deferred.promise;
}


getdb().then(function(collection) {
   // This function will be called afte getdb() will be executed. 

}).fail(function(err){
    // If Error accrued. 

});

Để biết thêm thông tin tham khảo điều này: https://github.com/kriskowal/q

Nếu bạn muốn nó rất đơn giản và dễ dàng, không có thư viện ưa thích nào, hãy đợi các hàm gọi lại được thực thi trong nút, trước khi thực thi một số mã khác, giống như sau:

//initialize a global var to control the callback state
var callbackCount = 0;
//call the function that has a callback
someObj.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});
someObj2.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});

//call function that has to wait
continueExec();

function continueExec() {
    //here is the trick, wait until var callbackCount is set number of callback functions
    if (callbackCount < 2) {
        setTimeout(continueExec, 1000);
        return;
    }
    //Finally, do what you need
    doSomeThing();
}

Lưu ý: Câu trả lời này có lẽ không nên được sử dụng trong mã sản xuất. Đó là một hack và bạn nên biết về những tác động.

Có mô-đun uvrun (được cập nhật cho các phiên bản Nodejs mới hơn ở đây ) nơi bạn có thể thực hiện một vòng lặp đơn của vòng lặp sự kiện chính libuv (là vòng lặp chính của Nodejs).

Mã của bạn sẽ trông như thế này:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  var uvrun = require("uvrun");
  while (!r)
    uvrun.runOnce();
  return r;
}

(Bạn có thể sử dụng thay thế uvrun.runNoWait(). Điều đó có thể tránh một số vấn đề với việc chặn, nhưng mất 100% CPU.)

Lưu ý rằng cách tiếp cận này làm mất hiệu lực toàn bộ mục đích của Nodejs, tức là có mọi thứ không đồng bộ và không chặn. Ngoài ra, nó có thể tăng độ sâu của nút gọi của bạn rất nhiều, vì vậy bạn có thể kết thúc với tràn ngăn xếp. Nếu bạn chạy chức năng như vậy một cách đệ quy, bạn chắc chắn sẽ gặp rắc rối.

Xem các câu trả lời khác về cách thiết kế lại mã của bạn để thực hiện "đúng".

Giải pháp này ở đây có lẽ chỉ hữu ích khi bạn thực hiện thử nghiệm và đặc biệt. muốn có mã đồng bộ và nối tiếp.

Vì nút 4.8.0, bạn có thể sử dụng tính năng của ES6 được gọi là trình tạo. Bạn có thể theo dõi bài viết này cho các khái niệm sâu hơn. Nhưng về cơ bản, bạn có thể sử dụng máy phát điện và hứa sẽ hoàn thành công việc này. Tôi đang sử dụng bluebird để quảng bá và quản lý trình tạo.

Mã của bạn sẽ ổn như ví dụ dưới đây.

const Promise = require('bluebird');

function* getResponse(query) {
  const r = yield new Promise(resolve => myApi.exec('SomeCommand', resolve);
  return r;
}

Promise.coroutine(getResponse)()
  .then(response => console.log(response));

giả sử bạn có một chức năng:

var fetchPage(page, callback) {
   ....
   request(uri, function (error, response, body) {
        ....
        if (something_good) {
          callback(true, page+1);
        } else {
          callback(false);
        }
        .....
   });


};

bạn có thể sử dụng các cuộc gọi lại như thế này:

fetchPage(1, x = function(next, page) {
if (next) {
    console.log("^^^ CALLBACK -->  fetchPage: " + page);
    fetchPage(page, x);
}
});

Điều đó đánh bại mục đích của việc không chặn IO - bạn đang chặn nó khi không cần chặn :)

Bạn nên lồng các cuộc gọi lại của mình thay vì buộc node.js phải chờ hoặc gọi một cuộc gọi lại khác bên trong cuộc gọi lại nơi bạn cần kết quả r.

Rất có thể, nếu bạn cần buộc chặn, bạn đang nghĩ về kiến ​​trúc của mình sai.

Sử dụng async và chờ đợi nó dễ dàng hơn nhiều.

router.post('/login',async (req, res, next) => {
i = await queries.checkUser(req.body);
console.log('i: '+JSON.stringify(i));
});

//User Available Check
async function checkUser(request) {
try {
    let response = await sql.query('select * from login where email = ?', 
    [request.email]);
    return response[0];

    } catch (err) {
    console.log(err);

  }

}