JavaScript Jenis Pengalaman Bacaan Inti, Nilai dan Variabel

Pengoperasian program komputer membutuhkan nilai operasi seperti angka 3.14 atau teks "Hello World". Dalam bahasa pemrograman, jenis nilai yang dapat diwakili dan dioperasikan disebut tipe data. Fitur paling mendasar dari bahasa pemrograman adalah meng -host beberapa tipe data. Ketika program perlu menjaga nilai untuk penggunaan di masa depan, itu ditetapkan untuk ("simpan" nilai ke) variabel. Variabel adalah nama simbolis dari suatu nilai, dan referensi ke nilai dapat diperoleh dengan nama. Mekanisme kerja variabel adalah fitur dasar bahasa pemrograman. Bab ini akan merujuk ke bagian sebelumnya untuk membantu memahami konten bab ini, dan akan dijelaskan secara lebih mendalam nanti.

Data JavaScript dibagi menjadi dua kategori: tipe primitif dan tipe objek

Kelas asli dalam JavaScript termasuk angka, string, dan nilai boolean. Bab ini akan memiliki bab terpisah yang secara khusus membahas angka, string, dan nilai boolean JavaScript. JavaScript juga memiliki dua nilai mentah khusus, null (kosong) dan tidak terdefinisi (tidak ditentukan), mereka bukan angka, string, atau nilai boolean. Mereka mewakili satu -satunya anggota dari tipe khusus masing -masing.

Javascript adalah objek selain angka, string, nilai boolean, nol, dan tidak terdefinisi. Objek adalah kumpulan properti. Setiap atribut terdiri dari "nama/nilai pasangan" (nilainya dapat berupa nilai primitif, seperti angka, string, atau objek). Salah satu objek yang lebih khusus (objek global akan diperkenalkan di Miss Fifth, dan bagian keenam akan dijelaskan secara lebih rinci)

Objek JavaScript normal adalah koleksi "nilai bernama" yang tidak perlu. JavaScript juga mendefinisikan objek khusus - array, mewakili set nilai bernomor yang dipesan. JavaScript mendefinisikan sintaks khusus untuk array. Buat array memiliki beberapa sifat perilaku unik yang berbeda dari objek biasa.

JavaScript juga mendefinisikan fungsi objek khusus. Fungsi adalah objek dengan kode yang dapat dieksekusi yang ingin dikaitkan dengan. Ini menjalankan kode dengan memanggil fungsi dan mengembalikan hasil operasi. Seperti array, karakteristik perilaku fungsi berbeda dari objek lain. JavaScript mendefinisikan sintaks khusus untuk menggunakan fungsi. Untuk fungsi JavaScript. Yang paling penting, mereka semua adalah nilai yang benar, dan JavaScript dapat digunakan untuk memperlakukannya sebagai objek biasa.

Jika suatu fungsi menginisialisasi (menggunakan operator baru) objek baru, kami menyebutnya konstruktor. Setiap konstruktor mendefinisikan objek kelas-Koleksi yang terdiri dari objek inisialisasi konstruktor. Kelas dapat dianggap sebagai subtipe jenis objek. Selain kelas array dan kelas fungsi, JavaScript juga mendefinisikan tiga kelas lain yang digunakan. Tanggal mendefinisikan objek yang mewakili tanggal. Regexp mendefinisikan objek ekspresi reguler. Kelas kesalahan mendefinisikan baris yang mewakili objek kesalahan runtime dan sintaks dalam program JavaScript. Anda dapat mendefinisikan kelas yang diperlukan dengan mendefinisikan konstruktor Anda sendiri.

Interpreter JavaScript memiliki mekanisme manajemen memori sendiri, yang dapat secara otomatis mengoleksi memori. Ini berarti bahwa program dapat membuat objek berdasarkan permintaan, dan pemrogram tidak perlu khawatir tentang penghancuran objek -objek ini dan daur ulang memori. Ketika tidak ada referensi yang menunjuk ke suatu objek, penerjemah tahu bahwa objek tidak berguna dan secara otomatis akan mendaur ulang sumber daya memori yang ditempati.

JavaScript adalah bahasa yang berorientasi objek. Tidak secara ketat, ini berarti bahwa kami tidak menggunakan fungsi definisi global untuk mengoperasikan berbagai jenis nilai. Jenis data itu sendiri dapat menentukan metode untuk menggunakan nilai. Misalnya, untuk mengurutkan elemen dalam array A, tidak perlu melewati fungsi sort (), tetapi untuk mentransfer metode sortir ()

a.sort (); // urutkan (a) versi berorientasi objek

Secara teknis, hanya objek JavaScript yang dapat memiliki metode. Namun, angka, string, dan nilai boolean juga memiliki metode sendiri. Dalam JavaScript, hanya null dan tidak terdefinisi adalah nilai -nilai yang tidak dapat memiliki metode.

Jenis JavaScript dapat dibagi menjadi tipe primitif dan tipe objek, dan dapat dibagi menjadi beberapa jenis yang dapat memiliki metode dan jenis yang tidak dapat memiliki metode. Ini juga dapat dibagi menjadi tipe yang dapat berubah dan tidak berubah. Nilai tipe yang dapat berubah dapat dimodifikasi, dan objek dan array milik tipe yang dapat berubah: program JavaScript dapat mengubah nilai nilai atribut objek dan nilai elemen array.

Angka, boolean, nol, dan tidak terdefinisi adalah tipe yang tidak dapat diubah. Misalnya, memodifikasi isi array itu sendiri tidak masuk akal. Sebuah string dapat dianggap sebagai array karakter, dan Anda dapat berpikir itu dapat diubah. Namun, dalam JavaScript, string tidak dapat diubah. Anda dapat mengakses teks pada posisi string apa pun, tetapi JavaScript tidak memberikan cara untuk memodifikasi konten teks dari string sepanjang waktu.

JavaScript dapat melakukan konversi tipe data dengan bebas. Misalnya, jika angka digunakan di mana program mengharapkan untuk menggunakan string, JavaScript akan secara otomatis mengonversi nomor menjadi string. Jika Anda berharap untuk menggunakan nilai non-Boolean di mana nilai boolean digunakan, JavaScript juga akan dikonversi. Dalam JavaScript, aturan "Kesetaraan Penghakiman" digunakan untuk "Equality Judgment" (Kesetaraan)

Variabel JavaScript tidak diketik. Variabel dapat ditugaskan untuk orang dan jenis. Variabel dapat dinyatakan menggunakan kata kunci VAR. JavaScript mengadopsi ruang lingkup sintaks. Variabel yang tidak dinyatakan dalam fungsi apa pun disebut variabel global. Mereka terlihat di mana saja dalam program JavaScript.

1. Angka

Tidak seperti bahasa pemrograman lainnya, JavaScript tidak membedakan antara nilai integer dan nilai titik mengambang. Semua nilai dalam JavaScript dinyatakan oleh nilai titik mengambang. Ketika angka muncul langsung dalam program JavaScript, kami adalah numerik literal, dan JavaScript mendukung jumlah langsung numerik dalam berbagai format. (Catatan: Menambahkan tanda negatif (-) langsung sebelum angka apa pun bisa mendapatkan nilai negatifnya) tetapi tanda negatifnya adalah operator terbalik satu arah. , bukan komponen tata bahasa dari jumlah numerik langsung. )

i Integer Type Kuantitas Langsung

Integer desimal diwakili oleh urutan array dalam JavaScript

Selain jumlah langsung integer desimal, JavaScript juga mengakui nilai -nilai mekanisme enam belas (16) sebagai kardinalitas. Sistem heksadesimal yang disebut adalah kuantitas langsung yang diawali dengan "0x" atau "0x" diikuti oleh string bilangan heksadesimal. Nilai heksadesimal terdiri dari huruf antara 0-9 dan a (a) -f (f). Surat-surat AF dinyatakan dalam angka 10-15 di bawah ini. Berikut adalah contoh jumlah langsung bilangan bulat heksadesimal

Salinan kode adalah sebagai berikut:

0xff // 15*16+15 = 255

0xCafe911

Meskipun ecmascript tidak mendukung kuantitas langsung oktal, beberapa implementasi JavaScript dapat memungkinkan representasi bilangan bulat dalam oktal (basis 8). Kuantitas langsung oktal dimulai dengan angka 0, diikuti oleh urutan angka antara 0 dan 7.

Salinan kode adalah sebagai berikut:

0377 // 3*64 +7*8 +7 = 255 (desimal)

Karena beberapa implementasi JavaScript mendukung oktal antar bilangan, sementara beberapa tidak, yang terbaik adalah tidak menggunakan integer antar bilangan yang diawali dengan 0. Lagipula, kita tidak dapat tahu apakah implementasi JavaScript saat ini mendukung penguraian oktal. Dalam mode ketat ecmascript6, kuantitas oktal langsung dilarang secara eksplisit.

ii. Kuantitas langsung titik mengambang

Jumlah langsung titik mengambang dapat berisi titik desimal, dan mereka menggunakan metode penulisan bilangan real tradisional. Bilangan real terdiri dari bagian integer, titik desimal dan bagian desimal.

Selain itu, metode penghitungan eksponensial juga dapat digunakan untuk mewakili jumlah langsung titik mengambang. Artinya, bilangan real diikuti oleh huruf E atau E, diikuti oleh tanda positif dan negatif, dan kemudian eksponen integer ditambahkan. Nilai numerik yang diwakili oleh metode penghitungan ini adalah kekuatan eksponensial dari bilangan real sebelumnya dikalikan 10.

Dapat diekspresikan dalam sintaks yang lebih ringkas

Salinan kode adalah sebagai berikut:

[digit] [. digit] [(e | e) [(+|-)] digit]

3.14

2345.455

.33333333333333333333333333333333333

6.02e23 //6.02*10 ke daya ke -23

1.255454e-23 //1.255454*10 ke daya ke-23

Operasi Aritmatika di III.Javascript

Program JavaScript menggunakan operator aritmatika yang disediakan oleh provinsi bahasa untuk melakukan operasi numerik. Operator ini mengandung + - * / dan operator yang tersisa (tersisa)

Selain operator dasar, JavaScript juga mendukung operasi aritmatika yang lebih kompleks. Operasi yang rumit garis ini diimplementasikan oleh fungsi dan konstanta yang didefinisikan sebagai sifat objek matematika.

Salinan kode adalah sebagai berikut:

Math.pow (2, 53) // => 9007199254740992 Document.write (Math.pow (2,53)))

Math.round (.6) //=>1.0 Round

Math.ceil (.6) //=>1.0 Pencarian ke atas

Math.floor (.6) //=>0.0 ke bawah

Math.abs (-5) // => 5 Temukan nilai absolut

Math.max (x, y, z) // mengembalikan nilai maksimum

Math.min (x, y, z) // mengembalikan nilai minimum

Math.random () // menghasilkan angka pseudo-acak lebih besar dari 0 dan kurang dari 1

Math.pi // pi

Math.e // E: Basis logaritma alami

Math.sqrt (3) // 3 root persegi

Math.Pow (3, 1/3) // Root Kubus 3

Math.sin (0) // Fungsi Trigonometrik, serta Math.cos, Math.atan, dll.

Math.log (10) //=>2.302585092994046 Natural Logaritma dengan Base 10

Math.log (512) /Math.ln2 // log 512 dengan basis 2

Math.log (100) /Math.ln10 // log 100 dengan basis 10

Math.exp (3) // Kekuatan Tiga E

Operasi aritmatika dalam JavaScript tidak akan melaporkan kesalahan saat meluap, underflow atau dibagi dengan nol. Namun, hasil operasi numerik melebihi angka yang dapat direpresentasikan dalam JavaScript (overflow), dan hasilnya adalah nilai nilai tak terbatas (infinty) khusus, yang dinyatakan sebagai jurang dalam JavaScript. Demikian pula, ketika nilai angka negatif melebihi kisaran angka negatif yang dapat diungkapkan JavaScript, hasilnya adalah infinity negatif, yang dinyatakan sebagai -infinty dalam JavaScript. Sifat perilaku dari nilai -nilai infinity konsisten dengan apa yang kita harapkan: hasil penambahan, pengurangan, perkalian dan pembagian berdasarkan pada mereka adalah tak terbatas (menjaga tanda -tanda)

Underflow adalah situasi yang terjadi ketika hasil perhitungan secara nirkabel mendekati nol dan lebih kecil dari nilai minimum yang dapat diwakili JavaScript. Ketika angka negatif menyala, JavaScript mengembalikan nilai khusus, "Nol Negatif", yang (nol negatif) hampir persis sama dengan nol normal. Pemrogram JavaScript jarang menggunakan nol negatif.

JavaScript variabel global yang telah ditentukan sebelumnya Infinaty dan Nan untuk mengekspresikan nilai-nilai non-numerik. Di ECMASCIPT3, kedua nilai ini dapat dibaca dan ditulis. Ecmascript5 Memperbaiki masalah ini dengan mendefinisikannya sebagai baca saja. Nilai atribut yang ditentukan oleh objek angka di ecmascipt3 juga hanya baca, berikut adalah beberapa contoh:

Salinan kode adalah sebagai berikut:

Infinity // Inisialisasi variabel yang dapat dibaca/tulis ke Infinity

Number.positive_infinity // nilai yang sama, hanya baca

1 /0 // ini adalah nilai yang sama

Number.max_value + 1 // Hasil perhitungannya masih tak terbatas

Number.negative_infinity // menunjukkan infinity negatif

-Ketakterbatasan

-1/0

-Number.max_value -1

Nan // inisialisasi variabel yang dapat dibaca/tulis ke NAN

Number.nan // nilai yang sama, tetapi baca saja

0/0 // Hasil perhitungannya masih NAN

Number.min_value/2 // underflow terjadi. Hasil yang dihitung adalah 0

-Number.min_value/2 // Nol negatif

-1/infinity // nol negatif

-0 // Nol negatif

Ada sedikit istimewa tentang nilai-nilai non-numerik dalam JavaScript, yang tidak sama dengan manusia dan nilai-nilai, termasuk diri mereka sendiri. Dengan kata lain, tidak mungkin untuk menilai apakah X nan oleh x == nan. Sebaliknya, X harus digunakan! = x Untuk menilai bahwa jika dan hanya ketika x adalah NAN, hasil dari ekspresi itu benar. Fungsi fungsi isnan () mirip dengan ini. Jika parameternya adalah NAN atau nilai non-numerik (seperti string dan objek), ia mengembalikan true. Ada fungsi serupa dalam JavaScript yang isfinite (), yang mengembalikan true ketika parameter tidak nan, infinty atau -infinity.

Nilai nol negatif juga sedikit istimewa. Ini sama dengan nol positif dan negatif (bahkan dinilai menggunakan uji kesetaraan ketat Javascript), yang berarti bahwa kedua nilai ini hampir persis sama kecuali sebagai tidak termasuk:

Salinan kode adalah sebagai berikut:

var nol = 0;

var negz = -0;

nol === negz // => nilai nol positif dan negatif sejati adalah sama

1/nol === 1/negz // False Positive Infinity dan negatif infinity berbeda

iiii.Binary Floating Point Number dan Rounding Error

Ada bilangan real yang tak terhitung jumlahnya, tetapi JavaScript hanya dapat mewakili bilangan terbatas melalui bentuk bilangan floating point (tepatnya, ada 18 437 736 874 454 810 627), yaitu, ketika bilangan real digunakan dalam JavaScript, seringkali hanyalah perkiraan representasi dari nilai nyata.

JavaScript mengadopsi notasi nomor floating point IEEE-754 (digunakan oleh hampir semua bahasa pemrograman modern). Ini adalah representasi biner yang dapat secara akurat mewakili fraksi, seperti 1/2 1/8 dan 1/1024. Sayangnya, fraksi yang sering kita gunakan, terutama dalam perhitungan keuangan, semuanya didasarkan pada fraksi desimal 1/10, 1/100, dll. Notasi biner tidak dapat mewakili angka sederhana seperti 0,1.

Angka dalam JavaScript memiliki presisi yang cukup. Dan bisa mendekati 0,1. Namun pada kenyataannya, ketidakmampuan untuk secara akurat mengekspresikan angka membawa beberapa masalah.

Salinan kode adalah sebagai berikut:

var x = .3 - .2;

var y = .2 - .1;

peringatan (x == y) // => false kedua nilai tidak sama

x == .1 // => false .3-.2 tidak sama .1

y == .1 // => true .2-.1 sama dengan 1

Karena kesalahan pembulatan, perbedaan perkiraan antara 0,3 dan 0,2 sebenarnya tidak sama dengan perbedaan perkiraan antara 0,2 dan 0,1 (dalam lingkungan simulasi nyata, 0,3-0,2 = 0,099 999 999 999 999 999 999 98). Masalah ini tidak hanya ada dalam JavaScript, sangat penting untuk memahami hal ini: masalah ini akan terjadi dalam bahasa pemrograman apa pun yang menggunakan angka titik mengambang biner. Penting juga untuk dicatat bahwa nilai x dan y dalam kode di atas sangat dekat satu sama lain dan nilai akhir yang benar. Hasil perhitungan ini dapat menjadi kompeten untuk sebagian besar tugas perhitungan. Masalah ini hanya terjadi ketika membandingkan apakah kedua nilai tersebut sama.

Versi JavaScript di masa depan dapat mendukung tipe numerik desimal untuk menghindari masalah ini, sebelum itu Anda mungkin lebih suka menggunakan bilangan bulat besar untuk perhitungan keuangan yang penting. Misalnya, gunakan bilangan bulat "segmen" alih -alih "elemen" desimal untuk unit moneter.

iiiii.date dan waktu

Inti dari bahasa JavaScript mencakup konstruktor tanggal (), yang awalnya membuat objek tanggal dan waktu. Metode objek tanggal ini memberikan API sederhana untuk perhitungan tanggal. Objek tanggal tidak bisa menjadi tipe data dasar seperti angka.

Salinan kode adalah sebagai berikut:

var zhen = tanggal baru (2011, 0, 1); // 1 Januari 2011

var kemudian = Tanggal baru (2011, 0, 1, 17, 10, 30); // hari yang sama

var sekarang = tanggal baru (); // Tanggal dan waktu saat ini

var berlalu = sekarang - zhen; // pengurangan tanggal. Hitung jumlah milidetik dari interval waktu

kemudian.getlyear (); // => 2011

kemudian.getMonth (); // => 0 bulan dihitung dari 0

kemudian.getDate (); // => 1 Jumlah hari dihitung dari 1

later.getday (); // => 5 Dapatkan hari dalam seminggu. 0 mewakili hari Minggu, 5 mewakili hari Minggu

later.getHours () // => waktu setempat

later.getUchours () // Gunakan UTC untuk mewakili waktu jam, berdasarkan zona waktu.

2. Teks

String adalah urutan nilai 16-bit yang tidak dapat diubah dan dipesan, setiap karakter biasanya berasal dari set karakter unicode. JavaScript mewakili teks melalui tipe string. Panjang string adalah jumlah nilai 16-bit yang dikandungnya. Indeks string JavaScript (dan arraynya) dimulai pada 0. Panjang string kosong adalah 0, dan tidak ada "tipe karakter" yang mewakili satu karakter dalam JavaScript. Untuk mewakili nilai 16-bit, cukup tetapkan ke variabel string. Panjang string ini adalah 1.

Set karakter, kode dalam dan string JavaScript

JavaScript menggunakan set karakter Unicode yang dikodekan UTF-16, dan string JavaScript adalah urutan yang terdiri dari satu set nilai 16-bit yang tidak dipesan. Karakter unicode yang paling umum digunakan diwakili oleh kode dalam 16-bit dan mewakili satu karakter dalam string. Karakter unicode yang tidak dapat direpresentasikan sebagai 16-bit diikuti oleh aturan pengkodean UTF-16-menggunakan dua nilai 16-bit untuk membentuk urutan (juga dikenal sebagai "pasangan proxy"). Ini berarti bahwa string JavaScript dengan panjang 2 (dua nilai 16-bit) dapat mewakili karakter unicode.

Salinan kode adalah sebagai berikut:

var p = "π"; // π diwakili oleh kode bagian dalam 16-bit 0x03c0

var e = "e"; // E diwakili oleh kode bagian dalam 17-bit 0x1d452

p.length // => 1 p berisi nilai 16-bit

E.Length // => 2 E dikodekan oleh UTF-16 berisi dua nilai: "/ud835/udc52"

Semua metode operasi string yang ditentukan oleh JavaScript Act pada nilai 16-bit, bukan karakter, dan jangan memproses item proxy secara terpisah. Demikian pula, JavaScript tidak akan menstandarkan pemrosesan string. Tidak ada jaminan bahwa string adalah format UTF-16 legal

i String Kuantitas Langsung

Kuantitas langsung string dalam program JavaScript adalah urutan karakter yang terlampir oleh penawaran tunggal atau kutipan ganda. Sebuah string yang dibatasi oleh kutipan tunggal dapat berisi kutipan ganda, dan string yang dibatasi oleh kutipan ganda juga dapat berisi kutipan tunggal. Berikut adalah beberapa contoh kuantifikasi langsung string.

Salinan kode adalah sebagai berikut:

"" // string kosong, 0 karakter

'Pengujian'

"3.14"

'name = "myform"'

"Tidakkah kamu lebih suka buku O'reily?"

Dalam ecmascript3, jumlah langsung dari string harus ditulis dalam satu baris, sedangkan dalam ecmascript5, jumlah langsung dari string dapat dibagi menjadi beberapa baris, dan setiap baris harus diakhiri dengan backslash (/). Baik backslash maupun karakter akhir garis adalah isi dari jumlah langsung string. Jika Anda ingin bersama, Anda dapat menggunakan /n untuk melarikan diri dari karakter.

Perlu dicatat bahwa ketika menggunakan kutipan tunggal untuk membatasi string, Anda harus ekstra hati -hati tentang singkatan dan semua format dalam bahasa Inggris. Apostrof bahasa Inggris dan kutipan tunggal adalah karakter yang sama, jadi backslash (/) harus digunakan untuk melarikan diri.

II Karakter Escape

Dalam string JavaScript, backslash (/) memiliki tujuan khusus. Menambahkan karakter ke backslashes tidak akan lagi mewakili makna literal mereka. Misalnya, /n adalah karakter pelarian, yang mewakili garis baru.

Salinan kode adalah sebagai berikut:

/o // karakter nul

/b // karakter backspace

/T // Karakter Tab Horizontal

/n // garis karakter garis baru

/v // karakter tab vertikal

/f // Page Renewal

/r // karakter carriage return

/"// Kutipan ganda

// Backslash

/xxx karakter Latin-1 yang ditentukan oleh heksadesimal dua-bit

/xxxxxx karakter unicode yang ditentukan oleh hexadecimal empat-bit xxxxx

Penggunaan string III

Salah satu fitur bawaan dari JavaScript adalah gabungan string. Gunakan operator + untuk string untuk mewakili gabungan string. Misalnya

Salinan kode adalah sebagai berikut:

var msg = "halo" + "dunia"; // menghasilkan string hello world

Untuk menentukan panjang string - jumlah nilai 16 -bit yang dikandungnya, Anda dapat menggunakan atribut panjang, seperti panjang string s.

s.length

Selain atribut panjang, string juga menyediakan banyak metode yang dapat dipanggil.

Salinan kode adalah sebagai berikut:

var s = "halo, dunia";

S.Charat (0); // karakter pertama "h"

S.Charat (S.Length - 1) // "D" Karakter Terakhir

S.Substring (1, 4) // "ell" 2-4 karakter

s.slice (1, 4) // ell sama seperti di atas

S.Slice (-3) // 3 karakter terakhir muncul

S.indexof (l ") // 2 karakter l Posisi kejadian pertama

S.LastIndexof ("l") // 10 Terakhir kali karakter L muncul

S.indexof ("l", 3) // Setelah posisi 3, posisi pertama di mana karakter L muncul

s.split (",") // => ["halo", "dunia"] dipisahkan menjadi substring

S.Replace ("H", "H") // => "Hllo, World" Penggantian Karakter Teks Lengkap

s.touppercase () // => "halo, dunia"

Dalam JavaScript, string diperbaiki dan tidak berubah. Metode seperti REPLECT () dan ToUpercase () mengembalikan string baru, dan karakter asli sendiri tidak berubah.

Dalam ecmascript, karakter dapat diperlakukan sebagai array hanya baca. Selain menggunakan metode chARAT (), tanda kurung persegi juga dapat digunakan untuk mengakses karakter individu dalam string. (Nilai 16-bit)

Salinan kode adalah sebagai berikut:

s = "halo, dunia"

S [0] // => "h"

s [s.length-1] // => "d"

Foxfire telah mendukung pengindeksan string untuk metode ini sejak lama, dan sebagian besar browser modern (kecuali IE) mengikuti jejak Mozailla dan menyelesaikan fitur ini sebelum ecmascript dibentuk.

Pencocokan pola IIII

JavaScript mendefinisikan konstruktor regexp (), yang digunakan untuk membuat objek yang mewakili pencocokan pola teks. Pola -pola ini disebut "ekspresi reguler", sintaks ekspresi reguler di JavaScript Perl. Objek String dan RegExp mendefinisikan fungsi yang menggunakan ekspresi reguler untuk mencocokkan pola, menemukan dan mengganti.

Objek RegExp bukan tipe data dasar dalam bahasa. Seperti kencan, itu hanya objek khusus dengan API praktis. Ekspresi reguler memiliki sintaksis yang kompleks dan API yang kaya. Ini akan diperkenalkan secara rinci dalam Bab 10. Regexp adalah alat pemrosesan teks yang kuat dan umum digunakan, dan di sini hanya gambaran umum.

Meskipun RegExp bukan tipe data dasar dalam bahasa, mereka masih memiliki jumlah langsung dan dapat digunakan langsung dalam JavaScript. Teks antara dua tebasan membentuk jumlah langsung dari ekspresi reguler. Slash kedua juga dapat mengikuti satu atau lebih huruf. Digunakan untuk memodifikasi arti pola pencocokan. Misalnya:

Salinan kode adalah sebagai berikut:

/^Html/// Cocokkan string dimulai dengan html

/[1-9] [0-9]*/// Cocokkan nomor non-nol, diikuti oleh angka apa pun

// bjavascript/b/i/// cocok dengan kata javascript dan abaikan huruf besar dan kecil

Objek RegExp mendefinisikan banyak metode yang berguna, dan string juga memiliki metode yang dapat menerima parameter RegExp. Misalnya:

Salinan kode adalah sebagai berikut:

var text = "pengujian: 1,2,3"; // Contoh teks

var pola = // d+/g // cocok dengan semua instance yang berisi satu atau lebih angka

pola.test (teks) // => true: kecocokan berhasil

text.search (pola) // => 9: Posisi di mana pertandingan pertama berhasil

text.match (pola) // => ["1", "2", "3"] Semua cocok membentuk array

text.repeat (pola, "#"); // => "Pengujian:#,#,#"

text.split (// d+/); // => ["", "1", "2", "3"]: Gunakan karakter non-numerik untuk mencegat string

3. Nilai Boolean

Nilai Boolean merujuk pada atau salah atau salah atau salah. Jenis ini hanya memiliki dua nilai, dan kata benar atau salah dicadangkan.

Hasil pernyataan perbandingan dalam JavaScript biasanya adalah nilai boolean. Misalnya

a == 4

Kode ini digunakan untuk mendeteksi apakah nilai a dari variabel sama dengan 4. Jika sama, nilainya benar, jika nilainya tidak sama, salah

Nilai boolean biasanya digunakan dalam pernyataan kontrol JavaScript, seperti pernyataan jika/else dalam JavaScript. Jika nilai boolean benar, jalankan bagian logika pertama, dan jika sepotong kode lain salah, mis.

Salinan kode adalah sebagai berikut:

if (a == 4)

B = B + 1;

kalau tidak

a = a + 1;

Nilai JavaScript apa pun dapat dikonversi menjadi nilai boolean, dan nilai -nilai berikut dikonversi menjadi false

Salinan kode adalah sebagai berikut:

belum diartikan

batal

0

-0

Nan

"" // string kosong

Semua nilai lain, termasuk semua objek (array), akan dikonversi menjadi benar, salah, dan 6 nilai di atas yang dapat dikonversi menjadi false kadang -kadang disebut "nilai palsu". JavaScript mengharapkan bahwa ketika menggunakan nilai boolean, nilai palsu akan diperlakukan sebagai salah, dan nilai sebenarnya akan diperlakukan sebagai benar.

Mari kita lihat contoh. Menambahkan variabel O adalah objek atau nol, Anda dapat menggunakan pernyataan IF untuk mendeteksi apakah O adalah nilai non-nol.

if (o! == null) ...

Operator yang tidak setara "! ==" membandingkan O dan NULL dan memberikan hasilnya benar atau salah. Anda pertama -tama dapat mengabaikan pernyataan perbandingan di sini. NULL adalah nilai yang salah dan objek adalah nilai sebenarnya.

if (o) ...

Untuk kasus pertama, kode setelah IF akan dieksekusi hanya ketika O bukan nol, dan keterbatasan kasus kedua tidak begitu ketat. Ini jika dijalankan hanya jika O tidak salah atau nilai palsu (seperti nol atau tidak terikat).

Boolean berisi metode tostring (), sehingga Anda dapat menggunakan metode ini untuk mengonversi string menjadi "benar" atau "false", tetapi tidak mengandung metode lain yang berguna, dan selain API yang tidak penting ini, ada tiga operator Boolean yang penting.

&& operator, || operator dan operator unary "!" Lakukan operasi boolean non (bukan). Jika nilai sebenarnya mengembalikan false, nilai false mengembalikan true, misalnya

Salinan kode adalah sebagai berikut:

if ((x == 0 && y == 0) ||! (z == 0)) {

// x dan y keduanya nol atau z tidak nol

}

4.Null dan tidak terdefinisi

NULL adalah kata kunci dalam bahasa JavaScript. Ini mewakili nilai khusus "nilai nol". Untuk NULL, ia melakukan operasi tipe () dan mengembalikan objek. Dengan kata lain, NULL dapat dianggap sebagai nilai objek khusus, yang berarti "non-objek". Namun pada kenyataannya, NULL biasanya dianggap sebagai satu -satunya anggota dari tipe bebasnya. Ini dapat mewakili angka, string, dan benda itu "tidak berharga". Sebagian besar bahasa pemrograman berisi null seperti JavaScript, dan Anda dapat terbiasa dengan null atau nihil.

JavaScript juga memiliki nilai kedua yang menunjukkan lowongan nilai. Digunakan untuk mewakili "nilai nol" yang lebih dalam. Itu adalah nilai variabel. Menunjukkan bahwa variabel belum diinisialisasi. Jika Anda ingin menanyakan nilai atribut objek atau elemen array, ia mengembalikan tidak terdefinisi, itu berarti bahwa atribut atau elemen tidak ada. Tidak terdefinisi adalah variabel global yang telah ditentukan sebelumnya (berbeda dari nol, itu bukan kata kunci), dan nilainya tidak ditentukan. Jika Anda menggunakan TypeOf untuk menguji tipe yang tidak ditentukan, "tidak ditentukan" dikembalikan, menunjukkan bahwa nilainya adalah satu -satunya anggota dari jenis tersebut.

Meskipun nol dan tidak terdefinisi berbeda, keduanya mewakili "lowongan nilai", dan keduanya sering dipertukarkan. Operator yang menilai kesetaraan "==" berpikir bahwa keduanya sama (gunakan operator kesetaraan yang ketat "===" untuk membedakan mereka). Di mana nilainya diharapkan dari tipe boolean, nilainya semua salah. Mirip dengan False. Baik nol dan tidak terdefinisi tidak mengandung sifat dan metode apa pun. Bahkan, menggunakan "." dan "[]" untuk mengakses anggota atau metode dari kedua nilai ini akan menghasilkan kesalahan tipe.

Anda mungkin berpikir bahwa tidak terdefinisi mewakili lowongan tingkat sistem yang tidak terduga dari nilai-nilai yang salah, sementara NULL mewakili lowongan nilai tingkat program, normal atau yang diharapkan. Jika Anda ingin menyalinnya ke variabel atau properti, atau meneruskannya sebagai parameter ke dalam suatu fungsi, nol adalah pilihan terbaik.

5. Objek Global

Bagian sebelumnya membahas jenis elemen dan nilai asli JavaScript. Jenis Objek - Objek, Array dan Fungsi / Tetapi ada kelas objek yang sangat penting yang tidak boleh jelas sekarang: Objek Global

Objek global memiliki kegunaan penting dalam JavaScript. Properti objek global adalah simbol yang ditentukan secara global. Program JavaScript dapat digunakan secara langsung. Ketika juru bahasa JavaScript dimulai, ia menciptakan objek global baru dan memberikannya satu set properti awal yang ditentukan.

Properti global seperti Infinty dan Nan yang tidak ditentukan

Fungsi global seperti isnan (), parseInt () dan eval ()

Konstruktor seperti tanggal (), regexp (), string (), objek (), dan array ()

Objek global, seperti matematika dan json

Atribut awal dari objek global bukanlah kata yang dipesan, tetapi mereka harus diperlakukan sebagai kata yang dipesan.

Di tingkat atas kode - kode JavaScript tidak dalam fungsi apa pun, Anda dapat merujuk ke objek global melalui kata kunci JavaScript.

var global = ini; // Tentukan variabel global yang merujuk objek global.

Dalam JavaScript klien, objek Window bertindak sebagai objek global. Objek jendela global ini memiliki referensi jendela yang akrab itu sendiri. Ini dapat menggantikan ini untuk merujuk ke objek global. Windows mendefinisikan atribut inti global. Namun, beberapa atribut global lainnya didefinisikan untuk browser web dan javascript interaktif.

Ketika dibuat untuk pertama kalinya, objek global mendefinisikan semua nilai global yang telah ditentukan dalam JavaScript, dan objek khusus ini juga berisi nilai -nilai global yang ditentukan untuk program. Jika kode menyatakan variabel global. Variabel global ini adalah atribut dari objek global.

6. Objek Pengemasan

Objek JavaScript adalah nilai majemuk: ini adalah kumpulan atribut atau nilai yang disebutkan. Nilai atribut dirujuk melalui "." Ketika nilai atribut adalah fungsi, itu adalah metode dan menggunakan om () untuk mentransfer metode dalam objek o.

Kami melihat bahwa string juga memiliki sifat dan metode.

Salinan kode adalah sebagai berikut:

var s = "halo dunia";

var word = s.substring (s.indexof ("")+1, s.length); // Gunakan atribut string.

Document.write (Word) // "Ello World"

Karena string bukan objek, mengapa ia memiliki properti? Selama atribut string S dirujuk, JavaScript akan mengonversi nilai string menjadi objek dengan memanggil string baru, yang mewarisi metode string. dan digunakan untuk memproses referensi atribut. Setelah atribut baru dirujuk. Setelah referensi selesai, objek yang baru dibuat akan dihancurkan. (Objek sementara ini sebenarnya tidak harus membuat atau menghancurkan, tetapi proses ini terlihat seperti ini.)

Seperti string, angka, dan nilai boolean juga memiliki metode mereka sendiri, membuat objek sementara melalui konstruktor angka () dan boolean (). Semua metode ini dipanggil dari objek sementara ini. (NULL dan tidak terdefinisi belum dibungkus objek, mengakses propertinya akan memiliki kesalahan tipe)

Lihatlah kode berikut dan pikirkan tentang proses eksekusi mereka

Salinan kode adalah sebagai berikut:

var s = "tes";

s.len = 4; // Tetapkan properti untuk itu

var t = s.len // temukan properti ini

Saat menjalankan kode ini, nilai T tidak ditentukan. Baris kode kedua membuat objek string sementara dan memberi Len nilai 4. Objek kemudian dihancurkan. Baris ketiga menggunakan string asli (tidak dimodifikasi) untuk membuat objek string baru dan mencoba membaca atribut Len.

Properti ini tidak ada secara alami, menunjukkan bahwa hasilnya tidak terdefinisi. Kode ini menunjukkan bahwa ketika membaca nilai properti (atau metode) dari string, array, dan nilai boolean, itu berperilaku seperti objek, tetapi jika Anda mencoba menetapkan nilai ke propertinya. Operasi ini akan diabaikan; Modifikasi hanya terjadi pada objek sementara. Objek sementara ini tidak dipertahankan.

Perlu dicatat bahwa pembuatan objek pembungkus dapat ditampilkan melalui string (), angka (), dan boolean () konstruktor:

Salinan kode adalah sebagai berikut:

var s = "tes",

n = 1,

b = true;

var s = string baru;

var n = angka baru (n);

var b = boolean baru (b);

JavaScript mengubah pembungkus ke nilai asli bila perlu, sehingga objek SNB dalam kode sebelumnya - tetapi tidak selalu - mewakili nilai yang sama dengan SNB, "==" sama dengan operator memperlakukan nilai asli dan objek pembungkusnya sama.

Tetapi operator penuh "===" memperlakukan mereka sebagai ketidaksetaraan, dan perbedaan antara nilai asli dan objek yang dibungkus dapat dilihat melalui tipe operator.

7. Nilai asli yang tidak dapat diubah dan referensi objek yang dapat berubah.

Nilai asli JavaScript (nomor dan string boolean nol yang tidak terdefinisi) pada dasarnya berbeda dari objek (termasuk array dan fungsi). Nilai aslinya tidak dapat diubah; Tidak ada metode yang dapat (atau bermutasi) nilai primitif. Jelas benar untuk angka dan boolean - mengubah nilai angka tidak masuk akal sendiri, tetapi tidak begitu jelas untuk string, karena string tampaknya merupakan array karakter. Kami berharap bahwa karakter dalam string dapat dimodifikasi dengan indeks yang ditentukan. Faktanya, JavaScript melarang melakukan ini. Semua metode dalam string tampaknya mengembalikan string yang dimodifikasi, yang sebenarnya merupakan string baru.

Salinan kode adalah sebagai berikut:

var s = "halo dunia";

S.Touppercase (); // kembalikan "halo dunia" dan tidak mengubah nilai s

s // => "halo dunia" string asli belum berubah

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

Salinan kode adalah sebagai berikut:

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

Salinan kode adalah sebagai berikut:

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

Salinan kode adalah sebagai berikut:

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

Salinan kode adalah sebagai berikut:

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

Salinan kode adalah sebagai berikut:

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

Kembali Benar; // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

Salinan kode adalah sebagai berikut:

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

Saya. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

ii.显式类型转化

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

Salinan kode adalah sebagai berikut:

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

Salinan kode adalah sebagai berikut:

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

Salinan kode adalah sebagai berikut:

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

Salinan kode adalah sebagai berikut:

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

Salinan kode adalah sebagai berikut:

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

Salinan kode adalah sebagai berikut:

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

aku aku aku. The object is converted to the original value.

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

Salinan kode adalah sebagai berikut:

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

Salinan kode adalah sebagai berikut:

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Misalnya:

Salinan kode adalah sebagai berikut:

for (var i = 0; i < 10; i++) log(i);

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

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Misalnya:

Salinan kode adalah sebagai berikut:

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

Salinan kode adalah sebagai berikut:

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

Salinan kode adalah sebagai berikut:

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

Salinan kode adalah sebagai berikut:

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

Saya. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

Salinan kode adalah sebagai berikut:

function test(o) {

var i = 0; //i is defined throughout the function body

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

Salinan kode adalah sebagai berikut:

var scope = "global";

function f() {

console.log (lingkup); //Output "undefined", not "global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log (lingkup); //Output "local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

Salinan kode adalah sebagai berikut:

function f() {

var scope; //在函数的顶部声明了局部变量

console.log (lingkup); //The variable exists, but its value is "undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log (lingkup); //Here it has the value we expect

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

Salinan kode adalah sebagai berikut:

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。