JavaScript Core Reading Expressions and Operator

Ekspresi adalah frasa dalam JavaScript, dan juru bahasa JavaScript akan menghitung hasil. Jumlah yang umum digunakan dalam program adalah jenis ekspresi paling sederhana yang merupakan variabel. Nama variabel juga merupakan ekspresi sederhana, dan nilainya adalah nilai yang ditetapkan untuk variabel.

Ekspresi kompleks terdiri dari ekspresi sederhana. Misalnya, ekspresi akses array terdiri dari ekspresi yang mewakili array, kurung persegi, dan ekspresi integer. Operasi ekspresi baru yang mereka bentuk adalah nilai elemen pada posisi tertentu dalam array. Surat yang sama

Ekspresi panggilan angka terdiri dari ekspresi yang mewakili objek fungsi dan 0 lebih dari 0 ekspresi parameter. Metode yang paling umum untuk menggabungkan ekspresi sederhana menjadi ekspresi kompleks adalah operator.

Bab ini (artikel ini) akan menjelaskan semua operator JavaScript. Ini juga menjelaskan ekspresi yang tidak melibatkan operator (seperti mengakses elemen array dan panggilan fungsi), dan sintaks dan gaya pemrogramannya sangat mirip dengan bahasa C.

1. Ekspresi elemen

Ekspresi paling sederhana adalah "ekspresi asli", yang merupakan unit ekspresi terkecil - mereka tidak mengandung ekspresi lain. Ekspresi asli dalam JavaScript berisi konstanta atau jumlah langsung. Kata kunci dan variabel.

Kuantitas langsung adalah nilai konstan yang muncul langsung dalam program. Mereka terlihat seperti:

Salinan kode adalah sebagai berikut:

1.23 // Kuantitas langsung

"halo" // berdiri kuantitas langsung

/ pola/ // ekspresi reguler kuantitas langsung

Beberapa kata yang dipesan dalam JavaScript membentuk ekspresi asli

Salinan kode adalah sebagai berikut:

Benar // Nilai Boolean: Benar

false // false

null // return a value: kosong

ini // mengembalikan objek "saat ini"

Melalui pembelajaran Bab 3, tidak seperti kata kunci lainnya, ini bukan konstan, dan nilai -nilai yang dikembalikannya di berbagai bagian program juga berbeda. Kata kunci ini sering muncul dalam pemrograman berorientasi objek. Ini mengembalikan objek metode persegi.

Akhirnya, ekspresi asli ketiga adalah variabel

Salinan kode adalah sebagai berikut:

i // mengembalikan nilai variabel i

jumlah // kembalikan nilai jumlah

tidak ditentukan // adalah variabel global, tidak seperti null, itu bukan kata kunci

2. Ekspresi inisialisasi objek dan array.

Inisialisasi objek dan array sebenarnya adalah objek dan array yang baru dibuat. Ekspresi yang diinisialisasi ini kadang -kadang disebut "Objek Kuantitas Langsung" dan "Array Kuantitas Langsung". Namun, tidak seperti kuantitas langsung Boolean, mereka bukan ekspresi asli karena anggota atau elemen yang dikandungnya adalah sub -ekspresi.

Sintaks dari ekspresi inisialisasi suatu array sangat sederhana, mari kita mulai di bawah

Ekspresi inisialisasi suatu array terdiri dari sepasang tanda kurung persegi dan daftar yang dipisahkan koma. Hasil inisialisasi adalah array yang baru dibuat. Unsur-unsur array adalah nilai ekspresi yang dipisahkan koma.

[] // Array kosong; [] Tinggalkan kosong di dalamnya berarti array tidak memiliki elemen

[1+2,3+4] // Array dengan dua elemen, yang pertama adalah 3, yang kedua adalah 7

Ekspresi inisialisasi elemen dalam ekspresi inisialisasi array dapat berupa ekspresi inisialisasi array. Artinya, ekspresi bisa bersarang

Salinan kode adalah sebagai berikut:

var mat = [[1,2,3], [4,5,6], [7,8,9]];

Elemen antara daftar dalam array dapat dihilangkan, dan ruang akan diisi dengan tidak terdefinisi. Misalnya:

Salinan kode adalah sebagai berikut:

var a = [1 ,,,, 5]

Empat elemen tidak terdefinisi. Suatu koma dibiarkan pada akhir jumlah langsung array, dan elemen baru dengan nilai yang tidak ditentukan tidak akan dibuat.

Ekspresi inisialisasi objek sangat mirip dengan ekspresi inisialisasi array, kecuali bahwa kurung persegi digantikan oleh kurung keriting. Dan setiap ekspresi kata berisi nama atribut dan non-kolon sebagai awalan.

Salinan kode adalah sebagai berikut:

var p = {x: 2.1, y: -3} // Objek dengan dua anggota atribut

var q = {}; // objek kosong

qx = 2.1; qy = -3; // Atribut anggota Q sama dengan PS

Objek tersebut juga dapat bersarang secara langsung, misalnya

Salinan kode adalah sebagai berikut:

var anh = {left: {x: 2, y: 3},

kanan: {x: 4, y: 5}}

Ketika JavaScript menghitung nilai ekspresi inisialisasi objek, ekspresi objek dihitung setiap kali, dan mereka tidak harus memasukkan nilai konstan: mereka dapat berupa ekspresi JavaScript. Demikian pula, nama properti dalam jumlah langsung objek dapat berupa string, bukan pengidentifikasi. (Ini sangat berguna ketika hanya kata -kata yang dicadangkan atau beberapa pengidentifikasi ilegal digunakan sebagai nama atribut pada baris itu)

Salinan kode adalah sebagai berikut:

Sisi var = 1;

var square = {"left": {x: px, y: py},

'kanan': {x: p.x+sisi, y: p.y+sisi}}

Bab 67 juga akan membahas ekspresi inisialisasi objek dan array lagi.

3. Ekspresi fungsi

Ekspresi definisi fungsi mendefinisikan fungsi JavaScript. Nilai ekspresi adalah fungsi yang baru didefinisikan ini. Dalam arti tertentu, ekspresi definisi fungsi dapat menjadi kuantitas fungsi langsung, dan ekspresi fungsi dapat disebut "jumlah fungsi langsung", setelah semua ekspresi inisialisasi objek juga disebut "jumlah objek langsung". Ekspresi definisi fungsi khas berisi fungsi kata kunci, diikuti oleh sepasang tanda kurung, daftar yang dipisahkan koma, dan daftar berisi 0 atau lebih pengidentifikasi (nama parameter). Kemudian ikuti segmen kode JavaScript (bodi fungsi) yang dibungkus dengan kawat gigi keriting.

var square = function (x) {return x*x};

Ekspresi definisi fungsi juga dapat berisi nama fungsi. Fungsi juga dapat didefinisikan oleh pernyataan fungsi, bukan ekspresi fungsi. Lebih banyak konten akan dijelaskan dalam Bab 8.

4. Ekspresi akses atribut

Operasi ekspresi akses atribut memperoleh nilai suatu objek atau elemen array. JavaScript mendefinisikan dua metode untuk akses properti.

Salinan kode adalah sebagai berikut:

ekspresi. indentifier

Ekspresi [Ekspresi]

Cara pertama adalah menulis ekspresi yang diikuti oleh periode dan pengidentifikasi. Ekspresi menentukan objek, dan pengidentifikasi menentukan atribut Mingchuan untuk diakses.

Bab 2 ditulis menggunakan tanda kurung persegi, yang merupakan ekspresi (metode ini cocok untuk objek dan array). Ekspresi kedua menentukan properti Mingchuan yang akan diakses atau indeks yang mewakili elemen array yang akan diakses. Berikut adalah beberapa contoh spesifik

Salinan kode adalah sebagai berikut:

OX // => Atribut Ekspresi O 1x

oyz // => 3 z atribut ekspresi oy

o. ["x"] // => 1 objek o atribut x

a [1] // => 4 elemen dengan indeks ekspresi a adalah 1

a [2] ["1"] // => 6 elemen dengan indeks 1 dalam ekspresi a [2]

A [0] .x // => 1: x Atribut ekspresi a [0]

Terlepas dari bentuk ekspresi akses atribut yang digunakan, ekspresi sebelumnya "." dan "[" selalu dievaluasi terlebih dahulu. Jika hasil evaluasi adalah nol atau tidak terdefinisi, ekspresi akan melempar pengecualian tipe kesalahan karena tidak satu pun dari nilai -nilai ini dapat berisi atribut apa pun. Jika hasil operasi bukan objek atau array, JavaScript akan mengubahnya menjadi objek (Bab 3, Bagian 6)

Meskipun .Identifier ditulis lebih sederhana, harus dicatat bahwa metode ini hanya berlaku untuk nama atribut yang akan diakses dan merupakan pengidentifikasi hukum. Dan Anda perlu mengetahui nama atribut yang akan diakses. Jika nama properti adalah kata yang dipesan atau berisi spasi dan tanda baca dan merupakan angka (untuk array), tanda kurung persegi harus ditulis. Ketika nama atribut adalah nilai yang berasal dari operator daripada nilai tetap, tanda kurung persegi harus ditulis. (Bab 6, 2, 1 bar)

5. Ekspresi transportasi

Ekspresi doa dalam JavaScript adalah representasi sintaks dari panggilan (atau mengeksekusi) fungsi atau metode. Dimulai dengan ekspresi fungsi yang mengacu pada fungsi yang akan dipanggil. Ekspresi fungsi diikuti oleh sepasang tanda kurung, dengan daftar parameter yang dipisahkan koma. Mungkin ada 0 parameter atau beberapa parameter.

F (0) // F adalah ekspresi fungsi: 0 adalah ekspresi parameter.

Math.max (x, y, z) //math.max adalah fungsi; x, y dan z adalah parameter

a.sort () //a.sort () adalah fungsi yang tidak memiliki parameter.

Ketika sebuah ekspresi dipanggil untuk evaluasi, pertama -tama hitung ekspresi fungsi, kemudian hitung ekspresi parameter untuk mendapatkan satu set nilai parameter. Jika nilai ekspresi fungsi bukanlah objek yang dapat dipanggil, pengecualian tipe kesalahan dilemparkan. Nilai parameter kemudian ditetapkan ke parameter formal, yang didefinisikan saat mendefinisikan fungsi. Selanjutnya, jalankan tubuh fungsi. Jika fungsi menggunakan pernyataan pengembalian untuk memberikan nilai pengembalian, maka nilai pengembalian ini adalah nilai dari seluruh ekspresi panggilan. Kalau tidak, nilai ekspresi panggilan tidak terdefinisi. Rincian panggilan fungsi - termasuk jumlah ekspresi parameter formal dan jumlah parameter aktual dalam definisi fungsi - akan dijelaskan secara rinci dalam Bab 8.

Ekspresi panggilan apa pun berisi sepasang tanda kurung dan ekspresi sebelum tanda kurung kiri. Jika ekspresi ini adalah ekspresi akses properti, maka panggilan ini disebut "Metode Undangan". Saat menjalankan badan fungsi dalam panggilan metode, objek dan array yang diakses sebagai atribut adalah penunjuk ini dalam metode panggilan. Fitur ini memungkinkan fungsi (yang nama OO yang "metode") untuk memanggil objek host mereka (lebih lanjut pada Bab 9).

6. Ekspresi Pembuatan Objek

Ekspresi pembuatan objek membuat objek dan memanggil fungsi (konstruktor) untuk menginisialisasi properti objek. Ekspresi pembuatan objek sangat mirip dengan ekspresi panggilan fungsi, kecuali bahwa ada kata kunci tambahan yang baru sebelum ekspresi pembuatan objek:

objek baru ()

Poin Baru (2,3)

Jika ekspresi pembuatan objek tidak memerlukan parameter apa pun untuk diteruskan ke konstruktor, maka sepasang tanda kurung ini dapat dihilangkan. Rincian lebih lanjut dari konstruktor akan dijelaskan di Bab 9

objek baru

poin baru

7. Gambaran Umum Operator

Operator dalam JavaScript digunakan untuk menghitung ekspresi tabel, ekspresi perbandingan, ekspresi logis, ekspresi penugasan, dll.

Perlu dicatat bahwa sebagian besar operator diwakili oleh tanda baca, seperti Delete dan Instanceof. Apakah itu operator kata kunci atau operator simbolik, operator yang diwakili adalah operator reguler, dan sintaksnya sangat ringkas.

Prioritas operator subskrip diurutkan, dan prioritas operator sebelumnya lebih tinggi dari prioritas operator berikutnya. Operator yang dipisahkan oleh huafeng horizontal memiliki prioritas yang berbeda.

A mewakili sifat pengikatan operator.

L dari kiri ke kanan atau r (dari kanan ke kiri)

Daftar judul N mewakili jumlah operan.

Jenis mewakili jenis operan yang diharapkan, dan jenis hasil operator (setelah simbol "→")

Saya. Jumlah operan

Operator dapat diklasifikasikan berdasarkan jumlah operan.

Sebagian besar operator dalam JavaScript adalah operator biner yang menggabungkan dua ekspresi menjadi ekspresi yang sedikit lebih kompleks.

JavaScript juga mendukung beberapa operator unary yang mengonversi satu ekspresi ke ekspresi yang sedikit lebih kompleks. Operator " -" dalam ekspresi -x adalah operator unary. Ini untuk menemukan nilai negatif untuk x.

JavaScript mendukung operator ternary: operator penilaian bersyarat "?:", yang menggabungkan tiga ekspresi menjadi satu ekspresi

ii. Jenis operan dan jenis hasil

Beberapa operator dapat digunakan untuk jenis data apa pun, tetapi mereka masih ingin mereka beroperasi pada data dari jenis yang ditentukan.

III.LVALUE

Operator penugasan dan beberapa operator lain dalam tabel mengharapkan jenis operan mereka, lvalue adalah istilah kuno. Ini berarti bahwa "ekspresi hanya dapat muncul di sisi kiri operator penugasan". Dalam JavaScript, variabel, properti objek, dan elemen array adalah semua lvalues. Spesifikasi ecmascript memungkinkan fungsi bawaan rentang untuk mengembalikan LValue, tetapi fungsi yang ditentukan tidak dapat mengembalikan LValue.

aku aku aku aku. Prioritas operator

Pada tabel di atas, operator yang ditampilkan diurutkan dari tinggi ke rendah berdasarkan prioritas, dengan satu set operator dalam setiap pemisah horizontal memiliki prioritas yang sama. Kontrol Prioritas Operator Perintah di mana operator dieksekusi. Operator dengan tinggi (atas meja) selalu dieksekusi lebih tinggi dari operator dengan prioritas rendah (bawah tabel).

Lihat ekspresi berikut

w = x+y*z;

Operator multiplikasi "*" memiliki prioritas yang lebih tinggi daripada penambahan "+", sehingga multiplikasi dieksekusi terlebih dahulu. Kemudian, karena operator penugasan "=" memiliki prioritas terendah. Oleh karena itu, operasi penugasan dilakukan setelah ekspresi di sebelah kanan menghitung hasilnya.

Prioritas operator dapat ditulis menggunakan tanda kurung taman. Ekspresi di atas dapat ditulis seperti ini.

w = (x + y) * z;

Perlu dicatat bahwa prioritas ekspresi akses properti dan ekspresi panggilan lebih tinggi dari semua operator dalam tabel.

typeof my.function [x] (y)

Meskipun TypeOF adalah salah satu operator prioritas tertinggi, TypeOF juga dieksekusi setelah dua akses properti dan panggilan fungsi.

Faktanya, jika Anda benar -benar tidak yakin dengan prioritas operator yang Anda gunakan, cara termudah adalah dengan menggunakan tanda kurung untuk memaksa urutan operasi. Beberapa aturan penting harus dihafal: perkalian dan pembagian lebih tinggi daripada penambahan dan pengurangan, dan prioritas operasi penugasan sangat rendah, dan biasanya dieksekusi terakhir.

IIIIIII.Operationity

Pada bagian ini, kolom berjudul A mengilustrasikan nodulenitas operator. L mengacu pada kombinasi dari kiri ke kanan, dan R mengacu pada kombinasi dari kanan ke kiri. Tuberkulosis menentukan urutan operasi dalam beberapa ekspresi operator dengan prioritas yang sama.

Misalnya, operasi pengurangan dilakukan dalam kombinasi dari kiri ke kanan.

Salinan kode adalah sebagai berikut:

w = x - y - z

Seperti kode ini:

Salinan kode adalah sebagai berikut:

w = ((x - y) - z)

Sebaliknya, ungkapan berikut:

Salinan kode adalah sebagai berikut:

x = ~ -y;

w = x = y = z;

Q = A? B: C? D: E? F: G;

Persis sama dengan kode ini

Salinan kode adalah sebagai berikut:

x = ~ (-y);

w = (x = (y = z));

Q = A? B: (C? D: (E? F: G))

Karena operator unary, penugasan dan operator kondisi terner semuanya memiliki kombinasi dari kanan ke kiri.

IIIIIIIII. Urutan Operasi

Prioritas dan pengikatan operator menentukan urutan operasi mereka dalam persamaan penugasan, tetapi tidak menentukan urutan operasi dalam proses perhitungan ekspresi kata. JavaScript selalu menghitung ekspresi secara ketat agar dari kiri ke kanan, misalnya:

Dalam ekspresi w = x+y*z, ekspresi w akan dihitung terlebih dahulu, maka x, y dan z akan dihitung, dan kemudian nilai y akan dikalikan dengan z, menambahkan nilai x. Akhirnya, variabel atau atribut yang dirujuk oleh ekspresinya yang dirujuk. Menambahkan braket lingkaran ke ekspresi akan mengubah hubungan antara multiplikasi, penambahan dan operasi penugasan. Namun pesanan dari kiri ke kanan tidak akan berubah.

8. Ekspresi aritmatika

Bagian ini mencakup operator perhitungan aritmatika tersebut, serta operasi aritmatika pada operan. Operator multiplikasi, pembagian dan pengurangan sangat sederhana. Operasi penambahan adalah bagian yang terpisah karena operator tambahan dapat mengoperasikan gabungan string dan konversi jenisnya agak istimewa.

Operator aritmatika dasar adalah *, /, %, +, -. Selain +penambahan, operator lain sangat sederhana. Mereka baru saja dikonversi menjadi angka bila perlu, dan kemudian mereka dapat menemukan produk, hasil bagi, residu (modul) dan perbedaan. Semua operasi yang tidak dapat dikonversi ke angka akan dikonversi ke nilai NAN. Jika operan (atau hasil konversi) adalah nilai NAN, hasil operasi aritmatika juga NAN

Operator "/" membagi operan kedua dengan operan pertama, jika Anda telah menggunakan bahasa pemrograman yang membedakan integer dan titik mengambang. Kemudian ketika Anda membagi bilangan bulat dengan bilangan bulat, hasil yang diinginkan juga merupakan bilangan bulat. Dalam JavaScript, semua angka adalah bilangan poin mengambang, dan hasil operasi divisi juga merupakan tipe titik mengambang. Misalnya, hasil 5/2 adalah 2,5, bukan 2. Hasil operasi dengan pembagi 0 adalah tak terhingga atau tak terbatas negatif. Dan hasil 0/0 adalah Nan. Semua operasi ini tidak akan melaporkan kesalahan.

Operator "%" menghitung modulus operan pertama ke operan kedua, dengan kata lain, operan pertama dibagi dengan sisa operan kedua. Simbol hasil konsisten dengan simbol operasi mouse pertama (dibagi). Misalnya, hasil 5%2 adalah 1, dan -5%2 adalah -1.

Operan operator sisa biasanya bilangan bulat, tetapi mereka juga cocok untuk bilangan titik mengambang. Hasil 6,5%2.1 adalah 0,2. (0,1999999999999999973)

Saya. Operator "+"

Operator Penambahan Biner "+" dapat menambahkan dua angka atau operasi concatenate string:

Salinan kode adalah sebagai berikut:

1+2 // => 3

"halo" + "" + "di sana" // => "halo di sana"

"1"+"2" // => "12"

Ketika kedua operan adalah angka atau string, hasil perhitungannya jelas. Namun, untuk kasus lain, beberapa konversi jenis yang diperlukan diperlukan. Dan perilaku operator tergantung pada hasil konversi jenis. Secara teknis, perilaku operator tambahan adalah:

Jika suatu operan adalah objek, objek akan mengikuti aturan konversi objek ke nilai asli ke nilai kelas asli (lihat Bab 3, Bagian 8, 3). Tanggal melakukan konversi pada metode objek toString (), sementara objek lain melakukan konversi melalui metode nilaiof () (jika metode nilaiof () mengembalikan nilai primitif). Karena sebagian besar objek tidak memiliki nilai yang tersedia metode (), mereka akan menggunakan metode tostring () untuk melakukan perayapan

Setelah objek ke nilai asli dikonversi, jika salah satu operasi adalah string, operan lain juga akan dikonversi menjadi string. Kemudian lakukan gabungan string.

Jika tidak, kedua operan akan dikonversi menjadi angka (atau NAN) dan kemudian ditambahkan.

Berikut adalah beberapa contoh

Salinan kode adalah sebagai berikut:

1 + 2 // => 3 penambahan

"1" + "2" // => "12" koneksi string

"1" + 2 // => "12" angka dikonversi menjadi string dan digabungkan

1 + {} // => "1 [Object Object]": Objek dikonversi ke string dan kemudian string gabungan dilakukan.

true + true // => 2 nilai boolean dikonversi ke angka dan ditambahkan

2 + null // => 2 null dikonversi ke 0 dan lakukan penambahan

2 + tidak terdefinisi // => nan tidak ditentukan dikonversi menjadi NAN untuk penambahan

Akhirnya, penting untuk dicatat. Ketika operasi tanda plus digunakan sesuai dengan string, efek penambahan pada urutan operasi harus dipertimbangkan. Dengan kata lain, hasil operasi tergantung pada perintah operasi operator, misalnya

Salinan kode adalah sebagai berikut:

1 + 2 + "bmice" // => "3 bmice"

1 + (2 + "bmice") => "12bmice"

ii. operator unary

Operator Unary bertindak berdasarkan operan terpisah. dan menghasilkan nilai baru. Dalam JavaScript, operator unary memiliki prioritas tinggi dan semuanya dikombinasikan. Bagian ini menjelaskan operator unary (+,-, ++ dan-), dan bila perlu, mereka mengonversi operasi menjadi angka. Perlu dicatat bahwa + - adalah operator unary, dan juga operator biner.

Penambahan satu-yuan+

Operator penambahan unary mengubah nomor operan menjadi angka (atau NAN) dan mengembalikan nomor yang dikonversi. Jika operan itu sendiri adalah angka, maka nomor tersebut dikembalikan secara langsung.

Pengurangan satu-yuan-

Ketika tanda - adalah operator unary, ia akan mengubah operan menjadi angka sesuai kebutuhan, dan kemudian mengubah simbol hasil operasi.

Kenaikan ++

Meningkatnya operator "++" untuk menambah (+1) operan, dan operan adalah LValue (variabel, elemen array, atau atribut objek). Operator mengonversi operan menjadi angka. Kemudian tambahkan 1 ke nomor dan peroleh kembali nilai setelah menambahkan 1 ke variabel, elemen array atau atribut objek.

Increment ++ Operation mengembalikan nilai yang tergantung pada posisinya pada operan.

Ketika operator sebelum nomor operan, itu disebut operator "pra-pendaratan", yang secara bertahap menghitung operan dan mengembalikan nilai yang dihitung.

Ketika operator mengejar operan, itu disebut operator "pasca-pendarahan". Ini melakukan perhitungan tambahan pada operan, tetapi mengembalikan nilai yang tidak ditimbulkan yang digunakan untuk perhitungan tambahan. menyukai

var i = 1, j = ++ i // nilai i dan j keduanya 2

var i = 1, j = i ++; // i is 2, j is 1

Perlu dicatat bahwa jumlah ++ x = x+1 persis sama. Operator "++" tidak pernah melakukan operasi gabungan string. Itu akan selalu mengonversi operan menjadi angka dan meningkatkannya dengan 1. Jika x adalah string "1", hasil ++ x adalah angka 2, dan x+1 adalah string "11"

Operasi penurunan dan penambahan adalah sama, yang mengubah operan menjadi array dan kemudian mengurangi 1.

aku aku aku. Operator Bit

Operator bit dapat melakukan operasi bitwise tingkat rendah pada data biner yang diwakili oleh angka. Meskipun mereka bukan operasi matematika murni tradisional, mereka juga diklasifikasikan di sini sebagai operator aritmatika karena mereka bertindak berdasarkan operasi jenis numerik dan angka pengembalian. Operator ini tidak umum di JavaScript. (Tidak dijelaskan di sini, silakan gunakan Baidu untuk detailnya ~-~)

9. Ekspresi Relasional

Bagian ini menjelaskan operator hubungan JavaScript. Operator relasional digunakan untuk menguji hubungan antara dua nilai (kesetaraan, kurang dari atau "atribut") dan mengembalikan benar dan salah menurut apakah ada hubungan. Ekspresi relasional selalu mengembalikan nilai boolean, dan biasanya menggunakan ekspresi relasional dalam jika sementara atau untuk pernyataan (Bab 5) untuk mengontrol proses eksekusi program.

Beberapa bagian berikutnya akan berbicara tentang kesetaraan dan operasi yang tidak setara, operator perbandingan dan dua karakter hubungan lainnya di JavaScript di dan instanceof

i Equality dan Operator yang tidak setara

Operator "==" dan "===" digunakan untuk membandingkan apakah dua nilai sama, dan kedua operator memungkinkan operator jenis apa pun. Kembalikan true jika sama, jika tidak, kembalikan salah. "===" juga disebut operator kesetaraan yang ketat (kadang -kadang disebut operator identitas), yang digunakan untuk mendeteksi apakah dua operan sangat sama. Operator "==" disebut operator kesetaraan. Ini digunakan untuk mendeteksi apakah dua operan sama. Definisi kesetaraan di sini longgar dan memungkinkan konversi tipe.

JavaScript mendukung operator "=", "==", "===", Anda harus memahami perbedaan antara operator (penugasan, kesetaraan, identitas). Dan berhati -hatilah saat pemrograman. Untuk mengurangi kebingungan, "=" "harus disebut" dapatkan atau ditugaskan "," == "" harus disebut "setara", dan "===" harus disebut "setara dengan ketat".

Aturan operator "! =" Dan "! ==" adalah "==", kebalikan dari operator "===", dan "!" adalah non-operator boolean. Kami menyebut "! =", "! ==" tidak setara dan tidak sepenuhnya sama.

Perbandingan objek JavaScript adalah perbandingan referensi, bukan perbandingan nilai. Objek dan diri mereka sendiri sama, tetapi mereka tidak sama dengan orang dan benda. Jika dua objek memiliki jumlah atribut yang sama, nama dan nilai atribut yang sama, mereka masih tidak setara. Elemen array pada posisi yang sesuai sama dan dua array juga tidak setara.

Operator Kesetaraan yang ketat "===" Pertama menghitung nilai operan, dan kemudian membandingkan kedua nilai ini. Tidak ada konversi dalam proses perbandingan.

Jika kedua jenis nilai tidak ingin sama, mereka tidak sama

Jika kedua nilai itu nol atau tidak terdefinisi, mereka tidak sama

Jika kedua nilai itu benar atau salah, mereka sama

Jika salah satu nilainya adalah NAN, atau keduanya adalah NAN, mereka tidak sama, dan NAN dan nilai -nilai lainnya tidak sama, termasuk itu sendiri.

Jika dua nilai adalah angka dan sama, mereka sama. Jika suatu nilai adalah 0 dan nilai adalah -0, mereka juga sama.

Jika kedua nilai adalah string dan angka 16 digit (lihat Bab 3, 2) yang terkandung dalam bit yang sesuai persis sama, mereka sama. Jika panjang atau kontennya berbeda, mereka tidak sama. Kedua string mungkin memiliki fungsi yang persis sama dan karakter yang ditampilkan adalah sama, tetapi memiliki nilai 16-bit yang tidak dikodekan. JavaScript tidak melakukan konversi standar pada Unicode, sehingga string seperti itu tidak sama dibandingkan dengan operator "===" dan "==". String.LocaleCompare () di bagian ketiga menyediakan cara lain untuk membandingkan string.

Jika dua nilai referensi menunjuk ke objek, array, atau fungsi yang sama, mereka sama. Jika menunjuk ke objek yang berbeda, mereka adalah ketidaksetaraan, meskipun kedua objek tersebut memiliki sifat yang persis sama.

Operator kesetaraan "==" mirip dengan operator identitas, tetapi operator kesetaraan tidak sepenuhnya dibandingkan. Jika dua angka tidak dari tipe yang sama, operator kesetaraan mencoba melakukan beberapa konversi jenis dan kemudian membandingkan.

Jika kedua operasi itu sama, aturan perbandingan untuk operator kesetaraan di atas adalah sama. Jika sangat sama, maka hasil perbandingannya sama. Jika mereka tidak sepenuhnya sama, hasil perbandingannya tidak sama.

Jika kedua jenis operasi berbeda, operator yang sama "==" juga akan menganggapnya sama. Deteksi kesetaraan akan mengikuti aturan berikut dan jenis konversi:

Jika suatu tipe nol dan biarkan yang lain tidak ditentukan, mereka sama

Jika satu nilai adalah angka dan yang lainnya adalah string, konversi string ke angka terlebih dahulu, dan kemudian gunakan nilai yang dikonversi untuk perbandingan.

Jika suatu nilai benar, itu dikonversi menjadi 1 dan kemudian dibandingkan. Jika suatu nilai salah, itu dikonversi menjadi 0 dan dibandingkan.

Jika satu nilai adalah objek dan yang lainnya adalah angka atau string, gunakan aturan konversi metode di Bab 3, Bagian 8, 3 untuk mengonversi objek ke nilai asli dan kemudian membandingkannya. Objek dikonversi ke nilai asli melalui metode tostring () atau metode nilai (). Kelas bawaan di inti bahasa JavaScript pertama kali mencoba menggunakan nilai () dan kemudian mencoba menggunakan tostring (). Selain kelas tanggal, kelas tanggal hanya dapat dikonversi melalui tostring (). Objek yang tidak berada dalam inti bahasa JavaScript dikonversi ke nilai -nilai asli melalui metode yang ditentukan dalam implementasi.

Perbandingan antara jenis lain tidak sama

Berikut adalah contoh kecil dari penilaian yang sama

"1" == Benar

Hasil ekspresi ini benar, yang menunjukkan bahwa hasil perbandingan dari jenis nilai yang sama sekali berbeda adalah sama. Nilai boolean benar pertama kali dikonversi ke angka 1 dan kemudian perbandingan dilakukan. Selanjutnya string "1" juga dikonversi ke angka 1, karena nilai -nilai dari kedua angka tersebut sama, jadi hasilnya benar.

ii. Operator perbandingan

Kurang dari (<)

Jika operan pertama lebih kecil dari operan kedua, hasil operasi "<" itu benar, jika tidak itu salah

Kurang dari atau sama dengan (<=)

Lebih besar dari (>)

Lebih besar dari atau sama dengan (> =)

.... (tidak ada pengantar rinci tentang maknanya)

Operan operator perbandingan mungkin dari jenis apa pun. Namun, hanya angka dan string yang benar-benar dapat melakukan operator perbandingan, sehingga operan yang bukan angka dan string akan dikonversi tipe. Aturan Konversi Jenis adalah sebagai berikut:

Jika operan adalah objek, itu akan dikonversi ke nilai asli sesuai dengan aturan konversi yang dijelaskan dalam Bagian 3, Bagian 8, 3: Jika nilai () mengembalikan nilai primitif, maka gunakan nilai asli ini secara langsung. Jika tidak, gunakan hasil konversi ToString () untuk perbandingan.

Setelah mengonversi ke nilai asli, jika kedua operan adalah string, kedua string akan dibandingkan dalam urutan alfabet. "Alfabet Order" yang disebutkan di sini adalah urutan indeks dari karakter unicode 16-bit yang membentuk dua string.

Setelah objek dikonversi ke nilai asli, jika setidaknya satu operan bukan string, kedua operan akan membandingkan nilai angka. 0 dan -0 sama. Angka lain apa pun di dinding yang tidak terbatas itu besar (kecuali infinty sendiri), -infinty lebih kecil dari angka apa pun (kecuali dirinya sendiri). Jika operan (atau dikonversi) adalah NAN, karakter perbandingan selalu mengembalikan false

Untuk operator numerik dan string, perilaku operator tanda plus berbeda dari operator perbandingan. Yang pertama lebih suka string dan melakukan operasi gabungan string jika salah satu operannya adalah string. Operator komparatif lebih suka angka hanya ketika kedua operan adalah string string. Hanya dengan begitu perbandingan string akan dilakukan.

Salinan kode adalah sebagai berikut:

1 + 2 // => 3 penambahan, hasilnya adalah 3

"1" + "2" // Sambungkan string, hasilnya adalah "12"

"1" + 2 // Sambungkan string, 2 dikonversi menjadi "2", hasilnya adalah "12"

11 <3 // Perbandingan angka, hasilnya benar

"11" <"3" // Perbandingan Stand, hasilnya benar

"11" <3 // Perbandingan Angka, "11" dikonversi menjadi 11, dan hasilnya benar

"satu" <3 // perbandingan angka, "satu" dikonversi menjadi NAN, dan hasilnya salah

Akhirnya, perlu dicatat bahwa ketika menilai kesetaraan, "<=" dan "> =" operator tidak bergantung pada operator kesetaraan dan aturan perbandingan operasi kesetaraan yang ketat. Sebaliknya, operator ZHI yang kurang dari atau sama dengan hanya "tidak lebih besar dari", sedangkan operasi yang lebih besar atau sama dengan hanya "tidak kurang dari". Dengan hanya satu pengecualian, ketika operan (setelah dikonversi) adalah NAN, semua 4 operator perbandingan akan mengembalikan fasle.

iii.in operator

Operator ingin operan kirinya menjadi string atau dapat dikonversi ke string, dan berharap itu adalah objek di sebelah kanan. Jika objek di sebelah kanan memiliki nama atribut yang disebut nilai operan kiri, ekspresi mengembalikan true. Misalnya

Salinan kode adalah sebagai berikut:

var point = {

X: 1,

Y: 1

} // tentukan suatu objek

"x" di point // => true objek memiliki properti bernama x

"z" di point // => false objek tidak memiliki name z atribut

"ToString" di titik // => objek sejati mewarisi metode tostring

var data = [7, 8, 8]

"0" dalam data // => true array berisi 0

1 dalam data // => Nomor Konversi True ke String

3 dalam data // => fase tidak ada elemen dengan indeks 3

iiii.instanceof operator

Contoh operator ingin operator kiri menjadi objek dan operan kanan menunjukkan kelas objek. Jika objek di sebelah kiri adalah instance dari kelas di sebelah kanan, ekspresi mengembalikan true; itu bertanggung jawab untuk mengembalikan false. Bab 9 akan membicarakannya. Kelas objek JavaScript didefinisikan dengan menginisialisasi konstruktor mereka. Dengan cara ini, operan yang tepat dari instanceof harus menjadi fungsi. Misalnya:

Salinan kode adalah sebagai berikut:

var d = tanggal baru (); // Bangun objek baru

D contoh tanggal; //The result of the calculation is true, d is created by Date()

d instanceof Object //计算结果为true ,所有的对象都是Object的实例

d instanceof Number //计算结果为false，d不是一个Number对象

var a = [1,2,3] //数组直接量创建数组

a instanceof Array //计算结果true a为数组

a instanceof Object //true 所有的数组都是对象

a instanceof RegExp //fasle 数组不是正则表达式

需要注意的是，所有对象都是Object的实例。当通过instanceof盘对一个对象是否为一个类的实例的时候，这个判断也叫“父类”(superclass)的检测，如果instanceof的左侧操作对象不是对象的话，instanceof返回false。如果右侧操作不是函数，则抛出类型错误的异常。

为了理解instanceof运算符是如何工作的，必须首先理解“原型类”（prototype chain），原型链作为javascript的继承机制，将在6章2节2小节详细描述。

为了计算表达式o instanceof f ,javascript笔仙首先计算f.prototyoe,然后在原型链中查询o,如果找到，那么o是f（或者f的父类）的一个实例，那么返回true。反之false

10.逻辑表达式

逻辑运算符"&&"、“||”、“!”是对操作进行布尔算术运算，经常和关系运算符一起配合使用，逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。

Saya. Logic and

"&&"运算符可以从三个不同的层次进行理解。最简单一层理解是，当操作数都是布尔值是，“&&”对两个布尔值执行布尔与（AND）操作，只有在第一个操作数和第二个操作数都是true的时候，它才返回true.如果其中有一个操作数为false.则它返回false.

"&&"长用来连接两个关系表达式

x == 0 && y == 0; //只有在x和y都是0时，才返回true

关系表达式总是返回true或false,因此当这样使用的时候，“&&”本身也返回true或false。关系运算符的优先级要比"&&"（和“||”）要高，因此类似这种表达式可以放心地书写，而不用补充园括号。

The "&&" operand is not necessarily a Boolean value. Recall that some values ​​can be regarded as "true value" and "false value". (For example, in Chapter 3, the false value is: false null undefined 0 -0 NaN and "", all and other values ​​including all objects are true values). The second level of understanding of "&&" is that "&&" can perform Boolean and (AND) operations on true and false values. If both operands are true, then a true value is returned; otherwise, at least one operand is false. In JavaScript, expression statements treat it as true or false when using boolean values, so in fact "&&" does not always return true and false. Tapi itu bukan masalah besar.

需要注意的是，上文提到了运算符返回“真值”和“假值”，但并没说说明这个“真值”或者“假值”到底是什么值，为此我们深入讨论对“&&”第三层的理解。运算符首先计算左操作数的值，即首先计算“&&”左侧的表达式，如果计算结果是假值，那么整个表达式的结果一定是假值，因此“&&”这时简单的返回左操作的值，而并不会对右边的操作数进行计算。

Salinan kode adalah sebagai berikut:

var o = {

x: 1

};

var p = null;

o && ox; //=>1 : 1:0是真值，因此返回值是ox

p && px //= null :p是假值，因此将其返回，而并不计算px

这对于理解“&&”可能不计算右操作数的情况至关重要，在上述代码中，变量P的值是null，而如果计算px的话则会抛出一个异常错误，因此，只有p为真值（不能是null或undefined）的情况下才计算px

"&&"的行为有时候被称为“短路”（short circuiting）,我们经常能看到很多代码利用了这一也行来有条件的执行代码。例如下面的两条代码是等价的

Salinan kode adalah sebagai berikut:

if (a == b) stop(); //只有a==b时才能调运stop()

(a == b) && stop(); //同上

一般来讲，当“&&”右侧的表达式具有副作用的时候（赋值，递增，递减和函数调用表达式）要格外小心。因为这些带有副作用的表达式的执行时候，依赖于左操作鼠的计算结果。

尽管“&&”可以按照第二层和第三层的理解进行一些复杂的表达式运算，但大多数的情况下，“&&”仅用来对真值和假值的做布尔计算。

ii. Logical or (||)

"||"运算符对两个操作数做布尔或（OR）运算。如果其中一个为真值，则返回真值，两个操作数都为假值，返回假值。

尽管“||”运算符大多情况下只是做简单的布尔或（OR）运算，和“&&”一样，也具备一些更复杂的行为，它首先计算第一个操作数的值，也就是说回首先计算左侧的表达式，如果计算结果为真，则返回真值，否则，再计算第二个值。

和“&&”一样，用于应该避免右操作数包含一些具有副作用的表达式，除非你目地明确在右侧使用带副作用的表达式，而有可能不会计算右侧的表达式。

这个运算符最常用的方式是用来从一组备选的表达中选取第一个真值的表达式。

Salinan kode adalah sebagai berikut:

//如果max_width已经定义了，则直接使用它。赋值在preferences对象中查找max_width

//如果没有定义它，则使用一个写死的常量。

var max =max_width || preferences.max_windth || 500;

这种贯用法通常在函数体内，用来给参数提供默认值。

Salinan kode adalah sebagai berikut:

//将o成功的属性复制到p中，并返回p

function copy(o, p) {

p = p || {}; //如果向参数p没有传入任何对象，则使用一个新创建对象。

//函数体内的主逻辑

iii.逻辑非(!)

"!"运算符是一元运算符，它放置在一个单独操作数之前。它的目的是将操作数的布尔值求反。

和"&&"、"||"运算符不同，“!”运算符首先将其操作数转换为布尔值（参考第三章的讲诉规则），然后再对布尔值求反。也就是"!"总是返回true和false。并且，可以通过使用两次逻辑非运算来得到一个值的布尔值：(!!x,参照第三章第八节第2小节)

"!" has a high priority and is closely tied to the operand. If you want to use p && q, you need to bracket! (p && q). The following code:

Salinan kode adalah sebagai berikut:

!(p && q) === !p || !Q

!(p || q) === !p && !q

对于p和q取任何值，这两个表达式永远成立。

11.赋值表达式

javascript使用"="运算符给变量或者属性来赋值，例如：

Salinan kode adalah sebagai berikut:

i = 0 //将变量i设置为0

ox = 1 //将对象o的属性x 设置为1

“=”运算符希望它的左操作数为一个左值：一个变量或者对象属性（或数组元素），它的右操作鼠可以是任意的类型的任意值。赋值表达式的值就是右操作数的值。赋值表达式的副作用是，右操作数的值赋值给左侧的变量或对象属性。这样的话，后续对这个变量和对象的属性的引用都将得到这个值。

尽管赋值表达式的值非常简单，但有时候会看到一些复杂表达式包含赋值表达式的情况。例如：将赋值和检测操作放在一个表达式中：

Salinan kode adalah sebagai berikut:

(a = b) == 0

如果这样的话，应该清楚地知道"="和"=="区别！，需要注意的是，“=”有非常低的优先级，通常在一个较长的表达式中用到一条赋值语句时，需要补充园括号以保障正确的运算顺序。

赋值操作符的结合性是从右至左，也就是说，一个表达式中出现了多个赋值运算符，运算顺序也从右至左，因此，可以通过以下方式对多个变量赋值。

Salinan kode adalah sebagai berikut:

i=j=k=0; //把三个变量初始化为0

带操作的赋值运算：

除了常规的赋值运算外，javascript还支持需要其他的赋值运算符，这些运算符将赋值运算符合其他的运算符连接起来。提供一种更为快捷的运算方式。例如+=运算符执行的是加法运算符和赋值操作，下面的表达式：

total += salaes_tax;

和下面的表达式等价的

total = total + salaes_tax

运算符“+=”可以作用于数字或字符串，如果其操作是数字，它将执行加法运算和赋值操作；如果是字符串，他就执行字符串的连接和赋值操作。

此类型的运算符还包括，"-=","*=","&="等，如下表赋值运算符

运算符示例等价于

+=a+=ba=a+b

-=a-=ba=ab

*=a*=ba=a*b

/=a/=ba=a/b

%=a%=ba=a%b

<<=a<<=ba=a<<b

>>=a>>=ba=a>>b

>>>=a>>>=ba=a>>>b

&=a&=ba=a&b

|=a|=ba=a|b

^=a^=ba=a^b

大多数情况下，表达式为

a op =b

这里的op代表一个运算符，这个表达式等价于

a =a op b

在第一行中，表达式a计算了一次，在第二行中，表达式a计算了两次。

只有a包含具有副作用的表达式（比如函数调用和赋值操作）的时候，两者才不等价。如下两个表达式不等价

Salinan kode adalah sebagai berikut:

data[i++] *= 2;

data[i++] = data[i++] * 2

12.表达式计算

和很多解释性语言一样，javascript同样可以解释运行由javascript源代码组成的字符串，并产生一个值。javascript通过全局函数eval()来完成这个工作。

eval("3+2") //=>5

动态判断源代码中的字符串是一种强大语言的特性，几乎没有必要在实际中应用。如果你使用了eval()，你应该仔细考虑真的需要它。

下面降价eval()基础用法，并介绍两种严格使用它的方法，从代码优化的角度来讲，这两种方法对原有的代码影响是最小的。

i.eval （eval()是一个函数，但由于它已经被当做运算符来对待了。）

eval()只有一个参数，如果传入的参数不是字符串，它直接返回这个参数。如果参数是字符串，它会把字符串当成javascript进行编译(parse)，如果编译失败则抛出一个语法错误(SyntaxError)。如果编译成功，则开始执行这段代码，并返回字符串中最后一个表达式或语句的值，如果最后一个表达式没有语句或者值，则最终返回undefined。如果字符串抛出一个异常，这个异常把该调用的传给eval()

关于eveal()最重要的是，它使用了调用它的变量作用域环境，也就是说，它查找变量的值和定义新变量和函数的操作和局部的代码作用域中的代码一样。如果一个函数定义了一个局部变量x,然后调用了eval("x"),它会返回局部变量的值。如果它调用eval("x=1"),它会改变局部变量的值。如果函数调用了eval("var y=3;")它声明一个新的局部变量y。同样的，一个函数可以通过如下代码声明一个局部函数：

eval("function f(){return x+1;}");

如果最顶层的代码中调用了eval()。当然它会作用于全局变量和全局函数。

ii. Global eval()

eval()具有改变局部变量的能力，这对javascript优化器来说，是一个很大的问题，然而作为一种权宜之计，javascript征对那行调用了eval()函数所做的优化并不多。但当脚本定义了一个别名，并且用令一个名称来调用它，javascript解释器又如何工作呢，为了javascript解释器更加简化。ECMAScipt3标准规定了任何解释器都不允许对eval()赋予别名。如果eval()使用别的别名来调用的话，则会抛出EvalError异常。

实际上，大多数的实现并不是这样做的。当通过别名调用时，eval()会将其字符串当成顶层的全局代码来执行。执行代码可能会定义新的全局变量和全局函数。执行的代码可能会定义新的全局变量和全局函数，或者给全局变量赋值。但却不能修改或修改主调函数中的局部变量，因此这不会影响到函数内的代码优化。

ECMAScript5是反对使用EvalError的，并且规范了eval()的行为。“直接的eval”，当直接使用非限定的“eval”名称，来调用eval()函数时，它总共是在它的上下文作用域内支线。其它间接调用则使用全局函数为其上下文作用域。并且无法读、写、定义局部变量和函数。下面有一段代码实例：

Salinan kode adalah sebagai berikut:

var geval = eval; //使用别名调用eval将是全局eval

var x = "global",

y = "global"; //两个全局变量

function f() { //函数内执行的局部eval

var x = "local" //定于局部变量

eval("x += 'changed';"); //直接eval更改了局部变量的

return x; //返回更改后的局部变量

}

function g() { //这个函数执行了全局eval

var y = "local" //定义了局部变量

geval("y += 'changed';"); //间接改变了局部变量的值

return y; //返回未更改的局部变量

}

console.log(f(), x); //更改了局部变量，输出local changed global

console.log(g(), y); //更改了全局变量，输出local globalchanged

13.其它运算符。

javascript支持很多其它各种各样的运算符。

Saya. Conditional operator (?:)

The conditional operator is the only ternary operator in javascript. Usually this operator is written as "?:". This operator has the third operand, the first operand is before "?", and the second operand is between "?" Dan ":". The third operand is long after ":", e.g.

x > 0 ? x : -x; //求x的绝对值

条件运算符的操作数可以是任意类型。第一个操作数当成布尔值，如果它是真值，那么将计算第二个操作数，并返回计算结果。赋值如果第一个值操作数是假值，那么将计算第三个操作数。并返回计算结果。第二个和第三个操作数总会计算其中之一。不可能两者同时进行。其实使用if语句也达到同样的效果(5.4.1),“?:”运算符只是提供了一种简写形式。这里是一个"?:"的典型使用场景，判断一个变量是否有定义，如果有定义则使用它，如果无定义，则使用一个默认值。

Salinan kode adalah sebagai berikut:

grett = "hello" + (username ? username : "three");

和以下的代码是等价的，但上面的更加简洁

Salinan kode adalah sebagai berikut:

grett = "hello";

if (username)

grett += username;

kalau tidak

grett + "three"

ii.typeof()运算符

typeof是一元运算符，放在单个操作数前面，操作数可以是任何类型，返回值表示操作类型的一个字符串。

Salinan kode adalah sebagai berikut:

x __ typeof x

undefined __ "undefined"

null __ "object"

ture或false __"boolean"

任意数字或NaN __ "Number"

任意字符串__ "String"

任意函数__ "function"

任意内容对象（非函数）__ "object"

任意宿主对象__ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"

typeof最常用的用法写在表达式中们就像这样

(typeof value == "string") ? "" + value + "":value;

typeof运算符同样在swith语句中（5.4.3）非常有用，需要注意的是，typeof运算可以带上园括号。这样让typeof看起来像一个函数名，而非关键字

typeof(i)

iii.delete运算符

delete是一元操作符，它用来删除对象的属性或者数组的元素。就像赋值、递增、递减运算符一样。delete也是具有副作用的。它是用来做删除操作的。不是用来返回一个值的。

Salinan kode adalah sebagai berikut:

var o = {

x: 1,

y: 2

}

delete ox;

"x" in o; //=>false

var a = [1, 2, 3];

delete a[2]; // 删除数组中最后一个元素

2 in a; //=> false 元素2已经在数组中不存在了

a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3

需要注意的是，删除属性或删除数组元素不仅仅设置了一个undefined值，当删除一个属性时，这个属性不复存在。读取一个不存在的值将会返回undefined.关于delete删除还有严格模式下的一些情况，需要学习的人自己试验，这里给一些例子。

Salinan kode adalah sebagai berikut:

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

delete ox; //删除一个对象属性，返回true

typeof ox; //属性不存在，返回"undefined"

delete ox; //删除不存在的属性，返回true;

delete o; //不能删除通过var关键字声明的变量，返回false

delete 1; //参数不是一个左值。

this.x = 1;// 给全局定义一个属性，这里没有使用var

delete x ; //试图删除它，在非严格模式下返回true

//在严格模式下回抛出异常，这时使用"delete this.x"来代替

X; // An error occurred during runtime, no x is defined

6章第三节还有关于delete的讨论。

iii.void运算符。

void是一元运算符，在出现操作数之前，操作数可以是任何类型。这个运算符并不是经常使用：操作数会照常计算，但会忽略计算结果并返回undefined。由于void会忽略操作数的值，因此在操作数具有副作用时使用void来程序更有意义。

这个最常用的带客户端url.在url写带有副作用的表达式，而void则让浏览器不显示在这个表达式的运算结果。

Salinan kode adalah sebagai berikut:

<a href="javascript:void window.open();">new</a>

iiii.逗号运算符。(,)

逗号运算符是二元运算符，它的操作数可以是任意类型。它首先计算左操作数，然后计算右操作数。

Salinan kode adalah sebagai berikut:

i = 0, j = 1, k = 2;

它和下面的代码基本上等价的

i = 0; j = 1; k = 2;

总是会计算左侧的表达式，但计算结果忽略掉，也就是说，只有左侧表达式具有副作用，才会使用逗号运算让代码变得更通畅。逗号运算符最常用的场景是for循环中，这个for循环通常有多个循环变量。

Salinan kode adalah sebagai berikut:

//for循环中的第一个逗号是var语句的一部分

//第二个逗号是逗号运算符

//它将两个表达式(i++和j++)放在一条(for循环中)语句中

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

console.log(i + j);