javascript - Masalah yang dihadapi apabila nodejs melaksanakan pelaksanaan tak segerak

Question

Sebagai contoh, terdapat tiga fungsi a, b dan c, yang kesemuanya menjalankan operasi penyegerakan untuk memudahkan, saya telah memudahkan operasi penyegerakan

function c(m) {
    m = m + 1;
    return m;
}
function b(m) {
    m = m + 1;
    return c(m);
}
function a(){
    let m = 0;
    return b(m);
}

Keluaran melaksanakan a() ialah 2
Tetapi jika fungsi c tidak melaksanakan fungsi segerak, tetapi operasi tak segerak, contohnya

function c(m) {
    setTimeout(function () {
        m = m + 1;
    }, 1000)
    return m;
}

Apabila melaksanakan a(), jika anda ingin mengeluarkan 2 dengan betul, anda mesti merangkum c melalui promise atau async,
Sama seperti

function promiseC(m) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
        m = m + 1;
        resolve(m);
        }, 1000)
    }
}
async function c(m) {
    m = await promiseC(m);
    return m; 
}

Oleh kerana c menjadi fungsi tak segerak, b perlu memanggil c, b juga perlu ditukar kepada tak segerak, dan seterusnya, a juga mesti ditukar kepada tak segerak

async function b(m) {
    m = m + 1;
    return await c(m);
}
async function a(){
    let m = 0;
    return await b(m);
}

a().kemudian(fungsi(data) {

console.log(data)

}) Dengan cara ini, 2

boleh menjadi output

Untuk mengeluarkan 2 dengan betul, saya menukar kedua-dua a dan b Saya tertanya-tanya adakah ada cara lain untuk mengelakkan perubahan a dan b dan mencapai output yang betul?
Memandangkan saya tidak mempertimbangkan situasi tak segerak semasa saya mula menulis kod, fungsi seperti a dan b diedarkan dalam fail yang berbeza, dan terdapat banyak daripadanya Sekarang untuk membolehkan c melakukan operasi tak segerak terlalu sukar untuk mengubahnya. Saya tidak tahu Adakah anda mempunyai kaedah lain yang bagus?

Berikut ialah soalan yang baru ditambah
Masalah di atas boleh diselesaikan dengan memulangkan terus objek janji dalam jawapan di bawah, tetapi struktur kod sebenar lebih seperti ini

function c(m) {
    m = m + 1;
    return m;
}
function b(m) {
    m = m + 1;
    let n = c(m)
    n = n + 1
    return n;
}
function a(){
    let m = 0;
    let k = b(m);
    k = k + 1;
    return k;
}

Jika saya mengikuti kaedah ini, saya perlu mengubah suai kaedah pulangan a dan b
supaya a dan b boleh mengembalikan objek yang dijanjikan
Untuk struktur sedemikian, saya tidak tahu sama ada terdapat cara untuk mencapai output yang betul tanpa menukar fungsi a dan b

Answer 1

Saya minta maaf untuk memberitahu anda bahawa nod secara jelas tidak segerak, jadi jika anda menukar fungsi daripada segerak kepada tidak segerak, maka fungsi yang bergantung padanya juga mesti ditukar bertahanlah.

Memfaktorkan semula seperti fibjs, yang tidak memerlukan kata kunci async, adalah sangat bebas kebimbangan Jika anda menukar c, anda tidak perlu menukar a dan b, kerana tak segerak tersirat tidak memerlukan anda menyatakannya.

Answer 2

Saya masih tidak faham Janji dengan cukup baik. Tak perlu tukar b()和a() di sini.

Untuk menangkap Janji ini dalam fungsi c，只需要返回一个promise对象，经过函数b的时候，直接同步返回这个Promise对象，不需要改动函数b使其为异步函数，因为异步操作是在函数c中，b中只进行了同步操作。此时需要在函数a, kod boleh ditukar kepada ini

function promiseC(m) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            m = m + 1;
            resolve(m);
        }, 1000)
    })
}


function c(m) {
    m = promiseC(m);
    return m;
}

function b(m) {
    m = m + 1;
    return c(m);
}
function a() {
    let m = 0;
    return b(m);
}

p.then(function(a){
    console.log(a)
})

Jadi, jika fungsi ini a(),b()tidak mengendalikan nilai pulangan operasi tak segerak, mengapa ia perlu ditukar kepada fungsi Async?

Answer 3

Anda boleh mencuba http://fibjs.org/docs/manual/... dan tukar terus kepada penyegerakan

Answer 4

Saya harus mengatakan bahawa saya merenung skrin dan membuat banyak draf, tetapi akhirnya saya gagal.

Saya tidak dapat memikirkan apa-apa cara untuk menyekat fungsi semasa dalam js tetapi masih melaksanakan azam janji tepat pada masanya. Idea kegagalan adalah seperti berikut

c_result=null
c=async (m)=>{return m+1}
c_sync = (m)=>{
    let n=0
        pc=c(m).then((m)=>{c_result=m})
    while(c_result===null && n++<100){}
    return c_result
}
b=(m)=>{return c_sync(m+1)}
a=()=>{return b(0)}
a()

Masalahnya ialah walaupun

panggilan balik dilaksanakan Disebabkan oleh mekanisme tak segerak berbenang tunggal, apabila panggilan balik tertentu dicetuskan, jika utas sibuk, panggilan balik tidak boleh melompat ke dalam baris gilir, mengakibatkan c_result tidak dapat melakukan apa-apa. semasa pelaksanaan gelung Ditugaskan kepada pembolehubah m, tiada cara untuk keluar dari gelung while(c_result===null && n++<100){}阻塞了函数c_sync, 但是也阻止了.then

Tetapi saya rasa soalan ini sangat menarik saya menjumpai artikel berkaitan Penulis menyelesaikan masalah penyekatan tempatan melalui perpustakaan binari luaran.

http://blog.csdn.net/xingqili...

Pemahaman saya ialah:

Berdasarkan gelung peristiwa enjin js itu sendiri, kita tidak boleh menyekat blok tertentu Kerana untuk kod js, gelung peristiwa enjin berada di bahagian bawah Tetapi untuk modul binari luaran, ia boleh menyekat dirinya sendiri. Dan pastikan gelung peristiwa enjin js sepenuhnya melintasi baris gilir acara setiap kali----untuk memastikan peristiwa baharu dalam enjin js boleh diproses semasa tempoh penyekatannya sendiri.

Answer 5

Biar janji output () memang boleh menyelesaikan masalah yang saya nyatakan
Tetapi apabila saya benar-benar mengubah suai kod, saya dapati bahawa struktur kebanyakan kod itu tidak seperti masalah saya di atas
tetapi struktur yang baru ditambah di bawah

function c(m) {
    m = m + 1;
    return m;
}
function b(m) {
    m = m + 1;
    let n = c(m)
    n = n + 1
    return n;
}
function a(){
    let m = 0;
    let k = b(m);
    k = k + 1;
    return k;
}

Answer 6

Dengan segala hormatnya, anda tidak mempunyai pemahaman yang mendalam tentang mekanisme gelung peristiwa dan modul teras acara node.js.
janji dan aysnc/wait sememangnya menjadi arus perdana dalam mengendalikan kawalan proses tak segerak hari ini, tetapi ia tidak bermakna ia tidak boleh dilakukan tanpa masalah mudah seperti itu boleh ditangani kembali kepada kaedah acara.

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

myEmitter.on('a', (m) => {
    console.log('a -> b');
    myEmitter.emit('b', m+1);
});
myEmitter.on('b', (m) => {
    console.log('b -> c');
    myEmitter.emit('c', m+1);
});
myEmitter.on('c', (m) => {
    console.log('result', m);
});
myEmitter.emit('a', 0);