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.

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?

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

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()

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

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.

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;
}

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);