golang pakej berbeza

Di Golang, pakej yang berbeza boleh memanggil dan merujuk antara satu sama lain, yang menyediakan asas untuk reka bentuk modular Golang. Jadi, bagaimana kita menggunakan pakej yang berbeza dengan betul di Golang? Dalam artikel ini, kami akan mendalami penggunaan dan pertimbangan pakej yang berbeza di Golang.

Pertama, kita perlu tahu cara merujuk pakej yang berbeza. Di Golang, anda boleh menggunakan pernyataan import untuk memperkenalkan pakej, seperti ditunjukkan di bawah:

import "packageName"

Perlu diingat bahawa selepas menggunakan pernyataan import, pengecam boleh eksport (atribut, atribut, kaedah, dsb.) boleh dipanggil dan digunakan, manakala pengecam yang tidak boleh dieksport tidak boleh diakses.

Seterusnya, mari kita lihat cara membuat panggilan antara pakej yang berbeza.

Katakan kita mempunyai dua pakej, packageA dan packageB, di mana terdapat fungsi packageA dalam funcA dan kami mahu memanggilnya dalam packageB. Kemudian, dalam packageB, kita perlu mengimport import melalui pernyataan packageA dan memanggilnya dengan cara berikut:

package packageB

import "packageA"

func main() {
    packageA.funcA()
}

Perlu diingat bahawa dalam kod di atas, sebelum funcA kaedah packageA. mewakili fungsi yang ditakrifkan dalam packageA, bukan fungsi dalam packageB. Di samping itu, satu-satunya perbezaan ialah huruf besar dan huruf kecil, dan nama pembolehubah dan fungsi dalam pakej yang berbeza boleh menjadi sama. Oleh itu, untuk mengelakkan kekeliruan dan ralat, kita harus memastikan nama pakej dan nama pembolehubah/fungsi unik.

Di Golang, semua pengecam adalah peribadi secara lalai dan hanya boleh diakses dalam pakej di mana ia berada Walau bagaimanapun, pengecam boleh eksport dan pengecam tidak boleh dieksport boleh dibezakan dengan kes huruf pertama pembolehubah. nama dan nama fungsi. Khususnya, huruf besar dalam nama pembolehubah dan nama fungsi mewakili pengecam yang boleh dieksport, manakala huruf kecil mewakili pengecam yang tidak boleh dieksport.

Sebagai contoh, fungsi berikut ditakrifkan dalam packageA:

package packageA

func FuncA() {
    fmt.Println("This is a public function.")
}

func funcA() {
    fmt.Println("This is a private function.")
}

di mana, FuncA ialah fungsi boleh eksport yang boleh dipanggil dalam pakej lain, dan funcA ialah It is fungsi peribadi dan hanya boleh digunakan dalam pakej packageA yang terdapat di dalamnya.

Untuk mengelakkan penggunaan yang tidak wajar, pengecam yang tidak boleh dieksport hendaklah menggunakan tatanama peribadi: huruf kecil + kombinasi garis bawah (seperti func_a).

Jika kita perlu berkongsi pembolehubah antara pakej yang berbeza, kita boleh menggunakan pembolehubah global di Golang. Pembolehubah global mesti diisytiharkan dengan kata kunci var sebelum pembolehubah, jika tidak pembolehubah akan dianggap sebagai pembolehubah tempatan fungsi. Contohnya:

package packageA

var GlobalVar int = 100

Dengan cara ini, kita boleh merujuk pembolehubah global ini dalam pakej lain. Perlu diingatkan bahawa pembolehubah global boleh menyebabkan masalah untuk senario berbilang benang, jadi anda perlu memberi perhatian kepada keselamatan berbilang benang apabila menggunakan pembolehubah global.

Di Golang, kami boleh membahagikan pakej yang sama dengan mencipta fail berbeza dalam folder yang sama. Kod dalam setiap fail tergolong dalam pakej yang sama dan boleh dipanggil terus dan dirujuk dalam fail lain. Contohnya:

Dalam direktori packageA, kami mencipta dua fail file1.go dan file2.go:

// file1.go
package packageA

func FuncA() {
    fmt.Println("This is a public function.")
}

// file2.go
package packageA

func FuncB() {
    fmt.Println("This is another public function.")
}

Kod dalam kedua-dua fail ini tergolong dalam pakej packageA, dalam Mereka boleh dipanggil terus dari fail lain.

Akhir sekali, perlu diingat bahawa jangan terlalu menggunakan pembolehubah global dan panggilan fungsi antara pakej yang berbeza, kerana ini akan mengurangkan kebolehbacaan dan kebolehselenggaraan kod. Amalan yang betul adalah untuk mengurangkan skop fungsi dan pembolehubah yang boleh dilihat kepada pakej mereka sendiri sebanyak mungkin untuk meningkatkan kebolehbacaan dan kebolehselenggaraan struktur kod.

Ringkasnya, di Golang, pakej yang berbeza boleh memanggil dan merujuk antara satu sama lain, yang menyediakan asas untuk reka bentuk modular Golang. Gunakan pernyataan import untuk memperkenalkan pakej Apabila menggunakan kaedah dan pembolehubah daripada pakej yang berbeza, anda perlu memberi perhatian kepada perbezaan antara pengecam boleh eksport dan pengecam tidak boleh dieksport. Pada masa yang sama, untuk meningkatkan kebolehbacaan dan kebolehselenggaraan kod, kurangkan skop fungsi dan pembolehubah yang boleh dilihat kepada pakej mereka sendiri sebanyak mungkin, dan elakkan penggunaan pembolehubah global dan panggilan fungsi secara berlebihan. Pertimbangan ini akan memastikan bahawa kami boleh merujuk dan memanggil fungsi dan pembolehubah dengan betul dalam pakej lain apabila menggunakan pakej yang berbeza.

Atas ialah kandungan terperinci golang pakej berbeza. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!