javascript - Apakah yang dimaksudkan untuk menulis secara tidak segerak dengan cara segerak?

Question

Bukankah penyegerakan hanya penyegerakan, dan bukankah asynchronous hanya asynchronous? Apakah yang dimaksudkan untuk menulis secara tidak segerak dengan cara segerak?

Answer 1

Panggilan tak segerak tidak menyekat untuk urutan semasa, jadi jika anda ingin mengetahui sama ada pemprosesan tak segerak selesai atau sama ada ralat berlaku, ia biasanya dicapai melalui peristiwa atau panggilan balik, yang biasa dalam Node.js. Ajax ialah panggilan tak segerak yang sangat tipikal, ambil jQuery.ajax sebagai contoh

$.getJSON("http://api.youapp.com/resouce1")
    .done(function(jo) {
        console.log("api resouce1 返回的是", jo);
    });

Ajax jQuery mengembalikan objek Promise jQuery Secara amnya, kami akan menggunakan done() 回调来处理调用完成之后的事情。但实际它也有标准 Promise 的 then()，所以上面的 done 是可以改成 then 的，但是要注意，done 是以事件的形式注册回调，它返回当前这个 Promise 对象本身，可以链式调用注册若干个回调。而 then untuk mengembalikan objek Promise yang lain (spesifikasi Promise standard Jika panggilan dirantai, setiap panggilan tidak bertindak pada objek Promise yang sama).

Jika anda perlu membuat satu lagi panggilan tak segerak dalam panggilan balik, anda perlu mendaftarkan panggilan balik lain dalam panggilan balik. Contohnya, untuk mendapatkan data tertentu, anda perlu terlebih dahulu mendapatkan nilai tertentu daripada api1, kemudian gunakan nilai ini untuk mendapatkan sumber tertentu daripada api2, dan kemudian gunakan nilai tertentu dalam sumber ini untuk mendapatkan nilai ini daripada api3 panggilan balik sedemikian akan kelihatan seperti ini apabila ditulis :

$.getJSON("http://api.youapp.com/resouce1")
    .then(function(jo) {
        $.getJSON("http://api.youapp.com/resouce2?id=" + jo.blaId)
            .then(function(jo2) {
                $.getJSON("http://api.youapp.com/resouce3?xxx=" + jo2.xxxValue)
                    .then(function(value) {
                        console.log("总算拿到了", value);
                    });
            });
    });

Ini baru tahap ketiga... bentuk yang sangat menakutkan. Borang ini dipanggil "neraka panggilan balik."

Semua orang dah fikir macam-macam cara nak selesaikan masalah ni, Janji salah satunya, tapi Janji masih tak boleh buang sepenuhnya dari borang ni. Pustaka bersama juga merupakan salah satu penyelesaian, tetapi ia tidak boleh dihapuskan sepenuhnya.

Walau bagaimanapun, ES2017 memperkenalkan async/wait, iaitu apa yang dipanggil tulisan asynchronous dalam bentuk segerak Contohnya, kod di atas boleh ditulis semula sebagai

async function xxx() {
    const jo = await $.getJSON("http://api.youapp.com/resouce1");
    const jo2 = await $.getJSON("http://api.youapp.com/resouce2?id=" + jo.blaId);
    const value = await $.getJSON("http://api.youapp.com/resouce3?xxx=" + jo2.xxxValue);
    console.log("总算拿到了", value);
}

async/tunggu menghapuskan panggilan balik, jadi ia kelihatan sama seperti menulis kod bukan segerak (iaitu, segerak).

Rujukan:

• Bercakap tentang "meratakan" panggilan tak segerak

• Dari neraka ke syurga, Panggilan balik Nod bertukar kepada tak segerak/menunggu

• Fahami async/menunggu JavaScript

Answer 2

Ia adalah perkara biasa untuk menyarangkan fungsi panggil balik apabila tidak segerak, dalam bentuk:

// 先读取 a
fs.readFile('a.txt', (a) => {
  // a 读取成功后读取 b
  fs.readFile('b.txt', (b) => {
    // b 读取成功后读取 c
    fs.readFile('c.txt'. (c) => {
      console.log(a + b + c)
    })
  })
})

Pada masa ini, sarang panggil balik muncul, yang perlu bersarang lapisan demi lapisan, yang sangat mudah ralat dan sukar untuk dikekalkan.

Menulis secara tak segerak dalam mod segerak adalah serupa dengan:

function * asyncWrapper () {
  const a = yield read('a.txt')
  const b = yield read('b.txt')
  const c = yield read('c.txt')
  console.log(a + b + c)
}
// 使用形如 co 的库自动执行异步逻辑
co(asyncWrapper)

Pada masa ini, logik perniagaan tak segerak dilaksanakan melalui penyegerakan biasa.

Answer 3

Menulis secara tak segerak dengan cara segerak merujuk kepada bentuk organisasi kod. Anda boleh menggunakan async/menunggu untuk menulis secara tidak segerak dengan cara segerak, lihat kod berikut:

const testAsync = async () => {
  const t = await f();
  console.log(t);
};

testAsync();

f是一个异步操作，如果不使用async/await,直接同步的方式打印t,结果肯定是undefined; Selepas menggunakan async/menunggu, kod masih kelihatan segerak, tetapi di dalamnya melaksanakan operasi tak segerak f dahulu, dan kemudian mencetak t

Answer 4

Dua jawapan di atas sudah memadai