JavaScript menjanjikan tutorial dengan contoh

Walaupun sebelum ini boleh didapati melalui perpustakaan pihak ketiga, janji diperkenalkan di JavaScript, sebagai orang asli
ciri, dengan ecmascript6.

Mereka memberikan alternatif kepada panggilan balik ketika berurusan dengan kod tak segerak, menyediakan,
Antara perkara lain, cara yang lebih bersih untuk mengendalikan kesilapan. Dalam tutorial ini kita akan melihat bagaimana janji berfungsi, bagaimana untuk
buat mereka dan cara menggunakan kaedah mereka.

Dalam tutorial ini anda akan belajar:

• Apakah janji JavaScript.
• Cara membuat janji javascript.
• Bagaimana janji dapat digunakan untuk menguruskan kod tak segerak.
• Apakah kaedah yang boleh digunakan dengan janji.

Keperluan perisian dan konvensyen yang digunakan

Apa itu "janji"?

Di JavaScript, a janji adalah objek yang dikembalikan sebagai hasil dari
Operasi yang tidak segerak, tidak menyekat, seperti itu, misalnya, yang dilakukan oleh ambil
fungsi terbina. Janji diperkenalkan sebagai ciri asli, dengan Ecmascript6: mereka mewakili a
Alternatif yang bersih untuk panggilan balik, terima kasih kepada ciri -ciri seperti kaedah yang berantai dan hakikat bahawa mereka menyediakan
cara untuk menguruskan kesilapan yang menyerupai pengendalian pengecualian dalam kod segerak. Terdapat tiga negeri yang dijanjikan
boleh masuk:

• Yang belum selesai
• Diselesaikan
• Ditolak

Seperti namanya, kita mengatakan bahawa janji adalah yang belum selesai Apabila hasilnya belum diputuskan,
Jadi masih dapat diselesaikan atau ditolak. Kami mengatakan bahawa janji adalah dipenuhi Apabila asynchronous
Operasi telah berjaya: Janji telah diselesaikan, dan ia mengandungi hasil operasi itu sendiri.
Akhirnya, janji dikatakan ditolak Apabila operasi tak segerak gagal: dalam hal ini
janji akan mengandungi alasan kegagalan.

Membuat janji JavaScript

Seperti yang disebutkan di atas, beberapa fungsi yang melaksanakan operasi tak segerak, seperti ambil, kembali
janji secara lalai, jadi kita boleh menggunakan kaedah dan corak yang akan kita terangkan kemudian dalam tutorial ini keluar dari kotak. Fungsi lain
belum menyokong janji, jadi kami mungkin mahu membuat janji di sekeliling mereka. Pembina janji mengambil satu hujah,
yang merupakan fungsi panggil balik yang sendiri, mengambil dua hujah: menyelesaikan dan menolak panggilan balik, yang
dipanggil untuk menyelesaikan atau menolak janji. Mari lihat contoh cepat tentang cara membuat janji yang remeh:

Const Promise = Janji Baru (Fungsi (menyelesaikan, menolak) setTimeout (menyelesaikan, 100, 'Kejayaan!'); ); 

Dengan kod di atas, kami mencipta janji, yang sebenarnya akan dapat diselesaikan, kerana dengan menggunakan
setTimeout fungsi, kami memanggil menyelesaikan Panggilan balik selepas tamat tempoh 100 milisaat,
Melewati rentetan "Kejayaan!"Sebagai hujah tunggal panggilan balik. Dengan cara yang sama, jika kita mahukan janji
untuk ditolak, kita sepatutnya memohon menolak Panggilan balik. Jelas janji seperti
Satu di atas tidak begitu berguna kepada kami, jadi kami sekarang akan mencipta janji di sekitar fungsi yang benar -benar berguna.

The ReadFile kaedah fs modul, secara asynchronously membaca kandungan fail, dan
Mengambil tiga hujah: dua daripadanya adalah wajib, dan satu adalah pilihan. Hujah pertama adalah jalan fail
untuk dibaca. Hujah kedua adalah pilihan, dan dengan itu, kita boleh, sebagai contoh, menentukan
pengekodan untuk digunakan. Hujah ketiga adalah fungsi panggil balik, yang sendiri mengambil dua argumen:
err dan data.

Sekiranya operasi bacaan gagal, hujah pertama akan mengandungi Ralat
objek dan yang kedua tidak akan ditentukan; Sekiranya operasi berjaya, sebaliknya, hujah kedua akan menjadi
rentetan yang mewakili kandungan fail, atau penampan mentah jika tiada pengekodan ditentukan, sementara hujah pertama akan
menjadi batal. Katakan contohnya saya mahu membaca saya .vimrc fail menggunakan fungsi ini:

const fs = memerlukan ('fs'); fs.ReadFile ('.vimrc ',' utf-8 ', fungsi (err, data) if (err) lempar err konsol.log (data)); 

Pertama sekali kita memerlukan fs modul dan diberikannya ke fs malar, daripada
Kami meneruskan dengan menggunakan ReadFile kaedah. Dalam panggilan balik yang diterima sebagai hujah terakhir fungsi, kami melaksanakan
Operasi yang diperlukan bergantung pada hasil yang diperoleh. Dalam kod di atas kita lemparkan Pengecualian Sekiranya berlaku ralat
Semasa cuba membaca fail, sementara kami hanya mencetak kandungan fail jika semuanya berjalan seperti yang diharapkan. Dalam kes ini ini akan berlaku
Hasil (dipotong):

[...] tetapkan fileFormat = unix set textWidth = 79 set noswapFile set foldMethod = indent set foldleVel = 99 set splitright set splitbelow set hlsearch set incsearch set ignorecase set smartcase [...] 

Kaedah yang hanya kita gunakan, ReadFile, melakukan operasi baca secara tidak segerak, jadi ia tidak menyekat. Secara lalai, tidak,
Walau bagaimanapun, janji sokongan. Jika kita mahu "mempromosikan" penggunaan kaedah ini, kita harus membuat janji di sekelilingnya dengan diri kita sendiri:

const fs = memerlukan ('fs'); fungsi ReadFilePromise (filePath) kembali janji baru (fungsi (menyelesaikan, menolak) fs.readFile (filePath, 'utf-8', fungsi (err, data) if (err) reject (err); else resolve (data);); );  

Lihat kod di atas, apa yang telah kita ubah? Kami mencipta ReadFilePromise Fungsi: di dalamnya
janji berdasarkan hasil dari fs.ReadFile kaedah dibuat dan dikembalikan. Dalam contoh sebelumnya,
Kami menyesuaikan kod untuk membuang pengecualian jika ralat dalam operasi bacaan hadir: dalam kes ini, sebaliknya, kerana kami
sedang membina janji, jika ralat berlaku, kita panggil menolak panggilan balik, melepaskan kesilapan sebagai hujah tunggalnya,
Dengan cara ini menolak janji. Sekiranya operasi bacaan berjaya dilakukan, sebaliknya, kami panggil menyelesaikan, lulus
Data yang terhasil daripada operasi bacaan sebagai hujah, dengan itu memenuhi janji. Dalam perenggan seterusnya kita akan melihat bagaimana
untuk benar -benar memakan janji yang baru saja kita buat.

Kaedah Janji

Objek janji tidak akan berguna jika kita tidak mempunyai cara untuk berinteraksi dengannya dan memakannya. Dalam bahagian ini kita akan
terangkan kaedah yang boleh kita gunakan pada objek janji. Setiap kaedah ini berfungsi dengan janji, dan seterusnya, mengembalikan janji
sendiri, membolehkan kita membuat "timbunan" dan melaksanakan kaedah Chaining.

The kemudian kaedah

The kemudian kaedah mengambil dua hujah, yang sebenarnya dua panggilan balik akan dilaksanakan masing -masing apabila janji
dipenuhi dan apabila ditolak, dan mengembalikan janji. Melekat dengan contoh di atas, inilah cara kita boleh menggunakan kaedah ini
untuk berinteraksi dengan janji kembali apabila kita memanggil ReadFilePromise fungsi:

ReadFilePromise ('.vimrc ').Kemudian (fungsi onResolVeCallback (data) konsol.log (data); , fungsi onRectCallback (alasan) konsol.log ('Mesej ralat ialah $ sebab'); ) 

Apabila janji keluar yang belum selesai nyatakan, dan dengan itu ia diselesaikan atau ditolak, kemudian kaedahnya
dilaksanakan. Sekiranya janji itu diselesaikan, panggilan balik pertama (dalam hal ini kami menamakan panggil balik hanya untuk memudahkan untuk memahami peranan mereka)
dilaksanakan, hujahnya memegang hasil operasi tak segerak (dalam hal ini kandungan ".fail vimrc "sebagai rentetan).
Sekiranya janji itu ditolak, sebaliknya, panggilan balik kedua (kami menamakannya onRectCallback) akan dilaksanakan: hujahnya akan mengandungi ralat
yang menyebabkan operasi membaca gagal.

The menangkap kaedah

Tidak seperti kemudian, yang mengendalikan kedua -dua janji diselesaikan dan ditolak, menangkap Kaedah lebih spesifik,
dan hanya berurusan dengan kes yang terakhir. Menggunakan kaedah ini adalah bersamaan dengan menggunakan kemudian dengan tidak ditentukan sebagai
Hujah pertama, bukannya panggil balik yang digunakan untuk mengendalikan kes apabila janji itu dipenuhi, dan dengan panggilan balik yang sah untuk mengendalikan
kes apabila janji ditolak, sebagai yang kedua. Kaedah ini mengembalikan janji, dan dengan menggunakannya, kita boleh menulis semula kod di atas dengan cara ini:

ReadFilePromise ('.vimrc ') // di dalam' maka 'kami menguruskan kes itu apabila janji itu dipenuhi, berurusan // dengan kemungkinan kesilapan di dalam' menangkap ' .kemudian (fungsi (data) konsol.log (data); ) .menangkap (fungsi (alasan) konsol.log ('Mesej ralat ialah $ sebab'); ) 

Perhatikan bagaimana kita melampirkan menangkap kaedah selepas kemudian: ini mungkin
Kerana, seperti yang kita katakan di atas, setiap kaedah mengembalikan janji itu sendiri, dan oleh itu mereka dapat dirantai.

The Akhirnya kaedah

Seperti kaedah yang kita lihat di atas, Akhirnya mengembalikan janji. Ia selalu dilaksanakan tanpa mengira keadaan janji,
kedua -duanya jika diselesaikan atau ditolak. Atas sebab ini, panggilan balik tidak mengambil hujah, kerana ketika ia berjalan tidak ada cara untuk menentukan
Sekiranya janji telah ditolak atau diselesaikan. Kami menggunakan kaedah ini apabila kami ingin menjalankan kod generik yang harus dijalankan dalam sebarang kes.

ReadFilePromise ('.vimrc ') .kemudian (fungsi (data) konsol.log (data); ) .menangkap (fungsi (alasan) konsol.log ('Mesej ralat ialah $ sebab'); ) .Akhirnya (fungsi () konsol.log ("Saya selalu dilaksanakan!");) 

Dalam contoh di atas, sama ada janji itu diselesaikan atau ditolak, rentetan "Saya selalu dilaksanakan!"Ia dicetak di konsol.

The perlumbaan kaedah

Kaedah ini mengambil satu contohnya (array misalnya) sebagai hujahnya. Ia mengembalikan janji yang diselesaikan atau ditolak sebaik sahaja
janji yang terkandung dalam keadaan itu, wujud keadaan yang belum selesai, dan menjadi ditolak atau diselesaikan. Janji yang dikembalikan, akan mempunyai
nilai pemenuhan atau alasan penolakan janji tersebut.

const p1 = janji baru (fungsi (menyelesaikan, menolak) setTimeout (menyelesaikan, 100, 'diselesaikan!'); ); const p2 = janji baru (fungsi (menyelesaikan, menolak) setTimeout (menolak, 50, 'ditolak!'); ); Janji.Perlumbaan ([P1, P2]) .kemudian (fungsi (data) konsol.log (data); ) .menangkap (fungsi (alasan) konsol.log (sebab); ) 

Dalam contoh ini kita mencipta dua janji baru: yang pertama, p1, akan diselesaikan selepas 100 milisaat;
yang kedua, p2, akan ditolak selepas 50 milisaat. Kami melewati satu janji yang mengandungi kedua -dua janji sebagai
hujah tunggal mengenai Janji.perlumbaan kaedah. Jika kita menjalankan kod di atas, kami memperoleh hasil berikut:

ditolak!

Apa yang berlaku? Seperti yang dijangkakan p2 Janji adalah yang pertama untuk menyelesaikannya (ditolak), akibatnya janji
dikembalikan oleh Janji.perlumbaan kaedah, menolak dengan alasan yang sama. Seperti yang anda lihat, keadaan janji tidak relevan:
yang pertama yang sebenarnya mendapat status selain yang belum selesai adalah yang penting.

The semua kaedah

Seperti perlumbaan, The semua Kaedah mengambilnya sebagai hujah tunggalnya. Ia mengembalikan janji yang
akan menyelesaikan sebaik sahaja semua janji yang terkandung di dalamnya akan menyelesaikannya (atau ketika itu tidak mengandungi janji) atau kehendak
menolak dengan alasan janji pertama dalam perkara yang akan ditolak. Sebagai contoh:

const p1 = janji baru (fungsi (menyelesaikan, menolak) setTimeout (menyelesaikan, 100, 'P1 diselesaikan!'); ) const p2 = janji baru (fungsi (menyelesaikan, menolak) setTimeout (menyelesaikan, 100, 'P2 diselesaikan!'); ) Janji.Semua ([P1, P2]) .kemudian (fungsi (nilai) konsol.log (nilai); ) 

Kod di atas akan kembali:

['P1 diselesaikan!',' P2 diselesaikan!']

Semua janji yang terkandung dalam yang dapat diselesaikan, jadi janji yang belum selesai yang dikembalikan oleh semua kaedah
diselesaikan juga, nilainya menjadi array yang mengandungi nilai semua janji yang diselesaikan. Sekiranya satu (dan sebaik sahaja) salah satu janji
Dalam penolakan itu, janji yang dikembalikan oleh kaedah menolak juga, dengan alasan yang sama. Sekiranya ia dapat diluluskan sebagai hujah
kosong, janji yang telah diselesaikan akan dikembalikan. Sekiranya ia tidak mengandungi janji, kaedah itu akan dikembalikan
janji yang tidak diselesaikan secara tidak segerak atau yang telah dijanjikan yang telah diselesaikan bergantung kepada alam sekitar.

The menyelesaikan dan menolak kaedah

Kedua -dua kaedah ini adalah penjelasan diri.

The menyelesaikan kaedah mengambil hujah yang merupakan nilai yang dapat diselesaikan oleh janji.
Ia mengembalikan janji yang diselesaikan dengan nilai itu. The menolak kaedah, sama, mengambil hujah yang menjadi alasan dengan
Janji harus ditolak, dan mengembalikan janji yang ditolak dengan alasan yang diberikan. Sebagai contoh:

// menyelesaikan janji janji.menyelesaikan ('nilai yang diselesaikan'); // menolak janji janji.menolak ('alasan untuk menolak'); 

Kesimpulan

Dalam tutorial ini, kami belajar mengetahui dan menggunakan janji dalam JavaScript. Kita melihat bagaimana kita dapat membina janji kita sendiri, apakah kaedah yang berkaitan
dengan janji, dan bagaimana kita boleh menggunakannya untuk menguruskan kod tak segerak, sebagai alternatif yang lebih bersih untuk panggilan balik. Sumber yang sah untuk meningkatkan lagi
Pengetahuan anda mengenai janji itu yang disediakan oleh Mozilla.
Dalam tutorial JavaScript seterusnya kita akan belajar cara menggunakan Fungsi anak panah. Nantikan Linuxconfig.org!

Tutorial Linux Berkaitan:

• Cara Membina Aplikasi TKInter Menggunakan Objek Berorientasikan ..
• Tutorial Debugging GDB untuk Pemula
• Cara Bekerja Dengan API Rest WooCommerce dengan Python
• Ungkapan biasa python dengan contoh
• Advanced Bash Regex dengan contoh
• Menguasai Gelung Skrip Bash
• Gelung bersarang dalam skrip bash
• Cara Menyiapkan Pelayan OpenVPN di Ubuntu 20.04
• Pasang Arch Linux di Workstation VMware
• Gelung bash dengan contoh