Rumah >hujung hadapan web >tutorial js >Ungkapan bacaan teras Javascript dan operator_Pengetahuan asas
Ungkapan bacaan teras Javascript dan operator_Pengetahuan asas
- WBOYasal
- 2016-05-16 16:14:251284semak imbas
Ungkapan ialah frasa dalam JavaScript yang akan dikira oleh jurubahasa JavaScript kepada hasil. Jenis ungkapan paling mudah yang biasa digunakan dalam atur cara ialah pembolehubah. Nama pembolehubah juga merupakan ungkapan mudah, dan nilainya ialah nilai yang diberikan kepada pembolehubah.
Ekspresi kompleks terdiri daripada ungkapan mudah. Sebagai contoh, ungkapan akses tatasusunan terdiri daripada ungkapan yang mewakili tatasusunan, kurungan segi empat sama dan ungkapan integer. Hasil daripada ungkapan baharu yang mereka bentuk ialah nilai elemen pada kedudukan tertentu dalam tatasusunan. Surat yang sama
Ungkapan panggilan nombor terdiri daripada ungkapan yang mewakili objek fungsi dan 0 ungkapan berbilang parameter. Cara paling biasa untuk menggabungkan ungkapan mudah menjadi ungkapan kompleks adalah melalui pengendali.
Bab ini (artikel ini) akan menerangkan semua pengendali javascript. Ia juga menerangkan ungkapan yang tidak melibatkan pengendali (seperti mengakses elemen tatasusunan dan panggilan fungsi Sintaks dan gaya pengaturcaraannya sangat serupa dengan bahasa C).
1. Ungkapan elemen
Ungkapan paling mudah ialah "ungkapan primitif", yang merupakan unit ungkapan terkecil - ia tidak mengandungi ungkapan lain. Ungkapan primitif dalam JavaScript mengandungi pemalar atau literal. Kata kunci dan pembolehubah.
Kuantiti langsung ialah nilai tetap yang muncul secara langsung dalam program. Mereka kelihatan seperti:
1.23 //Kuantiti langsung digital
"hello" //String literal
kepada
palsu. Null // Kembalikan nilai: kosong
Ini //Mengembalikan objek "semasa"
Undefined // ialah pembolehubah global, tidak seperti null, ia bukan kata kunci
Pemulaan objek dan tatasusunan sebenarnya adalah objek dan tatasusunan yang baru dicipta Ungkapan ini kadangkala dipanggil "literal objek" dan "literal tatasusunan". Walau bagaimanapun, tidak seperti literal Boolean, ia bukan ungkapan primitif kerana ahli atau unsur yang terkandung di dalamnya adalah subungkapan.
Sintaks ungkapan permulaan tatasusunan adalah sangat mudah. Mari kita mulakan dengan yang berikut
Ungkapan permulaan tatasusunan terdiri daripada sepasang kurungan segi empat sama dan senarai yang dipisahkan dengan koma Hasil permulaan ialah tatasusunan yang baru dibuat. Unsur tatasusunan ialah nilai ungkapan yang dipisahkan koma.
[] // Tatasusunan kosong; meninggalkan kosong dalam [] bermakna tatasusunan itu tidak mempunyai sebarang elemen
[1 2,3 4] // Tatasusunan dengan dua elemen, yang pertama ialah 3, yang kedua ialah 7
Ungkapan permulaan unsur dalam ungkapan permulaan tatasusunan boleh menjadi ungkapan permulaan tatasusunan. Dalam erti kata lain, ungkapan boleh bersarang
Empat daripada elemen tidak ditentukan dengan meninggalkan koma di hujung literal tatasusunan tidak akan mencipta elemen baharu dengan nilai tidak ditentukan.
Ungkapan pemulaan objek sangat serupa dengan ungkapan pemula tatasusunan, kecuali kurungan segi empat sama digantikan dengan pendakap kerinting. Dan setiap sub-ungkapan mengandungi nama sifat dan bukan bertitik sebagai awalan.
var p = {x: 2.1,y: -3} //Objek dengan dua ahli atribut
var q = {}; //Objek kosong
q.x=2.1;q.y=-3; //Ahli atribut q adalah sama dengan p
Tersurat objek juga boleh bersarang, seperti
var anh = {kiri:{x:2,y:3},
var square = {"kiri":{x:p.x,y:p.y},
'kanan':{x:p.x side,y:p.y side}}
3. Ungkapan fungsi
Ungkapan definisi fungsi mentakrifkan fungsi javascript. Nilai ungkapan ialah fungsi yang baru ditakrifkan ini. Dari satu segi, ungkapan definisi fungsi boleh menjadi literal fungsi, dan ungkapan fungsi boleh dipanggil "literal fungsi." Lagipun, ungkapan permulaan objek juga dipanggil "literal objek." Ungkapan definisi fungsi biasa mengandungi fungsi kata kunci, diikuti dengan sepasang kurungan Dalam kurungan ialah senarai dipisahkan koma yang mengandungi 0 atau lebih pengecam (nama parameter). Kemudian ikuti segmen kod JavaScript (badan fungsi) yang dibalut dengan pendakap kerinting.var square = function(x){ return x*x};
Ungkapan definisi fungsi juga boleh mengandungi nama fungsi. Fungsi juga boleh ditakrifkan melalui pernyataan fungsi dan bukannya ungkapan fungsi. Butiran lanjut akan diterangkan dalam Bab 8.
4. Ungkapan akses atribut
Operasi ungkapan akses atribut memperoleh nilai objek atau elemen tatasusunan. JavaScript mentakrifkan dua kaedah untuk akses harta benda.
. a[1] //=>4 Unsur ungkapan a dengan indeks 1
a[2]["1"]//=>6 Unsur dengan indeks 1 dalam ungkapan a[2]
a[0].x //=>1: x atribut ungkapan a[0]
Tidak kira bentuk ungkapan akses atribut yang digunakan, ungkapan sebelum "." dan "[" akan sentiasa dinilai dahulu. Jika ungkapan menilai kepada null atau undefined, ungkapan akan membuang pengecualian TypeError kerana kedua-dua nilai tidak boleh mengandungi sebarang sifat. Jika hasil operasi bukan objek atau tatasusunan, JavaScript akan menukarnya kepada objek (Bab 3, Bahagian 6)
Walaupun cara menulis .identifier adalah lebih mudah, perlu diingatkan bahawa kaedah ini hanya terpakai apabila nama atribut yang hendak diakses ialah pengecam yang sah. Dan perlu tahu nama hartanah yang hendak diakses. Jika nama sifat ialah perkataan terpelihara atau mengandungi ruang dan tanda baca, atau ialah nombor (untuk tatasusunan), ia mesti ditulis dalam kurungan segi empat sama. Apabila nama atribut ialah nilai yang diperoleh oleh operator dan bukannya nilai tetap, kurungan segi empat sama mesti digunakan. (Bab 6, ayat 2, bahagian 1)
5. Ekspresi pergerakan
Ungkapan seruan dalam JavaScript ialah perwakilan tatabahasa untuk memanggil (atau melaksanakan) fungsi atau kaedah. Ia bermula dengan ungkapan fungsi yang merujuk kepada fungsi yang akan dipanggil. Ungkapan fungsi diikuti oleh sepasang kurungan yang mengandungi senarai parameter yang dipisahkan koma. Terdapat 0 atau lebih parameter.
f(0) //f ialah ungkapan fungsi: 0 ialah ungkapan parameter.
Math.max(x,y,z) //Math.max ialah fungsi; x, y dan z ialah parameter
a.sort() //a.sort() ialah fungsi, ia tidak mempunyai parameter.
Apabila ungkapan dipanggil untuk penilaian, ungkapan fungsi pertama kali dinilai, dan kemudian ungkapan parameter dinilai untuk mendapatkan satu set nilai parameter. Jika nilai ungkapan fungsi bukan objek yang boleh dipanggil, pengecualian ralat jenis dilemparkan Kemudian nilai parameter diberikan kepada parameter formal secara bergilir, yang ditakrifkan apabila fungsi ditakrifkan. Seterusnya laksanakan badan fungsi. Jika fungsi menggunakan pernyataan pulangan untuk memberikan nilai pulangan, maka nilai pulangan ialah nilai keseluruhan ungkapan panggilan. Jika tidak, nilai ungkapan panggilan tidak ditentukan Butiran panggilan fungsi—termasuk perkara yang berlaku apabila bilangan ungkapan parameter formal tidak sepadan dengan bilangan parameter sebenar dalam definisi fungsi—akan diterangkan secara terperinci dalam Bab 8. .
Sebarang ungkapan panggilan mengandungi sepasang kurungan dan ungkapan sebelum kurungan kiri Jika ungkapan itu ialah ungkapan akses sifat, maka panggilan itu dipanggil "jemputan kaedah". Apabila badan fungsi dilaksanakan dalam panggilan kaedah, objek dan tatasusunan yang digunakan sebagai atribut untuk mengakses badan adalah titik ini dalam kaedah panggilan. Sifat ini membenarkan fungsi (nama OOnya ialah "kaedah") untuk memanggil objek hosnya dalam paradigma pengaturcaraan berorientasikan objek (lebih lanjut mengenai perkara ini dalam Bab 9).
6. Ekspresi penciptaan objek
Ekspresi penciptaan objek mencipta objek dan memanggil fungsi (pembina) untuk memulakan sifat objek. Ungkapan penciptaan objek sangat serupa dengan ungkapan panggilan fungsi, kecuali terdapat kata kunci tambahan baharu:
sebelum ungkapan penciptaan objek. Objek() baharu
Titik baharu(2,3)
Jika ungkapan penciptaan objek tidak memerlukan sebarang parameter untuk dihantar kepada pembina, maka pasangan kurungan ini boleh ditinggalkan Butiran lanjut pembina akan dijelaskan dalam Bab 9
Objek baharu
Titik baharu
7. Gambaran keseluruhan operator
Pengendali dalam JavaScript digunakan untuk ungkapan jadual, ungkapan perbandingan, ungkapan logik, ungkapan tugasan, dll.
Perlu diingatkan bahawa kebanyakan pengendali diwakili oleh tanda baca, seperti padam dan instanceof Sama ada ia adalah operator kata kunci atau operator simbolik, operator yang diwakili adalah semua operator biasa, dan sintaksnya sangat ringkas dan komprehensif.
Diisih mengikut keutamaan pengendali subskrip, keutamaan pengendali adalah lebih tinggi daripada keutamaan pengendali yang terakhir. Operator yang dipisahkan oleh skalar mendatar mempunyai keutamaan yang berbeza.
A mewakili pergaulan pengendali.
L dari kiri ke kanan atau R (dari kanan ke kiri)
Senarai pengepala N mewakili bilangan operan.
Jenis menunjukkan jenis operan yang dijangkakan dan jenis hasil pengendali (selepas simbol "→")
| Operator | Operasi | A | N | Jenis |
| Kenaikan Pra/Pos | R | 1 | lval→bilangan | |
| -- | Kurang sebelum dan selepas | R | 1 | lval→bilangan |
| - | Terbalik | R | 1 | bilangan→bilangan |
| Tukar kepada nombor | R | 1 | bilangan→bilangan | |
| ~ | Penolakan sedikit demi sedikit | R | 1 | int→int |
| ! | Logik BUKAN | R | 1 | bool→bool |
| padam | Padamkan atribut | R | 1 | lval→bool |
| jenis | Kesan jenis operasi | R | 1 | mana-mana→Str |
| batal | Kembalikan nilai yang tidak ditentukan | R | 1 | sebarang→undef |
| *,/,% | Darab dan bahagi untuk mencari baki | L | 2 | bilangan, bilangan→bilangan |
| , - | Tambah, tolak | L | 2 | bilangan, bilangan→bilangan |
| Gabungan rentetan | L | 2 | str, str→str | |
| << | Anjakan kiri | L | 2 | int, int→int |
| >> | Anjak ke kanan | L | 2 | int, int→int |
| >>> | Anjakan kanan yang tidak ditandatangani |
L |
2 | int, int→int |
| <, <=, >, >= | Bandingkan susunan berangka | L | 2 | num,num→bool |
| <, <=, >, >= | Bandingkan susunan dalam huruf | L | 2 | str, str→bool |
| contoh | Uji kelas objek | L | 2 | obj, func→bool |
| dalam | Uji sama ada atribut itu wujud | L | 2 | str,obj→bool |
| == | Penghakiman kesaksamaan | L | 2 | mana-mana, mana-mana→bool |
| ! = | Penghakiman yang tidak sama rata | L | 2 | mana-mana, mana-mana→bool |
| === | Identiti hakim | L | 2 | mana-mana, mana-mana→bool |
| ! == | Hakim bukan identiti | L | 2 | mana-mana, mana-mana→bool |
| & | Bitwise DAN | L | 2 | int, int→int |
| ^ | Bitwise XOR | L | 2 | int, int→int |
| | | Bitwise ATAU | L | 2 | int, int→int |
| && | Logik DAN | L | 2 | mana-mana, mana-mana→mana-mana |
| || | Logik ATAU | L | 2 | mana-mana, mana-mana→mana-mana |
| ?: | Pengendali bersyarat | R | 3 | bool, mana-mana, mana-mana→ mana-mana |
| = | Tugasan pembolehubah atau penetapan harta objek | R | 2 | lval, mana-mana→ mana-mana |
|
*= /= %= = -= &= ^= |= <<= >>= >>>= |
Operasi dan tugasan | R | 2 | lval, mana-mana→ mana-mana |
| , |
Abaikan operan pertama, Kembalikan operan kedua. |
L | 2 | mana-mana, mana-mana→mana-mana |
i. Bilangan operan
Pengendali boleh dikelaskan mengikut bilangan operan.
Kebanyakan pengendali dalam JavaScript ialah pengendali binari, menggabungkan dua ungkapan menjadi ungkapan yang lebih kompleks sedikit.
JavaScript juga menyokong beberapa operator unary, yang menukar satu ungkapan kepada ungkapan lain yang sedikit lebih kompleks. Operator "-" dalam ungkapan -x ialah operator unary. adalah untuk mengambil nilai negatif x.
JavaScript menyokong operator ternary: operator pertimbangan bersyarat "?:", yang menggabungkan tiga ungkapan menjadi satu ungkapan
ii. Jenis operan dan jenis hasil
Sesetengah operator boleh digunakan pada mana-mana jenis data, tetapi anda masih dijangka beroperasi pada data jenis tertentu.
iii. Nilai kiri
Pengendali tugasan dan beberapa pengendali lain dalam jadual menjangkakan operan mereka daripada jenis lval, nilai adalah istilah kuno. Ia bermaksud "ungkapan hanya boleh muncul di sebelah kiri pengendali tugasan". Dalam JavaScript, pembolehubah, sifat objek dan elemen tatasusunan adalah semua nilai. Spesifikasi ECMAScript membenarkan fungsi terbina dalam berskop untuk mengembalikan nilai, tetapi fungsi yang ditentukan tidak boleh mengembalikan nilai.
iiii Dalam jadual di atas, pengendali yang ditunjukkan disusun dari keutamaan tinggi ke rendah, dan sekumpulan operator dalam setiap garis pemisah mendatar mempunyai keutamaan yang sama. Keutamaan operator mengawal susunan pengendali dilaksanakan. Operator dengan keutamaan yang lebih tinggi (atas jadual) sentiasa dilaksanakan sebelum operator dengan keutamaan yang lebih rendah (bawah jadual).
Lihat ungkapan berikut
w=x y*z;
Operator pendaraban "*" mempunyai keutamaan yang lebih tinggi daripada penambahan " ", jadi pendaraban dilaksanakan terlebih dahulu. Kemudian, kerana pengendali tugasan "=" mempunyai keutamaan terendah. Oleh itu, operasi tugasan dilakukan selepas ungkapan di sebelah kanan dinilai.
Keutamaan pengendali boleh ditulis menggunakan kurungan. Ungkapan di atas boleh ditulis seperti ini.
w = (x y) * z;
Ambil perhatian bahawa ungkapan akses harta dan ungkapan panggilan mempunyai keutamaan yang lebih tinggi daripada semua pengendali dalam jadual.
jenis saya.Fungsi[x](y)
Malah, jika anda benar-benar tidak pasti tentang keutamaan pengendali yang anda gunakan, cara paling mudah ialah menggunakan kurungan untuk memaksa susunan operasi. Terdapat beberapa peraturan penting yang perlu diingat: pendaraban dan pembahagian adalah lebih tinggi daripada penambahan dan penolakan, dan operasi tugasan mempunyai keutamaan yang sangat rendah dan biasanya dilaksanakan terakhir.
Dalam bahagian jadual ini, lajur bertajuk A menerangkan nodulariti pengendali. L bermaksud menggabungkan dari kiri ke kanan, R bermaksud menggabungkan dari kanan ke kiri. Tuberculity menentukan susunan operasi dalam pelbagai ungkapan operator dengan keutamaan yang sama.
Sebagai contoh, operasi tolak dilakukan secara bersekutu dari kiri ke kanan.
q=a?b:c?d:e?f:g;
q=a?b:(c?d:(e?f:g))
Oleh kerana pengendali unari, tugasan dan pengendali bersyarat ternary semuanya mempunyai perkaitan kanan ke kiri.
iiiiiii. Susunan operasi
Keutamaan dan kaitan pengendali menentukan susunan operasi mereka dalam ungkapan tugasan, tetapi tidak menyatakan susunan operasi dalam proses pengiraan subungkapan. JavaScript sentiasa menilai ungkapan dengan ketat dari kiri ke kanan, contohnya:
Dalam ungkapan w=x y*z, ungkapan w akan dikira dahulu, dan kemudian x, y dan z akan dikira Kemudian, nilai y didarab dengan z, dan nilai x ditambah. Akhir sekali, pembolehubah atau atribut yang ditunjukkan oleh ungkapannya w. Menambah kurungan pada ungkapan mengubah hubungan antara operasi pendaraban, penambahan dan tugasan. Tetapi susunan dari kiri ke kanan tidak akan berubah.
8. Ungkapan aritmetik
Bahagian ini merangkumi operator yang melakukan pengiraan aritmetik, serta operasi aritmetik pada operan. Operator darab, bahagi dan tolak adalah sangat mudah. Operasi penambahan adalah bahagian yang berasingan, kerana pengendali penambahan boleh mengendalikan gabungan rentetan, dan penukaran jenisnya agak istimewa.
Pengendali aritmetik asas ialah *, /, %, , -. Kecuali penambahan, pengendali lain adalah sangat mudah. Mereka hanya menukar operator kepada nombor apabila perlu, dan kemudian mengira hasil, hasil, baki (modulus) dan perbezaan. Semua operasi yang tidak boleh ditukar kepada nombor akan ditukar kepada nilai NaN. Jika operan (atau hasil penukaran) ialah nilai NaN, hasil operasi aritmetik juga ialah NaN
Pengendali "/" membahagikan operan kedua dengan operan pertama, jika anda telah menggunakan bahasa pengaturcaraan yang membezakan antara integer dan jenis titik terapung. Kemudian apabila membahagikan integer dengan integer, hasil yang diingini juga adalah integer. Semua nombor dalam JavaScript adalah daripada jenis titik terapung, dan hasil operasi pembahagian juga adalah jenis titik terapung. Sebagai contoh, hasil 5/2 ialah 2.5, bukan 2. Hasil operasi yang membahagi dengan 0 ialah infiniti positif atau infiniti negatif. Dan keputusan 0/0 ialah NaN. Semua operasi ini bebas ralat.
Operan "%" mengira modulus operan pertama kepada operan kedua Dalam erti kata lain, ia adalah baki operan pertama dibahagikan dengan operan kedua. Tanda hasil tetap sama dengan tanda operan pertama (dividen). Sebagai contoh, keputusan 5%2 ialah 1, dan keputusan -5%2 ialah -1.
Operan pengendali selebihnya biasanya integer, tetapi ia juga berfungsi dengan nombor titik terapung. 6.5%2.1 menjadi 0.2. (0.19999999999999973)
i. " " pengendali
Operator penambahan binari " " boleh menambah dua nombor, dan juga boleh melakukan operasi penggabungan rentetan:
1 2 //=> 3
"hello" "" "sana" // =>"hello there"
"1" "2" //=>"12"
Apabila kedua-dua operan ialah nombor atau rentetan, hasil pengiraan adalah jelas. Walau bagaimanapun, untuk kes lain, beberapa penukaran jenis yang diperlukan mesti dilakukan. Dan tingkah laku pengendali bergantung pada hasil penukaran jenis. Dari segi teknikal, pengendali penambahan berkelakuan seperti ini:
Jika operan ialah objek, objek akan ditukar kepada nilai kelas primitif mengikut peraturan penukaran objek kepada nilai primitif (rujuk Bab 3, Bahagian 8, Bahagian 3). Tarikh ditukarkan oleh kaedah toString() objek, dan objek lain ditukar dengan kaedah valueOf() (jika kaedah valueOf() mengembalikan nilai primitif). Memandangkan kebanyakan objek tidak mempunyai kaedah valueOf() yang tersedia, ia akan melakukan penangkapan dan penggantian melalui kaedah toString()
Selepas menukar objek kepada nilai primitif, jika salah satu operan ialah rentetan, operan lain juga ditukar kepada rentetan. Kemudian lakukan penggabungan rentetan.
Jika tidak, kedua-dua operan ditukar kepada nombor (atau NaN) dan operasi tambah dilakukan.
Berikut ialah beberapa contoh
1 2 //=>3 Penambahan
"1" "2" //=>"12" Rangkaian rentetan
"1" 2 //=>"12"Nombor ditukar menjadi rentetan dan kemudian rentetan itu disambungkan
1 {} // = & gt; "1 [objek objek]": Tukar objek ke rentetan dan lakukan rentetan rentetan
benar benar //=>2 Tukar nilai Boolean kepada nombor dan kemudian tambahkannya
2 null //=>2 null ditukar kepada 0 dan kemudian ditambahkan
2 undefined //=>NaN undefined ditukar kepada NaN untuk penambahan
Akhir sekali, sesuatu yang istimewa untuk diperhatikan. Apabila operasi tambah digunakan dengan rentetan, kesan penambahan pada susunan operasi mesti dipertimbangkan. Dalam erti kata lain, hasil operasi bergantung pada susunan operasi pengendali, seperti
1 2 "btikus" //=> "3 btikus"
1 (2 "btikus") => "12btikus"
ii Pengendali unary bertindak pada satu operan. dan menghasilkan nilai baru. Dalam JavaScript, pengendali unari mempunyai keutamaan yang tinggi dan bersekutu kanan. Bahagian ini menerangkan operator unari ( ,-, dan --), yang menukar operasi kepada nombor apabila perlu. Perlu diingat bahawa - ialah pengendali unari dan pengendali binari,
Tambahan satu dolar
Operator penambahan unari menukar nombor operan kepada nombor (atau NaN) dan mengembalikan nombor yang ditukar. Jika operan itu sendiri ialah nombor, nombor ini dikembalikan terus.
Tolak satu dolar-
Apabila tanda - digunakan sebagai operator unary, ia akan menukar operan kepada nombor mengikut keperluan, dan kemudian menukar tanda hasil operasi
kenaikan
Operator kenaikan " " melakukan operasi kenaikan (1) pada operannya, iaitu nilai l (pembolehubah, elemen tatasusunan atau atribut objek). Operator menukarkan operan kepada nombor. Kemudian tambahkan 1 pada nombor dan tetapkan semula nilai tambah kepada pembolehubah, elemen tatasusunan atau harta objek.
Penambahan Nilai pulangan operasi bergantung pada kedudukan operannya.
Apabila operator mendahului operan, ia dipanggil operator "pra-kenaikan" Ia melakukan pengiraan tambahan pada operan dan mengembalikan nilai yang dikira.
Apabila operator selepas operan, ia dipanggil operator "pasca-kenaikan" Ia melakukan pengiraan tambahan pada operan, tetapi mengembalikan nilai yang tidak bertambah. Seperti
var i = 1,j = i //Nilai bagi i dan j ialah kedua-duanya 2
var i = 1,j = i; //i ialah 2, j ialah 1
Perlu diingat bahawa, sama seperti x dan sum x=x 1, pengendali " " tidak pernah melakukan penyambungan rentetan, ia sentiasa menukar operan kepada nombor dan menambahnya dengan 1. Jika x ialah rentetan "1" , hasilnya daripada x ialah nombor 2, dan x 1 ialah rentetan "11"
Kaedah operasi pengurangan dan kenaikan adalah sama Ia menukar operan kepada tatasusunan dan kemudian menurunkannya sebanyak 1.
Pengendali bitwise boleh melakukan operasi bitwise peringkat rendah pada data binari yang diwakili oleh nombor. Walaupun ia bukan operasi matematik tulen tradisional, ia diklasifikasikan di sini sebagai pengendali aritmetik kerana ia beroperasi pada jenis berangka dan nombor pulangan. Pengendali ini tidak biasa dalam JavaScript. (Tidak diterangkan di sini, sila rujuk Baidu untuk butiran~-~)
9. Ungkapan hubungan
Bahagian ini menerangkan operator relasi JavaScript Operator relasi digunakan untuk menguji hubungan antara dua nilai (kesamaan, kurang daripada atau "adalah atribut bagi..."), dan mengembalikan benar dan salah bergantung pada. sama ada hubungan itu wujud .Ungkapan hubungan sentiasa mengembalikan nilai Boolean biasanya digunakan dalam if while atau untuk pernyataan (Bab 5) untuk mengawal aliran pelaksanaan program.
Beberapa bahagian seterusnya akan membincangkan tentang operasi kesamaan dan ketidaksamaan, pengendali perbandingan dan dua lagi pengendali hubungan dalam dan instanceof dalam JavaScript
Pengendali iEquality dan ketidaksamaan
Pengendali "==" dan "===" digunakan untuk membandingkan sama ada dua nilai adalah sama. Mengembalikan benar jika ia sama, sebaliknya mengembalikan palsu "===" juga dipanggil pengendali kesaksamaan yang ketat (kadangkala dipanggil pengendali identiti), yang digunakan untuk mengesan sama ada dua operan adalah sama. Operator "==" dipanggil operator kesamaan, yang digunakan untuk menyemak sama ada dua operan adalah sama. Takrif kesamaan di sini adalah longgar dan membenarkan penukaran jenis.
Javascript menyokong pengendali "=", "==", "===", anda harus memahami perbezaan antara pengendali (tugasan, kesaksamaan, identiti). Dan gunakannya dengan berhati-hati dalam pengaturcaraan. Untuk mengurangkan kekeliruan, "=" hendaklah dipanggil "mendapat atau menugaskan", "==" hendaklah dipanggil "kesamaan", dan "===" hendaklah dipanggil "kesamaan ketat".Peraturan pengendali "!=" dan "!==" ialah "==", penafian pengendali "===", "!" ialah bukan pengendali Boolean, kami akan "!=", " !==" dipanggil ketaksamaan, bukan kesaksamaan ketat
Perbandingan objek JavaScript ialah perbandingan rujukan, bukan perbandingan nilai. Objek adalah sama dengan dirinya sendiri, tetapi orang atau objek itu tidak sama. Jika dua objek mempunyai bilangan sifat yang sama, nama dan nilai harta yang sama, ia masih tidak sama. Walaupun elemen tatasusunan pada kedudukan yang sepadan adalah sama, kedua-dua tatasusunan juga tidak sama.
Pengendali kesaksamaan yang ketat "===" mula-mula mengira nilai operan, dan kemudian membandingkan kedua-dua nilai tanpa sebarang penukaran jenis.
Jika dua jenis nilai tidak sama, ia tidak sama
Jika kedua-dua nilai adalah batal atau tidak ditentukan, ia tidak sama
Jika kedua-dua nilai adalah Boolean benar atau salah, maka ia adalah sama
Jika salah satu nilai adalah NaN, atau kedua-dua nilai adalah NaN, maka mereka tidak sama dengan nilai lain, termasuk dirinya sendiri.
Dua nilai adalah sama jika ia adalah nombor dan sama. Jika nilai ialah 0 dan nilai ialah -0, ia juga sama.
Dua nilai adalah sama jika ia adalah rentetan dan mengandungi 16 digit yang sama dalam bit yang sepadan (lihat Bab 3, Bahagian 2). Jika mereka berbeza dari segi panjang atau kandungan, mereka tidak sama. Dua rentetan mungkin berfungsi sama dan memaparkan aksara yang sama, tetapi mempunyai nilai 16-bit tanpa pengekodan JavaScript tidak melakukan penukaran standard kepada Unicode, jadi rentetan tersebut dihantar melalui "===" dan "==" The keputusan perbandingan operator juga tidak sama. String.localeCompare() dalam Bahagian 3 menyediakan cara lain untuk membandingkan rentetan.
Dua nilai rujukan adalah sama jika ia menunjuk ke objek, tatasusunan, atau fungsi yang sama. Jika mereka menunjuk kepada objek yang berbeza, mereka tidak sama, walaupun kedua-dua objek mempunyai sifat yang sama.
Pengendali kesamarataan "==" adalah serupa dengan pengendali identiti, tetapi perbandingan pengendali kesamarataan tidak ketat. Jika kedua-dua nombor bukan jenis yang sama, pengendali kesamarataan mencuba beberapa jenis penukaran dan kemudian membandingkannya.
Jika kedua-dua jenis operasi adalah sama, peraturan perbandingan adalah sama seperti pengendali kesamaan di atas. Jika benar-benar sama, hasil perbandingan adalah sama. Jika mereka tidak sama rata, hasil perbandingan adalah tidak sama.
Jika dua jenis operasi berbeza, pengendali kesamaan "==" juga akan menganggapnya sama. Mengesan kesaksamaan akan mengikut peraturan berikut dan penukaran jenis:
Jika satu jenis adalah batal dan satu tidak ditentukan, maka mereka adalah sama
Jika satu nilai ialah nombor dan satu lagi adalah rentetan, mula-mula tukar rentetan itu kepada nombor dan kemudian gunakan nilai yang ditukar untuk perbandingan.
Jika nilai adalah benar, ia ditukar kepada 1 dan dibandingkan Jika nilai adalah palsu, ia ditukar kepada 0 untuk perbandingan.
Jika satu nilai ialah objek dan nilai lain ialah nombor atau rentetan, gunakan peraturan penukaran kaedah dalam Bab 3, Bahagian 8, Subseksyen 3 untuk menukar objek kepada nilai primitif, dan kemudian bandingkan. Objek ditukar kepada nilai primitif melalui kaedah toString() atau kaedah valueOf(). Kelas terbina dalam dalam teras bahasa JavaScript mula-mula cuba menggunakan valueOf() dan kemudian cuba menggunakan toString() Kecuali untuk kelas tarikh, kelas tarikh hanya boleh ditukar melalui toString(). Objek yang bukan sebahagian daripada bahasa JavaScript teras ditukar kepada nilai primitif menggunakan kaedah yang ditakrifkan dalam pelaksanaan.
Perbandingan antara jenis lain yang berbeza tidak sama
Berikut ialah contoh kecil kesaksamaan
"1" == benar
Ungkapan ini dinilai kepada benar, yang menunjukkan bahawa nilai jenis yang sama sekali berbeza dibandingkan dengan sama. Boolean true terlebih dahulu ditukar kepada nombor 1 sebelum perbandingan dilakukan. Seterusnya, rentetan "1" juga akan ditukar kepada nombor 1, kerana nilai kedua-dua nombor adalah sama, jadi hasilnya adalah benar.
ii Kurang daripada (<)
Jika operan pertama kurang daripada operan kedua, hasil operasi "<" adalah benar, jika tidak ia adalah palsu
Kurang daripada atau sama dengan (<=)
Lebih hebat daripada (>)
Lebih besar daripada atau sama dengan (>=)
....(tidak memperincikan maksud)
Operan pengendali perbandingan mungkin daripada sebarang jenis. Walau bagaimanapun, hanya nombor dan rentetan yang sebenarnya boleh melakukan pengendali perbandingan, jadi mana-mana operan yang bukan nombor atau rentetan akan menjalani penukaran jenis. Peraturan penukaran jenis adalah seperti berikut:
Jika operan ialah objek, ia ditukar kepada nilai primitif mengikut peraturan penukaran yang diterangkan dalam perihalan kunci dalam Bab 3, Bahagian 8, Subseksyen 3: Jika valueOf() mengembalikan nilai primitif, maka gunakan primitif ini nilai secara langsung. Jika tidak, hasil penukaran toString() digunakan untuk perbandingan.
Selepas menukar pasangan kepada nilai primitif, jika kedua-dua operan ialah rentetan, maka kedua-dua rentetan itu akan dibandingkan dalam susunan abjad "tertib abjad" yang disebut di sini ialah yang membentuk dua rentetan aksara Unicode.
Selepas objek ditukar kepada nilai primitif, jika sekurang-kurangnya satu operan bukan rentetan, kedua-dua operan akan dibandingkan secara berangka. 0 dan -0 adalah sama. Infinty lebih besar daripada mana-mana nombor lain (kecuali infinty sendiri), dan -infinty lebih kecil daripada sebarang nombor (kecuali dirinya sendiri.) Jika operan (atau ditukar) ialah NaN, operator perbandingan sentiasa mengembalikan palsu
Untuk pengendali berangka dan rentetan, pengendali tambah dan pengendali perbandingan berkelakuan berbeza Yang pertama lebih suka rentetan dan melakukan penggabungan rentetan jika salah satu operannya ialah rentetan. Operator perbandingan memilih nombor hanya apabila kedua-dua operan adalah rentetan. Perbandingan rentetan akan dilakukan.
1 2 //=>3 penambahan, hasilnya ialah 3
"1" "2" //Gabungan rentetan, hasilnya ialah "12"
"1" 2 //Gabungan rentetan, 2 ditukar kepada "2", hasilnya ialah "12"
11 < 3 //Perbandingan nombor, hasilnya benar
"11" < "3" //Perbandingan rentetan, hasilnya benar
"11" < 3 //Perbandingan nombor, "11" ditukar kepada 11, dan hasilnya benar
"satu" < 3 //Perbandingan nombor, "satu" ditukar kepada NaN, hasilnya palsu
Akhir sekali, perlu diingatkan bahawa pengendali "<=" dan ">=" tidak bergantung pada pengendali kesaksamaan dan peraturan perbandingan kesaksamaan yang ketat semasa menentukan kesaksamaan. Sebaliknya, pengendali kurang daripada atau sama hanyalah "tidak lebih besar daripada" dan pengendali lebih besar daripada atau sama hanyalah "tidak kurang daripada". Dengan satu pengecualian, apabila salah satu operan (selepas penukaran) ialah NaN, keempat-empat operator perbandingan akan kembali fasle.
pengendali iii.in
Operatorin menjangkakan operan kirinya menjadi rentetan atau boleh ditukar kepada rentetan dan bahagian kanannya menjadi objek. Jika objek di sebelah kanan mempunyai nama sifat yang dinamakan nilai operan kiri, maka ungkapan itu kembali benar Sebagai contoh,
titik var = {
x: 1,
y: 1
// Takrif objek
"x" dalam titik //=>true Objek mempunyai sifat bernama x
"z" dalam titik //=>false Atribut tanpa nama objek ialah z
"toString" dalam titik // =>true Objek mewarisi kaedah toString
var data = [7, 8, 8]
"0" dalam data //=>tatasusunan benar mengandungi 0
1 dalam data //=>Nombor benar ditukar kepada rentetan
3 dalam data //=>fase Tiada unsur dengan indeks 3
iiii.instanceof operator
Operand instanceof menjangkakan operator kiri menjadi objek dan operan kanan untuk menunjukkan kelas objek. Jika objek di sebelah kiri adalah contoh kelas di sebelah kanan, ungkapan itu akan kembali benar; Kelas objek JavaScript ditakrifkan dengan memulakan pembinanya. Dalam kes ini, operan yang betul bagi instanceof harus menjadi fungsi. Contohnya:
var d = new Date(); //Membina objek baharu
d instanceof Date; //Hasil pengiraan adalah benar, d dicipta oleh Date()
d instanceof Object //Hasil pengiraan adalah benar, semua objek adalah contoh Object
d instanceof Number //Hasil pengiraan adalah palsu, d bukan objek Nombor
var a = [1,2,3] //Tersurat tatasusunan mencipta tatasusunan
a instanceof Array //Hasil pengiraan adalah benar a ialah array
instanceof Object //true Semua tatasusunan ialah objek
instanceof RegExp //array fasle bukan ungkapan biasa
Perlu diambil perhatian bahawa semua objek adalah contoh Objek. Apabila menyemak sama ada objek ialah contoh kelas melalui instanceof, penghakiman ini juga dipanggil pengesanan "superclass" Jika objek operasi kiri instanceof bukan objek, instanceof mengembalikan palsu. Jika operasi tangan kanan bukan fungsi, pengecualian kesalahan taip akan dilemparkan.
Untuk memahami cara operator instanceof berfungsi, anda mesti terlebih dahulu memahami "rantaian prototaip". Rantaian prototaip, sebagai mekanisme pewarisan JavaScript, akan diterangkan secara terperinci dalam Bab 6, Bahagian 2, Bahagian 2.
Untuk mengira ungkapan o instancef, JavaScript PenXian terlebih dahulu mengira f.prototyoe, dan kemudian bertanya o dalam rantai prototaip, maka o ialah tika f (atau kelas induk f), kemudian benar dikembalikan. Jika tidak palsu
10. Ungkapan logik
Operator logik "&&", "||", dan "!" menjalankan operasi aritmetik Boolean ia sering digunakan bersama-sama dengan operator logik untuk membentuk ungkapan yang lebih kompleks.
i. Logik DAN
Pengendali "&&" boleh difahami dari tiga tahap berbeza. Pemahaman yang paling mudah ialah apabila operan ialah kedua-dua nilai Boolean, "&&" melakukan operasi Boolean AND (AND) pada dua nilai Boolean, hanya apabila operan pertama dan operan kedua adalah benar, ia akan kembali benar operan adalah palsu, kemudian ia kembali palsu.
"&&" digunakan untuk menyambung dua ungkapan hubungan
x == 0 && y == 0; //Kembalikan benar hanya apabila x dan y kedua-duanya 0
Ungkapan hubungan sentiasa mengembalikan benar atau salah, jadi apabila digunakan seperti ini, "&&" itu sendiri juga mengembalikan benar atau salah. Pengendali perhubungan mempunyai keutamaan yang lebih tinggi daripada "&&" (dan "||"), jadi ungkapan seperti ini boleh ditulis dengan selamat tanpa memerlukan tanda kurungan.
Operan "&&" tidak semestinya nilai Boolean. Ingat bahawa sesetengah nilai boleh dianggap sebagai "nilai benar" dan "nilai palsu". (Seperti dalam Bab 3, Bahagian 3, nilai palsu ialah: false null undefined 0 -0 NaN dan "", semua dan nilai lain termasuk semua objek adalah nilai benar). Tahap kedua pemahaman "&&" ialah "&&" boleh melakukan operasi Boolean AND (AND) pada nilai benar dan salah. Jika kedua-dua operan adalah benar, maka nilai benar dikembalikan jika tidak, sekurang-kurangnya satu operan adalah palsu. Pada bila-bila masa nilai Boolean digunakan dalam JavaScript, pernyataan ungkapan akan menganggapnya sebagai nilai benar atau salah, jadi sebenarnya "&&" tidak selalu mengembalikan benar dan salah Tetapi ia bukan masalah besar.
Perlu diambil perhatian bahawa pengendali yang disebutkan di atas mengembalikan "nilai sebenar" dan "nilai palsu", tetapi ia tidak menjelaskan apakah "nilai sebenar" atau "nilai palsu" Atas sebab ini, kita akan membincangkan secara mendalam . Pemahaman tentang lapisan ketiga "&&". Operator mula-mula mengira nilai operan kiri, iaitu, ia mula-mula mengira ungkapan di sebelah kiri "&&". Jika hasil pengiraan adalah nilai palsu, maka hasil keseluruhan ungkapan mestilah nilai palsu, jadi "&&" hanya mengembalikan operan kiri Nilai operasi, tanpa mengira operan di sebelah kanan.
var o = {
x: 1
};
var p = null;
o && o.x; //=>1 : 1:0 ialah nilai sebenar, jadi nilai pulangan ialah o.x
p && p.x //= null: p ialah nilai palsu, jadi ia dikembalikan tanpa mengira p.x
Ini penting untuk memahami bahawa "&&" mungkin tidak mengira operan yang betul Dalam kod di atas, nilai pembolehubah P adalah nol, dan jika p.x dikira, ralat pengecualian akan dilemparkan
dikira hanya jika ia adalah nilai sebenar (tidak boleh batal atau tidak ditentukan)Tingkah laku "&&" kadangkala dipanggil "litar pintas", dan kita sering melihat banyak kod mengambil kesempatan daripada ini untuk melaksanakan kod secara bersyarat. Contohnya, dua kod berikut adalah bersamaan
Jika (a == b) berhenti (); // Hanya apabila anda hanya == B, anda boleh memindahkan hentian ()
(a == b) && stop(); //Sama seperti di atas
Secara amnya, berhati-hati apabila ungkapan di sebelah kanan "&&" mempunyai kesan sampingan (ungkapan penugasan, kenaikan, pengurangan dan panggilan fungsi). Kerana pelaksanaan ungkapan ini dengan kesan sampingan bergantung pada hasil pengiraan tetikus operator kiri.
Walaupun "&&" boleh melakukan beberapa operasi ungkapan kompleks mengikut pemahaman tahap kedua dan ketiga, dalam kebanyakan kes, "&&" hanya digunakan untuk melakukan pengiraan Boolean pada nilai benar dan salah.
ii. Logik ATAU (||)
Pengendali "||" melakukan operasi Boolean OR (OR) pada dua operan. Jika salah satu operan adalah benar, ia akan kembali benar, jika kedua-dua operan adalah palsu, ia akan kembali palsu.
Walaupun pengendali "||" hanya melakukan operasi Boolean OR (OR) dalam kebanyakan kes, seperti "&&", ia juga mempunyai beberapa gelagat yang lebih kompleks terlebih dahulu mengira nilai operan pertama untuk mengatakan, ungkapan di sebelah kiri pertama dikira Jika hasil pengiraan adalah benar, nilai sebenar dikembalikan.
Seperti "&&", anda harus mengelakkan operan kanan yang mengandungi beberapa ungkapan dengan kesan sampingan, melainkan anda secara eksplisit menggunakan ungkapan dengan kesan sampingan di sebelah kanan dan ungkapan di sebelah kanan mungkin tidak dinilai.
Cara paling biasa operator ini digunakan ialah memilih ungkapan bernilai benar pertama daripada set ungkapan alternatif.
//Jika max_width telah ditentukan, gunakan terus. Tugasan mencari max_width
dalam objek pilihan //Jika ia tidak ditakrifkan, pemalar berkod keras digunakan.
var max =max_width ||
salinan fungsi(o, p) {
p = p || {}; //Jika tiada objek dihantar ke parameter p, objek yang baru dibuat digunakan.
//Logik utama dalam badan fungsi
iii. Logik BUKAN (!)
Pengendali "!" ialah operator unari yang diletakkan sebelum operan tunggal. Tujuannya adalah untuk menafikan nilai Boolean operan.Berbeza daripada pengendali "&&" dan "||", pengendali "!" mula-mula menukar operannya kepada nilai Boolean (rujuk peraturan rayuan dalam Bab 3), dan kemudian menafikan nilai Boolean. Iaitu, "!" sentiasa kembali benar dan salah. Selain itu, nilai Boolean sesuatu nilai boleh diperolehi dengan menggunakan dua operasi NOT logik: (!!x, rujuk Bab 3, Bahagian 8, Bahagian 2)
"!" mempunyai keutamaan yang tinggi dan berkait rapat dengan operan Jika anda ingin membandingkan p && q, anda memerlukan tanda kurung! Kod berikut:
!(p || q) === !p && !q
11. Ungkapan tugasan
Javascript menggunakan operator "=" untuk memberikan nilai kepada pembolehubah atau atribut, contohnya:
o.x = 1 //Tetapkan atribut x objek o kepada 1
Der „="-Operator erwartet, dass sein linker Operand ein L-Wert ist: eine Variable oder Objekteigenschaft (oder ein Array-Element), und sein rechter Operand kann ein beliebiger Wert eines beliebigen Typs sein. Der Wert des Zuweisungsausdrucks ist der Wert des rechten Operanden. Ein Nebeneffekt eines Zuweisungsausdrucks besteht darin, dass der Wert des rechten Operanden der Variablen oder Objekteigenschaft auf der linken Seite zugewiesen wird. In diesem Fall erhalten nachfolgende Verweise auf diese Variable und die Eigenschaften des Objekts diesen Wert.
Obwohl der Wert eines Zuweisungsausdrucks sehr einfach ist, werden Sie manchmal einige komplexe Ausdrücke sehen, die Zuweisungsausdrücke enthalten. Beispiel: Fügen Sie Zuweisungs- und Erkennungsoperationen in einen Ausdruck ein:
(a = b) == 0
Wenn dies der Fall ist, sollten Sie den Unterschied zwischen „=“ und „==“ genau kennen! Es ist zu beachten, dass „=" normalerweise eine sehr niedrige Priorität hat, wenn eine Zuweisungsanweisung in einem langen Ausdruck verwendet wird, um die korrekte Reihenfolge der Operationen sicherzustellen.
Die Assoziativität von Zuweisungsoperatoren verläuft von rechts nach links, das heißt, in einem Ausdruck erscheinen mehrere Zuweisungsoperatoren, und die Reihenfolge der Operationen verläuft auch von rechts nach links. Daher können mehrere Variablen auf folgende Weise zugewiesen werden .
i=j=k=0; // Initialisiere die drei Variablen auf 0
Zuweisung Operation mit Operation:
Zusätzlich zu regulären Zuweisungsoperationen unterstützt JavaScript auch andere Zuweisungsoperatoren, die Zuweisungsoperationen mit anderen Operatoren verbinden. Stellen Sie eine schnellere Berechnungsmethode bereit. Beispielsweise führt der =-Operator den Additionsoperator und die Zuweisungsoperation mit dem folgenden Ausdruck aus:
total = salaes_tax;
Entspricht dem folgenden Ausdruck
total = gesamte salaes_tax
Der Operator „=“ kann auf Zahlen oder Zeichenfolgen einwirken. Wenn es sich bei seiner Operation um eine Zahl handelt, führt er Additions- und Zuweisungsoperationen aus.
Diese Art von Operatoren umfasst auch „-=“, „*=“, „&=" usw., wie in der folgenden Tabelle der Zuweisungsoperatoren gezeigt
Beispiel für den-Operator Äquivalent zu
= a =b a=a b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
<<= a<<=b a=a<
>>>= a>>>=b a=a>>>b
&= a&=b a=a&b
|= a|=b a=a|b
^= a^=b a=a^b
In den meisten Fällen lautet der Ausdruck
a op =b
Der op stellt hier einen Operator dar und dieser Ausdruck entspricht
a =a op b
In der ersten Zeile wird der Ausdruck a einmal ausgewertet und in der zweiten Zeile wird der Ausdruck a zweimal ausgewertet.
Die beiden sind nur dann nicht gleichwertig, wenn a Ausdrücke mit Nebenwirkungen enthält (z. B. Funktionsaufrufe und Zuweisungsoperationen). Die folgenden beiden Ausdrücke sind nicht gleichwertig
data[i] *= 2;
data[i] = data[i] * 2
12. Ausdrucksberechnung
Wie viele interpretierte Sprachen kann auch JavaScript eine aus JavaScript-Quellcode bestehende Zeichenfolge interpretieren und ausführen und einen Wert generieren. JavaScript verwendet die globale Funktion eval(), um diese Arbeit abzuschließen.
eval("3 2") //=>5
Die dynamische Bestimmung von Zeichenfolgen im Quellcode ist eine leistungsstarke Sprachfunktion, deren Anwendung in der Praxis selten erforderlich ist. Wenn Sie eval() verwenden, sollten Sie sorgfältig abwägen, ob Sie es wirklich benötigen.
Im Folgenden wird die grundlegende Verwendung von eval() reduziert und zwei Methoden für die strikte Verwendung vorgestellt. Aus Sicht der Codeoptimierung haben diese beiden Methoden den geringsten Einfluss auf den Originalcode.
i.eval (eval() ist eine Funktion, wurde aber als Operator behandelt.)
eval() hat nur einen Parameter. Wenn der übergebene Parameter kein String ist, wird dieser Parameter direkt zurückgegeben. Wenn der Parameter eine Zeichenfolge ist, wird die Zeichenfolge als JavaScript kompiliert (parsen). Wenn die Kompilierung fehlschlägt, wird ein Syntaxfehler (SyntaxError) ausgegeben. Wenn die Kompilierung erfolgreich ist, wird dieser Code ausgeführt und der Wert des letzten Ausdrucks oder der letzten Anweisung in der Zeichenfolge zurückgegeben. Wenn der letzte Ausdruck keine Anweisung oder keinen Wert hat, wird schließlich undefiniert zurückgegeben. Wenn die Zeichenfolge eine Ausnahme auslöst, übergibt die Ausnahme den Aufruf an eval()
Das Wichtigste an eveal() ist, dass es die Variablenbereichsumgebung des Aufrufers verwendet, das heißt, es sucht nach dem Wert der Variablen und definiert neue Variablen und Funktionen auf die gleiche Weise wie der Code im Lokaler Codebereich. Wenn eine Funktion eine lokale Variable x definiert und dann eval("x") aufruft, gibt sie den Wert der lokalen Variablen zurück. Wenn es eval("x=1") aufruft, ändert es den Wert der lokalen Variablen. Wenn die Funktion eval("var y=3;") aufruft, deklariert sie eine neue lokale Variable y. Ebenso kann eine Funktion über den folgenden Code eine lokale Funktion deklarieren:
eval("function f(){return x 1;}");
Wenn eval() im Code der obersten Ebene aufgerufen wird. Natürlich wird es auf globale Variablen und globale Funktionen wirken.
ii. Globale Bewertung()
eval() hat die Möglichkeit, lokale Variablen zu ändern. Dies ist ein großes Problem für den Javascript-Optimierer. Als Notlösung führt Javascript jedoch nicht das aus, was die Funktion eval() tut . Aber wie funktioniert der JavaScript-Interpreter, wenn das Skript einen Alias definiert und ihn mit einem Namen aufruft? Der ECMAScipt3-Standard schreibt vor, dass kein Interpreter eval() Aliase zuweisen darf. Wenn eval() unter Verwendung eines anderen Alias aufgerufen wird, wird eine EvalError-Ausnahme ausgelöst.
Tatsächlich tun dies die meisten Implementierungen nicht. Wenn eval() über einen Alias aufgerufen wird, führt es seine Zeichenfolge als globalen Code der obersten Ebene aus. Durch das Ausführen von Code können neue globale Variablen und globale Funktionen definiert werden. Der ausgeführte Code kann neue globale Variablen und globale Funktionen definieren oder globalen Variablen Werte zuweisen. Lokale Variablen in der aufrufenden Funktion können jedoch nicht geändert oder geändert werden, sodass dies keinen Einfluss auf die Codeoptimierung innerhalb der Funktion hat.
ECMAScript5 lehnt die Verwendung von EvalError ab und standardisiert das Verhalten von eval(). „Direkte Auswertung“: Wenn die Funktion eval() direkt unter Verwendung des unqualifizierten Namens „eval“ aufgerufen wird, verzweigt sie immer innerhalb ihres Kontextbereichs. Andere indirekte Aufrufe verwenden globale Funktionen als Kontextbereich. Und kann keine lokalen Variablen und Funktionen lesen, schreiben oder definieren. Hier ist ein Codebeispiel:
var geval = eval; // Der Aufruf von eval unter Verwendung eines Alias ist eine globale Auswertung
var x = "global",
y = "global" //Zwei globale Variablen
function f() { //Lokale Auswertung
innerhalb der Funktion ausgeführt var eval("x = 'changed';"); // Ändert direkt das
der lokalen Variablen Zurückkehren }
function g() { //Diese Funktion führt eine globale Auswertung aus
var y = "local" //Lokale Variablen sind definiert
geval("y = 'changed';" //Indirekt den Wert lokaler Variablen geändert
Return y; // Rückkehr zu den unveränderten lokalen Variablen
}
console.log(f(), x); //Lokale Variablen wurden geändert, Ausgabe lokal geändert global
console.log(g(), y); //Die globale Variable wurde geändert, Ausgabe lokal globalchanged
Javascript unterstützt viele andere verschiedene Operatoren.
i. Bedingter Operator (?:)Der bedingte Operator ist der einzige ternäre Operator in JavaScript. Normalerweise wird dieser Operator als „?:“ geschrieben. Der erste Operand steht vor „?“ und der zweite Operand steht zwischen „?“. Der dritte Operand steht erst nach „:“, z. B.
x > 0 ? x : -x; //Finde den absoluten Wert von x
Die Operanden von Bedingungsoperatoren können beliebigen Typs sein. Der erste Operand wird als boolescher Wert behandelt. Wenn er wahr ist, wird der zweite Operand ausgewertet und das Ergebnis zurückgegeben. Zuweisung: Wenn der erste Wertoperand falsch ist, wird der dritte Operand ausgewertet. und das Berechnungsergebnis zurückgeben. Der zweite und dritte Operand ergeben immer einen von ihnen. Es ist unmöglich, beides gleichzeitig zu tun. Tatsächlich kann der gleiche Effekt mit if-Anweisungen (5.4.1) erzielt werden. Der „?:“-Operator stellt lediglich eine Kurzform dar. Hier ist ein typisches Verwendungsszenario von „?:“, das bestimmt, ob eine Variable definiert ist, wird sie verwendet. Wenn sie nicht definiert ist, wird ein Standardwert verwendet.
Artikel berkaitan
Lihat lagi- Analisis mendalam bagi komponen kumpulan senarai Bootstrap
- Penjelasan terperinci tentang fungsi JavaScript kari
- Contoh lengkap penjanaan kata laluan JS dan pengesanan kekuatan (dengan muat turun kod sumber demo)
- Angularjs menyepadukan UI WeChat (weui)
- Cara cepat bertukar antara Cina Tradisional dan Cina Ringkas dengan JavaScript dan helah untuk tapak web menyokong pertukaran antara kemahiran_javascript Cina Ringkas dan Tradisional