Penjelasan terperinci tentang lulus parameter panjang berubah dalam fungsi Golang

Golang ialah bahasa pengaturcaraan yang mendapat perhatian meluas sejak beberapa tahun kebelakangan ini. Ia telah menunjukkan prestasi yang baik dalam banyak aspek. Antaranya, pemindahan parameter panjang pembolehubah fungsi adalah ciri yang agak istimewa, yang mempunyai kesan yang sangat praktikal pada meringkaskan fungsi dan mengurangkan lebihan kod. Seterusnya, mari kita terokai secara terperinci laluan parameter panjang berubah bagi fungsi dalam Golang.

1. Konsep asas bagi parameter panjang berubah-ubah

Di Golang, seperti beberapa bahasa pengaturcaraan lain, fungsi boleh menerima sifar atau lebih parameter input. Hantaran parameter panjang boleh ubah ialah sintaks khas yang membenarkan sebarang bilangan parameter dihantar ke fungsi. Khususnya, lulus parameter panjang berubah bermakna menentukan bahawa parameter adalah panjang berubah dengan menambahkan "..." pada senarai parameter fungsi, supaya sebarang bilangan parameter boleh diterima.

Berikut ialah format asas untuk menghantar parameter panjang berubah:

func func_name(args ...type) return_type{

// function body

}

Di mana, args ialah parameter pembolehubah, jenis ialah jenis pembolehubah, dan return_type ialah jenis pulangan fungsi.

Perlu diambil perhatian bahawa semua nilai parameter panjang berubah-ubah dibungkus dalam kepingan dan dihantar kepada parameter berubah.

2. Cara menggunakan parameter panjang berubah

Penggunaan parameter panjang berubah adalah sangat fleksibel dan pelbagai Seterusnya, kami akan menggunakan program sampel untuk mengetahui lebih lanjut tentang cara menggunakan ini ciri.

Andaikan kita perlu melaksanakan fungsi yang boleh menerima tiga jenis parameter input: integer, rentetan dan nombor titik terapung, tambahkannya dan cetaknya. Pendekatan yang lebih mudah dan kasar ialah menulis tiga fungsi berbeza untuk mengendalikan jenis parameter input yang berbeza, tetapi ini akan menjadikan kod berlebihan dan kekok. Menggunakan hantaran parameter panjang boleh ubah, kita boleh menyelesaikan masalah ini dengan elegan.

Kod adalah seperti berikut:

utama pakej

import (

"fmt"

)

fungsi Tambah(bilangan ...antara muka {}) float64 {

var sum float64
for _, val := range nums {
    switch v := val.(type) {
    case int:
        sum += float64(v)
    case float64:
        sum += v
    case string:
        fmt.Println("Cannot add a string")
        continue
    }
}
return sum

}

func main() {

fmt.Println(Add(1, 2, 3, 4, 5))
fmt.Println(Add(1.0, 2.0, 3.0, 4.0))
fmt.Println(Add("hello", "world", "golang"))

}

Kami mentakrifkan fungsi Tambah, yang mempunyai parameter panjang berubah-ubah nums, Nilai pulangan ialah jenis float64. Di dalam fungsi, kita mula-mula memulakan pembolehubah jumlah untuk menyimpan jumlah semua parameter input. Kemudian gunakan gelung for dan julat untuk melintasi senarai parameter var, dan lakukan pemprosesan yang berbeza mengikut jenis input yang berbeza.

Dalam contoh ini, kami menggunakan pertimbangan jenis suis. Apabila parameter input adalah jenis int, kami menukarnya kepada jenis float64 dan menambahnya kepada jumlah apabila parameter input adalah jenis float64, ia ditambah terus kepada jumlah apabila parameter input adalah daripada jenis rentetan, kami mencetak mesej ralat, dan langkau parameter ini.

Dalam fungsi utama, kami memanggil fungsi Tambah masing-masing dan lulus pelbagai jenis parameter. Ini ialah kuasa parameter variadic: tidak kira berapa banyak parameter yang anda masukkan daripada jenis yang berbeza, semuanya boleh dikendalikan oleh fungsi tanpa perlu menulis fungsi untuk setiap jenis.

3 Intipati parameter panjang boleh ubah

Parameter panjang boleh ubah pada dasarnya adalah jenis hirisan, iaitu, bukannya menghantar setiap parameter input kepada fungsi satu demi satu, ia dibungkus ke dalam sekeping dan dihantar ke parameter berubah-ubah. Ini menjadikan menghantar argumen panjang pembolehubah lebih cekap daripada menghantar sejumlah besar argumen individu.

Anda boleh menggunakan kata kerja pemformatan %v klasik untuk mencetak nilai parameter panjang pembolehubah:

func main() {

fmt.Printf("%v

", []rentetan{ "a" , "b", "c"})
}

Outputnya ialah: [a b c]

4. Nota

Perlu diingatkan bahawa parameter pembolehubah berada dalam Senarai parameter fungsi mesti diletakkan terakhir, jika tidak ralat kompilasi akan berlaku Sebabnya ialah parameter pembolehubah adalah bersamaan dengan kepingan, dan pengkompil tidak boleh menentukan panjangnya jika ia ditakrifkan sebelum parameter lain dalam. senarai parameter. 🎜>Selain itu, walaupun parameter pembolehubah boleh menerima sebarang bilangan parameter, untuk mengelakkan penggunaan memori yang berlebihan, ia harus digunakan mengikut situasi sebenar

Kesimpulan

Parameter pembolehubah. adalah item fungsi Golang. Ciri yang sangat praktikal, ia membolehkan kami menggunakan kod yang lebih ringkas dan cekap untuk memproses fungsi dengan sejumlah besar parameter input Dalam proses pengaturcaraan, penggunaan parameter pembolehubah yang rasional dapat meningkatkan kebolehbacaan dan kestabilan daripada kod, dan juga boleh menjadikan program ini lebih mudah

Atas ialah kandungan terperinci Penjelasan terperinci tentang lulus parameter panjang berubah dalam fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!