Fungsi tersuai JavaScript untuk terkumpul

JavaScript ialah bahasa pengaturcaraan peringkat tinggi yang digunakan untuk menulis aplikasi web Keupayaannya yang berkuasa dan pelbagai kegunaan telah menjadikannya salah satu alat yang mesti ada dalam pembangunan web. Dalam JavaScript, fungsi tersuai ialah teknologi yang sangat penting yang membolehkan kami menulis dan memanggil fungsi mengikut keperluan kami sendiri. Dalam artikel ini, kami akan memperkenalkan cara menggunakan fungsi tersuai JavaScript untuk terkumpul.

Apakah pengumpulan?

Penambahan ialah menambah semua nombor dalam urutan nombor. Sebagai contoh, jika kita mempunyai urutan nombor 1, 2, 3, 4, 5, maka hasil kumulatif ialah 15 (iaitu 1 + 2 + 3 + 4 + 5).

Bagaimana untuk menggunakan fungsi tersuai JavaScript untuk terkumpul?

Untuk menggunakan fungsi tersuai JavaScript untuk terkumpul, kita perlu menggunakan pembolehubah, gelung dan pernyataan bersyarat.

Berikut ialah atur cara pengumpulan paling mudah:

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

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15

Mari kita pecahkan atur cara ini selangkah demi selangkah:

1. Pertama, kita mentakrifkan fungsi yang dipanggil jumlah, Fungsi itu mempunyai satu parameter arr. Fungsi ini akan mengembalikan nombor, iaitu jumlah bagi jujukan nombor.
2. Kami menggunakan pembolehubah s untuk menyimpan hasil terkumpul dan memulakannya kepada 0. Di sini kami menggunakan kata kunci var untuk mengisytiharkan pembolehubah. Kata kunci var menunjukkan bahawa s ialah pembolehubah tempatan yang hanya boleh diakses dan digunakan dalam fungsi semasa. Jika kita mentakrifkan pembolehubah di luar fungsi, ia menjadi pembolehubah global dan boleh digunakan di mana-mana dalam atur cara.
3. Seterusnya, kami menggunakan gelung untuk melelaran melalui setiap elemen dalam urutan nombor. Pembolehubah gelung i dimulakan kepada 0 dan meningkat sebanyak 1 setiap kali sehingga i sama dengan arr.length.
4. Dalam gelung, kami menggunakan s += arr[i] untuk menambah nilai elemen semasa pada hasil terkumpul. Ini ialah singkatan mudah bersamaan dengan s = s + arr[i].
5. Akhir sekali, kami menggunakan penyata pulangan untuk mengembalikan hasil terkumpul.

Kita boleh menguji ini dengan memanggil fungsi jumlah dan menghantar dalam urutan nombor. Dalam contoh ini, kami mentakrifkan urutan nombor arr = [1, 2, 3, 4, 5] dan menggunakan fungsi console.log untuk mengeluarkan hasil terkumpulnya.

Atur cara di atas ialah bentuk paling asas fungsi tersuai JavaScript untuk pengumpulan. Walau bagaimanapun, ia meninggalkan banyak yang dikehendaki.

Ralat pengendalian

Atur cara sebelumnya menganggap bahawa data input adalah betul dan sah, dan melakukan pengiraan secara langsung. Walau bagaimanapun, dalam aplikasi sebenar, kami mungkin menghadapi data input yang salah atau ralat lain.

Untuk menulis atur cara yang lebih mantap, kita mesti menambah beberapa mekanisme pengendalian ralat. Berikut ialah atur cara pengumpulan yang dipertingkatkan:

function sum(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError('sum() expects an array as parameter.');
  }
  var s = 0;
  for (var i = 0; i < arr.length; i++) {
    if (typeof arr[i] !== 'number') {
      throw new TypeError('sum() expects an array of numbers.');
    }
    s += arr[i];
  }
  return s;
}

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15
console.log(sum('12345')); // TypeError: sum() expects an array as parameter.
console.log(sum([1, '2', 3, 4])); // TypeError: sum() expects an array of numbers.

Dalam versi ini, kami telah menambah dua syarat pengendalian ralat:

1. Jika parameter yang dihantar bukan tatasusunan, kami akan membuang jenis A ralat (TypeError) berlaku.
2. Kami juga akan membuang ralat jenis jika terdapat elemen dalam tatasusunan yang bukan nombor.

Pengendalian ralat boleh meningkatkan keteguhan dan kebolehpercayaan program, memastikan fungsi kami dapat dilaksanakan dengan betul dalam keadaan yang tidak dijangka.

Tandatangan fungsi

Dalam pengaturcaraan, tandatangan fungsi merujuk kepada nama, parameter dan jenis nilai pulangan fungsi. Menentukan tandatangan fungsi boleh membantu kami memahami dan menggunakan fungsi dengan lebih mudah.

Tandatangan fungsi hendaklah mengandungi perkara berikut:

1. Nama fungsi: Ini mestilah rentetan teks yang menerangkan kelakuan fungsi. Sebagai contoh, jumlah nama fungsi di atas menerangkan kelakuannya dengan baik.
2. Parameter: Ini mestilah rentetan teks yang menerangkan input kepada fungsi. Untuk fungsi pengumpulan, kita hanya memerlukan satu arr parameter tatasusunan.
3. Jenis nilai pulangan: Ini mestilah rentetan teks yang menerangkan jenis nilai pulangan fungsi. Untuk fungsi terkumpul, kami menjangkakan ia akan mengembalikan nombor.

Untuk fungsi pengumpulan, kita boleh menandatangani fungsinya seperti berikut:

sum(arr: Array) => Nombor

Ini menunjukkan bahawa fungsi jumlah memerlukan tatasusunan sebagai parameter dan mengembalikan nombor sebagai hasilnya.

Fungsi tertib lebih tinggi

Dalam JavaScript, fungsi tertib tinggi ialah fungsi yang menerima fungsi sebagai input atau mengembalikan fungsi sebagai output. Kita boleh menggunakan fungsi tertib lebih tinggi untuk merangkum operasi biasa dan menggunakannya pada jenis atau keadaan data yang berbeza.

Sebagai contoh, kita boleh menulis fungsi peta umum yang boleh menggunakan operasi untuk setiap elemen dalam mana-mana tatasusunan. Mari lihat cara menulis fungsi ini:

function map(arr, f) {
  if (!Array.isArray(arr)) {
    throw new TypeError('map() expects an array as parameter.');
  }
  if (typeof f !== 'function') {
    throw new TypeError('map() expects a function as second parameter.');
  }
  var result = [];
  for (var i = 0; i < arr.length; i++) {
    result.push(f(arr[i]));
  }
  return result;
}

var arr = [1, 2, 3, 4, 5];
console.log(map(arr, x => 2 * x)); // [2, 4, 6, 8, 10]

var words = ['JavaScript', 'is', 'awesome'];
console.log(map(words, w => w.toUpperCase())); // ['JAVASCRIPT', 'IS', 'AWESOME']

Fungsi ini mengambil dua parameter: arr tatasusunan dan fungsi f. Fungsi f akan digunakan pada setiap elemen dalam tatasusunan dan mengembalikan hasil yang dikira.

Kita boleh menggunakan fungsi peta untuk menggunakan operasi yang berbeza seperti pendaraban pada setiap elemen dalam tatasusunan nombor dan penukaran huruf besar pada setiap elemen dalam tatasusunan rentetan. Memandangkan fungsi peta ialah operasi umum, kita hanya perlu mentakrifkannya sekali dan menggunakannya dalam berbilang senario.

Ringkasan:

Melalui pengenalan artikel ini, kami telah mempelajari cara menggunakan fungsi tersuai JavaScript untuk terkumpul. Kami belajar cara mengendalikan ralat, mentakrifkan tandatangan fungsi dan menggunakan fungsi tertib lebih tinggi. Fungsi tersuai JavaScript adalah sangat fleksibel dan berkuasa, membolehkan kami menulis dan memanggil fungsi mengikut keperluan kami sendiri, meningkatkan kebolehulangan dan kebolehselenggaraan kod.

Atas ialah kandungan terperinci Fungsi tersuai JavaScript untuk terkumpul. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!