Mari kita bincangkan tentang definisi dan penggunaan asas fungsi JavaScript

Artikel ini membawa anda pengetahuan yang berkaitan tentang javascript Ia terutamanya mengatur isu yang berkaitan dengan definisi dan penggunaan asas fungsi, termasuk definisi dengan penyataan fungsi, panggilan fungsi dan tidak ditentukan Mari kita lihat pada yang sebenar. parameter dan sebagainya. Saya harap ia akan membantu semua orang.

[Cadangan berkaitan: tutorial video javascript, bahagian hadapan web]

1 penyataan fungsi

Mari kita berikan contoh dahulu Fungsi fungsi ini adalah untuk mengembalikan jumlah elemen tatasusunan

function sumArray(arr) {  
    var sum = 0;  
    for(var i = 0,aLength = arr.length;i < aLength;i++) {  
        sum += arr[i];  
    }  
    return sum;  }

Ada ruang selepas kata kunci function , dan sumArray ialah fungsi Nama mempunyai konvensyen penamaan yang sama seperti nama pembolehubah: hanya boleh mempunyai huruf, nombor, garis bawah dan tanda dolar serta tidak boleh bermula dengan nombor atau menjadi kata kunci.

Parameter dalam kurungan juga dipanggil parameter formal dan hanya nama parameter diperlukan. Parameter boleh 0, 1 atau lebih, dipisahkan dengan , dan {} mengandungi badan fungsi . Mengandungi satu atau lebih pernyataan. Badan fungsi digunakan untuk melaksanakan fungsi fungsi.

kata kuncireturn diikuti dengan nilai pulangan fungsi tersebut juga boleh tidak mempunyai nilai pulangan. Selepas fungsi selesai berjalan, return ayat ini di sini akan keluar dari pelaksanaan, dan return ayat berikut tidak akan dijalankan lagi . Nilai pulangan ialah output fungsi.

Untuk fungsi yang ditakrifkan dengan cara ini, anda boleh memanggil fungsi sebelum dan selepas definisi fungsi, selagi fungsi dan pernyataan yang memanggil fungsi itu berada dalam fail sumber yang sama .

2. Gunakan definisi ungkapan

Untuk mentakrifkan fungsi dalam bentuk ungkapan ialah menggunakan ungkapan tugasan untuk menetapkan fungsi kepada pembolehubah Ini sebenarnya untuk melihat fungsi sebagai pembolehubah. Pada masa ini, fungsi boleh mempunyai nama atau tiada nama Fungsi tanpa nama dipanggil fungsi tanpa nama.

• dengan nama;

var funct = function getMax(a,b) {  
    return a>b?a:b;  };//注意这后面的分号不能少，因为我们定义的是一个变量!

dan ditakrifkan menggunakan pernyataan fungsi Perbezaan antara ialah ia hanya boleh ditakrifkan selepas pernyataan definisi fungsi Panggil fungsi ini, dan apabila memanggil, anda hanya boleh menggunakan nama pembolehubah funct, bukan nama fungsi getMax, seperti:

var funct = function getMax(a,b) {  
    return a>b?a:b;  
};  
console.log(funct(1,2));//输出2

• fungsi tanpa nama ;
  Fungsi yang dipanggil tanpa nama ialah senarai parameter terus selepas kata kunci function:

var funct = function(a,b) {  
    return a>b?a:b;  };

Fungsi ini tidak mempunyai nama, ia diperuntukkan kepada pembolehubah funct, jadi ia dipanggil fungsi tanpa nama . Begitu juga, hanya boleh memanggil fungsi ini selepas pernyataan ini.

var funct = function(a,b) {  
    return a>b?a:b;  };  console.log(funct(1,2));//输出2

Ringkasan: Mentakrifkan fungsi dengan ungkapan sedia untuk digunakan Setelah ditakrifkan, fungsi hanya boleh dipanggil selepas pernyataan ini

3. . Panggilan fungsi

Dalam latihan 4, kami telah memperkenalkan bahawa objek boleh mempunyai kaedah sendiri, yang tentunya juga merupakan fungsi. Panggilan fungsi ini sedikit berbeza daripada fungsi yang ditakrifkan dalam dua peringkat sebelumnya.

//函数的定义：求三个数的最大值  
function max(a,b,c) {  
    if(a > b) {  
        if(a > c)  
            return a;  
        else   
            return c;  
    }  
    else {  
        if(b > c)  
            return b;  
        else   
            return c;  
    }  
}  
//调用该函数  
var result = max(1,2,3);//result为3  
console.log(result);//输出3

Apabila memanggil fungsi, anda perlu memasukkan bilangan nilai tertentu yang sama seperti parameter formal Fungsi di atas mempunyai parameter 3, jadi apabila memanggil yang berikut, masukkan 3 nilai khusus. Nilai 1 dihantar ke parameter a, 2 dihantar ke parameter b dan 3 dihantar ke parameter c. Nilai pulangan fungsi dihantar kepada pembolehubah = melalui simbol tugasan result. Jika tiada kata kunci return dalam badan fungsi, undefined akan dikembalikan. Fungsi panggilan yang ditakrifkan dalam objek

:

var ob = {  
    id:1,  
    getMax:function(a,b) {  
        return a>b?a:b;  
    }  };  var result = ob.getMax(2,1);//result值为2  var result1 = ob["getMax"](2,1);//result1的值也是2

Perbezaan daripada di atas ialah untuk mencari fungsi di sini, anda perlu menggunakan 对象名.函数名 atau 对象名["函数名"], yang lain ialah sama.

4. Parameter sebenar tidak ditentukan

Dalam kebanyakan bahasa pengaturcaraan, nombor dan jenis parameter sebenar yang dihantar semasa memanggil fungsi diperiksa dan JavaScript kedua-duanyaTidak menyemak jenis parameter sebenar, ia juga tidak menyemak bilangan parameter sebenar. Parameter sebenar dalam
JavaScript akan sepadan dengan parameter formal mengikut urutan dari kiri ke kanan , contohnya:

function myFunction(a,b,c) {  
    console.log(a);  
    console.log(b);  
    console.log(c);  }  myFunction(1,2,3);

parameter sebenar1parameter formal masuka, parameter sebenar 2 diluluskan dalam parameter formal b dan parameter sebenar 3 diluluskan dalam parameter formal c. Apabila bilangan parameter sebenar kurang daripada parameter formal, nilai undefined akan dihantar ke parameter formal yang betul. Contohnya:

function myFunction(a,b,c) {  
    console.log(a);  
    console.log(b);  
    console.log(c);  }  myFunction(1,2);

parameter sebenar1lulus dalam parameter formala, parameter sebenar2lulus dalam parameter formalb, undefinedlulus dalam parameter formalc. Jika anda hanya mahu menghantar data kepada parameter di sebelah kanan, anda boleh menghantar undefined kepada beberapa parameter sebenar yang pertama. Contohnya:

function myFunction(a,b,c){  console.log(a);  console.log(b);  console.log(c);  }  myFunction(undefined,1,2);

Dua kaedah di atas tidak cukup ketat Amalan terbaik ialah menetapkan undefinednilai lalai untuk parameter formal yang mungkin dihantar dalam nilai . Seperti:

function getSum(a,b,c) {  
    if(c === undefined)   
        c = 0;  
    console.log(a+b+c);  }  myFunction(1,2);

5.实参对象

JavaScript一切都是对象，实参也是一个对象，有一个专门的名字arguments，这个对象可以看成一个数组（类数组，不是真的数组），实参从左到右分别是arguments[0]、arguments[1]...，arguments.length表示实参的个数。

//求参数的和  function getSum() {  
    var aLength = arguments.length;  
    var sum = 0;  
    for(var i = 0;i < aLength;i++) {  
        sum += arguments[i];  
    }  
    return sum;  }  console.log(getSum(1,2,3,4,5))//输出15

这里的形参直接省略，使用arguments[i]表示。

6.对象作为参数

复杂的函数通常多达十几个参数，尽管JavaScript不做参数个数和类型的检查，但是调用时实参的顺序不能乱。开发人员需要检查每一个实参和形参的对应关系，这样效率很低。一种很好的解决方案是使用对象作为参数，函数会根据对象的属性名操作参数。

function myFunction(obj) {  
    console.log(obj.name);  
    obj.number++;  
    return obj.number;  }  myObj = {name:"myObj",number:34};  myFunction(myObj);//输出myObj  console.log(myObj.number);//输出35

7.函数对象作为另一个函数的参数

一个函数（为方便行文，称为a函数）可以作为另外一个函数（称为b函数）的参数，b函数最终可以返回一个具体的值。

从原理上来说，b函数在自己的函数体内调用了a函数，所以需要把a函数的名字作为实际参数传递给b函数。如下：

//求最大值  function getMax(a,b) {  
    return a>b?a:b;  }  //求最小值  function getMin(a,b) {  
    return a<b?a:b;  }  //下面这个函数以函数作为参数，并最终返回一个值  function getM(func,num1,num2) {  
    return func(num1,num2);  }  getM(getMax,1,2);//返回2  getM(getMin,1,2);//返回1

我们把a函数的名字（getMax或者getMin）传给b函数（getM（）），然后在b函数内部调用传入的a函数，得到相关的结果。

【相关推荐：javascript视频教程、web前端】

Atas ialah kandungan terperinci Mari kita bincangkan tentang definisi dan penggunaan asas fungsi JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!