Dalam artikel ini, anda akan belajar tentang fungsi yang berlebihan, kapan kita memerlukan fungsi yang berlebihan dan bagaimana untuk memuat dengan contoh.
Dua atau lebih fungsi mempunyai nama yang sama tetapi argumen yang berbeza dikenali sebagai fungsi yang berlebihan.
Mengapa kita memerlukan fungsi yang berlebihan?
Bayangkan anda sedang mengembangkan permainan penembak di mana pemain boleh menyerang musuhnya menggunakan pisau, pisau dan pistol. Penyelesaian anda untuk fungsi serangan mungkin menentukan tindakan menjadi fungsi seperti:
func attack() ( //… print("Attacking with Knife") ) func attack() ( //… print("Attacking with Blade") ) func attack() ( //… print("Attacking with Gun") )
Tetapi apabila anda cuba menjalankan program di atas, anda akan mendapat ralat waktu kompilasi di Swift sebagai 'serangan ()' yang dinyatakan sebelumnya di sini . Walau bagaimanapun, penyelesaian lain mungkin menentukan nama fungsi yang berbeza untuk fungsi tertentu seperti:
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attackUsingKnife(weapon:Knife) ( //… print("Attacking with Knife") ) func attackUsingBlade(weapon:Blade) ( //… print("Attacking with Blade") ) func attackUsingGun(weapon:Gun) ( //… print("Attacking with Gun") )
Jangan risau jika anda tidak tahu apa itu struktur. Buat masa ini anggap saja sebagai sesuatu yang membuat objek fizikal dalam pengaturcaraan, jadi anda membuat pisau, pistol dan pisau. Sekiranya anda ingin mengetahui lebih lanjut, lihat Swift Struct. Sekiranya tidak, kita akan membahasnya dalam bab-bab berikutnya.
Satu-satunya masalah dengan penyelesaian ini ialah anda perlu mengingat nama fungsi untuk memanggil tindakan serangan tertentu. Juga ketika level naik, pemain mungkin memiliki fitur tambahan untuk menyerang menggunakan bom, bom tangan, senapang, dll.
Membuat fungsi dengan nama yang berlainan memakan masa dan meningkatkan overhead mengingat nama fungsi untuk memanggilnya. Secara keseluruhan, ia tidak intuitif.
Akan lebih baik jika anda dapat membuat fungsi yang berbeda dengan nama yang sama tetapi pelaksanaan yang berbeza untuk setiap senjata. Dengan cara ini, mengingat satu nama fungsi sudah cukup dan anda tidak perlu risau tentang nama fungsi untuk senjata lain.
Apakah fungsi overloading?
Proses yang baru kami nyatakan dikenali sebagai fungsi overloading. Secara definisi, proses membuat dua atau lebih daripada dua fungsi dengan nama yang sama tetapi mempunyai bilangan atau jenis parameter yang berlainan dikenali sebagai fungsi berlebihan.
Mari lihat ini dalam contoh di bawah:
Contoh 1: Fungsi Berlebihan
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attack(with weapon:Knife) ( print("Attacking with Knife") ) func attack(with weapon:Gun) ( print("Attacking with Gun") ) func attack(with weapon:Blade) ( print("Attacking with Blade") ) attack(with: Gun()) attack(with: Blade()) attack(with: Knife())
Apabila anda menjalankan program di atas, outputnya adalah:
Menyerang dengan Pistol Menyerang dengan Pisau Menyerang dengan Pisau
Dalam program di atas, kami telah membuat tiga fungsi yang berbeza dengan nama yang sama attack. Walau bagaimanapun, ia menerima pelbagai jenis parameter. Dengan cara ini mengingat attacknama untuk memanggil fungsi sudah cukup.
- Panggilan
attack(with: Gun())mencetuskan pernyataan di dalam fungsifunc attack(with weapon:Gun). - Panggilan
attack(with: Blade())mencetuskan pernyataan di dalam fungsifunc attack(with weapon:Blade). attack(with: Knife())Pernyataan panggilan di dalam fungsifunc attack(with weapon:Knife).
Contoh 2: Kelebihan fungsi berdasarkan jenis parameter yang berbeza
func output(x:Int) ( print("The int value is (x)") ) func output(x:String) ( print("The string value is (x)") ) output(x: 2) output(x: "Swift")
Apabila anda menjalankan program di atas, outputnya adalah:
Nilai int adalah 2 Nilai rentetan adalah Swift
Dalam program di atas, kami mempunyai dua fungsi dengan nama yang output()sama dan bilangan parameter yang sama. Namun, output()fungsi pertama mengambil bilangan bulat sebagai parameter, dan output()fungsi kedua mengambil Stringparameter.
Sama dengan Contoh 1,
- panggilan untuk
output(x: 2)mencetuskan pernyataan di dalam fungsifunc output(x:Int)dan - panggilan untuk
output(x: "Swift")mencetuskan pernyataan di dalam fungsifunc output(x:String).
Contoh 3: Kelebihan fungsi berdasarkan bilangan parameter yang berbeza
func output() ( print("Good Morning!") ) func output(text:String) ( print(text) ) func output(text:String, num:Int) ( print("(text)(num)!") ) output() output(text: "Good Evening!") output(text1: "Good N", num: 8)
Apabila anda menjalankan program di atas, outputnya adalah:
Selamat Pagi! Selamat petang! Selamat Malam!
Dalam program di atas, fungsi output()telah dibebani berdasarkan jumlah argumen.
Yang pertama output()tidak menggunakan parameter, yang kedua output()mengambil parameter tunggal:, Stringdan yang ketiga output()mengambil dua parameter: Stringdan Int.
Mari kita cuba berlebihan dengan menukar nama parameter tetapi menjaga label argumen sama seperti:
Contoh 4: Fungsi berlebihan dengan label argumen yang sama
func output(value text:String) ( print(text) ) func output(value num:Int) ( print(num) ) output(value: 2) output(value: "Hello")
Apabila anda menjalankan program di atas, outputnya adalah:
2 Helo
Seperti yang anda lihat, dalam program di atas, anda boleh menggunakan label argumen yang sama untuk fungsi yang terlalu banyak. Walau bagaimanapun, seperti yang diperlukan oleh muatan berlebihan, anda mesti mempunyai bilangan parameter yang berbeza atau pelbagai jenis parameter.
