Sa wikang Go, ang isang istraktura ay isang koleksyon ng mga variable (mga patlang) na nakapangkat sa ilalim ng isang pangalan. Ito ay isang pinagsama-samang uri ng data na nagbibigay-daan sa amin na lumikha ng mga pasadyang istruktura ng data upang magkaroon ng kaugnay na impormasyon. Ang mga istruktura sa Go ay parang mga klase sa object-oriented programming tulad ng C, at C++, ngunit hindi nila sinusuportahan ang mana. Sa halip, umaasa sila sa komposisyon upang makamit ang muling paggamit ng code. Sinasaklaw ng artikulong ito ang mga istruktura sa Golang at kung paano namin maipahayag at ma-access ang mga miyembro ng istruktura.
Ano ang Istruktura sa Golang
Sa Golang, ang isang istraktura ay isang pinagsama-samang uri ng data na binubuo ng zero o higit pang pinangalanang mga patlang, na bawat isa ay may partikular na uri. Ang mga patlang ng isang istraktura ay maaaring maging anumang uri, kabilang ang iba pang mga istraktura, array, function, o interface.
Narito ang isang halimbawa ng isang istraktura sa Golang:
uri Istruktura ng tao {
FullName string
YearsOld int
Address ng Lokasyon
}
uri Istruktura ng address {
StreetName string
CityName string
String ng Pangalan ng Bansa
}
Dito ay tinukoy namin ang istraktura ng Tao na mayroong tatlong field: FullName, YearsOld, at Location. Ang field ng Lokasyon ay mismong isang istraktura na may tatlong field: StreetName, CityName, at CountryName.
Paano Magdeklara ng Struct sa Golang
Maaari tayong magdeklara ng isang struct sa Golang gamit ang uri keyword. Ang pangalan ng struct ay tinukoy pagkatapos ng uri keyword, at ang mga patlang nito ay nakapaloob sa mga kulot na brace { } . Narito ang syntax para sa pagdedeklara ng struct sa Go:
uri StructName struct {
FieldName1 FieldType1
FieldName2 FieldType2
...
}
Nasa ibaba ang isang halimbawa kung paano magdeklara ng isang struct na pinangalanang Tao na may dalawang pangalan ng field at edad ng mga uri ng string at int ayon sa pagkakabanggit:
string ng pangalan
edad int
}
Sa code sa itaas, ginamit namin ang uri keyword upang magdeklara ng bagong struct na pinangalanan Tao na may dalawang patlang pangalan ng uri ng string at edad ng uri int. Ang mga patlang ay pinaghihiwalay ng a Bagong linya tauhan ngunit a tuldok-kuwit (;) maaari ding gamitin para sa paghihiwalay sa kanila.
Paano Mag-access ng Struct Member sa Golang
Upang ma-access ang mga field ng isang struct instance sa Go language tuldok (“.”) ginagamit ang operator. Ang dot operator na ito ay sinusundan ng isang pangalan ng field. Narito ang isang halimbawa kung paano i-access ang mga field ng pangalan at edad ng isang halimbawa ng Person struct:
// Gumawa ng bago ` Tao ` struct instance na may pangalan 'kash' at edad 24kash := Tao { pangalan: 'kash' , edad: 24 }
// I-access ang mga patlang ng ` kash ` halimbawa ng istruktura
fmt.Println ( kash.name ) // Output: 'kash'
fmt.Println ( kash.age ) // Output: 24
Sa code sa itaas, gumawa kami ng bagong Person struct instance na pinangalanang kash na may pangalan kash at edad 24 . Pagkatapos ay ina-access namin ang mga field ng pangalan at edad ng instance ng kash struct gamit ang (“.”) operator at i-print ang mga ito sa console.
Mahalagang tandaan na ang mga field ng isang struct instance ay ina-access gamit ang dot notation at hindi ang palaso notasyon (->) ginagamit sa ilang iba pang mga programming language. Ang tuldok na notasyon ay palaging ginagamit sa Go para sa pag-access sa mga field ng mga struct, pati na rin sa mga katangian at pamamaraan ng iba pang mga uri.
Halimbawang Code ng Pagdedeklara at Pag-access sa Struct Member sa Golang
Nasa ibaba ang isang kumpletong halimbawa ng pagdedeklara ng Person struct sa Go at pag-print ng mga halaga nito sa screen:
pangunahing paketeangkat 'fmt'
uri Istruktura ng tao {
string ng pangalan
edad int
}
func main ( ) {
// Gumawa ng bago ` Tao ` struct instance na may pangalan 'kash' at edad 24
kash := Tao { pangalan: 'kash' , edad: 24 }
// I-print ang ` pangalan ` at ` edad ` ng ` kash ` struct instance sa console
fmt.Printf ( 'Pangalan: %s \n ' , kash.name )
fmt.Printf ( 'Edad: %d \n ' , kash.age )
}
Sa nakasulat sa itaas na code, una naming idineklara ang Tao struct. Ang struct na ito ay naglalaman ng dalawang field na pangalan at edad. Pagkatapos noon, gumawa kami ng bagong Person struct instance na pinangalanang kash na may pangalan kash at edad 24 .
Upang ipakita ang mga field ng pangalan at edad, ginagamit namin ang fmt.Printf function kasama ang %s at %d format specifiers upang i-print ang mga field ng pangalan at edad, ayon sa pagkakabanggit.
Pagkatapos tumakbo, lalabas ang sumusunod na code sa console:
Paano Ipasa ang Struct bilang Function Argument
Upang maipasa ang isang struct bilang argumento ng function sa Go, kailangan lang nating tukuyin ang uri ng struct bilang uri ng parameter sa signature ng function, at pagkatapos ay ipasa ang instance ng struct bilang argumento kapag tinatawagan ang function.
Halimbawang Code
Ang halimbawa sa ibaba ay nagpapakita kung paano ipasa ang isang Person struct instance bilang argumento sa isang function sa Go language at i-print ang mga value nito sa screen:
pangunahing paketeangkat 'fmt'
// Ipahayag ang isang struct na pinangalanan ` Tao ` na may dalawang patlang: ` pangalan ` at ` edad `
uri Istruktura ng tao {
string ng pangalan
edad int
}
// Ipahayag a function pinangalanan ` printPerson ` na tumatagal ng a ` Tao ` struct bilang pagtatalo
func printPerson ( p Tao ) {
fmt.Printf ( 'Pangalan: %s \n ' , p.pangalan )
fmt.Printf ( 'Edad: %d \n ' , p.edad )
}
func main ( ) {
// Gumawa ng bago ` Tao ` struct instance na may pangalan 'kash' at edad 24
kash := Tao { pangalan: 'kash' , edad: 24 }
// Ipasa ang ` kash ` struct halimbawa sa ` printPerson ` function
printPerson ( kash )
}
Sa code sa itaas, una naming idineklara ang Person struct na may dalawang field, pangalan, at edad . Pagkatapos ay idedeklara namin ang isang function na pinangalanan printPerson na tumatagal ng isang Person struct bilang argumento at nagpi-print ng pangalan at edad nito sa screen gamit ang fmt.Printf function.
Sa pangunahing function, gumawa kami ng bagong Person struct instance na pinangalanang kash na may pangalan kash at edad 24. Pagkatapos ay ipinapasa namin ang instance ng kash struct sa printPerson function sa pamamagitan ng pagtawag sa printPerson function at pagpasa kash bilang argumento.
Ang sumusunod na output ay makikita sa console pagkatapos patakbuhin ang code sa itaas:
Konklusyon
Sa Golang, maaaring kumatawan ang mga istruktura ng mga kumplikadong uri ng data at i-encapsulate ang mga nauugnay na data. Ang istraktura ay isang uri ng data na binubuo ng isa o higit pang mga field, na ang bawat isa ay binibigyan ng partikular na pangalan at uri. Ang mga patlang ng isang istraktura ay maaaring maging anumang uri, kabilang ang iba pang mga istraktura, array, function, o interface. Tinalakay ng artikulong ito ang mga istruktura ng Go nang detalyado, para sa higit pang impormasyon sa pagdedeklara at pag-access sa mga elemento ng istruktura basahin ang artikulo.