Ayat bacaan teras javascript_kemahiran javascript-tutorial js-php.cn

Dalam JavaScript, ungkapan ialah frasa dan pernyataan ialah keseluruhan ayat atau perintah. Sama seperti penyataan bahasa Inggeris berakhir dengan noktah, JavaScript berakhir dengan koma bertitik.

Ungkapan menilai kepada nilai, tetapi pernyataan membuat sesuatu berlaku.

Satu cara untuk "membuat sesuatu berlaku" adalah dengan menilai ungkapan dengan kesan sampingan. Ungkapan dengan kesan sampingan, seperti tugasan dan panggilan fungsi, boleh dianggap sebagai pernyataan berasingan. Penggunaan ungkapan sebagai pernyataan ini juga dipanggil pernyataan ungkapan. Pernyataan yang serupa termasuk penyataan pengisytiharan, yang digunakan untuk mengisytiharkan pembolehubah baharu atau mentakrifkan fungsi baharu.

Atur cara JavaScript ialah koleksi penyataan boleh laku Secara lalai, penterjemah JavaScript melaksanakannya mengikut urutan. Satu lagi cara untuk "membuat sesuatu" berlaku ialah menukar susunan pelaksanaan lalai pernyataan:

1. Pernyataan bersyarat: Jurubahasa JavaScript boleh menilai berdasarkan nilai ungkapan sama ada untuk melaksanakan atau melangkau pernyataan ini, seperti jika dan menukar pernyataan.

2. Penyataan gelung: pernyataan yang boleh dilaksanakan berulang kali, seperti sementara dan untuk pernyataan

3. Pernyataan lompat: membenarkan jurubahasa melompat ke bahagian lain program untuk meneruskan pelaksanaan, seperti penyataan break, return dan throw

Artikel berikut akan memperkenalkan pelbagai pernyataan dan sintaksnya dalam JavaScript. Bab ini diakhiri dengan ringkasan pernyataan ini. Program javascript tidak lebih daripada koleksi pernyataan yang dipisahkan dengan pemisahan, jadi setelah anda menguasai pernyataan javascript, anda boleh menulis program javascript.

1. Penyataan ungkapan

Pernyataan tugasan ialah pernyataan ungkapan yang agak penting Fungsinya adalah untuk menukar nilai pembolehubah, sama seperti melaksanakan pernyataan tugasan: contohnya

Salin kod Kod adalah seperti berikut:

              salam = nama "hello";

             i *= 3;

Operator kenaikan ( ) dan operator pengurangan (--) adalah berkaitan dengan penyata tugasan. Tujuan mereka adalah untuk menukar nilai pembolehubah, sama seperti melaksanakan pernyataan tugasan.

Salin kod Kod adalah seperti berikut:

kaunter ;

Peranan penting operator

padam adalah untuk memadamkan atribut objek (atau elemen tatasusunan), jadi ia biasanya digunakan sebagai pernyataan dan bukannya sebagai sebahagian daripada ungkapan kompleks.

Salin kod Kod adalah seperti berikut:

padam o.x;

Panggilan fungsi ialah satu lagi kategori utama pernyataan ungkapan, seperti

Salin kod Kod adalah seperti berikut:

makluman(salam);

              window.close();

Walaupun fungsi bahagian pelanggan ini adalah ekspresi, ia mempunyai kesan tertentu pada pelayar web. Oleh itu, kami fikir juga pernyataan, tidak masuk akal untuk memanggil fungsi yang tidak mempunyai kesan sampingan melainkan ia adalah sebahagian daripada ungkapan kompleks atau pernyataan tugasan, sebagai contoh. Adalah mustahil untuk membuang nilai kosinus secara santai;

Math.cos(x);

Sebaliknya, untuk mendapatkan nilai kosinus, anda perlu menetapkannya kepada pembolehubah supaya nilai itu boleh digunakan pada masa hadapan:

var cx = Math.cos(x);

Ingatkan semua orang sekali lagi bahawa setiap baris kod berakhir dengan koma bertitik.

2. Penyataan majmuk dan pernyataan kosong

Anda boleh menggunakan pengendali koma untuk menggabungkan beberapa ungkapan bersama-sama untuk membentuk satu ungkapan. Begitu juga, JavaScript juga boleh menggabungkan berbilang pernyataan untuk membentuk pernyataan majmuk. Hanya sertakan berbilang pernyataan dalam pendakap kerinting. Oleh itu, baris kod berikut boleh dianggap sebagai satu pernyataan dan digunakan di mana-mana sahaja dalam JavaScript di mana pernyataan dikehendaki.

Salin kod Kod adalah seperti berikut:

{

                    x = Math.PI;

                     cx = Math.cos(x);

console.log("cos(π)=" cx);

            }

Terdapat beberapa perkara yang perlu diberi perhatian tentang blok pernyataan: Pertama, blok pernyataan tidak memerlukan koma bertitik. Pernyataan elemen dalam blok mesti berakhir dengan koma bertitik, tetapi blok pernyataan tidak.

Kedua, garisan dalam blok pernyataan adalah inden Ini tidak perlu, tetapi lekukan yang kemas boleh menjadikan kod lebih mudah dibaca dan lebih mudah difahami.

Ketiga, JavaScript tidak mempunyai skop peringkat blok dan pembolehubah yang diisytiharkan dalam blok pernyataan bukan peribadi kepada blok pernyataan. (Rujuk bahagian pertama Bab 3, Bahagian 10)

Amalan menggabungkan banyak pernyataan ke dalam blok pernyataan yang besar adalah sangat biasa dalam pengaturcaraan JavaScript. Ungkapan yang serupa selalunya mengandungi subungkapan, dan banyak JavaScript mengandungi pencawang lain Secara formal, JavaScript biasanya membenarkan blok pernyataan mengandungi satu pencawang. Contohnya: badan gelung gelung sementara boleh mengandungi hanya satu pernyataan. Menggunakan blok pernyataan, anda boleh meletakkan sebarang bilangan pernyataan ke dalam blok ini, dan blok pernyataan ini boleh digunakan sebagai satu pernyataan.

Dalam JavaScript, apabila anda mahu berbilang pernyataan digunakan sebagai satu pernyataan, gunakan pernyataan yang sepadan. Kenyataan kosong adalah sebaliknya, membenarkan 0 pernyataan. Kenyataan kosong kelihatan seperti ini:

;//Koma bertitik

Jurubahasa JavaScript jelas tidak melakukan apa-apa tindakan apabila melaksanakan pernyataan kosong, tetapi amalan telah membuktikan bahawa kenyataan kosong kadangkala berguna apabila mencipta gelung dengan badan gelung kosong, seperti berikut untuk gelung

Salin kod Kod adalah seperti berikut:

//Memulakan tatasusunan a

untuk (i = 0; i < a.length; a[i ] = 0);

Dalam gelung ini, semua operasi diselesaikan dalam ungkapan a[i]=0 dan tiada badan gelung diperlukan di sini. Walau bagaimanapun, JavaScript memerlukan badan gelung mengandungi sekurang-kurangnya satu pernyataan, jadi koma bertitik tunggal digunakan di sini untuk mewakili pernyataan kosong.

Perhatikan bahawa koma bernoktah dalam kurungan kanan gelung for, gelung while atau pernyataan jika sangat tidak mencolok, yang berkemungkinan menyebabkan beberapa pepijat maut dan pepijat ini sukar dikesan. Sebagai contoh, hasil pelaksanaan kod berikut mungkin merupakan kesan yang tidak dimaksudkan oleh pengarang:

Salin kod Kod adalah seperti berikut:

If((a==0)||(b==0)); //Barisan kod ini tidak melakukan apa-apa....

              o = null; //Barisan kod ini akan sentiasa dilaksanakan 

Jika anda menggunakan pernyataan kosong untuk tujuan khas, sebaiknya tambahkan ulasan dalam kod untuk menjelaskan dengan lebih jelas bahawa pernyataan kosong ini berguna

Salin kod Kod adalah seperti berikut:

untuk (i = 0; i < a.length; a[i ] = 0) /*kosong*/;

3. Pernyataan Pengisytiharan

Var dan fungsi ialah pernyataan pengisytiharan, yang mengisytiharkan atau mentakrifkan pembolehubah atau fungsi. Pernyataan ini mentakrifkan dan memberikan nilai kepada pengecam (nama pembolehubah dan fungsi) yang boleh digunakan di mana-mana dalam atur cara. Pernyataan pengisytiharan itu sendiri tidak melakukan apa-apa, tetapi ia mempunyai makna yang penting: dengan mencipta pembolehubah dan fungsi, semantik kod boleh disusun dengan lebih baik.

Beberapa bahagian seterusnya akan menerangkan penyataan var dan penyataan fungsi, tetapi ia tidak merangkumi semua kandungan pembolehubah dan fungsi.

i.var

Pernyataan

var digunakan untuk mengisytiharkan satu atau lebih pembolehubah Sintaksnya adalah seperti berikut:

nama var_1[ = nilai_1][, ..., nama_n[ = nilai_n]]

Kata kunci var diikuti dengan senarai pembolehubah yang akan diisytiharkan Setiap pembolehubah dalam senarai boleh mempunyai ungkapan permulaan, yang boleh digunakan untuk menentukan nilai awalnya. Contohnya:

Salin kod Kod adalah seperti berikut:

              var i; //Pembolehubah ringkas

                var j = 0; //Pembolehubah dengan nilai awal

               var p, q; //Dua pembolehubah 

               var greet = nama "hello"; // Ungkapan permulaan yang lebih kompleks 

               var x = 2.34,y = Math.cos(0.75),r, theta; //Banyak pembolehubah

               var x = 2,y = x * x; //Pembolehubah kedua menggunakan pembolehubah pertama 

          var x = 2,

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f = function(x) {return x * x}, //Setiap pembolehubah mempunyai barisnya sendiri

            y = f(x)

Jika pernyataan var muncul dalam badan fungsi, maka pembolehubah tempatan ditakrifkan dan skopnya ialah fungsi ini. Jika anda menggunakan pernyataan var dalam kod peringkat atas, ia mengisytiharkan pembolehubah global, yang boleh dilihat di seluruh JavaScript. Ia disebut dalam Bab 3, Bahagian 10: Pembolehubah global ialah atribut bagi objek global Tidak seperti atribut objek global yang lain, pembolehubah yang diisytiharkan dengan var tidak boleh dipadamkan melalui pemadaman.

Jika pembolehubah dalam pernyataan var tidak menyatakan ungkapan permulaan, maka nilai pembolehubah ini pada mulanya tidak ditentukan. Oleh itu, nilai pembolehubah sebelum pernyataan pengisytiharan tidak ditentukan.

Perlu diambil perhatian bahawa pernyataan var juga boleh digunakan sebagai komponen gelung for atau gelung for/in. (Sama seperti pengisytiharan pembolehubah yang diisytiharkan sebelum gelung, pembolehubah yang diisytiharkan di sini juga akan menjadi "lanjutan"), contohnya:

Salin kod Kod adalah seperti berikut:

untuk (var i = 0; i < 10; i ) console.log(i);

untuk (var i = 0, j = 10; i < 10; i , j--) console.log(i * j);

untuk (var i in o)console.log(i);

Perhatikan bahawa tidak penting jika anda mengisytiharkan pembolehubah yang sama beberapa kali.

ii.fungsi

Fungsi kata kunci digunakan untuk mengisytiharkan fungsi Kami telah mempelajari ungkapan fungsi (4.3 Definisi fungsi boleh ditulis dalam bentuk pernyataan. Contohnya: dua kaedah penulisan definisi dalam kod sampel di bawah:

Salin kod Kod adalah seperti berikut:

                var f = fungsi f(x) {return x 1;} //Tugaskan ungkapan kepada pembolehubah 

               fungsi f(x){return x 1;} //Pernyataan yang mengandungi nama pembolehubah

Sintaks pengisytiharan fungsi adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

function funcname([arg1[, arg2[..., argn]]]) {

kenyataan

            }

funcname ialah pengecam nama bagi fungsi yang akan diisytiharkan. Mengikuti nama fungsi ialah senarai parameter, dipisahkan dengan koma. Apabila fungsi dipanggil, pengecam ini merujuk kepada parameter sebenar yang dihantar ke dalam fungsi.

Isi fungsi terdiri daripada pernyataan JavaScript Tiada had kepada bilangan pernyataan dan ia disertakan dalam pendakap kerinting. Apabila fungsi ditakrifkan, pernyataan dalam badan fungsi tidak dilaksanakan, tetapi dikaitkan dengan objek fungsi baharu yang akan dilaksanakan apabila fungsi dipanggil. Ambil perhatian bahawa pendakap kerinting dalam pernyataan fungsi diperlukan, yang berbeza daripada blok pernyataan yang digunakan oleh gelung while dan kunci pernyataan lain Walaupun badan fungsi hanya mempunyai satu pernyataan, pendakap kerinting masih diperlukan untuk melampirkannya.

Salin kod Kod adalah seperti berikut:

fungsi hyteus(x, y) {

                      kembalikan Math.sqrt(x * x y * y);

            }

hyteus(1, 2) //=>2.23606797749979

              fungsi muka(n) { //Fungsi rekursif

Jika (n <= 1) kembalikan 1;

Kembalikan n * muka(n - 1);

            }

muka(11) //=>39916800

Pengisytiharan fungsi biasanya muncul di bahagian atas kod JavaScript dan juga boleh disarangkan dalam badan fungsi lain. Tetapi apabila bersarang, pengisytiharan fungsi hanya boleh muncul di bahagian atas fungsi bersarang. Maksudnya: definisi fungsi tidak boleh muncul dalam if, while, atau pernyataan lain.

Seperti pernyataan var, pembolehubah yang dicipta oleh pernyataan pengisytiharan fungsi tidak boleh dipadamkan. Tetapi pembolehubah ini bukan baca sahaja dan nilai pembolehubah boleh ditimpa.

4. Pernyataan bersyarat

Pernyataan bersyarat digunakan untuk melaksanakan atau melangkau pernyataan tertentu dengan menilai sama ada nilai ungkapan yang ditentukan itu. Pernyataan ini ialah "titik keputusan" kod, kadangkala dipanggil "cawangan." Jika penterjemah javascript dilaksanakan mengikut "laluan" kod. Kenyataan bersyarat adalah persimpangan jalan. Program mencapai tahap ini dan mesti memilih laluan untuk meneruskan pelaksanaan.

i.jika pernyataan

Pernyataan

if ialah pernyataan kawalan asas Untuk tepat, ia membenarkan program untuk melaksanakan secara bersyarat. Pernyataan ini mempunyai dua bentuk: yang pertama ialah

Salin kod Kod adalah seperti berikut:

Jika (ungkapan)

kenyataan

Dalam borang ini, nilai ungkapan dinilai Jika ia benar, pernyataan itu dilaksanakan Jika ia salah, pernyataan itu tidak dilaksanakan

Salin kod Kod adalah seperti berikut:

Jika (nama pengguna == null) //Jika nama pengguna adalah batal atau tidak ditentukan

                    nama pengguna = "jack wong";

Perlu diambil perhatian bahawa kurungan yang mengelilingi ungkapan dalam pernyataan if adalah perlu.

Sintaks Javascript menetapkan bahawa kata kunci if dan ungkapan dengan kurungan mesti diikuti dengan pernyataan. Walau bagaimanapun, anda boleh menggunakan blok pernyataan untuk menggabungkan berbilang pernyataan menjadi satu. Oleh itu, pernyataan if kelihatan seperti ini:

Salin kod Kod adalah seperti berikut:

jika (!alamat) {

                 alamat = "";

                   message = "sila alamat surat menyurat"

            }

Bentuk kedua pernyataan if memperkenalkan klausa else Apabila nilai ungkapan palsu, logik else dilaksanakan

Salin kod Kod adalah seperti berikut:

Jika (ungkapan)

               pernyataan1

           lain

                pernyataan2

Contohnya, kod berikut

Salin kod Kod adalah seperti berikut:

                  jika (n == 1)

console.log("1 mesej baharu");

           lain

console.log("anda ada" n "mesej baharu");

Apabila meletakkan pernyataan if dalam pernyataan if/else, berhati-hati mesti diambil untuk memastikan pernyataan else sepadan dengan pernyataan if yang betul. Pertimbangkan kod berikut:

Salin kod Kod adalah seperti berikut:

             i = j = 1;

              k = 2;

                 jika (i == j)

Jika (j == k)

console.log("i equs k");

           lain

                  console.log("saya tidak sama dengan j"); !

Dalam contoh ini, pernyataan if dalam membentuk klausa yang diperlukan oleh pernyataan if luar. Walau bagaimanapun, hubungan padanan antara if dan else tidak jelas (hanya lekukan memberikan petunjuk) dan dalam kes ini, lekukan memberikan petunjuk yang salah, kerana ini adalah cara penterjemah JavaScript memahaminya.

Salin kod Kod adalah seperti berikut:

Jika (i == j) {

Jika (j == k)

console.log("i equs k");

Lain 
console.log("saya tidak sama dengan j");

            }

Seperti kebanyakan bahasa pengaturcaraan, peraturan padanan if and else dalam JavaScript ialah yang lain sentiasa sepadan dengan pernyataan if yang terdekat Untuk menjadikan contoh lebih mudah dibaca, lebih mudah difahami dan lebih mudah diselenggara dan nyahpepijat, Curly braces harus digunakan

Salin kod Kod adalah seperti berikut:

Jika (i == j) {

Jika (j == k) {

console.log("i equs k");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .
console.log("saya tidak sama dengan j");

                }

            }

Ramai pengaturcara akan mempunyai tabiat melampirkan badan pernyataan if and else dalam pendakap kerinting (sama seperti dalam padanan pernyataan seperti gelung while Walaupun hanya terdapat satu pernyataan setiap cawangan, berbuat demikian boleh mengelakkan masalah tadi). Masalah kekaburan program.

ii.lain jika

Pernyataan if/else memilih salah satu daripada dua cabang dengan menilai hasil penilaian sesuatu ungkapan. Apakah yang perlu kita lakukan apabila terdapat banyak cawangan dalam kod? Satu penyelesaian ialah menggunakan pernyataan else if. else if bukan pernyataan javascript sebenar, ia hanyalah satu cara untuk menulis beberapa pernyataan if/else yang disambungkan bersama.

Salin kod Kod adalah seperti berikut:

                  jika (n == 1) {

//Laksanakan blok kod 1

               } lain jika (n == 2) {

//Laksanakan blok kod 2

                } lain jika (n == 3) {

//Laksanakan blok kod 3

              } lain {

//Syarat sebelumnya semuanya palsu, kemudian laksanakan blok kod 4

            }

Tiada apa-apa yang istimewa tentang kod ini Ia terdiri daripada berbilang pernyataan if, dan klausa lain bagi setiap pernyataan if mengandungi pernyataan if yang lain. Kod setara secara sintaksis boleh dilengkapkan menggunakan bentuk penyataan if bersarang, tetapi berbanding dengan ini, kod lain jika cara penulisan jelas lebih jelas dan lebih disukai.

iii.suis

Pernyataan if mencipta cawangan semasa pelaksanaan program, dan jika tidak boleh digunakan untuk memproses berbilang cawangan. Walau bagaimanapun, jika bukan penyelesaian terbaik apabila semua cawangan bergantung pada nilai ungkapan yang sama. Dalam kes ini, adalah membazir untuk menilai berulang kali ungkapan dalam berbilang pernyataan if.

Pernyataan suis sesuai untuk mengendalikan situasi ini. Suis kata kunci diikuti dengan ungkapan yang disertakan dalam kurungan. Ini diikuti dengan blok kod yang disertakan dalam pendakap kerinting.

Salin kod Kod adalah seperti berikut:

suis (ungkapan) {

kenyataan

            }

Walau bagaimanapun, sintaks lengkap pernyataan suis adalah lebih rumit daripada ini. Huruf diikuti dengan ungkapan dan huruf bertindih sangat serupa dengan teg, kecuali teg itu tidak mempunyai nama.

Ia hanya dikaitkan dengan ungkapan yang mengikutinya. Apabila pernyataan suis ini dilaksanakan, ia mula-mula mengira nilai ungkapan, dan kemudian menyemak sama ada ungkapan dalam klausa kes adalah sama dengan nilai ungkapan. (Persamaan di sini dibandingkan mengikut operator "==="), jika kes itu dipadankan, ia akan melaksanakan kod yang sepadan. Jika tiada kes sepadan ditemui, ia akan melaksanakan blok kod dalam teg "lalai:". Tanpa teg "lalai:", suis akan melangkau semua blok kod.

Pernyataan suis sangat mudah dikelirukan. Ia akan menjadi lebih jelas dengan contoh Pernyataan suis di bawah adalah bersamaan dengan pernyataan if/else tadi

Salin kod Kod adalah seperti berikut:

suis (n) {

                      kes 1: //Jika n ===1 mulakan dari sini 

//Laksanakan blok kod 1

rehat;

                kes 2:

//Laksanakan blok kod 2

rehat;

                kes 3:

//Laksanakan blok kod 3

rehat;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lalai:

//Laksanakan blok kod 4

rehat;

            }

Perlu diambil perhatian bahawa pemecahan kata kunci digunakan pada akhir setiap pernyataan kes. Kami akan memperkenalkan penyataan putus kemudian Pernyataan putus boleh menyebabkan jurubahasa melompat keluar dari penyataan suis atau penyataan gelung. Dalam suis, case hanya menentukan titik permulaan kod yang akan dilaksanakan, tetapi bukan titik akhir. Jika tiada penyataan putus, penyataan suis mula melaksanakan daripada kod pada label kes sepadan bagi nilai ungkapan, dan melaksanakan penyataan seterusnya mengikut urutan sehingga penghujung keseluruhan blok kod suis. Sudah tentu, jika anda menggunakan pernyataan suis dalam fungsi, anda boleh menggunakan return untuk menggantikan break kedua-dua return dan break digunakan untuk menamatkan pernyataan suis dan juga akan menghalang blok pernyataan kes seterusnya daripada terus dilaksanakan selepas satu pernyataan kes. dilaksanakan.

Pernyataan berikut hampir kepada amalan, ia menukar nilai kepada rentetan mengikut jenisnya.

Salin kod Kod adalah seperti berikut:

fungsi tukar(x) {

suis (jenis x) {

'nombor' kes: //Tukar nombor kepada perenambelasan

Kembalikan x.toString(16);

kes 'rentetan':

                          kembalikan '"' x '"'; //Kembalikan dua rentetan dengan petikan berganda. 

lalai: //Gunakan kaedah biasa untuk menukar jenis lain

Kembalikan Rentetan(x);

                }

            }

console.log(convert(100255114)) //=>5f9c58a

Perhatikan bahawa dalam dua contoh di atas, kata kunci huruf besar diikuti oleh nombor dan literal rentetan Dalam amalan, ini adalah penggunaan suis yang paling biasa, tetapi piawaian ECMAScript membenarkan setiap kata kunci diikuti oleh sebarang ungkapan.
Pernyataan suis mula-mula mengira ungkapan selepas kata kunci suis, dan kemudian mengira ungkapan selepas setiap kes mengikut tertib dari atas ke bawah sehingga nilai ungkapan kes adalah sama dengan nilai ungkapan suis. Memandangkan operasi pemadanan untuk setiap kes sebenarnya ialah perbandingan pengendali identiti "===" dan bukannya "==", tiada penukaran jenis dilakukan apabila memadankan ungkapan dan kes.

Setiap kali penyataan suis dilaksanakan, bukan semua ungkapan huruf besar boleh dilaksanakan oleh itu, ungkapan kes dengan kesan sampingan, seperti ungkapan panggilan fungsi dan ungkapan tugasan, harus dielakkan. Pendekatan paling selamat ialah menggunakan ungkapan malar dalam ungkapan kes.
Seperti yang dinyatakan sebelum ini, jika ungkapan suis tidak sepadan dengan mana-mana ungkapan kes, blok pernyataan yang ditandakan dengan "lalai:" akan dilaksanakan Jika tiada label "lalai:", keseluruhan pernyataan suis akan dilangkau. Dalam contoh sebelumnya, teg "lalai:" muncul di hujung suis, selepas semua teg kes Sudah tentu, ini adalah cara penulisan yang paling munasabah dan biasa digunakan. Malah, teg "lalai:" boleh diletakkan di mana-mana sahaja dalam pernyataan suis.

Untuk memahami pernyataan bersyarat, anda boleh menganggap kod dalam JavaScript sebagai laluan cawangan. Kenyataan gelung ialah gelung dalam laluan program yang membenarkan sebahagian daripada kod dilaksanakan berulang kali. Terdapat empat jenis pernyataan gelung dalam JavaScript: sambil, lakukan/sementara, untuk, untuk/dalam Bahagian berikut akan menerangkan semuanya sekaligus. Gelung yang paling biasa digunakan ialah traversal elemen tatasusunan (7.6 akan membincangkan gelung ini dan kaedah gelung khas yang ditakrifkan menggunakan kelas tatasusunan secara terperinci.)

i.sementara

Pernyataan if ialah pernyataan kawalan asas, digunakan untuk memilih pernyataan cawangan program pelaksanaan. Seperti jika, pernyataan while juga merupakan pernyataan gelung asasnya adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

          sambil (ungkapan)

kenyataan

Sebelum melaksanakan pernyataan sementara, jurubahasa JavaScript terlebih dahulu mengira nilai ungkapan Jika nilainya palsu, atur cara akan melangkau pernyataan logik dalam badan gelung dan melaksanakan pernyataan seterusnya dalam atur cara. Jika nilainya benar, logik dalam pernyataan dalam badan gelung dilaksanakan, dan kemudian nilai ungkapan dikira Gelung akan diteruskan sehingga nilai ungkapan adalah palsu. Dalam erti kata lain, apabila ungkapan itu benar, pernyataan itu dilaksanakan dalam gelung Ambil perhatian bahawa menggunakan while(true) akan mencipta gelung tak terhingga.

Secara umumnya, kami tidak mahu javascript melakukan operasi yang sama berulang kali. Dalam hampir setiap gelung, satu atau lebih pembolehubah diulang melalui gelung. Ia adalah tepat kerana pembolehubah ini diubah bahawa operasi pernyataan yang dilaksanakan setiap kali dalam gelung juga berbeza Selain itu, jika pembolehubah yang diubah digunakan dalam ungkapan, nilai ungkapan dalam setiap gelung juga akan berbeza. Ini sangat penting. Ungkapan yang bertanggungjawab untuk nilai awal menjadi benar akan sentiasa benar dan gelung tidak akan berakhir.

Salin kod Kod adalah seperti berikut:

      kiraan var = 0;

           manakala (kira < 10) {

console.log(count);

Kira ;

}

Anda boleh mendapati bahawa dalam contoh ini, nilai awal kiraan pembolehubah ialah 0. Semasa gelung, nilainya meningkat sebanyak 1 setiap kali apabila gelung dilaksanakan sepuluh kali. Nilai ungkapan diprogramkan kepada palsu, kemudian sementara akan berakhir, dan jurubahasa JavaScript akan melaksanakan pernyataan program seterusnya. Kebanyakan gelung mempunyai pembolehubah pembilang seperti kiraan. Walaupun nama pembolehubah seperti i j k biasanya digunakan untuk pembilang, jika anda ingin menjadikan kod lebih mudah dibaca, anda harus menggunakan nama sintaks yang lebih khusus.

ii.do/while

Gelung do/while sangat serupa dengan gelung while, kecuali gelung itu menguji ungkapan gelung pada penghujung gelung dan bukannya bahagian atas, yang bermaksud bahawa badan gelung dilaksanakan sekurang-kurangnya sekali. Sintaks gelung do/while adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

lakukan 

kenyataan 

             sambil(ungkapan);

Gelung do/while tidak seperti biasa digunakan seperti gelung while. Ini kerana dalam praktiknya, jarang sekali mahukan gelung dilaksanakan sekurang-kurangnya sekali. Di bawah ialah contoh gelung do/while

Salin kod Kod adalah seperti berikut:

              fungsi printArray(a) {
var len = a.panjang,
                      i = 0;
Jika (len == 0)
console.log("tatasusunan kosong");
Lain <<>                       lakukan {
console.log(a[i]);
                            } manakala ( i < len);

}

printArray([1,5,2,6])

Terdapat dua perbezaan sintaks antara gelung do/while dan gelung while biasa. Pertama sekali, gelung do memerlukan kata kunci do untuk menandakan permulaan gelung, dan pembolehubah while untuk menandakan penghujung gelung dan memasukkan pertimbangan keadaan gelung kedua, tidak seperti gelung while, gelung do berakhir dengan a koma bertitik. Jika badan gelung while dikurung dalam pendakap kerinting, gelung while tidak akan berakhir dengan koma bernoktah.

iii.untuk

Pernyataan for menyediakan struktur kawalan pernyataan gelung yang lebih mudah berbanding while. Pernyataan for membuat beberapa penyederhanaan corak gelung yang biasa digunakan. Kebanyakan gelung mempunyai pembolehubah pembilang tertentu. Mulakan pembolehubah ini sebelum gelung bermula, dan kemudian semak nilainya sebelum setiap gelung. Akhir sekali, pembolehubah pembilang ditambah, jika tidak, ia diubah suai selepas gelung berakhir dan sebelum penghakiman seterusnya. Dalam jenis gelung ini, tiga operasi utama pembilang ialah pemulaan, pengesanan dan kemas kini. Pernyataan for secara eksplisit mengisytiharkan ketiga-tiga operasi ini sebagai sebahagian daripada sintaks gelung, setiap satu menggunakan ungkapan untuk mewakilinya. Sintaks pernyataan for adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

untuk (memulakan; ujian; kenaikan)

kenyataan

Tiga ungkapan permulaan, ujian dan kenaikan dipisahkan oleh koma bertitik Ia bertanggungjawab untuk operasi pemula, pertimbangan keadaan gelung dan kemas kini pembolehubah balas. Meletakkannya pada baris pertama gelung menjadikannya lebih mudah untuk memahami perkara yang dilakukan oleh gelung for, dan juga menghalang anda daripada terlupa untuk memulakan atau menambah pembolehubah pembilang.

Cara paling mudah untuk menerangkan cara gelung for berfungsi ialah dengan menyenaraikan gelung while yang setara

Salin kod Kod adalah seperti berikut:

mulakan

              manakala (ujian) {

kenyataan

kenaikan;

            }

Dalam erti kata lain, ungkapan permulaan hanya dilaksanakan sekali sebelum gelung bermula. Ungkapan permulaan harus mempunyai kesan sampingan (biasanya pernyataan tugasan). JavaScript juga membenarkan ungkapan permulaan dengan pernyataan pengisytiharan pembolehubah var, supaya pembolehubah boleh diisytiharkan dan dimulakan. Ungkapan ujian akan dilaksanakan sebelum setiap gelung, dan hasil ungkapan akan dinilai untuk menentukan sama ada untuk melaksanakan badan gelung. Sebelum setiap gelung, ungkapan ujian akan dilaksanakan, dan keputusannya akan dinilai untuk melaksanakan badan gelung Jika keputusan ujian adalah benar, pernyataan dalam badan gelung akan dilaksanakan. Akhirnya, ungkapan kenaikan dilaksanakan. Juga untuk berguna, ungkapan kenaikan di sini juga mesti mempunyai kesan sampingan. Secara umumnya, ia sama ada ungkapan tugasan atau ungkapan yang terdiri daripada pengendali " " dan "--".

Gelung while di atas boleh ditulis menggunakan gelung for

Salin kod Kod adalah seperti berikut:

untuk (var count = 0; count < 10; count )

console.log(count)

Sudah tentu, sesetengah gelung lebih kompleks dan mempunyai berbilang pembolehubah yang diulangi sekali gus. Dalam JavaScript, situasi ini mesti menggunakan pengendali koma, yang menggabungkan ungkapan permulaan dan ungkapan kenaikan menjadi satu ungkapan untuk digunakan dalam gelung for.

Salin kod Kod adalah seperti berikut:

          var i, j;

untuk (i = 0, j = 10; i < 10; i , j--)

console.log(i * j);

Setakat ini, pembolehubah gelung dalam kod contoh semuanya ialah nombor. Nombor sudah tentu yang paling biasa digunakan, tetapi tidak diperlukan. Kod berikut menggunakan gelung for untuk melintasi hasil data jadual dan mengembalikan objek terakhir dalam senarai terpaut (iaitu, objek pertama yang tidak mengandungi atribut seterusnya)

Salin kod Kod adalah seperti berikut:

              fungsi ekor(o) { //Kembalikan objek nod terakhir senarai terpaut 

untuk (; o.next; o = o.next) /*kosong*/ //Melaksanakan traversal berdasarkan penilaian sama ada o.next ialah nilai sebenar

                      kembali o;

            }

Perlu diambil perhatian bahawa kod ini tidak mengandungi ungkapan permulaan Satu dan satu daripada tiga ungkapan dalam gelung for boleh diabaikan, tetapi dua koma bertitik adalah penting. Jika ungkapan ujian diabaikan, ia akan menjadi gelung tak terhingga. Sama seperti jenis while(ture), satu cara untuk menulis gelung tak terhingga adalah untuk(;;).

iiii.for/in

Pernyataan untuk/dalam menggunakan kata kunci untuk, tetapi ia adalah jenis gelung yang berbeza daripada gelung untuk biasa. Sintaks gelung for/in adalah seperti berikut

Salin kod Kod adalah seperti berikut:

untuk (pembolehubah dalam objek)

kenyataan

pembolehubah biasanya nama pembolehubah, atau ia boleh menjadi ungkapan yang boleh menghasilkan nilai l atau pembolehubah yang diisytiharkan melalui pernyataan var. Ringkasnya, ia ialah nilai yang digunakan pada sebelah kiri ungkapan tugasan. objek ialah ungkapan, dan hasil ungkapan ini ialah objek. Begitu juga, pernyataan ialah pernyataan atau blok pernyataan yang membentuk badan gelung.

Sangat mudah untuk mengulang elemen tatasusunan menggunakan gelung for

Salin kod Kod adalah seperti berikut:

          var a = [1, 3, 5, "44"];

untuk (var i = 0; i < a.length; i ) //i mewakili indeks elemen tatasusunan 

console.log(a[i]) //Output elemen setiap tatasusunan 

Gelung untuk/dalam digunakan untuk melintasi atribut ahli objek dengan mudah

Salin kod Kod adalah seperti berikut:

                 untuk (var p in o) //Tetapkan nama atribut kepada pembolehubah p

console.log(o[p]); //Keluarkan nilai setiap atribut

Semasa pelaksanaan pernyataan untuk/dalam, jurubahasa JavaScript terlebih dahulu menilai ungkapan objek. Jika ungkapan itu batal atau tidak ditentukan, jurubahasa JavaScript akan melangkau gelung dan melaksanakan kod berikutnya. Jika ungkapan itu sama dengan nilai primitif, nilai primitif ditukar kepada objek waxer yang sepadan (Bahagian 3.6). Jika tidak, ungkapan itu sendiri sudah menjadi objek. JavaScript akan menghitung sifat objek dalam urutan untuk melaksanakan gelung. Walau bagaimanapun, sebelum setiap gelung, JavaScript menilai ungkapan pembolehubah dan memberikan nama sifat (rentetan) kepadanya.

Perlu diambil perhatian bahawa selagi dalam gelung untuk/dalam, nilai varibale boleh digunakan sebagai lnilai ungkapan tugasan, dan ia boleh menjadi sebarang ungkapan. Ungkapan ini dinilai setiap kali melalui gelung, yang bermaksud ia mungkin menilai kepada nilai yang berbeza setiap kali melalui gelung. Sebagai contoh, anda boleh menggunakan kod berikut untuk menyalin semua sifat objek ke dalam tatasusunan:

Salin kod Kod adalah seperti berikut:

          var o = {x: 1,y: 2,z: 3};

          var a = [],i = 0;

untuk (a[i ] dalam o) /*kosong*/;

document.write(a)//=> x,y,z

Tatasusunan Javascript hanyalah sejenis objek khas, jadi untuk/dalam gelung boleh menghitung indeks data sama seperti sifat objek. Sebagai contoh, jika anda menambah kod ini selepas kod di atas, anda boleh menghitung indeks data 0,1,2:

Salin kod Kod adalah seperti berikut:

var o = {x: 1,y: 2,z: 3};
var a = [],i = 0;
untuk (a[i ] dalam o) /*kosong*/;
document.write(a)//=> untuk(i dalam a)
document.write(i) //=>Indeks data penghitungan 0 1 2

Sebenarnya, gelung for/in tidak akan merentasi semua sifat objek, hanya sifat "terhitung" akan dilalui (rujuk 6.7). Kerana kaedah terbina dalam yang ditakrifkan oleh teras bahasa JavaScript tidak "terhitung". Sebagai contoh, semua objek mempunyai toString(), tetapi gelung for/in tidak menghitung sifat toString(). Sebagai tambahan kepada kaedah terbina dalam, terdapat banyak sifat objek terbina dalam yang tidak dapat dikira (nonenumberable). Semua sifat dan kaedah yang ditakrifkan dalam kod boleh dikira (kita akan membincangkannya dalam Bahagian 6.7, tetapi terdapat cara khas dalam ECMAScript5 untuk menjadikan sifat tidak boleh dikira).

Objek boleh mewarisi sifat objek lain dan baris sifat tersuai yang diwarisi (6.2.ii) juga boleh dikira menggunakan untuk/dalam.

Jika badan gelung untuk/dalam memadamkan atribut yang belum dikira, maka atribut ini tidak akan dikira lagi. Jika badan gelung mentakrifkan sifat baharu objek, sifat ini biasanya tidak disenaraikan (namun, sesetengah pelaksanaan JavaScript boleh menghitung sifat yang ditambahkan dalam badan gelung).

Tertib penghitungan atribut

Spesifikasi ECMAScript tidak menyatakan susunan untuk/dalam gelung menghitung sifat objek. Tetapi sebenarnya, pelaksanaan JavaScript pengeluar penyemak imbas arus perdana menyenaraikan sifat-sifat objek mudah dalam susunan di mana ia ditakrifkan, dengan sifat yang ditakrifkan terlebih dahulu disenaraikan dahulu. Jika anda mencipta objek menggunakan bentuk literal objek, sifat dalam literal disenaraikan mengikut susunan ia muncul. (Sesetengah tapak web dan perpustakaan JavaScript bergantung pada susunan penghitungan ini dan kebanyakan pengeluar penyemak imbas tidak mengubah suai pesanan ini, dalam kes berikut, susunan penghitungan bergantung pada pelaksanaan khusus (bukan interaktif)
1. Objek mewarisi sifat terhitung
2. Objek mempunyai sifat
dengan indeks tatasusunan integer 3. Gunakan padam untuk memadam atribut sedia ada objek
4. Gunakan Object.defineProperty() atau kaedah serupa untuk menukar sifat objek

6. Lompat

Jenis pernyataan pertama dalam JavaScript ialah pernyataan lompat. Daripada pemahaman penyataan, ia boleh membuat pelaksanaan javascript melompat dari satu kedudukan ke kedudukan yang lain.

Pernyataan putus melompat ke penghujung gelung atau pernyataan lain. Pernyataan continue menamatkan pelaksanaan gelung ini dan memulakan pelaksanaan gelung seterusnya. Pernyataan dalam JavaScript boleh dinamakan atau dilabelkan, dan putus dan teruskan boleh mengenal pasti gelung sasaran atau label pernyataan lain.

Pernyataan pulangan membenarkan jurubahasa melompat keluar daripada pelaksanaan badan fungsi. Dan berikan nilai pulangan panggilan ini. Pernyataan lontaran mencetus atau melontar pengecualian Ia digunakan bersama dengan pernyataan cuba/tangkap/akhir, yang menentukan logik kod untuk mengendalikan pengecualian. Ini adalah pernyataan lompat yang kompleks Apabila pengecualian dilemparkan, atur cara akan melompat ke bintang pengecualian tertutup yang terdekat Program pengecualian ini boleh berada dalam fungsi yang sama atau dalam timbunan panggilan peringkat lebih tinggi.

Seterusnya, huraikan setiap jenis pernyataan lompat

i. Penyataan teg

Pernyataan boleh dilabelkan Label terdiri daripada pengecam dan titik bertindih sebelum pernyataan:

pengecam:pernyataan

Dengan mentakrifkan label untuk pernyataan, anda boleh merujuk pernyataan melalui nama label di mana-mana dalam program. Label boleh ditakrifkan untuk berbilang kenyataan, walaupun ia lebih berguna apabila mentakrifkan label untuk blok pernyataan, seperti gelung atau bersyarat. Dengan mentakrifkan nama label untuk gelung, anda boleh menggunakan putus dan teruskan di dalam badan gelung untuk keluar dari gelung atau mencabar terus permulaan gelung seterusnya. break dan continue adalah satu-satunya pernyataan dalam JavaScript yang boleh menggunakan label pernyataan (dibincangkan seterusnya dalam bab ini). Dalam contoh berikut, gelung while mentakrifkan label dan pernyataan continue menggunakan label ini:

Salin kod Kod adalah seperti berikut:

Mainloop: manakala (token != null) {

//Abaikan kod ini...

Teruskan mapoop; // lompat ke gelung seterusnya 

//Abaikan kod di sini...

            }

Pengecam yang digunakan sebagai teg di sini mestilah pengecam JavaScript yang sah, bukan perkataan yang dikhaskan. Ruang nama label adalah berbeza daripada ruang nama pembolehubah atau fungsi, jadi anda boleh menggunakan pengecam yang sama sebagai label pernyataan dan sebagai pembolehubah atau nama fungsi. Label pernyataan ditakrifkan hanya dalam pernyataan yang bertindak padanya (atau dalam klausanya, sudah tentu). Label pernyataan tidak boleh mempunyai nama yang sama dengan label pernyataan dalamannya, tetapi label pernyataan dengan nama yang sama boleh muncul apabila kedua-dua kod tidak bersarang antara satu sama lain. Kenyataan berlabel juga boleh dilabel, iaitu, sebarang pernyataan boleh mempunyai banyak label.

ii.pecah

Fungsi menggunakan pernyataan putus sahaja adalah untuk segera keluar dari pernyataan gelung atau suis dengan memori yang paling banyak. Sintaksnya adalah seperti berikut:

rehat;

Memandangkan ia boleh menyebabkan gelung dan penyataan suis keluar, bentuk pemecahan ini hanya sah dalam penyataan sedemikian.
Kami telah melihat penyataan putus dalam contoh penyataan suis. Dalam gelung, jika anda tidak mahu terus melaksanakan keseluruhan gelung atas apa jua sebab, anda boleh menggunakan rehat untuk keluar awal. Apabila keadaan penamatan gelung adalah sangat kompleks, adalah lebih mudah untuk menggunakan pernyataan putus dalam badan fungsi untuk melaksanakan pertimbangan bersyarat tersebut daripada menulis syarat penamatan kompleks secara terus dalam ungkapan gelung.

Dalam contoh berikut, gelung merentasi keseluruhan elemen tatasusunan untuk mencari nilai tertentu Apabila keseluruhan traversal tatasusunan selesai, gelung keluar seperti biasa Jika elemen tatasusunan ditemui, gunakan pernyataan putus untuk keluar gelung:

Salin kod Kod adalah seperti berikut:

untuk (var i = 0; i < a.length; i ) {

Jika (a[i] == sasaran) pecah;

}

JavaScript juga membenarkan kata kunci pemecahan diikuti oleh label pernyataan (hanya pengecam, tiada titik bertindih)

pecahkan nama label;

Apabila pemecahan digunakan bersama-sama dengan label, atur cara akan melompat ke penghujung blok pernyataan yang dikenal pasti oleh label, atau secara langsung menamatkan pelaksanaan blok pernyataan tertutup. Ralat sintaks berlaku apabila tiada blok pernyataan penutup menentukan label untuk rehat. Apabila menggunakan bentuk pernyataan putus ini, pernyataan berlabel tidak seharusnya berupa pernyataan gelung atau suis, kerana pernyataan putus boleh "melompat keluar" dari mana-mana blok pernyataan yang disertakan. Pernyataan di sini boleh menjadi sekumpulan pernyataan yang dikumpulkan oleh pendakap kerinting, menggunakan label yang sama untuk mengenal pasti kumpulan pernyataan.

Tidak boleh ada pemisah baris antara kata kunci pemisah dan nama label. Oleh kerana JavaScript boleh melengkapkan koma bernoktah yang ditinggalkan secara automatik untuk penyataan, jika terdapat baris baharu antara kata kunci pemecahan dan label, jurubahasa JavaScript akan berfikir bahawa anda menggunakan bentuk pemecahan termudah tanpa label, jadi ia akan menambah koma bertitik selepas pemecahan .
Apabila anda ingin keluar dari gelung bukan berdekatan atau pernyataan suis, anda akan menggunakan pernyataan putus berlabel. Berikut ialah kod sampel:

Salin kod Kod adalah seperti berikut:

          var matrix = getData(); //Dapatkan tatasusunan dua dimensi dari suatu tempat 

//Jumlah semua elemen dalam matriks

      var sum = 0,

              kejayaan = palsu;

//Mulakan dari tandatangan untuk melancarkan program apabila ralat dilaporkan. 

          jumlah_kompulasi: jika (matriks) {

untuk (var x = 0; x < matriks.panjang; x ) {

                  baris var = matriks[x];

Jika (!row) memecahkan compute_sum;

untuk (var y = 0; y < row.length; y ) {

                       sel var = baris [y];

Jika (isNaN(sel)) memecahkan jumlah_kira;

                     jumlah = sel;

                 }

                }

                     kejayaan = benar;

            }

//pernyataan break melompat di sini

//Jika kejayaan =keadaan palsu sampai di sini, bermakna terdapat ralat dalam matriks yang kami berikan 

//Jika tidak, jumlahkan semua elemen dalam matriks

Akhir sekali, perlu diambil perhatian bahawa tidak kira sama ada pernyataan putus dilabelkan atau tidak, kawalannya tidak boleh melepasi sempadan fungsi. Contohnya: Untuk pernyataan definisi fungsi dengan label, anda tidak boleh menggunakan label ini untuk melompat ke luar fungsi melalui bahagian dalam fungsi.

iii.teruskan kenyataan

Pernyataan continue sangat serupa dengan pernyataan putus, tetapi ia tidak keluar dari gelung, sebaliknya melaksanakan gelung seterusnya. Sintaks pernyataan continue adalah semudah sintaks pernyataan break

teruskan;

Pernyataan continue juga akan mempunyai tag

teruskan lebname;

Tidak kira sama ada pernyataan continue mempunyai label atau tidak, ia hanya boleh digunakan dalam badan gelung Jika digunakan di tempat lain, ralat sintaks akan dilaporkan.
Apabila pernyataan continue dilaksanakan, logik gelung semasa ditamatkan dan gelung seterusnya dilaksanakan serta-merta Dalam jenis gelung yang berbeza, gelagat continue juga berbeza
1. Dalam gelung while, menyatakan ungkapan pada permulaan gelung akan diuji berulang kali Jika keputusan ujian adalah benar, badan gelung akan dilaksanakan dari awal.
2. Dalam gelung do/while, perlaksanaan program melonjak ke penghujung gelung Pada masa ini, keadaan gelung akan dinilai semula sebelum meneruskan ke gelung seterusnya.
3. Dalam gelung for, ungkapan kenaikan automatik dikira dahulu, dan kemudian ungkapan ujian dikesan untuk menentukan sama ada hendak melaksanakan badan gelung.
4. Dalam gelung untuk/dalam, gelung mula melintasi nama atribut seterusnya, yang diperuntukkan kepada pembolehubah yang ditentukan.

Anda perlu memberi perhatian kepada perbezaan antara penyataan continue dalam while dan untuk gelung Gelung while terus memasuki pusingan seterusnya penghakiman keadaan gelung, tetapi gelung for terlebih dahulu mengira ungkapan kenaikan dan kemudian menilai keadaan gelung. . Bab sebelumnya membincangkan kelakuan "setara" bagi gelung untuk kepada gelung sementara. Walau bagaimanapun, kerana continue berkelakuan berbeza dalam kedua-dua gelung ini, adalah mustahil untuk mensimulasikan dengan sempurna gelung setara untuk menggunakan gelung sementara.

Kod berikut menunjukkan pernyataan continue tanpa label, yang melangkau logik seterusnya bagi gelung semasa apabila ralat berlaku

Salin kod Kod adalah seperti berikut:

untuk (i = 0; i < data.length; i ) {

Jika (!data[i]) diteruskan; //Tidak boleh mengendalikan data yang tidak ditentukan

                  jumlah = data[i];

            }

Sama seperti pernyataan putus, pernyataan continue berlabel boleh digunakan dalam gelung bersarang untuk melompat keluar daripada logik badan gelung bersarang secara hierarki. Juga serupa dengan penyataan putus, tidak boleh ada baris baharu antara penyataan sambung dan nama makmal.

iiii.kembali

Ingat bahawa panggilan fungsi ialah ungkapan dan semua ungkapan mempunyai nilai. Pernyataan pulangan dalam fungsi merujuk kepada nilai pulangan selepas panggilan fungsi. Berikut ialah sintaks pernyataan pulangan:

ungkapan kembali;

Pernyataan pulangan hanya boleh muncul dalam badan fungsi Jika tidak, ralat sintaks akan dilaporkan. Apabila pernyataan pulangan dilaksanakan, fungsi menamatkan pelaksanaan dan mengembalikan nilai ungkapan kepada program panggilan. Contohnya:

Salin kod Kod adalah seperti berikut:

              fungsi segi empat sama(x) {return x * x} //Fungsi pernyataan yang mengandungi pulangan

                segi empat sama(4) //Pelaksanaan ialah 16

Jika tiada penyataan pemulangan, panggilan fungsi hanya akan melaksanakan setiap penyataan dalam badan fungsi mengikut urutan sehingga penghujung fungsi, dan akhirnya kembali ke program panggilan. Dalam kes ini, hasil panggilan ungkapan tidak ditentukan. Pernyataan pulangan sering muncul sebagai pernyataan terakhir dalam fungsi, tetapi ia tidak semestinya bermakna ia mesti diletakkan di penghujung fungsi Walaupun terdapat banyak kod yang belum dilaksanakan apabila penyataan pulangan dilaksanakan , fungsi itu masih akan kembali ke program panggilan.
Pernyataan pulangan boleh digunakan secara bersendirian tanpa ungkapan Dalam kes ini, fungsi itu juga akan mahu memanggil program dan kembali tidak ditentukan. Contohnya:

Salin kod Kod adalah seperti berikut:

//Jika parameter adalah batal atau tidak ditentukan, kembali segera 

Jika (!o) kembali;

                                                                                                                                                                                                                                                                                                                   // Logik lain

Memandangkan JavaScript boleh memasukkan koma bertitik secara automatik, tidak boleh ada baris baharu antara kata kunci kembali dan ungkapan yang mengikutinya.

iiiiii.kenyataan buang

Apa yang dipanggil pengecualian (pengecualian) ialah isyarat yang dijana apabila beberapa situasi atau ralat yang tidak normal berlaku. Melemparkan pengecualian bermakna memberi isyarat bahawa ralat atau keadaan tidak normal telah berlaku. Menangkap pengecualian bermakna memproses isyarat dan melontar pengecualian, iaitu menggunakan isyarat untuk memberitahu bahawa ralat atau situasi tidak normal telah berlaku. Menangkap pengecualian merujuk kepada pengendalian isyarat ini, iaitu, mengambil langkah yang perlu untuk pulih daripada pengecualian. Dalam JavaScript, pengecualian dilemparkan secara eksplisit apabila ralat masa jalan berlaku atau apabila program menggunakan pernyataan lontaran. Pengecualian boleh ditangkap menggunakan kenyataan cuba/tangkap/akhirnya, yang akan diperkenalkan secara terperinci dalam bahagian seterusnya.

Sintaks pernyataan lontaran adalah seperti berikut:

melemparkan ekspresi

Nilai ungkapan boleh terdiri daripada sebarang jenis. Boleh membuang tatasusunan yang mewakili kod ralat, atau rentetan yang mengandungi mesej ralat. Apabila jurubahasa JavaScript melemparkan pengecualian, ia biasanya menggunakan jenis Eeeor atau subjenisnya, tetapi ia juga boleh digunakan. Objek ralat mempunyai perwakilan jenis ralat yang biasa, dan atribut mesej yang digunakan untuk menghantar rentetan kepada pembina (lihat kelas Ralat dalam Bahagian 3 Dalam contoh berikut, Ralat dilemparkan apabila fungsi dipanggil dengan menyalahi undang-undang). parameter

Salin kod Kod adalah seperti berikut:

fungsi fa(x) {