จะตัดการเรียกฟังก์ชัน async ลงในฟังก์ชัน sync ใน Node.js หรือ Javascript ได้อย่างไร

สมมติว่าคุณรักษาห้องสมุดที่ exposes getDataฟังก์ชัน ผู้ใช้ของคุณเรียกสิ่งนี้ว่ารับข้อมูลจริง: ข้อมูล
var output = getData();
Under the hood จะถูกบันทึกไว้ในไฟล์เพื่อให้คุณใช้งานgetDataโดยใช้ Node.js ในfs.readFileSyncตัว เห็นได้ชัดทั้งคู่getDataและfs.readFileSyncเป็นฟังก์ชันการซิงค์ วันหนึ่งคุณได้รับคำสั่งให้เปลี่ยนแหล่งข้อมูลพื้นฐานเป็น repo เช่น MongoDB ซึ่งสามารถเข้าถึงได้แบบอะซิงโครนัสเท่านั้น นอกจากนี้คุณยังได้รับคำสั่งให้หลีกเลี่ยงการทำให้ผู้ใช้ของคุณgetDataขุ่นเคืองไม่สามารถเปลี่ยน API ให้กลับมาเป็นเพียงคำสัญญาหรือเรียกร้องพารามิเตอร์การเรียกกลับ คุณมีคุณสมบัติตามข้อกำหนดทั้งสองอย่างไร

ฟังก์ชันอะซิงโครนัสโดยใช้การเรียกกลับ / สัญญาคือ DNA ของ JavasSript และ Node.js แอป JS ที่ไม่สำคัญใด ๆ อาจจะเต็มไปด้วยรูปแบบการเข้ารหัสนี้ แต่การปฏิบัตินี้สามารถนำไปสู่สิ่งที่เรียกว่าปิรามิดแห่งการลงโทษได้อย่างง่ายดาย ยิ่งไปกว่านั้นหากรหัสใด ๆ ในผู้โทรใด ๆ ในสายการโทรขึ้นอยู่กับผลลัพธ์ของฟังก์ชัน async รหัสเหล่านั้นจะต้องถูกรวมไว้ในฟังก์ชันการโทรกลับเช่นกันซึ่งเป็นการกำหนดข้อ จำกัด รูปแบบการเข้ารหัสสำหรับผู้โทร ในบางครั้งฉันพบว่าจำเป็นต้องห่อหุ้มฟังก์ชัน async (มักมีให้ในไลบรารีของบุคคลที่สาม) ลงในฟังก์ชันการซิงค์เพื่อหลีกเลี่ยงการแยกตัวประกอบซ้ำทั่วโลกจำนวนมาก การค้นหาวิธีแก้ปัญหาในเรื่องนี้มักจะลงเอยด้วยNode Fibersหรือแพ็คเกจ npm ที่ได้มาจากมัน แต่เส้นใยไม่สามารถแก้ปัญหาที่ฉันเผชิญได้ แม้แต่ตัวอย่างที่จัดทำโดยผู้เขียนของ Fibers ก็แสดงให้เห็นถึงข้อบกพร่อง:

...
Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

เอาต์พุตจริง:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

หากฟังก์ชัน Fiber เปลี่ยนฟังก์ชั่น async เป็น sync จริงๆผลลัพธ์ควรเป็น:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
back in main

ฉันได้สร้างตัวอย่างง่ายๆอีกอย่างในJSFiddleและกำลังมองหาโค้ดเพื่อให้ได้ผลลัพธ์ที่คาดหวัง ฉันยอมรับโซลูชันที่ใช้งานได้เฉพาะใน Node.js ดังนั้นคุณมีอิสระที่จะต้องใช้แพ็คเกจ npm ใด ๆ แม้ว่าจะไม่ทำงานใน JSFiddle ก็ตาม

deasyncเปลี่ยนฟังก์ชัน async เป็นการซิงค์นำไปใช้กับกลไกการบล็อกโดยการเรียก Node.js event loop ที่เลเยอร์ JavaScript ด้วยเหตุนี้ deasync จึงบล็อกโค้ดที่ตามมาไม่ให้ทำงานโดยไม่บล็อกเธรดทั้งหมดและไม่ต้องรอให้วุ่นวาย ด้วยโมดูลนี้นี่คือคำตอบสำหรับความท้าทาย jsFiddle:

function AnticipatedSyncFunction(){
  var ret;
  setTimeout(function(){
      ret = "hello";
  },3000);
  while(ret === undefined) {
    require('deasync').runLoopOnce();
  }
  return ret;    
}


var output = AnticipatedSyncFunction();
//expected: output=hello (after waiting for 3 sec)
console.log("output="+output);
//actual: output=hello (after waiting for 3 sec)

(ข้อจำกัดความรับผิดชอบ: ฉันเป็นผู้เขียนร่วมdeasyncโมดูลถูกสร้างขึ้นหลังจากโพสต์คำถามนี้และไม่พบข้อเสนอที่สามารถใช้งานได้)

นอกจากนี้ยังมีโมดูลการซิงค์ npm ซึ่งใช้สำหรับซิงโครไนซ์กระบวนการดำเนินการสืบค้น

เมื่อคุณต้องการเรียกใช้แบบสอบถามคู่ขนานในแบบซิงโครนัสโหนดจะ จำกัด ให้ทำเช่นนั้นเพราะไม่รอการตอบสนอง และโมดูลการซิงค์นั้นสมบูรณ์แบบมากสำหรับโซลูชันประเภทนั้น

โค้ดตัวอย่าง

/*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

ลิงค์อ้างอิง: https://www.npmjs.com/package/sync

ถ้าฟังก์ชัน Fiber เปลี่ยนฟังก์ชัน async sleep ให้เป็น sync จริงๆ

ใช่. okภายในเส้นใยฟังก์ชั่นรอก่อนการเข้าสู่ระบบ เส้นใยไม่ทำให้ฟังก์ชัน async ซิงโครนัส แต่อนุญาตให้เขียนโค้ดที่มีลักษณะซิงโครนัสซึ่งใช้ฟังก์ชัน async จากนั้นจะทำงานแบบอะซิงโครนัสภายในไฟล์Fiber.

ในบางครั้งฉันพบว่าจำเป็นต้องห่อหุ้มฟังก์ชัน async ไว้ในฟังก์ชันการซิงค์เพื่อหลีกเลี่ยงการแยกตัวประกอบซ้ำทั่วโลก

คุณไม่สามารถ. เป็นไปไม่ได้ที่จะสร้างรหัสอะซิงโครนัสแบบซิงโครนัส คุณจะต้องคาดการณ์สิ่งนั้นในโค้ดส่วนกลางของคุณและเขียนในรูปแบบ async ตั้งแต่เริ่มต้น ไม่ว่าคุณจะรวมรหัสส่วนกลางไว้ในเส้นใยใช้คำสัญญาสร้างสัญญาหรือเรียกกลับง่ายๆขึ้นอยู่กับความต้องการของคุณ

วัตถุประสงค์ของฉันคือเพื่อลดผลกระทบต่อผู้โทรเมื่อวิธีการรับข้อมูลเปลี่ยนจากการซิงค์เป็น async

ทั้งคำสัญญาและเส้นใยสามารถทำเช่นนั้นได้

คุณต้องใช้คำสัญญา:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async () => {
    return await asyncOperation();
}

const topDog = () => {
    asyncFunction().then((res) => {
        console.log(res);
    });
}

ฉันชอบคำจำกัดความของฟังก์ชันลูกศรมากกว่า แต่สตริงใด ๆ ของรูปแบบ "() => {... }" สามารถเขียนเป็น "function () {... }"

ดังนั้น topDog จึงไม่ async แม้ว่าจะเรียกใช้ฟังก์ชัน async ก็ตาม

แก้ไข: ฉันตระหนักดีว่าหลายครั้งที่คุณต้องรวมฟังก์ชัน async ไว้ในฟังก์ชันการซิงค์นั้นอยู่ภายในคอนโทรลเลอร์ สำหรับสถานการณ์เหล่านั้นนี่คือเคล็ดลับสำหรับปาร์ตี้:

const getDemSweetDataz = (req, res) => {
    (async () => {
        try{
            res.status(200).json(
                await asyncOperation()
            );
        }
        catch(e){
            res.status(500).json(serviceResponse); //or whatever
        }
    })() //So we defined and immediately called this async function.
}

เมื่อใช้สิ่งนี้กับการโทรกลับคุณสามารถทำคำสัญญาที่ไม่ใช้สัญญาได้:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async (callback) => {
    let res = await asyncOperation();
    callback(res);
}

const topDog = () => {
    let callback = (res) => {
        console.log(res);
    };

    (async () => {
        await asyncFunction(callback)
    })()
}

โดยใช้เคล็ดลับนี้กับ EventEmitter คุณจะได้รับผลลัพธ์เดียวกัน กำหนด Listener ของ EventEmitter ที่ฉันกำหนดการโทรกลับและปล่อยเหตุการณ์ที่ฉันโทรกลับ

ฉันไม่พบสถานการณ์ที่ไม่สามารถแก้ไขได้โดยใช้โหนดไฟเบอร์ ตัวอย่างที่คุณระบุโดยใช้โหนดไฟเบอร์ทำงานตามที่คาดไว้ กุญแจสำคัญคือการรันโค้ดที่เกี่ยวข้องทั้งหมดภายในไฟเบอร์ดังนั้นคุณไม่จำเป็นต้องเริ่มไฟเบอร์ใหม่ในตำแหน่งสุ่ม

มาดูตัวอย่าง:สมมติว่าคุณใช้เฟรมเวิร์กซึ่งเป็นจุดเริ่มต้นของแอปพลิเคชันของคุณ (คุณไม่สามารถแก้ไขเฟรมเวิร์กนี้ได้) เฟรมเวิร์กนี้โหลดโมดูล nodejs เป็นปลั๊กอินและเรียกใช้เมธอดบางอย่างบนปลั๊กอิน สมมติว่าเฟรมเวิร์กนี้ยอมรับเฉพาะฟังก์ชันซิงโครนัสและไม่ใช้เส้นใยด้วยตัวเอง

มีไลบรารีที่คุณต้องการใช้ในหนึ่งในปลั๊กอินของคุณ แต่ไลบรารีนี้เป็นแบบ async และคุณไม่ต้องการแก้ไขด้วย

เธรดหลักไม่สามารถให้ผลลัพธ์ได้เมื่อไม่มีไฟเบอร์ทำงาน แต่คุณยังสามารถสร้างปลั๊กอินโดยใช้เส้นใยได้! เพียงแค่สร้างรายการ Wrapper ที่เริ่มต้นเฟรมเวิร์กทั้งหมดภายในไฟเบอร์คุณจึงสามารถดำเนินการจากปลั๊กอินได้

ข้อเสีย: หากเฟรมเวิร์กใช้setTimeoutหรือPromises ภายในมันจะหนีบริบทไฟเบอร์ นี้สามารถทำงานรอบโดยเยาะเย้ยsetTimeout, Promise.thenและทุกจัดการเหตุการณ์

นี่คือวิธีที่คุณจะได้เส้นใยจนกว่า a Promiseจะได้รับการแก้ไข รหัสนี้ใช้ฟังก์ชัน async (Promise return) และเรียกใช้ไฟเบอร์ต่อเมื่อคำสัญญาได้รับการแก้ไข:

กรอบ entry.js

console.log(require("./my-plugin").run());

async-lib.js

exports.getValueAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Async Value");
    }, 100);
  });
};

-plugin.js ของฉัน

const Fiber = require("fibers");

function fiberWaitFor(promiseOrValue) {
  var fiber = Fiber.current, error, value;
  Promise.resolve(promiseOrValue).then(v => {
    error = false;
    value = v;
    fiber.run();
  }, e => {
    error = true;
    value = e;
    fiber.run();
  });
  Fiber.yield();
  if (error) {
    throw value;
  } else {
    return value;
  }
}

const asyncLib = require("./async-lib");

exports.run = () => {
  return fiberWaitFor(asyncLib.getValueAsync());
};

-entry.js ของฉัน

require("fibers")(() => {
  require("./framework-entry");
}).run();

เมื่อคุณเรียกใช้node framework-entry.jsจะทำให้เกิดข้อผิดพลาด: Error: yield() called with no fiber running. หากคุณเรียกใช้node my-entry.jsงานได้ตามที่คาดไว้

การซิงค์โค้ด Node.js มีความจำเป็นในบางด้านเช่นฐานข้อมูล แต่ข้อดีที่แท้จริงของ Node.js อยู่ในรหัส async เนื่องจากเป็นเธรดเดียวจึงไม่บล็อก

เราสามารถซิงค์โดยใช้ฟังก์ชันที่สำคัญ Fiber () ใช้ await () และ defer () เราเรียกวิธีการทั้งหมดโดยใช้ await () จากนั้นแทนที่ฟังก์ชันเรียกกลับด้วย defer ()

รหัส Async ปกติสิ่งนี้ใช้ฟังก์ชัน CallBack

function add (var a, var b, function(err,res){
       console.log(res);
});

 function sub (var res2, var b, function(err,res1){
           console.log(res);
    });

 function div (var res2, var b, function(err,res3){
           console.log(res3);
    });

ซิงค์รหัสด้านบนโดยใช้ Fiber (), await () และ defer ()

fiber(function(){
     var obj1 = await(function add(var a, var b,defer()));
     var obj2 = await(function sub(var obj1, var b, defer()));
     var obj3 = await(function sub(var obj2, var b, defer()));

});

ฉันหวังว่านี่จะช่วยได้ ขอบคุณ

ปัจจุบันรูปแบบเครื่องกำเนิดไฟฟ้านี้สามารถแก้ปัญหาได้ในหลายสถานการณ์

นี่คือตัวอย่างของพรอมต์คอนโซลตามลำดับใน nodejs โดยใช้ฟังก์ชัน async readline.question:

var main = (function* () {

  // just import and initialize 'readline' in nodejs
  var r = require('readline')
  var rl = r.createInterface({input: process.stdin, output: process.stdout })

  // magic here, the callback is the iterator.next
  var answerA = yield rl.question('do you want this? ', r=>main.next(r))    

  // and again, in a sync fashion
  var answerB = yield rl.question('are you sure? ', r=>main.next(r))        

  // readline boilerplate
  rl.close()

  console.log(answerA, answerB)

})()  // <-- executed: iterator created from generator
main.next()     // kick off the iterator, 
                // runs until the first 'yield', including rightmost code
                // and waits until another main.next() happens

คุณไม่ควรมองไปที่สิ่งที่เกิดขึ้นรอบ ๆการโทรที่สร้างเส้นใย แต่ดูว่าเกิดอะไรขึ้นภายในเส้นใย เมื่อคุณอยู่ในไฟเบอร์คุณสามารถตั้งโปรแกรมในรูปแบบการซิงค์ได้ ตัวอย่างเช่น:

ฟังก์ชัน f1 () {
    console.log ('รอ ... ' + วันที่ใหม่);
    การนอนหลับ (1000)
    console.log ('ตกลง ... ' + วันที่ใหม่);   
}

ฟังก์ชัน f2 () {
    f1 ();
    f1 ();
}

ไฟเบอร์ (ฟังก์ชัน () {
    F2 ();
}).วิ่ง();

ภายในเส้นใยที่คุณโทรf1, f2และsleepราวกับว่าพวกเขาซิงค์

ในเว็บแอปพลิเคชันทั่วไปคุณจะสร้าง Fiber ในโปรแกรมจัดการคำขอ HTTP ของคุณ เมื่อคุณทำเสร็จแล้วคุณสามารถเขียนตรรกะการจัดการคำขอทั้งหมดของคุณในรูปแบบการซิงค์แม้ว่าจะเรียกใช้ฟังก์ชัน async (fs, ฐานข้อมูล ฯลฯ )

ตอนแรกฉันพยายามดิ้นรนกับ node.js และ async.js เป็นไลบรารีที่ดีที่สุดที่ฉันพบเพื่อช่วยคุณจัดการกับสิ่งนี้ หากคุณต้องการเขียนโค้ดซิงโครนัสด้วยโหนดวิธีการคือวิธีนี้

var async = require('async');

console.log('in main');

doABunchOfThings(function() {
  console.log('back in main');
});

function doABunchOfThings(fnCallback) {
  async.series([
    function(callback) {
      console.log('step 1');
      callback();
    },
    function(callback) {
      setTimeout(callback, 1000);
    },
    function(callback) {
      console.log('step 2');
      callback();
    },
    function(callback) {
      setTimeout(callback, 2000);
    },
    function(callback) {
      console.log('step 3');
      callback();
    },
  ], function(err, results) {
    console.log('done with things');
    fnCallback();
  });
}

โปรแกรมนี้จะผลิตสิ่งต่อไปนี้เสมอ ...

in main
step 1
step 2
step 3
done with things
back in main

Javascript เป็นภาษาเธรดเดียวคุณไม่ต้องการบล็อกเซิร์ฟเวอร์ทั้งหมดของคุณ! รหัส Async กำจัดเงื่อนไขการแข่งขันโดยการทำให้การอ้างอิงชัดเจน

เรียนรู้ที่จะรักรหัสอะซิงโครนัส!

ดูpromisesรหัสอะซิงโครนัสโดยไม่ต้องสร้างปิรามิดแห่งนรกเรียกกลับ ฉันแนะนำไลบรารี promQ สำหรับ node.js

httpGet(url.parse("http://example.org/")).then(function (res) {
    console.log(res.statusCode);  // maybe 302
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);  // maybe 200
});

http://howtonode.org/promises

แก้ไข: นี่เป็นคำตอบที่ถกเถียงกันมากที่สุดของฉันตอนนี้โหนดมีคีย์เวิร์ดที่ให้ผลตอบแทนซึ่งช่วยให้คุณจัดการโค้ดอะซิงโครนัสราวกับว่ามันเป็นซิงโครนัส http://blog.alexmaccaw.com/how-yield-will-transform-node