Petua Pantas: Cara Mengisytiharkan Pembolehubah dalam JavaScript

Apabila belajar JavaScript salah satu asasnya adalah untuk memahami cara menggunakan pembolehubah. Pembolehubah adalah bekas untuk nilai semua jenis yang mungkin, mis. nombor, rentetan atau array (lihat jenis data). Setiap pembolehubah mendapat nama yang kemudiannya boleh digunakan di dalam aplikasi anda (mis. Untuk membaca nilainya).

Dalam hujung cepat ini, anda akan belajar cara menggunakan pembolehubah dan perbezaan antara pelbagai deklarasi.

Takeaways Key

Pembolehubah dalam JavaScript diisytiharkan menggunakan kata kunci 'var', 'biarkan', atau 'const', masing -masing dengan skop dan penggunaannya sendiri. 'Var' adalah fungsi-scoped, 'Let' adalah blok-scoped, dan 'const' adalah blok-scoped tetapi tidak boleh ditugaskan semula selepas permulaan.
Pengisytiharan, permulaan, dan tugasan adalah tiga langkah yang berbeza dalam penggunaan berubah -ubah. Deklarasi memperkenalkan pemboleh ubah baru, permulaan memberikan nilai untuk kali pertama, dan tugasan memberikan nilai khusus kepada pembolehubah.
Hoisting adalah mekanisme JavaScript di mana pengisytiharan pembolehubah dan fungsi dipindahkan ke bahagian atas skop mereka semasa fasa kompilasi. Walau bagaimanapun, hanya pengisytiharan yang dinaikkan, bukan permulaan. 'Var' mengembalikan 'tidak ditentukan' jika diakses sebelum pengisytiharan akibat angkat, sementara 'let' dan 'const' membuang kesilapan.

Perbezaan antara perisytiharan, permulaan dan tugasan

Sebelum kita mula mempelajari pelbagai perisytiharan, mari lihat kitaran hayat pembolehubah.

Deklarasi: Pembolehubah didaftarkan menggunakan nama yang diberikan dalam skop yang sepadan (dijelaskan di bawah - mis. Di dalam fungsi).

1. Inisialisasi: Apabila anda mengisytiharkan pemboleh ubah, ia secara automatik dimulakan, yang bermaksud memori diperuntukkan untuk pembolehubah oleh enjin JavaScript.
2. Tugasan: Ini adalah apabila nilai tertentu diberikan kepada pembolehubah.
Jenis pengisytiharan

NOTA: Walaupun Varhas tersedia di JavaScript sejak Releast awalnya, Letand Const hanya tersedia dalam ES6 (ES2015) dan UP. Lihat halaman ini untuk keserasian penyemak imbas.

var

sintaks:

Pengisytiharan ini mungkin yang paling popular, kerana tidak ada alternatif sehingga ECMAScript 6. Pembolehubah yang diisytiharkan dengan VAR boleh didapati dalam skop fungsi yang dilampirkan. Sekiranya tidak ada fungsi melampirkan, ia boleh didapati di seluruh dunia.

<span>var x; // Declaration and initialization
</span>x <span>= "Hello World"; // Assignment
</span>
<span>// Or all in one
</span><span>var y = "Hello World";
</span>

Contoh:

Ini akan menyebabkan rujukan referror: Hello tidak ditakrifkan, kerana pembolehubah hello hanya tersedia dalam fungsi Sayhello. Tetapi yang berikut akan berfungsi, kerana pembolehubah akan diisytiharkan secara global - dalam konsol skop yang sama.log (hello) terletak:

<span>function sayHello(){
</span>  <span>var hello = "Hello World";
</span>  <span>return hello;
</span><span>}
</span><span>console.log(hello);
</span>

biarkan

<span>var hello = "Hello World";
</span><span>function sayHello(){
</span>  <span>return hello;
</span><span>}
</span><span>console.log(hello);
</span>

sintaks:

<span>var x; // Declaration and initialization
</span>x <span>= "Hello World"; // Assignment
</span>
<span>// Or all in one
</span><span>var y = "Hello World";
</span>

biarkan keturunan VAR dalam JavaScript moden. Skopnya tidak hanya terhad kepada fungsi yang melampirkan, tetapi juga kepada pernyataan blok yang melampirkannya. Kenyataan blok adalah segala -galanya di dalam {dan}, (mis. Keadaan atau gelung). Manfaat Let adalah mengurangkan kemungkinan kesilapan, kerana pembolehubah hanya tersedia dalam skop yang lebih kecil.

Contoh:

<span>function sayHello(){
</span>  <span>var hello = "Hello World";
</span>  <span>return hello;
</span><span>}
</span><span>console.log(hello);
</span>

Ini akan menyebabkan rujukan referror: Hello tidak ditakrifkan sebagai Hello hanya tersedia di dalam blok yang dilampirkan - dalam kes ini keadaan jika. Tetapi yang berikut akan berfungsi:

<span>var hello = "Hello World";
</span><span>function sayHello(){
</span>  <span>return hello;
</span><span>}
</span><span>console.log(hello);
</span>

const

sintaks:

<span>let x; // Declaration and initialization
</span>x <span>= "Hello World"; // Assignment
</span>
<span>// Or all in one
</span><span>let y = "Hello World";
</span>

Secara teknikal, pemalar bukan pembolehubah. Keistimewaan pemalar adalah bahawa anda perlu memberikan nilai apabila mengisytiharkannya dan tidak ada cara untuk menugaskan semula. Const adalah terhad kepada skop blok yang melekat, seperti LET.

Pemalar harus digunakan apabila nilai tidak boleh berubah semasa aplikasi berjalan, seperti yang anda akan diberitahu dengan kesilapan ketika cuba menimpa mereka.

Penciptaan global yang tidak sengaja

Anda boleh menulis semua pengisytiharan yang dinamakan di atas dalam konteks global (iaitu di luar mana -mana fungsi), tetapi walaupun dalam fungsi, jika anda lupa menulis var, biarkan atau const sebelum tugasan, pembolehubah akan secara automatik menjadi global.

Contoh:

<span>var name = "Peter";
</span><span>if(name === "Peter"){
</span>  <span>let hello = "Hello Peter";
</span><span>} else {
</span>  <span>let hello = "Hi";
</span><span>}
</span><span>console.log(hello);
</span>

di atas akan mengeluarkan Hello World ke konsol, kerana tidak ada perisytiharan sebelum tugasan hello = dan oleh itu pembolehubah tersedia di seluruh dunia.

nota: Untuk mengelakkan secara tidak sengaja mengisytiharkan pembolehubah global, anda boleh menggunakan mod ketat.

angkat dan zon mati temporal

Perbezaan lain antara VAR dan LET/Const berkaitan dengan pembolehubah angkat. Perisytiharan pembolehubah akan sentiasa diangkat secara dalaman (dipindahkan) ke bahagian atas skop semasa. Ini bermakna yang berikut:

<span>var name = "Peter";
</span><span>if(name === "Peter"){
</span>  <span>let hello = "Hello Peter";
</span>  <span>console.log(hello);
</span><span>} else {
</span>  <span>let hello = "Hi";
</span>  <span>console.log(hello);
</span><span>}
</span>

bersamaan dengan:

<span>const x = "Hello World";
</span>

Petunjuk tingkah laku ini adalah bahawa kedua -dua contoh akan log tidak ditentukan ke konsol. Sekiranya var hello; tidak akan selalu berada di atas ia akan membuang referensi.

Tingkah laku ini dipanggil Hoisting terpakai kepada var dan juga untuk membiarkan/const. Seperti yang disebutkan di atas, mengakses pembolehubah VAR sebelum perisytiharannya akan kembali tidak ditentukan kerana ini adalah nilai JavaScript yang diberikan apabila memulakannya.

tetapi mengakses pembolehubah let/const sebelum pengisytiharannya akan membuang kesilapan. Ini disebabkan oleh hakikat bahawa mereka tidak dapat diakses sebelum pengisytiharan mereka dalam kod. Tempoh antara memasuki skop pembolehubah dan mencapai perisytiharan mereka dipanggil zon mati temporal - iaitu tempoh di mana pembolehubah tidak dapat diakses.

anda boleh membaca lebih lanjut mengenai angkat dalam artikel yang demystifying JavaScript Variable Scope and Hoisting.

Kesimpulan

Untuk mengurangkan kerentanan terhadap kesilapan, anda harus menggunakan const dan biarkan apabila mungkin. Jika anda benar -benar perlu menggunakan VAR maka pastikan anda memindahkan pengisytiharan ke bahagian atas skop, kerana ini mengelakkan tingkah laku yang tidak diingini yang berkaitan dengan angkat.

Soalan Lazim (Soalan Lazim) Mengenai Pengisytiharan Pembolehubah JavaScript

Apakah perbezaan antara pengisytiharan pembolehubah dan inisialisasi dalam JavaScript? Perisytiharan adalah proses memperkenalkan pemboleh ubah baru kepada program ini. Ia dilakukan dengan menggunakan kata kunci VAR, LET, atau Const. Sebagai contoh, biarkan x; Di sini, X diisytiharkan tetapi tidak ditakrifkan. Ia seperti memberitahu program ini, "Hei, saya akan menggunakan pembolehubah bernama X." Inisialisasi, sebaliknya, adalah proses memberikan nilai kepada pemboleh ubah yang diisytiharkan untuk kali pertama. Sebagai contoh, x = 5; Di sini, X dimulakan dengan nilai 5. Ia seperti memberitahu program, "Pembolehubah X yang saya ceritakan sebelum ini? Nilai itu adalah 5. "

Bolehkah saya mengisytiharkan pembolehubah tanpa memulakannya dalam JavaScript? Apabila anda mengisytiharkan pembolehubah tanpa memberikan nilai kepadanya, JavaScript secara automatik memberikan nilai yang tidak ditentukan. Sebagai contoh, jika anda mengisytiharkan pembolehubah seperti ini: biarkan x; Dan kemudian cuba log X ke konsol, anda akan mendapat undefined kerana X telah diisytiharkan tetapi tidak diinisialisasi. JavaScript, jika anda menggunakan pembolehubah tanpa mengisytiharkannya terlebih dahulu, anda akan mendapat referensi. Ini kerana JavaScript perlu tahu tentang pembolehubah sebelum ia boleh digunakan. Jika anda cuba menggunakan pemboleh ubah yang belum diisytiharkan, JavaScript tidak tahu apa yang anda maksudkan dan melemparkan ralat. Contohnya, jika anda cuba log X ke konsol tanpa mengisytiharkan X terlebih dahulu, anda akan mendapat referenceRor: x tidak ditakrifkan. ?

Dalam JavaScript, var, let, dan const semuanya digunakan untuk mengisytiharkan pembolehubah, tetapi mereka mempunyai tingkah laku yang berbeza. var adalah fungsi-scoped, yang bermaksud pembolehubah yang diisytiharkan dengan VAR boleh didapati dalam fungsi yang diisytiharkan. Biarkan dan const adalah blok-scoped, yang bermaksud mereka hanya boleh didapati di dalam blok yang diisytiharkan. Selain itu, Const digunakan untuk digunakan untuk digunakan untuk digunakan untuk digunakan untuk mengisytiharkan pemalar, atau pembolehubah yang tidak dapat ditugaskan semula setelah dimulakan. Pada mulanya mengisytiharkannya. Jika anda mengisytiharkan pembolehubah dengan VAR, anda boleh mengulanginya. Walau bagaimanapun, jika anda mengisytiharkan pembolehubah dengan LeT atau Const, anda tidak boleh mengulanginya dalam skop yang sama. Percubaan untuk berbuat demikian akan menghasilkan syntaxError.

Apa yang Hoisting dalam JavaScript?

Hoisting adalah mekanisme JavaScript di mana pembolehubah dan pengisytiharan fungsi dipindahkan ke bahagian atas skop yang mengandungi mereka semasa fasa penyusunan. Ini bermakna anda boleh menggunakan pembolehubah dan fungsi sebelum diisytiharkan. Walau bagaimanapun, hanya pengisytiharan yang dinaikkan, bukan permulaan. Sekiranya pemboleh ubah diisytiharkan dan dimulakan selepas menggunakannya, pembolehubah tidak akan ditentukan. boleh diakses dari dalam kod anda. Pembolehubah yang diisytiharkan dengan VaR mempunyai skop fungsi, yang bermaksud mereka boleh diakses di mana -mana sahaja dalam fungsi yang diisytiharkan dalam. Pembolehubah yang diisytiharkan dengan LeT dan Const mempunyai skop blok, yang bermaksud mereka hanya boleh diakses dalam blok yang mereka diisytiharkan dalam.

Apakah perbezaan antara NULL dan Undefined dalam JavaScript? Walau bagaimanapun, mereka digunakan dengan cara yang sedikit berbeza. Undefined adalah nilai yang diberikan kepada pembolehubah yang telah diisytiharkan tetapi tidak diasaskan. Null, sebaliknya, adalah nilai yang tidak mewakili nilai atau tiada objek. Ia perlu diberikan kepada pembolehubah secara eksplisit. Mereka mesti bermula dengan tanda surat, garis bawah, atau dolar. Watak khas seperti!, @, #, %, Dan lain -lain, tidak dibenarkan dalam nama yang berubah -ubah. diisytiharkan di luar sebarang fungsi atau blok. Kerana ia tidak terikat pada fungsi atau blok, pembolehubah global boleh diakses dari mana saja dalam kod anda. Walau bagaimanapun, pembolehubah global boleh membawa kepada isu -isu dengan konflik penamaan dan pada umumnya paling baik dielakkan apabila mungkin.

Atas ialah kandungan terperinci Petua Pantas: Cara Mengisytiharkan Pembolehubah dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!