Rumah > Artikel > hujung hadapan web > Jenis bacaan teras Javascript, nilai dan pembolehubah_Pengetahuan asas
Jenis bacaan teras Javascript, nilai dan pembolehubah_Pengetahuan asas
- WBOYasal
- 2016-05-16 16:14:291144semak imbas
Pengendalian program komputer memerlukan operasi nilai seperti nombor 3.14 atau teks "hello world". Dalam bahasa pengaturcaraan, jenis nilai yang boleh diwakili dan dimanipulasi dipanggil jenis data ( jenis). Bahasa pengaturcaraan yang paling asas Ciri ini adalah untuk mengehoskan pelbagai jenis data. Apabila program perlu menyimpan nilai untuk kegunaan masa hadapan, ia memberikannya ("menjimatkan" nilai kepada) pembolehubah. Pembolehubah ialah nama simbolik untuk nilai, dan rujukan kepada nilai boleh diperoleh dengan nama. Cara pembolehubah berfungsi ialah ciri asas bahasa pengaturcaraan. Bab ini akan merujuk kepada bahagian sebelumnya untuk membantu memahami kandungan bab ini, dan akan diterangkan dengan lebih mendalam kemudian.
Data JavaScript dibahagikan kepada dua kategori: jenis primitif dan jenis objek
Kelas asal dalam JavaScript termasuk nombor, rentetan dan nilai Boolean Bab ini akan mempunyai bab berasingan yang dikhaskan untuk nombor, rentetan dan nilai Boolean dalam JavaScript. JavaScript juga mempunyai dua nilai primitif khas, null (kosong) dan Undefined (undefined) Ia bukan nombor, rentetan atau nilai Boolean. Mereka masing-masing mewakili ahli unik jenis khas mereka sendiri.
Javascript ialah objek sebagai tambahan kepada nombor, rentetan, nilai Boolean, null dan undefined. Objek ialah koleksi sifat. Setiap atribut terdiri daripada "pasangan nama/nilai" (nilai boleh menjadi nilai primitif, seperti nombor, rentetan atau objek). Salah satu objek yang lebih istimewa (objek global akan diperkenalkan dalam Miss 5, dan akan diterangkan dengan lebih terperinci dalam Bahagian 6)
Objek JavaScript biasa ialah koleksi "nilai bernama" yang tidak diperlukan. JavaScript juga mentakrifkan objek khas - tatasusunan, yang mewakili koleksi tersusun nilai bernombor. JavaScript mentakrifkan sintaks khas untuk tatasusunan. Buat tatasusunan mempunyai beberapa sifat tingkah laku unik yang berbeza daripada objek biasa.
Javascript juga mentakrifkan fungsi objek khas. Fungsi ialah objek yang mempunyai kod boleh laku yang dikaitkan dengannya Fungsi dipanggil untuk menjalankan kod boleh laku dan mengembalikan hasil operasi. Seperti tatasusunan, fungsi berkelakuan berbeza daripada objek lain. JavaScript mentakrifkan sintaks khas untuk menggunakan fungsi. Untuk fungsi javascript. Paling penting, semuanya adalah nilai sebenar, dan JavaScript boleh memperlakukannya seperti objek biasa.
Jika fungsi memulakan (menggunakan operator baharu) objek baharu, kami memanggilnya sebagai pembina. Setiap pembina mentakrifkan kelas objek—kumpulan objek yang dimulakan oleh pembina. Kelas boleh dianggap sebagai subjenis jenis objek. Sebagai tambahan kepada kelas tatasusunan dan kelas fungsi, JavaScript juga mentakrifkan tiga kelas berguna lain. Tarikh mentakrifkan objek yang mewakili tarikh. Objek biasa (regExp) mentakrifkan ungkapan biasa. Kelas ralat mentakrifkan objek yang mewakili ralat masa jalan dan ralat sintaks dalam program JavaScript. Anda boleh menentukan kelas yang diperlukan dengan menentukan pembina anda sendiri.
Jurubahasa JavaScript mempunyai mekanisme pengurusan ingatan sendiri yang boleh melakukan pengumpulan sampah secara automatik pada memori. Ini bermakna program ini boleh mencipta objek atas permintaan, dan pengaturcara tidak perlu risau tentang kemusnahan objek ini dan kitar semula memori. Apabila tiada lagi rujukan kepada objek, penterjemah tahu bahawa objek itu tidak lagi berguna, dan secara automatik akan menuntut semula sumber memori yang didudukinya.
JavaScript ialah bahasa berorientasikan objek. Secara longgar, ini bermakna kita tidak perlu mentakrifkan fungsi secara global untuk mengendalikan jenis nilai yang berbeza. Jenis data itu sendiri boleh menentukan kaedah untuk menggunakan nilai Contohnya, untuk mengisih unsur dalam tatasusunan a, tidak perlu lulus a Masukkan fungsi sort(), tetapi panggil method sort()
a.sort(); //Versi berorientasikan objek bagi sort(a)
Secara teknikal, hanya objek JavaScript boleh mempunyai kaedah. Walau bagaimanapun, nombor, rentetan, dan nilai Boolean juga mempunyai kaedah mereka sendiri. Dalam JavaScript, hanya null dan undefined adalah nilai yang tidak boleh mempunyai kaedah.
Jenis JavaScript boleh dibahagikan kepada jenis primitif dan jenis objek, dan boleh dibahagikan kepada jenis yang boleh mempunyai kaedah dan jenis yang tidak mempunyai kaedah. Ia juga boleh dibahagikan kepada jenis boleh ubah dan tidak berubah. Nilai jenis pembolehubah boleh diubah suai Objek dan tatasusunan adalah jenis pembolehubah: Program JavaScript boleh menukar nilai atribut objek dan nilai elemen tatasusunan.
Nombor, nilai Boolean, null dan undefined ialah jenis yang tidak boleh diubah. Sebagai contoh, mengubah suai kandungan tatasusunan tidak masuk akal dengan sendirinya. Rentetan boleh dianggap sebagai tatasusunan aksara, dan anda boleh menganggapnya sebagai boleh diubah. Walau bagaimanapun, dalam JavaScript, rentetan tidak boleh diubah. Anda boleh mengakses teks di mana-mana kedudukan dalam rentetan, tetapi JavaScript tidak menyediakan kaedah untuk mengubah suai kandungan teks rentetan.
Javascript boleh melakukan penukaran jenis data secara bebas. Contohnya, jika nombor digunakan di mana program menjangkakan rentetan, JavaScript akan menukar nombor itu kepada rentetan secara automatik. Jika nilai bukan Boolean digunakan di mana nilai Boolean dijangka, JavaScript akan menukar sewajarnya. Peraturan merebut dan menukar jenis fleksibel dalam JavaScript untuk "kesamaan"
Pembolehubah JavaScript tidak ditaip Pembolehubah boleh diberikan nilai manusia dan jenis Gunakan kata kunci var untuk mengisytiharkan pembolehubah. JavaScript menggunakan skop sintaksis Pembolehubah yang tidak diisytiharkan dalam mana-mana fungsi dipanggil pembolehubah global, yang boleh dilihat di mana-mana dalam program JavaScript.
1
Tidak seperti bahasa pengaturcaraan lain, JavaScript tidak membezakan antara nilai integer dan nilai titik terapung. Nilai berangka dalam JavaScript diwakili oleh nilai titik terapung. Apabila nombor muncul terus dalam program JavaScript, kami memanggilnya literal angka JavaScript menyokong literal angka dalam berbilang format. (Nota: Menambah tanda tolak (-) terus sebelum sebarang nombor memberikan anda nilai negatifnya) Tetapi tanda tolak ialah operator penolakan unary. , bukan sebahagian daripada tatabahasa literal angka. )kuantiti langsung integer i
Gunakan jujukan tatasusunan untuk mewakili integer perpuluhan dalam JavaScript
Selain literal integer perpuluhan, JavaScript juga mengiktiraf nilai dalam heksadesimal asas (16). Nombor perenambelasan yang dipanggil diawali dengan "0X" atau "0x", diikuti dengan kuantiti langsung rentetan nombor perenambelasan. Nilai heksadesimal terdiri daripada nombor 0-9 dan huruf antara a(A)-f(F). Huruf a-f mewakili nombor 10-15 Berikut ialah contoh literal integer heksadesimal
0xCAFE911
ii. Titik terapung literal
Tersurat titik terapung boleh mengandungi titik perpuluhan dan ia menggunakan kaedah penulisan tradisional nombor nyata. Nombor nyata terdiri daripada bahagian integer, titik perpuluhan, dan bahagian perpuluhan.
Selain itu, anda juga boleh menggunakan tatatanda eksponen untuk mewakili literal titik terapung. Iaitu, nombor sebenar diikuti oleh huruf E atau e, diikuti dengan tanda positif atau negatif, dan kemudian eksponen integer. Nilai yang diwakili oleh kaedah pengiraan ini ialah kuasa eksponen bagi nombor nyata sebelumnya yang didarab dengan 10.
Sintaks yang lebih ringkas boleh digunakan untuk mewakili
3.14
2345.455
.33333333333333333
6.02e23 //6.02*10 hingga kuasa ke-23
1.255454E-23 //1.255454*10 kepada kuasa negatif 23
Atur cara Javascript menggunakan operator aritmetik yang disediakan oleh bahasa untuk melaksanakan operasi berangka. Pengendali ini termasuk - * / dan selebihnya (baki selepas pembahagian) pengendali %
Selain operator asas, JavaScript juga menyokong operasi aritmetik yang lebih kompleks Operasi kompleks ini dilaksanakan melalui fungsi dan pemalar yang ditakrifkan sebagai sifat objek Matematik.
Math.pow(2, 53) //=>9007199254740992 document.write(Math.pow(2,53) )
Math.round(.6) //=>1.0 Membundarkan
Math.ceil(.6) //=>1.0 bulatkan
Math.floor(.6) //=>0.0 bulat ke bawah
Math.abs(-5) //=>5 Cari nilai mutlak
Math.max(x, y, z) //Kembalikan nilai maksimum
Math.min(x, y, z) //Kembalikan nilai minimum
Math.random() //Jana nombor rawak pseudo yang lebih besar daripada 0 dan kurang daripada 1
Math.PI //Pi
Matematik.E //e: Asas logaritma semula jadi
Math.sqrt(3) //Punca kuasa dua bagi 3
Math.pow(3, 1 / 3) //Punca kubus 3
Math.sin(0) //Fungsi trigonometri, serta Math.cos, Math.atan, dsb.
Math.log(10) //=>2.302585092994046 Logaritma asli bagi asas 10
Math.log(512) / Math.LN2 //Logaritma 512 dengan asas 2
Math.log(100) / Math.LN10 //Logaritma 100 dengan asas 10
Math.exp(3) //Kuasa ketiga e
Operasi aritmetik dalam JavaScript tidak akan melaporkan ralat apabila melimpah, melimpah atau membahagi dengan sifar. Walau bagaimanapun, hasil operasi berangka melebihi had atas nombor yang boleh dinyatakan dalam JavaScript (limpahan), dan hasilnya ialah nilai nilai tak terhingga khas (infinty), yang diwakili oleh infinty dalam JavaScript. Begitu juga, apabila nilai nombor negatif melebihi julat nombor negatif yang JavaScript boleh ungkapkan, hasilnya ialah infiniti negatif, yang diwakili oleh -Infinty dalam JavaScript. Nilai tak terhingga berkelakuan seperti yang kita jangkakan: penambahan, penolakan, pendaraban dan pembahagian berdasarkan nilai tersebut menghasilkan infiniti (tanda dikekalkan)
Aliran bawah ialah situasi yang berlaku apabila hasil operasi menghampiri sifar secara tak terhingga dan lebih kecil daripada nilai minimum yang boleh diwakili oleh JavaScript. Apabila nombor negatif mengalir bawah, JavaScript mengembalikan nilai khas, "sifar negatif", yang hampir sama dengan sifar biasa. Pengaturcara JavaScript jarang menggunakan sifar negatif.
Javascript mentakrifkan pembolehubah global Infinaty dan NaN, yang digunakan untuk menyatakan nilai infiniti dan bukan angka positif Dalam ECMAScipt3, kedua-dua nilai ini boleh dibaca dan ditulis. ECMAScript5 membetulkan masalah ini dengan mentakrifkannya sebagai baca sahaja. Nilai sifat yang ditakrifkan oleh objek Nombor dalam ECMAScipt3 juga adalah baca sahaja Berikut ialah beberapa contoh:
Infiniti //Memulakan pembolehubah baca/tulis kepada infiniti
Nombor.POSITIVE_INFINITY //Nilai yang sama, baca sahaja
1 / 0 //Ini juga nilai yang sama
Nombor.MAX_VALUE 1 //Hasil pengiraan masih Infiniti
Nombor.NEGATIVE_INFINITY //Mewakili infiniti negatif
-Infiniti
-1/0
-Nombor.MAX_VALUE -1
Nombor.NaN //Nilai yang sama, tetapi baca sahaja
0/0 // Hasil pengiraan masih nan
Nombor.MIN_VALUE/2 //Aliran bawah berlaku. Hasil pengiraan ialah 0
-Nombor.MIN_VALUE/2 //Sifar negatif
-1/Infiniti //Sifar negatif
-0
Nilai sifar negatif juga agak istimewa sama dengan sifar positif dan negatif (malah dinilai menggunakan ujian kesamaan ketat JavaScript), yang bermaksud kedua-dua nilai itu hampir sama, kecuali sebagai pembahagi:
Sifar === negz //=>benar Nilai sifar positif dan negatif adalah sama
1/sifar === 1/negz //palsu Infiniti positif dan infiniti negatif tidak sama
Terdapat banyak nombor nyata, tetapi JavaScript hanya boleh mewakili nombor terhad dalam bentuk nombor titik terapung (18 437 736 874 454 810 627 tepatnya, dalam erti kata lain, apabila nombor nyata digunakan dalam JavaScript, ia selalunya Ia hanya perwakilan anggaran nilai sebenar.
Javascript menggunakan perwakilan nombor titik terapung IEEE-754 (digunakan oleh hampir semua bahasa pengaturcaraan moden). Ini adalah perwakilan binari yang boleh mewakili pecahan dengan tepat, seperti 1/2 1/8 dan 1/1024 Malangnya, pecahan yang sering kita gunakan, terutamanya dalam pengiraan kewangan, semuanya pecahan perpuluhan 1/10 ,1/100 dll. Perwakilan binari tidak boleh mewakili nombor mudah seperti 0.1.
Nombor dalam javascript mempunyai ketepatan yang mencukupi. Dan boleh hampir 0.1 Tetapi fakta bahawa nombor itu tidak dapat dinyatakan dengan tepat membawa beberapa masalah.
alert(x == y) //=>false Kedua-dua nilai tidak sama
x == .1 //=>salah .3-.2 tidak sama dengan .1
y == .1 //=>benar .2-.1 bersamaan dengan 1
Disebabkan oleh ralat pembundaran, perbezaan anggaran antara 0.3 dan 0.2 sebenarnya tidak sama dengan perbezaan anggaran antara 0.2 dan 0.1 (dalam persekitaran simulasi sebenar, 0.3-0.2=0.099 999 999 999 999 98 bukan unik kepada JavaScript, tetapi penting untuk memahami bahawa ia berlaku dalam mana-mana bahasa pengaturcaraan yang menggunakan nombor titik terapung binari. Juga ambil perhatian bahawa nilai x dan y dalam kod di atas adalah sangat dekat antara satu sama lain dan nilai akhir yang betul. Hasil pengiraan ini boleh digunakan untuk kebanyakan tugas pengkomputeran. Masalah ini hanya berlaku apabila membandingkan dua nilai untuk kesamaan.
Versi JavaScript akan datang mungkin menyokong jenis nombor perpuluhan untuk mengelakkan masalah ini, tetapi sehingga itu anda mungkin lebih suka menggunakan integer besar untuk pengiraan kewangan yang penting. Contohnya, gunakan "sen" integer dan bukannya "dolar" perpuluhan untuk operasi berasaskan unit kewangan.
iiiii.Tarikh dan masa
Inti bahasa JavaScript mengandungi pembina Date(), yang pada asalnya mencipta objek tarikh dan masa Kaedah objek tarikh ini menyediakan API mudah untuk pengiraan tarikh tidak boleh menjadi jenis data asas seperti nombor.
var zhen = new Date(2011, 0, 1); //1 Januari 2011
var kemudian = Tarikh baharu(2011, 0, 1, 17, 10, 30); //Hari yang sama
var now = new Date(); //Tarikh dan masa semasa
var berlalu = sekarang - zhen; Kira bilangan milisaat dalam selang
nanti.getFullYear(); //=>2011
nanti.getMonth(); //=>0 Bulan bermula dari 0
nanti.getDate(); //=>1 Bilangan hari bermula dari 1
nanti.getDay(); //=>5 Dapatkan hari dalam seminggu. 0 mewakili Ahad, 5 mewakili Isnin 1
nanti.getHours() //=>Waktu tempatan
nanti.getUTCHours() //Gunakan UTC untuk mewakili waktu, berdasarkan zon waktu.
2. Teks
Rentetan ialah urutan tertib yang tidak boleh diubah dengan nilai 16-bit Setiap aksara biasanya datang daripada set aksara Unicode. JavaScript mewakili teks melalui jenis rentetan. Panjang rentetan ialah bilangan nilai 16-bit yang terkandung di dalamnya. Rentetan Javascript (dan tatasusunannya) diindeks bermula dari 0. Panjang rentetan kosong ialah 0 dan tiada "jenis aksara" yang mewakili satu aksara dalam JavaScript. Untuk mewakili nilai 16-bit, hanya berikannya kepada pembolehubah rentetan. Panjang rentetan ini ialah 1.
Set aksara, kod dalaman dan rentetan javascript
JavaScript menggunakan set aksara Unicode yang dikodkan UTF-16 Rentetan JavaScript ialah jujukan yang terdiri daripada satu set nilai 16-bit yang tidak bersiri. Aksara Unicode yang paling biasa digunakan diwakili oleh kod dalaman 16-bit dan mewakili satu aksara dalam rentetan aksara Unicode yang tidak boleh diwakili sebagai aksara 16-bit mengikut peraturan pengekodan UTF-16 - gunakan dua aksara 16-bit diwakili sebagai urutan (juga dipanggil "pasangan pengganti"). Ini bermakna rentetan JavaScript dengan panjang 2 (dua nilai 16-bit) mungkin mewakili aksara Unicode.
var p ="π" ; //π diwakili oleh kod dalaman 16-bit 0x03c0
var e = "e"; //e diwakili oleh kod dalaman 17-bit 0x1d452
p.length // =>1 p mengandungi nilai 16-bit
e.length // =>2 e mengandungi dua nilai selepas pengekodan UTF-16: "ud835udc52"
Pelbagai kaedah operasi rentetan yang ditakrifkan oleh JavaScript semuanya beroperasi pada nilai 16-bit, bukan aksara dan pasangan pengganti tidak akan diproses secara berasingan. Begitu juga, JavaScript tidak melakukan pemprosesan piawai pada rentetan. Tiada jaminan bahawa rentetan itu adalah sama dalam format UTF-16 yang sah
i rentetan literal
Rentetan literal dalam program JavaScript ialah jujukan aksara yang disertakan dengan petikan tunggal atau petikan berganda Rentetan yang dibatasi oleh petikan tunggal boleh mengandungi petikan berganda, dan rentetan yang dibatasi oleh petikan berganda juga boleh mengandungi Boleh mengandungi petikan tunggal. Berikut ialah beberapa contoh literal rentetan.
"" //Rentetan kosong, 0 aksara
'ujian'
"3.14"
'name="myform"'
"Adakah anda lebih suka buku O'Reily?"
Dalam ECMAScript3, literal rentetan mesti ditulis dalam satu baris, tetapi dalam ECMAScript5, literal rentetan boleh dipecahkan kepada beberapa baris dan setiap baris mesti diakhiri dengan garis miring ke belakang (), garis miring ke belakang dan penamat baris Tiada satu pun daripadanya adalah kandungan literal rentetan. Jika anda mahu mereka bersama-sama anda boleh gunakan Watak melarikan diri.
Perlu diambil perhatian bahawa apabila menggunakan petikan tunggal untuk mengehadkan rentetan, anda perlu lebih berhati-hati tentang singkatan dan semua pemformatan dalam bahasa Inggeris Apostrof dan petikan tunggal bahasa Inggeris adalah aksara yang sama, jadi anda mesti menggunakan escape.
ii watak melarikan diri
Dalam rentetan JavaScript, garis miring ke belakang () mempunyai tujuan khas Menambahkan aksara selepas garis miring tidak lagi mewakili maksud literalnya, sebagai contoh, n ialah aksara lari.
o //Aksara NUL
b //Watak backspace
t //Watak tab mendatar
n //Watak pemecah baris
v //Watak tab menegak
F // Aksara Perspage
\ Sengkang ke belakang
xXX aksara Latin-1 ditentukan oleh dua digit heksadesimal
xXXXX aksara Unikod ditentukan oleh empat aksara XXXX perenambelasan
Salah satu fungsi terbina dalam JavaScript ialah penggabungan rentetan. Menggunakan operator dengan rentetan bermakna penggabungan rentetan. Contohnya
s.panjang
Selain atribut panjang, rentetan juga menyediakan banyak kaedah yang boleh dipanggil.
s.charAt(s.length - 1) //"d"Watak terakhir
s.substring(1, 4) //"ell" 2-4 aksara
s.slice(1, 4) //ell Sama seperti di atas
s.slice(-3) // 3 aksara terakhir
s.indexOf(l ")//Kedudukan di mana 2 aksara l mula-mula muncul
s.lastIndexOf("l") //10 Kedudukan tempat terakhir aksara l muncul
s.indexOf("l",3)//Selepas kedudukan 3, kedudukan di mana aksara l mula-mula muncul
s.split(",") //=> ["hello", "world"] dipisahkan kepada subrentetan
s.replace("h","H")// =>"Halo,dunia" penggantian aksara teks penuh
s.toUpperCase() //=>"HELLO,WORLD"
Dalam JavaScript, rentetan ditetapkan Kaedah seperti replace() dan toUpperCase() mengembalikan rentetan baharu, dan aksara asal itu sendiri tidak berubah.
Dalam ECMAScript, aksara boleh dianggap sebagai tatasusunan baca sahaja Selain menggunakan kaedah charAt(), anda juga boleh menggunakan kurungan segi empat sama untuk mengakses aksara individu dalam rentetan. (nilai 16-bit)
s = "hello, dunia"
s[0] //=>"h"
s[s.length-1] //=>"d"
Foxfire telah menyokong pengindeksan rentetan dengan cara ini sejak lama dahulu, dan kebanyakan penyemak imbas moden (kecuali IE) telah mengikuti jejak Mozailla dan melengkapkan ciri ini sebelum ECMAScript terbentuk
iiii padanan corak
Javascript mentakrifkan pembina RegExp(), yang digunakan untuk mencipta objek yang mewakili padanan corak teks Corak ini dipanggil "ungkapan biasa" (ungkapan biasa), sintaks ungkapan biasa dalam JavaScript Caiyang Perl. Kedua-dua objek String dan RegExp mentakrifkan fungsi yang menggunakan ungkapan biasa untuk padanan corak dan carian serta penggantian.
Objek RegExp bukan jenis data asas dalam bahasa Seperti Tarikh, ia hanyalah objek khas dengan API praktikal. Sintaks ungkapan biasa adalah kompleks dan API adalah kaya. Ia akan diperkenalkan secara terperinci dalam Bab 10. RegExp ialah alat pemprosesan teks yang berkuasa dan biasa digunakan, ini hanyalah gambaran keseluruhan.
Walaupun RegExp bukan jenis data asas dalam bahasa, mereka masih mempunyai cara penulisan langsung dan boleh digunakan secara langsung dalam JavaScript. Teks antara dua garis miring membentuk literal ungkapan biasa. Garis miring kedua juga boleh diikuti dengan satu atau lebih huruf. Digunakan untuk mengubah suai maksud corak padanan. Contohnya:
/^HTML/ // Padankan rentetan bermula dengan HTML
/[1-9][0-9]*/ //Padankan nombor bukan sifar, diikuti dengan sebarang nombor
/bjavascriptb/i/ // Padankan perkataan javascript dan abaikan kes
Objek RegExp mentakrifkan banyak kaedah berguna dan rentetan juga mempunyai kaedah yang boleh menerima parameter RegExp. Contohnya:
var text = "testing:1,2,3"; //Contoh teks
corak var = /d /g / // Padankan semua kejadian yang mengandungi satu atau lebih digit
pattern.test(text) // =>true: Perlawanan berjaya
text.search(corak) //=>9: Kedudukan perlawanan pertama yang berjaya
text.match(corak) //=> ["1", "2", "3"] Semua padanan membentuk tatasusunan
text.repeat(pattern,"#"); //=>"testing:#,#,#"
text.split(/D /); //=>["","1","2","3"]: Gunakan aksara bukan angka untuk memintas rentetan
3.Nilai Boolean
Nilai Boolean merujuk kepada benar atau salah, hidup atau mati Jenis ini hanya mempunyai dua nilai, perkataan terpelihara benar atau salah
Hasil penyataan perbandingan dalam JavaScript biasanya nilai Boolean. Contohnya
a==4
Kod ini digunakan untuk mengesan sama ada nilai pembolehubah a bersamaan dengan 4. Jika sama, nilainya benar, jika tidak, nilainya palsu
Nilai Boolean biasanya digunakan dalam pernyataan kawalan JavaScript, seperti pernyataan if/else dalam JavaScript Jika nilai Boolean adalah benar, laksanakan bahagian logik yang pertama, dan jika ia palsu, laksanakan sekeping kod yang lain. seperti
Jika (a == 4)
b = b 1;
lain
a = a 1;
Sebarang nilai JavaScript boleh ditukar kepada nilai Boolean Nilai berikut ditukar kepada palsu
tidak ditentukan
null
0
-0
NaN
""//Rentetan kosong
Semua nilai lain, termasuk semua objek (tatasusunan) akan ditukar kepada benar, palsu dan 6 nilai di atas yang boleh ditukar kepada palsu kadangkala dipanggil "nilai palsu". nilai palsu akan Dilayan sebagai palsu, nilai benar akan dianggap benar
Mari kita lihat contoh dengan menambahkan pembolehubah o ialah objek atau nol, anda boleh menggunakan pernyataan if untuk mengesan sama ada o ialah nilai bukan nol.
jika(o!==null)...
Operator ketaksamaan "!==" membandingkan o dan null dan hasilnya adalah benar atau salah. Anda boleh mengabaikan pernyataan perbandingan di sini dahulu, null ialah nilai palsu, dan objek ialah nilai benar.
jika(o)...
Untuk kes pertama, kod selepas if akan dilaksanakan selagi o tidak batal Sekatan dalam kes kedua tidak begitu ketat. Jika ini dilaksanakan hanya jika o tidak palsu atau sebarang nilai palsu (seperti batal atau tidak didenda).
Boolean mengandungi kaedah toString(), jadi anda boleh menggunakan kaedah ini untuk menukar rentetan kepada "true" atau "false", tetapi ia tidak mengandungi kaedah lain yang berguna Selain API yang tidak penting ini, terdapat tiga perkara penting satu operator Boolean.
&& operator, ||. dan operator unary "!" lakukan operasi Boolean NOT (NOT) Jika nilai benar mengembalikan palsu, nilai palsu mengembalikan benar, seperti
Jika ((x == 0 && y == 0) || !(z == 0)) {
// x dan y kedua-duanya sifar atau z bukan sifar
}
4.null dan undefined
Null ialah kata kunci dalam bahasa JavaScript Ia mewakili nilai khas "nilai nol". , yang bermaksud "bukan objek". Tetapi sebenarnya, null biasanya dianggap sebagai satu-satunya ahli jenis bebasnya. Ia boleh mewakili nombor, rentetan dan objek yang "tidak bernilai". Kebanyakan bahasa pengaturcaraan mengandungi null seperti JavaScript, dan anda mungkin biasa dengan null atau nil.
Javascript juga mempunyai nilai kedua yang menunjukkan kekosongan nilai. Digunakan untuk mewakili "nilai nol" yang lebih mendalam. Ia adalah nilai pembolehubah. Menunjukkan bahawa pembolehubah tidak dimulakan. Jika anda ingin menanyakan nilai harta objek atau elemen tatasusunan dan mengembalikan tidak ditentukan, ini bermakna sifat atau elemen itu tidak wujud. undefined ialah pembolehubah global yang dipratentukan (ia berbeza daripada null, ia bukan kata kunci), dan nilainya tidak ditentukan. Jika typeof digunakan untuk menguji jenis yang tidak ditentukan, "undefined" dikembalikan, menunjukkan bahawa nilai ini adalah satu-satunya ahli jenis ini.
Walaupun null dan undefined berbeza, kedua-duanya mewakili "kekosongan nilai" dan kedua-duanya sering boleh ditukar ganti. Pengendali kesamarataan "==" menganggap kedua-duanya adalah sama (pengendali kesaksamaan yang ketat "===" mesti digunakan untuk membezakannya). Jika nilai dijangkakan daripada jenis Boolean, nilainya adalah palsu. Serupa dengan palsu. Kedua-dua null dan undefined tidak mengandungi sebarang sifat atau kaedah. Malah, menggunakan "." dan "[]" untuk mengakses ahli atau kaedah kedua-dua nilai ini akan menghasilkan ralat jenis.
Anda mungkin berpendapat bahawa undefined mewakili kekosongan peringkat sistem yang tidak dijangka atau nilai seperti ralat, manakala null mewakili kekosongan peringkat program yang merupakan nilai biasa atau jangkaan Jika anda ingin menyalinnya Pembolehubah atau sifat, atau memasukkannya ke berfungsi sebagai parameter, null adalah pilihan terbaik.
5. Objek Global
Bahagian sebelumnya membincangkan jenis elemen JavaScript dan nilai primitif. Jenis objek - objek, tatasusunan dan fungsi/Tetapi terdapat kelas objek yang sangat penting yang mesti dijelaskan sekarang: objek global
Objek global memainkan peranan penting dalam JavaScript. Sifat objek global ialah simbol yang ditakrifkan secara global. Program JavaScript boleh digunakan secara langsung. Apabila jurubahasa JavaScript bermula, ia mencipta objek global baharu dan memberikannya satu set sifat awal yang ditentukan.
Sifat global seperti Infinty dan NaN yang tidak ditentukan
Fungsi global seperti isNaN(), parseInt() dan eval()
Pembina seperti Date(), RegExp(), String(), Object() dan Array()
Objek global, seperti Matematik dan JSON
Sifat awal objek global bukanlah perkataan yang dikhaskan, tetapi ia harus dianggap sedemikian.
Di peringkat atas kod - kod javascript yang tiada dalam mana-mana fungsi, objek global boleh dirujuk melalui kata kunci javascript.
var global = ini; //Tentukan pembolehubah global yang merujuk kepada objek global.
Dalam JavaScript sisi klien, objek tetingkap bertindak sebagai objek global ini mempunyai rujukan tetingkap yang biasa kepada dirinya sendiri. Ia boleh menggantikan ini untuk merujuk kepada objek global. Tetapi ia juga mentakrifkan beberapa sifat global lain untuk pelayar web dan JavaScript interaktif.
Apabila pertama kali dibuat, objek global mentakrifkan semua nilai global yang dipratentukan dalam JavaScript ini juga mengandungi nilai global yang ditentukan untuk program. Jika kod itu mengisytiharkan pembolehubah global. Pembolehubah global ini adalah hak milik objek global.
6. Objek pembungkusan
Objek JavaScript ialah nilai komposit: ia ialah koleksi sifat atau nilai yang dinamakan. Nilai atribut dirujuk melalui "." Apabila nilai atribut ialah fungsi, ia adalah kaedah dan kaedah dalam objek o dihantar melalui o.m().
Kami melihat bahawa rentetan juga mempunyai sifat dan kaedah.
var s="hello world";
var word = s.substring(s.indexOf("") 1,s.length);//Gunakan atribut rentetan.
document.write(word) //"ello world"
Memandangkan rentetan bukan objek, mengapa ia mempunyai atribut? Selagi sifat rentetan s dirujuk, JavaScript akan menukar nilai rentetan menjadi objek dengan memanggil Rentetan baharu Objek ini mewarisi kaedah rentetan. dan digunakan untuk mengendalikan rujukan harta benda. Sebaik sahaja atribut baharu dirujuk. Sebaik sahaja rujukan tamat, objek yang baru dibuat akan dimusnahkan. (Objek sementara ini sebenarnya tidak dicipta atau dimusnahkan, namun prosesnya kelihatan seperti ini.)
Seperti rentetan, nombor dan nilai Boolean juga mempunyai kaedah tersendiri, mencipta objek sementara melalui pembina Number() dan Boolean(). Panggilan kepada kaedah ini semuanya datang dari objek sementara ini. (null dan undefined bukanlah objek yang dibalut, dan mengakses sifatnya akan mengakibatkan ralat jenis)
Lihat kod berikut dan fikirkan tentang proses pelaksanaannya
var s = "ujian";
s.len = 4; //Tetapkan atribut untuknya
var t = s.len //Cari atribut ini
Apabila kod ini dijalankan, nilai t tidak ditentukan Baris kedua kod mencipta objek rentetan sementara dan memberikan nilai len sebagai 4, kemudian memusnahkan objek baris ketiga menggunakan kod asal (tidak diubah ) ) mencipta objek rentetan baharu dan cuba membaca sifat len.
Atribut ini secara semula jadi tidak wujud, menunjukkan bahawa hasilnya tidak ditentukan Kod ini menggambarkan bahawa apabila membaca nilai atribut (atau kaedah) rentetan, tatasusunan dan nilai Boolean, ia berkelakuan seperti objek, tetapi jika anda cuba berikan nilai kepada atributnya. Operasi ini diabaikan; pengubahsuaian hanya berlaku pada objek sementara. Objek sementara ini tidak dikekalkan.
Perlu diingat bahawa anda boleh mencipta objek pembalut secara eksplisit melalui String(), Number(), dan Boolean() pembina:
var s = "ujian",
n = 1,
b = benar;
var S = Rentetan baharu;
var N = Nombor baharu(n);
var B = Boolean(b) baharu;
Javascript akan menukar pembungkus kepada nilai primitif apabila perlu, jadi objek S N B dalam kod di atas selalunya - tetapi tidak selalu - berkelakuan sama seperti s n b Operator "==" sama menukar nilai asal dan Mereka dibalut objek dianggap sama.
Tetapi pengendali "===" menganggapnya sebagai tidak sama rata dan jenis pengendali boleh melihat perbezaan antara nilai asal dan objek yang dibalutnya.
7. Nilai primitif tidak berubah dan rujukan objek boleh ubah.
Nilai primitif JavaScript (nilai Boolean nol tidak ditentukan, nombor dan rentetan) pada asasnya berbeza daripada objek (termasuk tatasusunan dan fungsi Nilai primitif tidak boleh diubah (atau mengubah) nilai primitif. Ini jelas benar untuk nombor dan nilai Boolean - menukar nilai nombor itu sendiri tidak masuk akal, tetapi kurang jelas untuk rentetan, yang kelihatan seperti tatasusunan aksara. Kami menjangkakan bahawa aksara dalam rentetan boleh diubah suai oleh indeks yang ditentukan. Malah, JavaScript melarang ini. Semua kaedah dalam rentetan kelihatan mengembalikan rentetan yang diubah suai, tetapi sebenarnya mengembalikan rentetan baharu.
var s = "hello dunia";
s.toUpperCase(); //Mengembalikan "HELLO WORLD" dan tidak mengubah nilai s
s //=> "hello world" Rentetan asal tidak berubah
Perbandingan nilai asal ialah perbandingan nilai nilainya sama hanya apabila nilainya sama. Ini kedengaran agak sukar untuk nombor, boolean, null dan undefined, dan tidak ada cara lain untuk membandingkannya. Sekali lagi, untuk rentetan ia tidak begitu jelas jika anda membandingkan dua rentetan berasingan, JavaScript menganggapnya sama jika dan hanya jika panjangnya sama dan aksara pada setiap indeks adalah sama.
var o = {x:1} //Takrifkan objek
o.x = 2 //Tukar objek dengan mengubah suai sifatnya
o.y = 3 //Tukar objek ini sekali lagi dan tambahkan atribut baharu padanya
var a =[1,2,3] // Tatasusunan juga boleh diubah suai
a[0]=0; //Tukar elemen dalam tatasusunan
a[3]=4; Tambahkan elemen baharu pada tatasusunan
Perbandingan objek bukan perbandingan nilai: walaupun dua objek mengandungi atribut yang sama dan nilai yang sama, ia tidak sama dan dua tatasusunan dengan elemen indeks yang betul-betul sama tidak sama
var o ={x:1}, p={x:1}//Dua objek dengan atribut yang sama
O === p; // = & gt; palsu dua objek berasingan tidak pernah sama (o == p; = & gt; palsu)
var a =[],b=[]; //Dua tatasusunan kosong yang berasingan
a === b; //=>false Dua tatasusunan berasingan tidak pernah sama
Kami biasanya memanggil jenis rujukan objek untuk membezakannya daripada jenis asas JavaScript. Menurut istilah, objek adalah rujukan, dan perbandingan objek adalah perbandingan rujukan; mereka hanya sama apabila dan apabila mereka menggunakan objek asas yang sama.
var a = []; //Tentukan pembolehubah a
yang merujuk kepada tatasusunan kosong var b = a; //Pembolehubah b merujuk kepada tatasusunan yang sama
b[0] = 1;
a[0] //=>1 Pembolehubah a juga akan diubah suai
a === b //=>benar a dan b merujuk kepada tatasusunan yang sama, jadi ia adalah sama.
Sama seperti kod yang baru anda lihat di atas, memberikan objek (atau tatasusunan) kepada pembolehubah hanyalah nilai rujukan yang diberikan: objek itu sendiri tidak disalin sekali.
Jika anda ingin mendapatkan salinan objek atau tatasusunan, anda mesti menyalin secara eksplisit setiap sifat objek atau setiap elemen tatasusunan. Contoh berikut melengkapkan salinan tatasusunan melalui gelung.
var a = ['a', 'b', 'c']; //array untuk disalin
var b = []; //Salin ke tatasusunan kosong sasaran
untuk (var i = 0; i < a.length; i ) { //Melintasi setiap elemen dalam []
b[i] = a[i]; //Salin elemen ke b.
}
Begitu juga, jika kita ingin membandingkan dua individu atau tatasusunan, mereka mesti membandingkan atribut atau elemen mereka. Kod berikut mentakrifkan fungsi yang membandingkan tatasusunan.
fungsi equalArrays(a, b) {
Jika (a.length != b.length) mengembalikan palsu; //Dua tatasusunan dengan panjang yang berbeza adalah tidak sama
untuk (var i = 0; i < a.length; i) // Gelung melalui semua elemen
Jika (a[i] !== b[i]) mengembalikan palsu; //Jika mana-mana elemen tidak sama, tatasusunan tidak sama
kembali benar; // Jika tidak, ia adalah sama
}
8. Jenis penukaran
Jenis nilai dalam JavaScript sangat fleksibel Kami telah melihat ini dengan nilai Boolean: apabila JavaScript menjangkakan nilai Boolean, anda boleh memberikan sebarang jenis nilai. JavaScript akan menukar jenis itu sendiri mengikut keperluan. Sesetengah nilai (nilai kebenaran) adalah benar, dan nilai lain (nilai palsu) ditukar kepada palsu Perkara yang sama berlaku untuk jenis lain. Jika JavaScript menjangkakan rentetan, ia menukar nilai yang diberikan kepada rentetan. Jika JavaScript menjangka tatasusunan, ia menukar nilai yang diberikan kepada nombor (mengembalikan NaN jika hasil penukaran tidak bermakna), beberapa contoh adalah seperti berikut:
10 "objek" //=> "10objek";
"7" * "4" // =>28 Kedua-dua rentetan ditukar kepada nombor
var n = 1 - "x" // =>Rentetan NaN x tidak boleh ditukar kepada nombor
N "objek" // => "objek nan": nan ditukar kepada rentetan "nan"
Jadual berikut menerangkan cara melakukan penukaran jenis dalam JavaScript. Jenis sorotan tebal yang mungkin mengejutkan anda. Sel kosong mewakili penukaran yang tidak perlu dan tidak dilakukan.
| Nilai | Tukar kepada rentetan | Nombor | Nilai Boolean | Objek |
| tidak ditentukan null |
"tidak ditentukan" "null" |
NaN 0 |
palsu palsu |
membuang TypeError membuang TypeError |
| true false |
"ture" "false" |
1 0 |
new Boolean(true) new Boolean(false) |
|
| ""（空字符串） "1.2"(非空，数字) "one"(非空，非数字) |
0 1.2 NaN |
false benar benar |
String("") baharu Rentetan baharu("1.2") Rentetan baharu("satu") |
|
| 0 -0 NaN Infinty -Infinty 1(infiniti, bukan sifar) |
"0" "0" "NaN" "Infiniti" "-Infiniti" "1" |
palsu palsu palsu benar benar benar |
Nombor baharu(0); Nombor baharu(-0); Nombor baharu(NaN) Nombor baharu(Infinty) Nombor baharu(-Infinty) Nombor baharu(1) |
|
| {}(sebarang objek) [](tatasusunan sewenang-wenangnya) [9](1 elemen angka) ['a'](tatasusunan lain) fungsi(){}(beliebige Funktion) |
Siehe den dritten Abschnitt dieses Abschnitts "" „9“ Verwenden Sie die Methode join() Bitte beachten Sie den dritten Abschnitt dieses Abschnitts |
Siehe den dritten Abschnitt dieses Abschnitts 0 9 NaN NaN |
wahr wahr wahr wahr wahr |
Die in der obigen Tabelle erwähnte Umrechnung vom Originalwert in den Originalwert ist relativ einfach. Die Umrechnung in den Booleschen Wert haben wir bereits im dritten Abschnitt dieses Artikels besprochen. Auch die Konvertierung aller Grundwerte in Strings ist klar definiert. Die Umrechnung in Zahlen ist subtiler. Als Zahlen dargestellte Zeichenfolgen können direkt in Zahlen umgewandelt werden, wobei Leerzeichen am Anfang und Ende zulässig sind. Allerdings werden alle Nicht-Null-Zeichen am Anfang und Ende nicht als Teil der Zahl betrachtet, was dazu führt, dass das Ergebnis der Zeichenfolge NaN ist. Es gibt einige Zahlenkonvertierungen, die seltsam aussehen: true wird in 1 konvertiert, false und die leere Zeichenfolge „“ wird in 0 konvertiert.
Die Umwandlung primitiver Werte in Objekte ist ebenfalls ein sehr einfacher, primitiver Wert
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