Perbezaan antara fungsi biasa yang ditakrifkan dalam kemahiran javascript_javascript

Perbezaan antara fungsi yang lebih biasa yang ditakrifkan dalam JavaScript terutamanya dijelaskan melalui tiga aspek berikut Rakan yang memerlukan boleh merujuknya

1: Panggil fungsi kata kunci untuk membina

Contohnya:

function distance(x1,x2,y1,y2) 
　　{ 
　　　　var dx=x2-x1; 
　　　　var dy=y2-y1; 
　　　　return Math.sqrt(dx*dx+dy*dy); 
　　} 

2: Gunakan pembina Function()

Contohnya:

var f=new Function*"x","y","return x*y"); 

Baris kod ini mencipta fungsi baharu yang pada asasnya bersamaan dengan fungsi yang ditakrifkan menggunakan sintaks yang anda kenali:

function f(x,y) 
　　{ 
　　  return x*y; 
　　} 

Pembina Functino() boleh menerima sebarang bilangan parameter rentetan. Parameter terakhirnya ialah badan fungsi, yang boleh mengandungi sebarang pernyataan JavaScript yang dipisahkan oleh koma bertitik. Parameter lain ialah rentetan yang digunakan untuk menerangkan nama parameter formal yang akan ditakrifkan oleh fungsi. Jika fungsi yang anda takrifkan tidak mempunyai parameter, anda hanya boleh menghantar rentetan (badan fungsi) kepada pembina.

Ambil perhatian bahawa tiada parameter yang dihantar kepada Function() pembina menyatakan nama fungsi yang diciptanya. Fungsi tanpa nama yang dibuat dengan pembina Function() kadangkala dipanggil "fungsi tanpa nama".

Anda mungkin sangat ingin tahu untuk apa pembina Function() digunakan. Mengapa kita tidak boleh menggunakan penyataan fungsi untuk menentukan semua fungsi? Sebabnya ialah pembina Function() membenarkan kami membina dan menyusun fungsi secara dinamik tanpa mengehadkan kami kepada badan fungsi yang telah disusun sebelumnya bagi pernyataan fungsi. Kesan sampingan ini ialah setiap kali fungsi dipanggil, pembina Function() mesti menyusunnya. Oleh itu, kita tidak sepatutnya memanggil pembina ini dengan kerap dalam badan gelung atau dalam fungsi yang kerap digunakan.

Satu lagi sebab untuk menggunakan pembina Function() ialah ia boleh mentakrifkan fungsi sebagai sebahagian daripada ungkapan JavaScript dan bukannya mentakrifkannya sebagai pernyataan Dalam kes ini, menggunakannya adalah lebih mudah dan lebih elegan.

3: Fungsi literal

Fungsi literal ialah ungkapan yang boleh mentakrifkan fungsi tanpa nama. Sintaks literal fungsi sangat serupa dengan pernyataan fungsi, kecuali ia digunakan sebagai ungkapan dan bukannya pernyataan, dan tidak perlu menentukan nama fungsi. Tiga baris kod berikut mentakrifkan tiga pada asasnya fungsi yang sama menggunakan pernyataan function(), pembina Function() dan fungsi literal:

function f(x){return x*x}; 
　　var f=new Function("x","return x*x;"); 
　　var f=function(x){reurn x*x}; 

Walaupun literal fungsi mencipta fungsi tanpa nama, sintaksnya juga menyatakan bahawa ia boleh menentukan nama fungsi, yang sangat berguna apabila menulis fungsi rekursif yang memanggil dirinya sendiri.

Contohnya:

var f=function fact(x){if(x<=1)return 1;else return x*fact(x-1);}; 

Kod di atas mentakrifkan fungsi yang tidak dinamakan dan menyimpan rujukan kepadanya dalam pembolehubah f. Ia sebenarnya tidak mencipta fungsi bernama fact(), ia hanya membenarkan badan fungsi merujuk kepada dirinya sendiri dengan nama ini. Walau bagaimanapun, ambil perhatian bahawa fungsi literal yang dinamakan ini tidak dilaksanakan dengan betul dalam versi sebelum JavaScript 1.5.

Penggunaan literal fungsi adalah sangat serupa dengan kaedah mencipta fungsi menggunakan pembina Function(). Memandangkan ia dicipta oleh ungkapan JavaScript dan bukannya pernyataan, cara ia digunakan adalah lebih fleksibel, terutamanya untuk fungsi yang hanya digunakan sekali dan tidak perlu dinamakan. Contohnya, fungsi yang ditentukan menggunakan ungkapan literal fungsi boleh disimpan dalam pembolehubah, dihantar ke fungsi lain, atau dipanggil terus:

a[0]=function(x){return x*x;};//定义一个函数并保存它 
　　a.sort(function(a,b){return a-b;});//定义一个函数；把它传递给另一个函数 
　　var tensquared=(function(x){return x*x;})(10); 

　　和Function()构造函数一样，函数直接量创建的是未命名函数，而且不会自动地将这个函数存储在属性中。但是，比起Function()构造函数来说，函数直接量有一个重要的优点。由Function()构造函数创建的函数的主体必须用一个字符串说明，用这种方式来表达一个长而复杂的函数是狠笨拙的。但是函数直接量的主体使用的却是标准的JavaScript语法。而且函数直接量只被解析一次，而作为字符串传递给Function()构造函数的JavaScript代码则在每次调用构造函数时只需被解析一次和编译一次。

　　 　　在JavaScript1.1中，可以使用构造函数Function()来定义函数，在JavaScript1.2和其后的版本中，还可以使用函数直接量来构造函数。你应该注意这两种方法之间的重要差别。

　　首先，构造函数Function()允许在运行时动态地创建和编译JavaScript代码。但是函数直接量却是函数结构的一个静态部分，就像function语句一样。

　　其次，作为第一个差别的必然结果，每次调用构造函数Function()时都会解析函数体并且创建一个新东汉数对象。如果对构造函数的调用出现在一个循环中，或者出现在一个经常被调用的函数中，这种方法的效率非常低。另一个方面，函数直接量或出现在循环和函数中的嵌套函数不是在每次调用时都被重新编译，而且每当遇到一个函数直接量时也不创建一个新的函数对象。

　　Function()构造函数和函数之间量之间的第三点差别是，使用构造函数Function()创建的函数不使用词法作用域，相反的，它们总是被当作顶级函数来编译，就像下面代码所说明的那样：

　var y="global"; 
　　function constructFunction() 
　　{ 
　　　　var y="local"; 
　　　　return new Function("return y");//不捕捉局部作用域。 
　　} 
　　//这行代码将显示"global"，因为Function()构造函数返回的函数并不使用局部作用域。 
　　//假如使用一个函数直接量，这行代码则可能显示"local"。 
　　alert(constructFunction());