JavaScript Basic Functions_in-Depth Analisis variabel dan lingkup

Definisi dan panggilan fungsi

Menentukan fungsi. Dalam JavaScript, cara untuk mendefinisikan fungsi adalah sebagai berikut:

 fungsi abs (x) {if (x> = 0) {return x;} else {return -x;}}

Fungsi ABS () di atas didefinisikan sebagai berikut:

Fungsi menunjukkan bahwa ini adalah definisi fungsi;

ABS adalah nama fungsi;

(x) Sebutkan parameter fungsi dalam tanda kurung, dipisahkan oleh beberapa parameter;

Kode antara {...} adalah badan fungsi, yang dapat berisi beberapa pernyataan, atau bahkan tanpa pernyataan apa pun.

Catatan: Ketika pernyataan di dalam badan fungsi dieksekusi, setelah dieksekusi untuk kembali, fungsi dieksekusi dan hasilnya dikembalikan. Oleh karena itu, penentuan dan loop internal dapat diimplementasikan dengan sangat kompleks.

Jika tidak ada pernyataan pengembalian, hasilnya akan dikembalikan setelah fungsi dieksekusi, tetapi hasilnya tidak ditentukan.

Karena fungsi JavaScript juga merupakan objek, fungsi ABS () yang didefinisikan di atas sebenarnya adalah objek fungsi, dan nama fungsi ABS dapat dianggap sebagai variabel yang menunjuk ke fungsi.

 var abs = function (x) {if (x> = 0) {return x;} else {return -x;}}

Dengan cara ini, fungsi (x) {...} adalah fungsi anonim yang tidak memiliki nama fungsi. Namun, fungsi anonim ini ditetapkan untuk variabel ABS, sehingga fungsi dapat dipanggil melalui variabel ABS.

Kedua definisi itu sepenuhnya setara. Perhatikan bahwa metode kedua perlu menambahkan satu di akhir badan fungsi sesuai dengan sintaks lengkap, menunjukkan bahwa pernyataan penugasan berakhir.

Saat memanggil fungsi, cukup lewati parameter secara berurutan:

abs (10); // Kembalikan 10

ABS (-9); // kembali ke 9

Karena JavaScript memungkinkan parameter apa pun untuk dilewati tanpa terpengaruh, tidak ada masalah bahwa ada lebih banyak parameter yang dilewati daripada parameter yang ditentukan, meskipun parameter ini tidak diperlukan dalam fungsi.

ABS (10, 'blablabla'); // Kembalikan 10

abs (-9, 'haha', 'hehe', null) // kembali ke 9

Tidak ada masalah dengan parameter lebih sedikit dari yang ditentukan

abs (); Kembali nan

Pada saat ini, parameter x fungsi ABS (x) akan menerima yang tidak ditentukan dan hasil perhitungannya adalah NAN

 fungsi abs (x) {if (typeof x! == 'nomor') {throw 'bukan angka':} if (x> = 0) {return x;} else {return -x;}}

argumen

JavaScript juga memiliki argumen kata kunci gratis, yang hanya berfungsi di dalam fungsi dan selalu menunjuk ke semua parameter yang dilewati oleh penelepon fungsi saat ini.

 function foo (x) {alert (x); // 10 untuk (var i = 0; i <arguments.length; ++) {alert (argumen [i]); // 10,20,30}} foo (10.20,30)

Dengan argumen, Anda bisa mendapatkan semua parameter yang dilewatkan oleh penelepon. Dengan kata lain, bahkan jika fungsi tidak menentukan parameter apa pun, nilai parameter masih dapat diperoleh:

 fungsi abs () {if (arguments.length === 0) {return 0;} var x = argumen [0] return x> = 0? x: -x;} abs (); // 0abs (10); // 10ABS (-9) // 9

Faktanya, argumen paling sering digunakan untuk menentukan jumlah parameter yang masuk. Anda mungkin melihat tulisan ini:

// foo (a [, b], c)

// Terima 2 ~ 3 parameter, B adalah parameter opsional. Jika hanya dua parameter yang dimasukkan dan keluar, B adalah nol secara default

 fungsi foo (a, b, c) {if (arguments.length === 2) {// parameter aktual yang diperoleh adalah a dan bc tidak terdefinisi = b; b = null; // b menjadi nilai default

Untuk mengubah parameter tengah B menjadi parameter "opsional", Anda hanya dapat menilai melalui argumen, kemudian menyesuaikan parameter dan menetapkan nilai.

parameter istirahat

Karena fungsi JavaScript memungkinkan untuk menerima parameter apa pun, kami harus menggunakan argumen untuk mendapatkan semua parameter saat menghadapi masalah:

 function foo (a, b) {var i, rest = []; if (arguments.length> 2) {for (i = 2; i <arguments.length; i ++) {rest.push (argumen [i]);}} konsol.log ('a =' + a); console.log ('b =' + b);

Untuk mendapatkan parameter selain parameter yang ditentukan A dan B, kita harus menggunakan argumen, dan loop dimulai dari indeks 2 untuk mengecualikan dua parameter pertama. Metode penulisan ini canggung, hanya untuk mendapatkan parameter REST tambahan. Apakah ada cara yang lebih baik?

Standar ES6 memperkenalkan parameter REST, dan fungsi di atas dapat ditulis ulang sebagai:

 fungsi foo (a, b, ... istirahat) {console.log ('a =' + a); console.log ('b =' + b); console.log (istirahat);} foo (1,2,3,4,5); // hasil // a = 1 // b = 2 // array [3,4,5] foo (1) = 1)//1 // // 1 // aRay//1 // 1 // aRAY//1//1//1 // 1 // aRAY//1 // 1 // 1 // 1 // aRAY//1 // 1 // ARAY//1 // ARAY//1 // ARAY//1//ARAY//1 // ARAY//1//ARRAY/1 // ARAY//1//ARRAY/1//ARRAY/1//ARAY/1//ARAY/1//ARRAY/ARAY [3) [

Parameter sisanya hanya dapat ditulis di akhir, dan ditandai dengan ... dari hasil lari. Dari hasil operasi, kita dapat melihat bahwa parameter yang ditularkan terikat ke A, B, dan parameter tambahan diserahkan ke variabel istirahat dalam array, jadi,

Kami mendapatkan semua parameter tanpa memerlukan argumen.

Jika parameter yang ditularkan tidak diisi dengan parameter yang ditentukan normal, tidak masalah, parameter sisanya akan menerima array kosong (perhatikan bahwa itu tidak ditentukan).

pernyataan pengembalian

Kami menyebutkan sebelumnya bahwa mesin JavaScript memiliki mekanisme untuk secara otomatis menambahkan titik koma di akhir garis, yang dapat menyebabkan Anda jatuh ke dalam lubang besar dalam pernyataan pengembalian:

 function foo () {return {name: 'foo'};} foo (); // {name: 'foo'}

Catatan:

 function foo () {return: // A titik koma ditambahkan secara otomatis, yang setara untuk mengembalikan {name: 'foo'}; // Garis pernyataan ini tidak dapat lagi dieksekusi. }

Jadi cara yang benar untuk menulis beberapa baris adalah

 function foo () {return {// A titik koma tidak akan ditambahkan secara otomatis di sini karena itu berarti pernyataan itu belum berakhir. Nama: 'foo'}}

Ruang lingkup variabel

Dalam JavaScript, apa yang dinyatakan dengan VAR sebenarnya terselubung.

Jika suatu variabel dinyatakan di dalam tubuh fungsi, ruang lingkup variabel adalah seluruh tubuh fungsi, dan variabel tidak boleh dirujuk di luar tubuh fungsi.

 'Gunakan strict': function foo () {var x = 1; x = x +1;} x = x +2; // refrenceerror tidak dapat merujuk ke variabel x di luar fungsi

Jika dua fungsi yang berbeda masing -masing mendeklarasikan variabel yang sama, maka variabel hanya berfungsi di dalam tubuh fungsi masing -masing. Dengan kata lain, variabel dengan nama yang sama dalam fungsi yang berbeda tidak tergantung satu sama lain dan tidak saling mempengaruhi:

 'Gunakan struct': function foo () {var x = 1; x = x +1;} batang fungsi () {var x = 'a'; x = x + 'b';}

Karena fungsi JavaScript dapat bersarang, fungsi internal dapat mengakses variabel yang ditentukan oleh fungsi eksternal, dan sebaliknya adalah bukan:

 'Gunakan strict'; function foo () {var x = 1; function bar () {var x = 1; function bar () {var y = x +1; // batang dapat mengakses variabel x foo z = y + 1; // ReferenceError! foo tidak dapat mengakses variabel y batang! }}

Bagaimana jika nama variabel fungsi internal dan eksternal digandakan?

 'Gunakan strict': function foo () {var x = 1; function bar () {var x = 'a'; alert ('x in bar () =' + x); // 'a'} alert ('x in foo () =' + x) // 1bar ();}

Peningkatan variabel

Definisi fungsi JavaScript memiliki fitur, yang pertama -tama akan memindai seluruh pernyataan tubuh fungsi dan "meningkatkan" semua variabel yang diumumkan ke bagian atas fungsi:

 'Gunakan ketat'; function foo () {var x = 'hello,'+y; alert (x); var y = 'bob';} foo ();

Untuk fungsi FOO () di atas, kode yang dilihat oleh mesin JavaScript setara dengan:

 function foo () {var y; // Naikkan var x dari variabel y = 'hello' + y; alert (x); y = 'bob';}

Karena "karakteristik" yang aneh dari JavaScript ini, ketika kita mendefinisikan variabel di dalam suatu fungsi, harap benar -benar mematuhi aturan "untuk mendeklarasikan semua variabel terlebih dahulu dalam suatu fungsi". Cara yang paling umum adalah menggunakan VAR untuk mendeklarasikan semua variabel yang digunakan secara internal dalam fungsi:

 function foo () {var x = 1, // x diinisialisasi ke 1y = x +1, // y diinisialisasi ke 2Z, i; // z dan saya tidak terdefinisi // pernyataan lain untuk (i = 0; i <100; i ++) {...}}

Ruang lingkup global

Variabel yang tidak didefinisikan dalam fungsi apa pun memiliki ruang lingkup global. Faktanya, JavaScript memiliki variabel cakupan global secara default yang sebenarnya terikat pada properti jendela.

 'Gunakan ketat'; var source = 'pelajari javascript'; alert (kursus); // 'pelajari javascript'; alert (window.course); // 'pelajari javascript'

Namespace

Variabel global akan terikat ke jendela. File JavaScript yang berbeda menggunakan variabel global yang sama, atau memiliki nama fungsi tingkat atas yang sama, yang akan menyebabkan

Penamaan konflik dan sulit dideteksi.

Salah satu cara untuk mengurangi konflik adalah dengan mengikat semua variabel dan fungsi Anda menjadi variabel global.

 // Satu -satunya variabel qui myappvar myapp = {}; // variabel lain: myapp.name = 'myapp'; myapp.version = 1.0; // fungsi lain myapp.foo = function () {return 'foo';};

Menempatkan semua kode Anda ke dalam namespace unik MyApp akan sangat mengurangi kemungkinan konflik variabel global.

Ruang lingkup lokal

Karena ruang lingkup variabel Javascript sebenarnya berada di dalam fungsi, kami tidak dapat mendefinisikan variabel yang tidak dapat didefinisikan dalam blok pernyataan seperti untuk loop.

 function foo () {for (var i = 0; i <100; i ++) {//} i+= 100; // Variabel masih dapat direferensikan;}

Untuk menyelesaikan lingkup level blok, ES6 memperkenalkan kata kunci baru, dan bukannya VAR, Anda dapat mendeklarasikan variabel lingkup level blok:

 function foo () {var sum = 0; for (let i = 0; i <100; i ++) {sum += i;} i += 1;}

konstan

Karena var dan biarkan variabel menyatakan, jika Anda ingin menyatakan konstan, itu tidak akan berhasil sebelum ES6. Kami biasanya menggunakan semua variabel modal untuk menunjukkan bahwa ini adalah konstan

Jangan memodifikasi nilainya.

var pi = 3.14;

Standar ES6 memperkenalkan kata kunci baru Const untuk mendefinisikan konstanta, baik Const maupun Let memiliki ruang lingkup level blok;

const pi = 3.14;

Pi = 3; // Beberapa browser tidak melaporkan kesalahan, tetapi tidak berpengaruh.

Pi; // 3.14

Analisis variabel dan ruang lingkup Functions_in-Depth di atas adalah semua konten yang saya bagikan dengan Anda. Saya harap Anda dapat memberi Anda referensi dan saya harap Anda dapat mendukung wulin.com lebih lanjut.