Amalan pengaturcaraan fungsional fungsi Golang

Golang ialah bahasa pengaturcaraan berkuasa yang menyokong paradigma pengaturcaraan berfungsi. Pengaturcaraan fungsional ialah pendekatan pengaturcaraan berorientasikan fungsi yang menekankan bahawa fungsi adalah warga kelas pertama bahasa pengaturcaraan dan fungsi tersebut seharusnya tidak mempunyai kesan sampingan. Dalam artikel ini, kami akan meneroka cara menggunakan amalan pengaturcaraan berfungsi di Golang.

1. Asas pengaturcaraan berfungsi di Golang

Di Golang, fungsi adalah warga kelas pertama. Ini bermakna fungsi boleh dihantar dan diikat seperti pembolehubah. Oleh itu, fungsi boleh dianggap sebagai nilai, sama seperti integer atau rentetan. Golang juga menyediakan beberapa fungsi tertib lebih tinggi, seperti peta, kurangkan dan penapis, yang boleh digunakan untuk memproses jenis koleksi (seperti tatasusunan atau kepingan).

Fungsi tertib tinggi ini boleh digunakan untuk melaksanakan beberapa operasi pengaturcaraan berfungsi biasa. Sebagai contoh, fungsi peta memetakan setiap elemen dalam koleksi kepada elemen dalam koleksi lain. Fungsi pengurangan boleh mengumpul elemen dalam koleksi. Fungsi penapis boleh menapis elemen dalam koleksi yang tidak memenuhi syarat.

2. Amalan pengaturcaraan fungsional

Di bawah kami menggunakan contoh untuk menunjukkan cara mempraktikkan pengaturcaraan berfungsi di Golang. Kami akan mencipta fungsi yang mengira jumlah kuasa dua semua nombor dalam tatasusunan. Katakan kita mempunyai tatasusunan berikut:

numbers := []int{1, 2, 3, 4, 5}

Kita boleh menggunakan gelung for untuk mengira jumlah kuasa dua setiap elemen:

sum := 0
for _, number := range numbers {
    sum += number * number
}

Gelung for ini menggunakan jumlah penumpuk, yang dimulakan kepada 0 . Ia kemudian melelar melalui setiap elemen dalam tatasusunan dan menambah segi empat samanya kepada penumpuk. Akhirnya, kita mendapat jumlah kuasa dua semua nombor dalam tatasusunan.

Menggunakan pengaturcaraan berfungsi, kami boleh memudahkan kod ini menjadi panggilan fungsi. Kita boleh menggunakan fungsi peta untuk mengkuadangkan setiap elemen dalam tatasusunan dan kemudian menggunakan fungsi pengurangan untuk mengumpulnya. Berikut ialah fungsi yang melaksanakan operasi ini:

func square(n int) int {
    return n * n
}

func sum(numbers []int) int {
    squaredNumbers := Map(numbers, square)
    return Reduce(squaredNumbers, func(acc, n int) int {
        return acc + n
    })
}

Dalam fungsi ini, kita mula-mula mentakrifkan fungsi segi empat sama, yang digunakan untuk mengira kuasa dua nombor. Kemudian, kami mentakrifkan fungsi jumlah yang menerima tatasusunan integer sebagai parameter dan mengembalikan jumlah kuasa dua tatasusunan ini.

Dalam fungsi jumlah, kami menggunakan fungsi Peta untuk mengkuadangkan setiap elemen dalam tatasusunan. Kemudian, kami menggunakan fungsi Kurangkan untuk mengumpul elemen dalam tatasusunan kuasa dua. Fungsi Reduce menerima dua parameter: parameter pertama ialah tatasusunan integer, dan parameter kedua ialah fungsi. Fungsi ini digunakan untuk melakukan operasi pengumpulan pada setiap elemen dalam tatasusunan. Dalam contoh ini, kami menggunakan fungsi tanpa nama untuk mengumpul unsur.

3. Pelaksanaan fungsi tertib lebih tinggi

Dalam kod di atas, kami menggunakan fungsi Map and Reduce. Fungsi ini tidak wujud dalam perpustakaan standard Golang. Walau bagaimanapun, kita boleh melaksanakan fungsi ini sendiri.

Pertama, mari kita lihat pelaksanaan fungsi Peta. Fungsi Peta menerima dua parameter: tatasusunan integer dan fungsi, yang akan digunakan untuk beroperasi pada setiap elemen dalam tatasusunan. Fungsi Peta mengembalikan tatasusunan integer baharu yang mengandungi hasil operasi.

func Map(numbers []int, f func(int) int) []int {
    result := make([]int, len(numbers))
    for i, n := range numbers {
        result[i] = f(n)
    }
    return result
}

Dalam fungsi Peta, kami mula-mula mencipta hasil tatasusunan baharu dengan panjang yang sama seperti tatasusunan asal. Kami kemudian mengulangi setiap elemen dalam tatasusunan asal, menyampaikannya kepada fungsi f untuk beroperasi, dan menyimpan hasilnya dalam tatasusunan baharu. Akhirnya, kami mengembalikan tatasusunan baharu ini.

Seterusnya, mari kita lihat pelaksanaan fungsi Reduce. Fungsi Reduce menerima dua parameter: tatasusunan integer dan fungsi yang akan digunakan untuk mengumpul setiap elemen dalam tatasusunan. Fungsi Kurangkan mengembalikan nilai integer, yang merupakan hasil pengumpulan.

func Reduce(numbers []int, f func(int, int) int) int {
    result := numbers[0]
    for _, n := range numbers[1:] {
        result = f(result, n)
    }
    return result
}

Dalam fungsi Reduce, kita mula-mula memulakan hasil penumpuk kepada elemen pertama dalam tatasusunan. Kami kemudian melelang melalui elemen yang tinggal dalam tatasusunan dan mengumpulkannya menggunakan fungsi f yang dihantar ke fungsi Kurangkan. Akhirnya, kami mengembalikan hasil terkumpul.

IV. Kesimpulan

Dalam artikel ini, kami menyemak asas pengaturcaraan berfungsi di Golang dan menunjukkan cara menggunakan pengaturcaraan berfungsi untuk melaksanakan fungsi yang mudah situasi yang kompleks. Walau bagaimanapun, kita boleh menggunakan fungsi tertib tinggi seperti Map dan Reduce untuk mengendalikannya. Fungsi ini membolehkan kami membina logik yang kompleks dengan cara yang mudah dan boleh digubah, menjadikan kod lebih mudah dibaca, diselenggara dan diuji.

Atas ialah kandungan terperinci Amalan pengaturcaraan fungsional fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!