Kalimat Bacaan Inti JavaScript

Dalam JavaScript, ekspresi adalah frasa, dan pernyataan adalah seluruh kalimat atau perintah. Sama seperti pernyataan bahasa Inggris diakhiri dengan suatu periode, JavaScript berakhir dengan titik koma.

Ekspresi menghitung nilai, tetapi pernyataan itu membuat sesuatu terjadi.

Salah satu cara untuk "mewujudkan sesuatu" adalah dengan menghitung ekspresi dengan efek samping. Ekspresi dengan efek samping seperti penugasan dan panggilan fungsi dapat digunakan sebagai pernyataan terpisah. Penggunaan ekspresi ini sebagai pernyataan juga disebut pernyataan ekspresi. Pernyataan serupa termasuk pernyataan deklarasi, yang digunakan untuk mendeklarasikan variabel baru atau mendefinisikan fungsi baru.

Program JavaScript adalah kumpulan serangkaian pernyataan yang dapat dieksekusi. Secara default, juru bahasa JavaScript dieksekusi secara berurutan dalam urutan penulisan. Cara lain untuk "mewujudkan sesuatu" adalah dengan mengubah urutan eksekusi default pernyataan:

1. Pernyataan Bersyarat: Interpreter JavaScript dapat menentukan apakah akan menjalankan atau melewatkan pernyataan ini, seperti Pernyataan IF dan Switch.

2. Pernyataan loop: Pernyataan yang dapat dieksekusi berulang kali, seperti saat dan untuk pernyataan

3. Pernyataan lompat: Anda dapat membiarkan penerjemah melompat ke bagian lain dari program untuk melanjutkan eksekusi, seperti Break, Return dan Throw Pernyataan

Selanjutnya, artikel ini akan memperkenalkan berbagai pernyataan dan sintaksnya di JavaScript. Bab ini merangkum kalimat -kalimat ini di akhir. Program JavaScript tidak lebih dari kumpulan pernyataan yang dipisahkan oleh pemisahan, jadi begitu Anda menguasai pernyataan JavaScript, Anda dapat menulis program JavaScript.

1. Pernyataan ekspresi

Pernyataan penugasan adalah pernyataan ekspresi yang relatif penting. Fungsi mereka adalah mengubah nilai variabel, seperti halnya melaksanakan pernyataan penugasan: misalnya

Salinan kode adalah sebagai berikut:

sapa = "halo" + nama;

i *= 3;

Operator kenaikan (++) dan operator penurunan (-) terkait dengan pernyataan penugasan. Fungsinya adalah mengubah nilai variabel, seperti halnya melaksanakan pernyataan penugasan.

Salinan kode adalah sebagai berikut:

Counter ++;

Fungsi penting dari operator hapus adalah untuk menghapus sifat objek (atau elemen array) dan semua yang umumnya digunakan sebagai pernyataan, bukan sebagai bagian dari ekspresi kompleks.

Salinan kode adalah sebagai berikut:

hapus sapi;

Panggilan fungsi adalah kategori utama pernyataan ekspresi lainnya, misalnya

Salinan kode adalah sebagai berikut:

waspada (salam);

window.close ();

Meskipun fungsi klien ini adalah ekspresi, mereka memiliki dampak tertentu pada browser web. Jadi kami pikir itu juga pernyataan, dan tidak masuk akal untuk memanggil fungsi tanpa efek samping kecuali itu bagian dari ekspresi atau pernyataan penugasan yang kompleks, misalnya. Tidak mungkin untuk membuang nilai kosinus secara acak;

Math.cos (x);

Sebaliknya, untuk mendapatkan nilai kosinus, Anda harus menetapkannya ke variabel sehingga nilai ini dapat digunakan di masa depan:

var cx = math.cos (x);

Sekali lagi, setiap baris kode berakhir dengan titik koma.

2. Pernyataan majemuk dan pernyataan kosong

Beberapa ekspresi dapat digabungkan bersama dengan operator koma untuk membentuk ekspresi. Demikian pula, JavaScript juga dapat memberi tahu Anda bahwa banyak pernyataan disatukan untuk membentuk pernyataan majemuk. Cukup bungkus beberapa pernyataan dalam kawat gigi keriting. Oleh karena itu, baris kode berikut dapat digunakan sebagai pernyataan terpisah di mana saja di JavaScript Anda ingin menggunakan pernyataan.

Salinan kode adalah sebagai berikut:

{

x = Math.pi;

cx = math.cos (x);

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

}

Ada beberapa poin yang perlu diperhatikan tentang blok pernyataan: Pertama, blok pernyataan tidak memerlukan titik koma. Pernyataan elemen dalam blok harus diakhiri dengan titik koma, tetapi blok pernyataan tidak.

Kedua, baris dalam blok pernyataan indentasi, yang tidak perlu, tetapi lekukan yang rapi dapat membuat kode lebih mudah dibaca dan lebih mudah dipahami.

Ketiga, JavaScript tidak memiliki ruang lingkup tingkat blok, dan variabel yang dinyatakan dalam blok pernyataan tidak dimiliki secara pribadi oleh blok pernyataan. (Lihat bagian pertama Bab 3, 10)

Praktek menggabungkan banyak pernyataan ke dalam blok pernyataan besar sangat umum dalam pemrograman JavaScript. Ekspresi yang serupa biasanya berisi sub -ekspresi, banyak javascript berisi substatement lainnya. Dalam hal bentuk, JavaScript biasanya memungkinkan blok pernyataan mengandung substatemen. Misalnya: Badan loop while hanya dapat berisi satu pernyataan. Menggunakan blok pernyataan, Anda dapat memasukkan sejumlah pernyataan ke dalam blok ini, dan blok pernyataan ini dapat digunakan sebagai pernyataan.

Dalam JavaScript, ketika Anda ingin beberapa pernyataan digunakan sebagai satu pernyataan, gunakan pernyataan yang sesuai sebagai gantinya. Pernyataan kosong (pernyataan kosong) justru sebaliknya, memungkinkan untuk berisi 0 pernyataan. Pernyataan kosong terlihat seperti ini:

;//titik koma

Interpreter JavaScript jelas tidak melakukan tindakan apa pun saat menjalankan pernyataan kosong, tetapi praktik telah membuktikan bahwa pernyataan kosong terkadang berguna saat membuat loop dengan loop body kosong, seperti yang berikut untuk loop

Salinan kode adalah sebagai berikut:

// inisialisasi array a

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

Dalam loop ini, semua operasi diselesaikan dalam ungkapan A [i ++] = 0, dan tidak diperlukan badan loop di sini. Namun, JavaScript mensyaratkan bahwa badan loop berisi setidaknya satu pernyataan, jadi hanya titik koma terpisah yang digunakan di sini untuk mewakili pernyataan kosong.

Perhatikan bahwa titik koma di sisi kanan loop for, sedangkan loop atau jika pernyataan tidak mencolok, yang dapat menyebabkan beberapa bug fatal, yang sulit ditemukan. Misalnya, hasil eksekusi dari kode berikut cenderung menjadi efek yang tidak diinginkan penulis:

Salinan kode adalah sebagai berikut:

if ((a == 0) || (b == 0)); // Baris kode ini tidak melakukan apa -apa ...

o = null; // baris kode ini akan selalu dieksekusi

Jika Anda menggunakan pernyataan kosong untuk tujuan khusus, yang terbaik adalah menambahkan komentar dalam kode, yang dapat dengan jelas menunjukkan bahwa pernyataan kosong ini berguna.

Salinan kode adalah sebagai berikut:

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

3. Pernyataan deklarasi

VAR dan fungsi adalah pernyataan deklarasi yang mendeklarasikan atau mendefinisikan variabel atau fungsi. Pernyataan ini menentukan dan menetapkan pengidentifikasi (nama variabel dan nama fungsi) untuk mereka, yang dapat digunakan di mana saja dalam program. Pernyataan deklarasi tidak melakukan apa pun sendiri, tetapi memiliki arti penting: dengan membuat variabel dan fungsi, semantik kode dapat diatur dengan lebih baik.

Bagian berikut akan berbicara tentang pernyataan VAR dan pernyataan fungsi, tetapi tidak mengandung semua isi variabel dan fungsi.

i.var

Pernyataan VAR digunakan untuk mendeklarasikan satu atau lebih variabel. Sintaksnya adalah sebagai berikut:

var name_1 [= value_1] [, ..., name_n [= value_n]]

Kata kunci VAR diikuti oleh daftar variabel yang akan dinyatakan. Setiap variabel dalam daftar dapat memiliki ekspresi inisialisasi yang dapat digunakan untuk menentukan nilai awalnya. Misalnya:

Salinan kode adalah sebagai berikut:

var i; // Variabel sederhana

var j = 0; // Variabel dengan nilai awal

var p, q; // Dua variabel

var salam = "halo" + nama; // ekspresi inisialisasi yang lebih kompleks

var x = 2.34, y = math.cos (0.75), r, theta; // banyak variabel

var x = 2, y = x * x; // Variabel kedua menggunakan variabel pertama

var x = 2,

f = function (x) {return x * x}, // Setiap variabel memiliki satu baris eksklusif

y = f (x)

Jika pernyataan VAR muncul di badan fungsi, maka ia mendefinisikan variabel lokal, dan ruang lingkupnya adalah fungsi ini. Jika Anda menggunakan pernyataan VAR dalam kode tingkat atas, maka ia menyatakan variabel global, yang terlihat di seluruh JavaScript. Dalam Bab 3, Bagian 10, disebutkan bahwa variabel global adalah sifat objek global. Kemudian, tidak seperti properti objek global lainnya, variabel yang dinyatakan oleh VAR tidak dapat dihapus melalui Hapus.

Jika variabel dalam pernyataan VAR tidak menentukan ekspresi inisialisasi, nilai variabel ini awalnya tidak terdefinisi. Oleh karena itu, nilai variabel sebelum pernyataan deklarasi tidak ditentukan.

Perlu dicatat bahwa pernyataan VAR juga dapat digunakan sebagai komponen dari loop atau untuk/dalam loop. (Sama seperti deklarasi variabel yang dideklarasikan sebelum loop, variabel yang dinyatakan di sini juga akan "maju"), misalnya:

Salinan kode adalah sebagai 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 bahwa tidak masalah jika Anda menyatakan variabel yang sama beberapa kali.

ii.function

Fungsi kata kunci digunakan untuk mendeklarasikan fungsi. Kami telah mempelajari ekspresi fungsi (4.3). Definisi fungsi dapat ditulis dalam bentuk pernyataan. Misalnya: Dua definisi ditulis dalam kode contoh berikut:

Salinan kode adalah sebagai berikut:

var f = fungsi f (x) {return x + 1;} // Tetapkan ekspresi ke variabel

fungsi f (x) {return x + 1;} // kalimat yang berisi nama variabel

Sintaks Deklarasi Fungsi adalah sebagai berikut:

Salinan kode adalah sebagai berikut:

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

pernyataan

}

Funcname adalah pengidentifikasi nama fungsi yang akan dinyatakan. Nama fungsi diikuti oleh daftar parameter, dipisahkan oleh koma. Saat memanggil fungsi, pengidentifikasi ini merujuk pada parameter aktual yang diteruskan ke fungsi.

Badan fungsi terdiri dari pernyataan JavaScript, tanpa batas pada jumlah pernyataan dan tertutup dalam kawat gigi keriting. Saat mendefinisikan suatu fungsi, pernyataan dalam badan fungsi tidak dieksekusi, tetapi dikaitkan dengan objek fungsi baru yang akan dieksekusi saat memanggil fungsi. Perhatikan bahwa kawat gigi keriting dalam pernyataan fungsi pernyataan diperlukan, yang berbeda dari blok pernyataan yang digunakan oleh while loop dan kunci pernyataan lainnya. Bahkan jika tubuh fungsi hanya memiliki satu pernyataan, kawat gigi keriting masih diperlukan untuk membungkusnya.

Salinan kode adalah sebagai berikut:

fungsi hyteus (x, y) {

return math.sqrt (x * x + y * y);

}

Hyteus (1, 2) //=>2.2360679749979

function facial (n) {// fungsi rekursif

if (n <= 1) return 1;

return n * facial (n - 1);

}

facial (11) // => 39916800

Deklarasi fungsi biasanya muncul di bagian atas kode JavaScript dan juga dapat bersarang dalam fungsi lain. Tetapi ketika bersarang, deklarasi fungsi hanya dapat muncul di bagian atas fungsi bersarang. Dengan kata lain: definisi fungsi tidak dapat muncul di jika, sementara, atau pernyataan lainnya.

Seperti pernyataan VAR, variabel yang dibuat oleh pernyataan deklarasi fungsi tidak dapat dihapus. Namun, variabel-variabel ini tidak hanya dibaca, dan nilai variabel dapat ditulis ulang.

4. Pernyataan bersyarat

Pernyataan bersyarat adalah untuk mengeksekusi atau melewatkan pernyataan tertentu dengan menentukan apakah nilai ekspresi yang ditentukan harus dinilai. Pernyataan ini adalah "titik keputusan" dari kode, kadang -kadang disebut "cabang". Jika penerjemah JavaScript dieksekusi mengikuti "jalur" kode. Pernyataan bersyarat adalah titik garpu di jalur ini. Ketika program mencapai titik ini, Anda harus memilih jalur untuk melanjutkan eksekusi.

Pernyataan i.if

Jika pernyataan adalah pernyataan kontrol dasar. Tepatnya, memungkinkan program untuk mengeksekusi secara kondisional. Ada dua bentuk pernyataan ini: yang pertama adalah

Salinan kode adalah sebagai berikut:

if (ekspresi)

penyataan

Dalam bentuk ini, jika nilai ekspresi benar, jalankan pernyataan pernyataan, dan jika itu salah, jangan menjalankan pernyataan tersebut. Misalnya,

Salinan kode adalah sebagai berikut:

if (username == null) // Jika nama pengguna nol atau tidak terdefinisi

nama pengguna = "Jack Wong"; // tentukan

Perlu dicatat bahwa perlu melampirkan tanda kurung taman ekspresi jika pernyataan.

Sintaks JavaScript menetapkan bahwa jika kata kunci dan ekspresi dengan tanda kurung kebun harus diikuti oleh pernyataan. Namun, beberapa pernyataan dapat digabungkan menjadi satu menggunakan blok pernyataan. Oleh karena itu, bentuk pernyataan IF terlihat seperti ini:

Salinan kode adalah sebagai berikut:

if (! address) {

alamat = "";

pesan = "Harap alamat surat"

}

Bentuk kedua dari pernyataan IF memperkenalkan klausa yang lain, dan mengeksekusi logika yang lain ketika nilai ekspresi salah.

Salinan kode adalah sebagai berikut:

if (ekspresi)

Pernyataan1

kalau tidak

pernyataan2

Misalnya, kode berikut

Salinan kode adalah sebagai berikut:

if (n == 1)

console.log ("1 pesan baru");

kalau tidak

console.log ("Anda memiliki" + n + "pesan baru");

Saat menggunakan pernyataan IF/Lain dalam penggunaan pernyataan IF bersarang, Anda harus berhati -hati untuk memastikan bahwa pernyataan yang lain cocok dengan pernyataan IF yang benar. Pertimbangkan kode berikut:

Salinan kode adalah sebagai berikut:

i = j = 1;

k = 2;

if (i == j)

if (j == k)

Console.log ("Saya sama dengan k");

kalau tidak

console.log ("Saya dosen sama j"); //Kesalahan! Lai

Dalam contoh ini, pernyataan IF bagian dalam merupakan klausa yang diperlukan oleh pernyataan IF luar. Namun, hubungan yang cocok antara jika dan yang tidak jelas (hanya lekukan memberikan sedikit petunjuk) dan dalam contoh ini, petunjuk yang diberikan oleh indentasi salah, karena penerjemah JavaScript memahaminya.

Salinan kode adalah sebagai berikut:

if (i == j) {

if (j == k)

Console.log ("Saya sama dengan k");

kalau tidak

console.log ("Saya dosen sama j");

}

Seperti kebanyakan bahasa pemrograman, aturan IF dan yang lain cocok dengan JavaScript adalah bahwa selalu cocok dengan pernyataan IF di dekatnya. Untuk membuat contoh dapat dibaca, lebih mudah dipahami, dan lebih nyaman untuk pemeliharaan dan debugging, kawat gigi keriting harus digunakan.

Salinan kode adalah sebagai berikut:

if (i == j) {

if (j == k) {

Console.log ("Saya sama dengan k");

} else {// kawat gigi scape membuat hasil kode lebih jelas

console.log ("Saya dosen sama j");

}

}

Banyak programmer memiliki kebiasaan melampirkan tubuh jika dan pernyataan lain dalam kawat gigi keriting (seperti dalam pernyataan yang cocok seperti loop sementara). Bahkan jika hanya ada satu pernyataan per cabang, hal itu dapat menghindari masalah yang ambigu dari program sekarang.

ii.else if

Pernyataan IF/Else memilih salah satu dari dua cabang dengan menilai hasil perhitungan dari suatu ekspresi. Apa yang harus saya lakukan ketika ada banyak cabang dalam kode? Salah satu solusi adalah menggunakan pernyataan IF yang lain. Lain jika bukan pernyataan JavaScript nyata, itu hanya cara untuk menulis beberapa pernyataan jika/lain bersama -sama.

Salinan kode adalah sebagai berikut:

if (n == 1) {

// Jalankan Blok Kode 1

} lain jika (n == 2) {

// jalankan blok kode 2

} lain jika (n == 3) {

// Jalankan Blok Kode 3

} kalau tidak {

// Ketentuan sebelumnya salah, maka blok kode 4 dijalankan

}

Tidak ada yang istimewa tentang kode semacam ini. Ini terdiri dari beberapa pernyataan IF, dan masing -masing klausul pernyataan IF yang lain berisi pernyataan IF lainnya. Kode setara sintaks dapat diselesaikan menggunakan bentuk bersarang dari pernyataan IF, tetapi dibandingkan dengan ini, jelas bahwa penulisan yang lain jika lebih jelas dan lebih disukai.

III.Switch

Selama pelaksanaan program, pernyataan IF membuat cabang, dan dapat menggunakan yang lain jika menangani banyak cabang. Kemudian, ketika semua cabang bergantung pada nilai dari ekspresi yang sama, jika tidak, jika bukan solusi terbaik. Dalam hal ini, adalah praktik yang sangat boros untuk berulang kali menghitung ekspresi dalam beberapa pernyataan IF.

Pernyataan sakelar cocok untuk menangani situasi ini. Sakelar kata kunci diikuti oleh ekspresi yang terlampir dalam tanda kurung taman. Lalu ada blok kode yang terlampir dalam kawat gigi keriting.

Salinan kode adalah sebagai berikut:

switch (ekspresi) {

pernyataan

}

Namun, sintaks lengkap dari pernyataan sakelar lebih rumit dari ini. Kasus ini diikuti oleh ekspresi dan usus besar. Case sangat mirip dengan bahasa markup, kecuali bahwa bahasa markup ini tidak memiliki nama.

Ini hanya terkait dengan ekspresi yang mengikutinya. Saat menjalankan pernyataan sakelar ini, pertama -tama menghitung nilai ekspresi, dan kemudian menemukan apakah ekspresi klausa kasus sama dengan nilai ekspresi. (Hal yang sama dibandingkan dengan operator "==="). Jika kasing dicocokkan, itu akan menjalankan kode yang sesuai. Jika casing yang cocok tidak dapat ditemukan, itu akan menjalankan blok kode di tag "Default:". Jika tidak ada tag "default:", sakelar akan melewatkan semua blok kode.

Pernyataan sakelar sangat mudah dibingungkan, dan pengantar dengan contoh akan lebih jelas. Pernyataan sakelar berikut ini setara dengan pernyataan IF/Else sekarang.

Salinan kode adalah sebagai berikut:

switch (n) {

Kasus 1: // jika n === 1 dimulai dari sini

// Jalankan Blok Kode 1

merusak;

Kasus 2:

// jalankan blok kode 2

merusak;

Kasus 3:

// Jalankan Blok Kode 3

merusak;

bawaan:

// Jalankan Blok Kode 4

merusak;

}

Perlu dicatat bahwa istirahat kata kunci digunakan di akhir setiap pernyataan kasus. Kami akan memperkenalkan pernyataan istirahat nanti. Pernyataan Break dapat membuat penerjemah melompat keluar dari pernyataan sakelar atau pernyataan loop. Di Switch, Case hanya menunjukkan titik awal kode yang akan dieksekusi, tetapi tidak menentukan titik akhir. Jika tidak ada pernyataan break, pernyataan sakelar mulai mengeksekusi dari kode pada tag kasus pencocokan dari nilai ekspresi, dan menjalankan pernyataan berikutnya secara bergantian hingga akhir seluruh blok kode sakelar. Tentu saja, jika Anda menggunakan pernyataan sakelar dalam suatu fungsi, Anda dapat menggunakan kembali untuk mengganti break. Pengembalian dan istirahat keduanya digunakan untuk mengakhiri pernyataan sakelar, yang juga akan mencegah pernyataan kasus dari terus menjalankan blok pernyataan kasus berikutnya.

Pernyataan berikut mendekati pertempuran aktual, dan mengubah nilai menjadi string sesuai dengan jenis nilai.

Salinan kode adalah sebagai berikut:

function convert (x) {

sakelar (typeof x) {

Kasus 'Nomor': // Konversi Nomor ke Hexadecimal

mengembalikan x.tostring (16);

case 'string':

return '"' + x + '"'; // Kembalikan dua string dengan kutipan ganda.

Default: // Gunakan metode biasa untuk mengonversi jenis lain

return string (x);

}

}

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

Perhatikan bahwa dalam dua contoh di atas, kata kunci case diikuti oleh nomor langsung dan string, yang merupakan penggunaan sakelar yang paling umum dalam praktik, tetapi standar ecmascript memungkinkan setiap kata kunci untuk mengikuti ekspresi sewenang -wenang.

Pernyataan sakelar pertama kali menghitung ekspresi setelah kata kunci sakelar, dan kemudian menghitung ekspresi setelah setiap kasus agar dari atas ke bawah, mengetahui bahwa nilai ekspresi yang dieksekusi ke kasus dan nilai ekspresi sakelar sama. Karena operasi pencocokan untuk setiap kasus sebenarnya adalah perbandingan operator identitas "===", bukan "==", pencocokan ekspresi dan case tidak melakukan konversi jenis apa pun.

Setiap kali pernyataan sakelar dieksekusi, tidak semua ekspresi kasus dapat dieksekusi. Oleh karena itu, ekspresi kasus dengan efek samping harus dihindari, seperti ekspresi panggilan fungsi dan ekspresi penugasan. Cara teraman adalah dengan menggunakan ekspresi konstan dalam kasus ekspresi.

Seperti yang disebutkan sebelumnya, jika ekspresi sakelar tidak cocok dengan semua ekspresi kasus, blok pernyataan bertanda "default:" akan dieksekusi. Jika tidak ada tag "default:", seluruh pernyataan sakelar akan dilewati. Pada contoh sebelumnya, tag "Default:" muncul di akhir sakelar dan berada di belakang semua tag case. Tentu saja, ini adalah cara menulis yang paling masuk akal dan paling umum digunakan. Faktanya, tag "Default:" dapat ditempatkan di mana saja dalam pernyataan Switch.

5. Loop.

Untuk memahami pernyataan bersyarat, Anda dapat menganggap kode dalam JavaScript sebagai jalur cabang. Pernyataan looping adalah pernyataan looping yang memungkinkan beberapa kode dieksekusi berulang kali. Ada empat pernyataan loop di JavaScript: while, do/while, for, dan for/in. Bagian berikut akan menjelaskannya sekaligus. Loop yang paling umum digunakan adalah traversal elemen array. (7.6 akan membahas loop ini dan metode loop khusus yang ditentukan oleh kelas array secara rinci.)

i.setika

Jika pernyataan adalah pernyataan kontrol dasar yang digunakan untuk memilih pernyataan cabang yang menjalankan program. Seperti jika, pernyataan sementara juga merupakan pernyataan loop dasar, dan sintaksinya adalah sebagai berikut:

Salinan kode adalah sebagai berikut:

While (ekspresi)

penyataan

Sebelum mengeksekusi pernyataan sementara, juru bahasa JavaScript terlebih dahulu menghitung nilai ekspresi. Jika nilainya adalah nilai yang salah, program akan melewatkan pernyataan logis di badan loop dan menjalankan pernyataan berikutnya dalam program. Jika nilainya benar, maka logika dalam pernyataan Loop Body dieksekusi, dan kemudian nilai ekspresi ekspresi dihitung. Loop akan berlanjut sampai nilai ekspresi salah. Dengan kata lain, ketika ekspresi itu benar, pernyataan itu akan dieksekusi dalam satu lingkaran. Perhatikan bahwa menggunakan while (true) akan membuat loop dead.

Secara umum, kami tidak ingin JavaScript melakukan operasi yang sama berulang kali. Di hampir setiap loop, satu atau lebih variabel akan berubah secara iteratif dengan loop. Justru karena variabel -variabel ini diubah sehingga operasi pernyataan yang dilakukan di setiap loop berbeda. Selain itu, jika mengubah variabel digunakan dalam ekspresi, nilai ekspresi setiap loop juga berbeda. Ini sangat penting. Ekspresi yang bertanggung jawab untuk nilai awal dari nilai sebenarnya selalu merupakan nilai sebenarnya, dan loop tidak akan berakhir. Contoh di bawah ini menunjukkan bahwa sementara nilai output loop 0-9.

Salinan kode adalah sebagai berikut:

var count = 0;

while (hitung <10) {

Console.log (Count);

Count ++;

}

Dapat ditemukan bahwa dalam contoh ini, nilai awal dari jumlah variabel adalah 0, dan selama loop, nilainya bertambah 1 setiap kali, ketika loop dieksekusi sepuluh kali. Nilai ekspresi diprogram salah, dan kemudian sementara akan berakhir, dan juru bahasa JavaScript akan menjalankan pernyataan program berikutnya. Sebagian besar loop memiliki variabel penghitung seperti hitungan. Meskipun penghitung sering menggunakan nama variabel seperti IJK, jika Anda ingin membuat kode lebih mudah dibaca, Anda harus menggunakan nama sintaks yang lebih spesifik.

II.DO/Shile

Loop do/while sangat mirip dengan loop while, kecuali bahwa ia mendeteksi ekspresi loop di ekor loop daripada di atas, yang berarti bahwa badan loop dieksekusi setidaknya sekali. Sintaks dari loop do/while adalah sebagai berikut:

Salinan kode adalah sebagai berikut:

Mengerjakan

penyataan

sementara (ekspresi);

Lakukan/sementara loop tidak biasa digunakan seperti saat loop. Ini karena tidak umum dalam praktiknya ingin menjalankan loop setidaknya sekali. Berikut adalah contoh dari loop do/while

Salinan kode adalah sebagai berikut:

fungsi printarray (a) {

var len = a.length,

i = 0;

if (len == 0)

console.log ("array kosong");

kalau tidak

Mengerjakan {

console.log (a [i]);

} while (++ i <len);

}

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

Ada dua perbedaan sintaksis antara do/sementara loop dan normal sementara loop. Pertama, loop DO mensyaratkan bahwa kata kunci harus digunakan untuk mengidentifikasi awal loop, digunakan sementara variabel untuk mengidentifikasi akhir loop dan memasukkan kondisi loop untuk menilai; Kedua, tidak seperti loop sementara, loop DO menggunakan akhir titik titik koma. Jika bodi loop sementara tertutup dalam kawat gigi keriting, loop sementara tidak berakhir dengan titik koma.

iii.for

Pernyataan untuk memberikan struktur kontrol pernyataan loop yang lebih nyaman daripada sementara. Pernyataan untuk menyederhanakan mode loop yang umum digunakan. Sebagian besar loop memiliki variabel penghitung spesifik. Variabel ini diinisialisasi sebelum loop dimulai, dan kemudian periksa nilainya sebelum setiap loop. Akhirnya, variabel penghitung tidak dituntut sendiri, jika tidak maka akan dimodifikasi setelah siklus selesai dan sebelum penilaian berikutnya. Dalam jenis loop ini, tiga operasi utama penghitung adalah inisialisasi, deteksi, dan pembaruan. Pernyataan untuk secara eksplisit menyatakan ketiga operasi ini sebagai bagian dari sintaks loop, masing -masing menggunakan ekspresi untuk mewakilinya. Sintaks dari pernyataan untuk adalah sebagai berikut:

Salinan kode adalah sebagai berikut:

untuk (inisialisasi; tes; kenaikan)

penyataan

Tiga ekspresi inisialisasi, tes, dan kenaikan dipisahkan oleh titik koma. Mereka bertanggung jawab untuk menginisialisasi operasi, penilaian kondisi siklik dan memperbarui variabel penghitung. Menempatkan mereka di baris pertama loop membuatnya lebih mudah untuk memahami apa yang dilakukan untuk loop, dan juga mencegah lupa untuk menginisialisasi atau menambah variabel penghitung.

Cara termudah untuk menjelaskan cara kerja loop adalah dengan daftar setara saat loop

Salinan kode adalah sebagai berikut:

inisialisasi

while (test) {

penyataan

kenaikan;

}

Dengan kata lain, ekspresi inisialisasi dieksekusi hanya sekali sebelum loop dimulai. Ekspresi inisialisasi harus memiliki efek samping (biasanya pernyataan penugasan). JavaScript juga memungkinkan ekspresi inisialisasi dengan pernyataan deklarasi variabel var, sehingga variabel dapat dinyatakan dan diinisialisasi. Sebelum setiap loop, ekspresi uji akan dieksekusi, dan hasil ekspresi akan dinilai untuk menentukan apakah akan menjalankan badan loop. Sebelum setiap loop, ekspresi uji akan dieksekusi dan hasilnya akan ditentukan apakah badan loop akan dieksekusi. Jika hasil tes adalah nilai sebenarnya, pernyataan dalam badan loop akan dieksekusi. Akhirnya, jalankan ekspresi kenaikan. Juga demi kegunaan, ekspresi kenaikan di sini juga harus memiliki efek samping. Secara umum, ini adalah ekspresi penugasan atau ekspresi yang terdiri dari operator "++" dan "-".

Di atas saat loop dapat ditulis menggunakan loop untuk

Salinan kode adalah sebagai berikut:

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

Console.log (Count)

Tentu saja, beberapa loop lebih kompleks, dan beberapa variabel diulang pada satu waktu dalam loop. Dalam JavaScript, kasus ini harus digunakan dengan operator koma, yang menggabungkan ekspresi inisialisasi dan ekspresi autointrement menjadi satu ekspresi untuk digunakan dalam loop untuk.

Salinan kode adalah sebagai berikut:

var i, j;

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

console.log (i * j);

Sejauh ini, variabel loop dalam kode sampel adalah semua angka. Tentu saja, angka adalah yang paling umum digunakan, tetapi tidak perlu. Kode berikut menggunakan loop untuk melintasi hasil data tabel dan mengembalikan objek terakhir dalam daftar tertaut (yaitu, objek pertama yang tidak berisi atribut berikutnya)

Salinan kode adalah sebagai berikut:

Function Tail (o) {// Kembalikan objek simpul terakhir dari daftar tertaut

untuk (; o.next; o = o.next) /*kosong* /// Jalankan traversal berdasarkan apakah O.Next adalah nilai sebenarnya

kembali o;

}

Perlu dicatat bahwa kode ini tidak mengandung ekspresi inisialisasi, dan orang -orang dan salah satu dari tiga ekspresi dalam loop untuk dapat diabaikan, tetapi dua titik koma sangat diperlukan. Jika ekspresi uji dihilangkan, itu akan menjadi loop yang mati. Juga dengan tipe sementara (Ture), salah satu cara untuk menulis loop dead adalah untuk (;;).

iiii.for/in

Pernyataan untuk/dalam menggunakan kata kunci untuk, tetapi ini adalah jenis loop yang berbeda dari loop reguler. Sintaks dari loop for/in adalah sebagai berikut

Salinan kode adalah sebagai berikut:

untuk (variabel dalam objek)

penyataan

Variabel biasanya merupakan nama variabel, atau ekspresi yang dapat menghasilkan lvalues ​​atau variabel yang dinyatakan melalui pernyataan VAR. Bagaimanapun, itu adalah nilai yang berlaku untuk sisi kiri ekspresi penugasan. Objek adalah ekspresi, dan hasil dari ekspresi ini adalah objek. Demikian pula, pernyataan adalah pernyataan atau blok pernyataan yang membentuk tubuh loop.

Menggunakan loop untuk berulang melalui elemen array sangat sederhana

Salinan kode adalah sebagai berikut:

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

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

Console.log (a [i]) // elemen output dari setiap array

Loop for/in digunakan untuk dengan mudah melintasi properti anggota objek

Salinan kode adalah sebagai berikut:

untuk (var p dalam o) // Tetapkan nama atribut ke variabel p

console.log (o [p]); // keluaran nilai masing -masing atribut

Dalam proses melaksanakan pernyataan FOR/IN, interpreter JavaScript pertama kali menghitung ekspresi objek. Jika ekspresi nol atau tidak terdefinisi, interpreter JavaScript akan melewatkan loop dan menjalankan kode selanjutnya. Jika ekspresi sama dengan nilai primitif, nilai primitif ini akan dikonversi ke objek pembungkus (Bagian 3.6). Kalau tidak, ekspresi itu sendiri sudah menjadi objek. JavaScript menyebutkan properti objek yang secara bergantian untuk menjalankan loop. Namun, sebelum setiap loop, JavaScript menghitung nilai ekspresi variabel dan menetapkan nama atribut (string) ke dalamnya.

Perlu dicatat bahwa selama loop For/In, nilai varibale dapat dianggap sebagai LValue dari ekspresi penugasan, dan itu bisa berupa ekspresi apa pun. Ekspresi ini dihitung setiap loop, yang berarti bahwa nilai yang dihitungnya mungkin berbeda setiap kali loop. Misalnya, Anda dapat menggunakan kode berikut untuk menyalin semua properti objek ke dalam array:

Salinan kode adalah sebagai 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

Array JavaScript hanyalah objek khusus, sehingga loop untuk/di loop dapat menyebutkan indeks data seperti menyebutkan properti objek. Misalnya, menambahkan kode ini setelah kode di atas dapat menyebutkan indeks data 0, 1, 2:

Salinan kode adalah sebagai 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 Salin properti objek ke dalam array

untuk (saya dalam a)

Document.write (i) // => indeks data enum 0 1 2

Faktanya, loop FOR/IN tidak melintasi semua sifat objek. Hanya atribut "yang dapat dihindarkan" yang akan dilalui (lihat 6.7). Karena metode bawaan yang ditentukan oleh inti bahasa JavaScript tidak "dihakuskan". Misalnya, semua objek memiliki tostring (), tetapi loop for/in tidak menyebutkan properti tostring (). Selain metode bawaan, ada banyak objek bawaan yang tidak dapat dihitung. Semua atribut dan metode yang didefinisikan dalam kode dapat dihitung (Bagian 6.7 akan disebutkan, tetapi ada cara khusus dalam ecmascript5 yang dapat membuat atribut tidak dapat dihitung).

Objek dapat mewarisi sifat -sifat objek lain, dan garis mewarisi properti khusus (6.2.ii) juga dapat disebutkan menggunakan untuk/in.

Jika badan loop for/in menghapus properti yang tidak diungkapkan, maka properti ini tidak akan disebutkan lagi. Jika badan loop mendefinisikan sifat -sifat baru dari objek, sifat -sifat ini biasanya tidak disebutkan (tetapi beberapa implementasi JavaScript dapat menyebutkan sifat -sifat yang ditambahkan dalam badan loop).

Urutan enumerasi atribut

Spesifikasi ecmascript tidak menentukan urutan mana untuk/dalam loop menyebutkan sifat -sifat objek. Namun pada kenyataannya, produsen browser utama implementasi JavaScript menyebutkan sifat -sifat objek sederhana dalam urutan definisi atribut, dan properti yang ditentukan terlebih dahulu disebutkan terlebih dahulu. Jika suatu objek dibuat dalam bentuk kuantitas langsung, itu akan disebutkan dalam urutan di mana properti dalam kuantitas langsung muncul. (Beberapa pustaka jaringan dan javascript bergantung pada urutan enumerasi ini, sementara produsen browser sebagian besar tidak memodifikasi pesanan ini). Dalam kasus berikut, urutan enumerasi tergantung pada implementasi spesifik (bukan interaksi)

1. Objek mewarisi atribut yang dapat dihindari

2. Objek memiliki sifat indeks array integer

3. Gunakan Hapus untuk menghapus sifat objek yang ada

4. Gunakan Object.defineproperty () atau metode serupa untuk mengubah sifat objek

6. Jump

Dalam JavaScript, jenis pernyataan adalah pernyataan lompatan. Dari pemahaman pernyataan, itu dapat membuat eksekusi JavaScript melompat dari satu posisi ke satu posisi.

Pernyataan Break adalah untuk melompat ke akhir loop atau pernyataan lainnya. Pernyataan Lanjutkan mengakhiri pelaksanaan loop ini dan memulai pelaksanaan loop berikutnya. Pernyataan dalam JavaScript dapat dinamai atau diberi label, Break dan Lanjutan dapat mengidentifikasi loop target atau tag pernyataan lainnya.

Pernyataan pengembalian memungkinkan penerjemah untuk melompat keluar dari pelaksanaan tubuh fungsi. Dan memberikan nilai pengembalian panggilan ini. Pernyataan lemparan memicu atau melempar pengecualian, yang digunakan dengan pernyataan coba/tangkap/akhirnya, yang menentukan logika kode penanganan pengecualian. Ini adalah pernyataan lompatan yang kompleks. Ketika pengecualian dilemparkan, program akan melompat ke bintang pengecualian terdekat. Program pengecualian ini dapat berada dalam fungsi yang sama atau di tumpukan panggilan di tingkat yang lebih tinggi.

Selanjutnya, jelaskan setiap pernyataan lompatan

Saya. Pernyataan tag

Pernyataan dapat diberi label, dan label terdiri dari pengidentifikasi dan usus besar sebelum pernyataan:

Identifier: Pernyataan

Dengan mendefinisikan tag untuk pernyataan, Anda dapat merujuk pada pernyataan ini dengan nama tag di mana saja dalam program. Anda dapat mendefinisikan label untuk beberapa pernyataan, meskipun hanya lebih berguna ketika mendefinisikan label untuk blok pernyataan, seperti pernyataan loop atau pernyataan penilaian bersyarat. Dengan mendefinisikan nama tag untuk loop, Anda dapat menggunakan istirahat dan melanjutkan di dalam badan loop untuk keluar dari loop atau secara langsung menantang ke awal loop berikutnya. break and continue are the only statements in JavaScript that can use statement tags (this chapter will be discussed next). The following example, where the while loop defines a tag, and the continue statement uses this tag:

Salinan kode adalah sebagai berikut:

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

}

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

单独使用break语句的作用是立即退出最内存的循环或switch语句。它的语法如下：

merusak;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到了需要查找的数组元素，则使用break语句退出循环：

Salinan kode adalah sebagai berikut:

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

if (a[i] == target) break;

}

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

Break LabelName;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

Salinan kode adalah sebagai berikut:

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

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

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

}

}

success = true;

}

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

melanjutkan;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1.在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2.在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3.在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4.在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

Salinan kode adalah sebagai berikut:

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

}

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

The return statement can only appear in the function body. If not, it will report a syntax error. When the return statement is executed, the function terminates the execution and returns the value of the expression to the calling program. Misalnya:

Salinan kode adalah sebagai berikut:

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

The return statement can be used alone without having expression, so the function will also want to call the program to return undefined. Misalnya:

Salinan kode adalah sebagai berikut:

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

Salinan kode adalah sebagai berikut:

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

return f;

}

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

Salinan kode adalah sebagai berikut:

mencoba{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

}

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

}

Akhirnya{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

}

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

Salinan kode adalah sebagai berikut:

mencoba {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

}

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

Salinan kode adalah sebagai berikut:

mencoba {

print("Outer try running..");

mencoba {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} Akhirnya {

print("Nested finally is running...");

}

} catch (e) {

print("Outer catch caught " + e);

} Akhirnya {

print("Outer finally running");

}

// Windows Script Host 作出该修改从而得出WScript.Echo(s)

function print(s) {

document.write(s);

}

Keluaran:

Salinan kode adalah sebagai berikut:

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

penyataan

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

Salinan kode adalah sebagai berikut:

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

}

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

Salinan kode adalah sebagai berikut:

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

Salinan kode adalah sebagai berikut:

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

Salinan kode adalah sebagai berikut:

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

}

F();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

aku aku aku. "use strict"

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

Salinan kode adalah sebagai berikut:

var hasStrictMode = (function() {

"use strict";

return this === undefined

}());

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：