Analisis penggunaan Promise dalam kemahiran NodeJS_javascript

Ciri-ciri Javascript tidak segerak jika anda melaksanakan sesuatu yang perlu menunggu, anda tidak boleh berhenti di situ dan menunggu hasilnya kembali, sebaliknya, gunakan panggilan balik tentukan fungsi, dan fungsi ini hanya boleh menunggu sehingga Ia hanya boleh dipanggil apabila keputusan tersedia.

Model panggilan balik ini bukan masalah untuk organisasi kod yang baik, tetapi banyak masalah juga boleh diselesaikan dengan menukar daripada panggilan balik asal kepada janji Anggap janji sebagai bekas data standard, yang akan memudahkan organisasi kod anda seni bina.

Apa itu Janji?

Janji ialah objek dengan kaedah ".then()" Ia mewakili bahawa hasil operasi mungkin belum tersedia atau diketahui Tidak kira siapa yang mengakses objek ini, mereka boleh menggunakan ".then(). ". Tambah panggilan balik untuk menunggu pemberitahuan peringatan apabila operasi berjaya atau gagal.

Jadi mengapa ini lebih baik daripada panggil balik? Mod panggil balik standard memerlukan fungsi panggil balik apabila kami memproses permintaan:

request(url, function(error, response) { 

 // handle success or error.

});

doSomethingElse(); 

Malangnya, kod ini bermakna fungsi permintaan tidak tahu bila ia akan dilengkapkan, sudah tentu, ia tidak perlu, dan kami akhirnya menghantar hasilnya melalui panggilan balik. Ini mengakibatkan berbilang panggilan balik membentuk panggilan balik bersarang atau perangkap panggil balik.

queryTheDatabase(query, function(error, result) { 

 request(url, function(error, response) {

  doSomethingElse(response, function(error, result) {

   doAnotherThing(result, function(error, result) {

    request(anotherUrl, function(error, response) {

     ...

    });

   });

  });

 });

});

Promise boleh menyelesaikan masalah ini, membenarkan kod peringkat rendah membuat permintaan dan kemudian mengembalikan objek, yang mewakili operasi yang belum selesai, membolehkan pemanggil memutuskan panggilan balik yang perlu ditambah.

Apa itu Janji?

Promise ialah abstraksi pengaturcaraan tak segerak Ia adalah objek proksi yang mengembalikan nilai atau melemparkan pengecualian Secara amnya, objek janji mempunyai kaedah kemudian ini adalah bagaimana kita mendapatkan nilai pulangan kejayaan pelaksanaan janji, Dipanggil pemenuhan) atau melontarkan pengecualian (sebab menolak janji, dipanggil penolakan), kemudian menggunakan dua panggilan balik pilihan sebagai parameter, yang boleh kita panggil padaFulfilled dan OnRejected:

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)

Apabila janji ini diselesaikan, iaitu selepas proses tak segerak selesai, sama ada onFulfilled atau OnRejected akan dipanggil,

Oleh itu, janji mempunyai tiga keadaan berbeza berikut:

■janji tertunda - janji keadaan awal
■janji ditepati - status janji berjaya ditunaikan
■ditolak - keadaan di mana janji gagal

Mengambil membaca fail sebagai contoh, berikut ialah perkara yang perlu dilakukan selepas menggunakan panggilan balik untuk melaksanakan pembacaan fail (pencetakan output):

readFile(function (err, data) {

 if (err) return console.error(err)

 console.log(data)

})

Jika fungsi readFile kami mengembalikan janji, maka kami boleh melaksanakan logik yang sama (pencetakan output) seperti berikut:

var promise = readFile()
promise.then(console.log, console.error)

Di sini kami mempunyai janji nilai yang mewakili operasi tak segerak Kami sentiasa boleh meluluskan janji nilai ini Sesiapa sahaja yang mengakses nilai ini boleh menggunakannya, tidak kira sama ada operasi tak segerak yang diwakili oleh nilai ini telah selesai atau tidak. , kami juga boleh menjamin bahawa hasil tak segerak tidak akan berubah, kerana operasi tak segerak yang diwakili oleh janji ini hanya akan dilaksanakan sekali dan statusnya sama ada dipenuhi atau ditolak.

Memahami Janji

Janji mungkin berbeza daripada intuisi harian untuk memahaminya, beberapa prinsip penting mesti diingat: .then() sentiasa mengembalikan janji baru., seperti kod berikut:

var promise = readFile()
var promise2 = promise.then(readAnotherFile, console.error)

Parameter readAnotherFile dan console.error kemudian di sini mewakili tindakan onFulfilled selepas operasi tak segerak berjaya atau tindakan OnRejected selepas kegagalan Maksudnya, fungsi readAnotherFile dilaksanakan selepas fail berjaya dibaca, jika tidak, ralat. dicetak dan direkodkan apabila gagal. Pelaksanaan ini hanya satu daripada dua yang mungkin.

Mari kita lihat kod di atas seperti berikut:

var promise = readFile()

var promise2 = promise.then(function (data) {

 return readAnotherFile() // 如果readFile成功，执行readAnotherFile

}, function (err) {

 console.error(err) // 如果readFile不成功，记录，但是还是执行readAnotherFile

 return readAnotherFile()

})

promise2.then(console.log, console.error) // readAnotherFile函数的执行结果

Kerana kemudian mengembalikan janji, bermakna janji itu boleh dibelanjakan oleh rantai bersiri, yang boleh mengelakkan panggilan balik neraka:

readFile()

 .then(readAnotherFile)

 .then(doSomethingElse)

 .then(...)

Promise法则有两部分必须分离：

（1）.then()总是返回一个新的promise，每次你调用它，它不管回调做什么，因为.then()在回调被调用之前已经给了你一个承诺promise，回调的行为只影响承诺promise的实施，如果回调返回一个值，那么promise将使用那个值，如果这个值是一个promise，返回这个promise实施后的值给这个值，如果回调抛出错误，promise将拒绝错误。

（2）被.then()返回的promise是一个新的promise，它不同于那些.then()被调用的promise，promise长长的链条有时会好些隐藏这个事实，不管如何，每次.then()调用都会产生一个新的promise，这里必须注意的是你真正需要考虑的是你最后调用.then()可能代表失败，那么如果你不捕获这种失败，那么容易导致你的错误exception消失。

一些人认为.then()串联链条调用很类似fluent风格，但是长长的promise链条会让人迷惑，最后切分为一个个有意义的函数：

function getTasks() { 

 return $http.get('http://example.com/api/v1/tasks')

  .then(function(response) {

   return response.data;

  });

}

 

function getMyTasks() { 

 return getTasks()

  .then(function(tasks) {

   return filterTasks(tasks, {

    owner: user.username

   });

  });

}

在这个例子中，两个函数各自获得一个promise，携带了一个回调函数。

有趣的Promise

同样的promise能够接受任何数目的回调，当一个Promise被解决实施后，其中所有回调函数都会被调用，此外，一个promise在被解决实施后，甚至可以接受一个新的回调，这些回调完成能以正常方式被调用，这就允许我们使用回调实现简单形式的缓存：

var tasksPromise; 

function getTasks() { 

 taskPromise = taskPromise || getTasksFromTheServer();

 return taskPromise;

}

这个案例中，getTasks()函数可以被任意次数调用，它总是返回铜牙的promise，其中函数getTasksFromTheServer()却只是被调用一次。

以上这篇NodeJS的Promise的用法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。