Dziļa niršana pārdomās ceļā

Go programmēšanas valoda ir plaši pazīstama ar savu izteiksmīgumu. Tā ir stingri drukāta valoda, taču tā joprojām nodrošina lietojumprogrammām iespēju dinamiski manipulēt un pārbaudīt objektus, tostarp mainīgos, funkcijas un tipus izpildlaikā.

Pārdomas ir mehānisms, ko Go izmanto, lai sasniegtu šo spēju. Kas tad ir refleksija un kā jūs varat izmantot refleksiju savās Go lietojumprogrammās?

Kas ir atspulgs?

Refleksija ir programmas spēja pārbaudīt tās mainīgos lielumus un struktūru un manipulēt ar tiem izpildes laikā.

Reflection in Go ir mehānisms, ko valoda nodrošina dinamiskai veida un objektu manipulācijām. Jums var būt nepieciešams pārbaudīt objektus, atjaunināt tos, izsaukt to metodes vai pat veikt darbības, kas ir raksturīgas to tipiem, nezinot to tipus kompilēšanas laikā. Pārdomas padara to visu iespējamu.

Dažādi komplekti Go, ieskaitot kodējums kas ļauj jums

strādāt ar JSON, un fmt, lai veiktu savus pienākumus, lielā mērā paļaujas uz pārdomām zem pārsega.

Izpratne par atspoguļoto paketi Go

Golanga mācīšanās var būt izaicinājums tās semantikas un robustās pakotņu un metožu bibliotēkas dēļ, kas veicina efektīvas programmatūras izstrādi.

The atspoguļot iepakojums ir viens no šiem daudzajiem iepakojumiem. Tas sastāv no visām metodēm, kas nepieciešamas, lai Go lietojumprogrammās ieviestu refleksiju.

Lai sāktu darbu ar atspoguļot pakotni, varat to vienkārši importēt šādi:

import"reflect"

Paketē ir definēti divi galvenie veidi, kas veido pamatu pārdomām Go: atspoguļot. Tips un atspoguļot. Vērtība.

A Tips ir vienkārši Go veids. atspoguļot. Tips ir saskarne, kas sastāv no dažādām metodēm dažādu veidu identificēšanai un to komponentu pārbaudei.

Funkcija jebkura objekta veida pārbaudei programmā Go, atspoguļot. TypeOf, pieņem jebkuru vērtību (an saskarne{}) kā vienīgo argumentu un atgriež a atspoguļot. Tips vērtība, kas apzīmē objekta dinamisko tipu.

Tālāk sniegtais kods parāda, kā lietot atspoguļot. TypeOf:

x := "3.142"
y := 3.142
z := 3
typeOfX := reflect.TypeOf(x)
typeOfY := reflect.TypeOf(y)
typeOfZ := reflect.TypeOf(z)
fmt.Println(typeOfX, typeOfY, typeOfZ) // string float64 int

Otrais veids atspoguļot iepakojums, atspoguļot. Vērtība var saturēt jebkura veida vērtību. The atspoguļot. ValueOf funkcija pieņem jebkuru saskarne{} un atgriež saskarnes dinamisko vērtību.

Šeit ir piemērs, kas parāda, kā lietot atspoguļot. ValueOf lai pārbaudītu iepriekš minētās vērtības:

valueOfX := reflect.ValueOf(x)
valueOfY := reflect.ValueOf(y)
valueOfZ := reflect.ValueOf(z)
fmt.Println(valueOfX, valueOfY, valueOfZ) // 3.142 3.142 3

Lai pārbaudītu vērtību veidus un veidus, varat izmantot Laipni un Tips šāda metode:

typeOfX2 := valueOfX.Type()
kindOfX := valueOfX.Kind()
fmt.Println(typeOfX2, kindOfX) // string string

Lai gan abu funkciju izsaukumu rezultāts ir vienāds, tie ir atšķirīgi. tipsOfX2 būtībā ir tas pats, kas tipsOfX jo tie abi ir dinamiski atspoguļot. Tips vērtības, bet kindOfX ir konstante, kuras vērtība ir noteikta veida x, virkne.

Tāpēc ir ierobežots skaits veidu, piemēram, starpt, virkne, peldēt, masīvsutt., bet bezgalīgs skaits veidu, jo var būt vairāki lietotāja definēti veidi.

An saskarne{} un a atspoguļot. Vērtība darbojas gandrīz tādā pašā veidā, tajās var būt jebkura veida vērtības.

Atšķirība starp tām slēpjas tajā, cik tukša saskarne{} nekad neatklāj tajā esošās vērtības vietējās darbības un metodes. Tāpēc visbiežāk jums ir jāzina vērtības dinamiskais veids un jāizmanto tipa apgalvojums, lai tai piekļūtu (t.i., i.(virkne), x.(int)u.c.), pirms varat ar to veikt darbības.

Turpretim a atspoguļot. Vērtība ir metodes, kuras varat izmantot, lai pārbaudītu tā saturu un īpašības neatkarīgi no tā veida. Nākamajā sadaļā šie divi veidi tiek apskatīti praktiski un parādīts, kā tie ir noderīgi programmās.

Reflection ieviešana programmās Go

Pārdomas ir ļoti plašas, un to var izmantot programmā jebkurā brīdī. Tālāk ir sniegti daži praktiski piemēri, kas parāda refleksijas izmantošanu programmās:

• Pārbaudiet dziļu vienlīdzību: atspoguļot pakete nodrošina DeepEqual funkcija divu objektu vērtību padziļinātai vienlīdzības pārbaudei. Piemēram, divas struktūras ir dziļi vienādas, ja visiem to atbilstošajiem laukiem ir vienādi veidi un vērtības. Šeit ir koda piemērs:

   // deep equality of two arrays
   arr1 := [...]int{1, 2, 3}
   arr2 := [...]int{1, 2, 3}
   fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  

• Kopējiet šķēles un masīvus: Varat arī izmantot Go refleksijas API, lai kopētu vienas šķēles vai masīva saturu citā. Lūk, kā to izdarīt:

   slice1 := []int{1, 2, 3}
   slice2 := []int{4, 5, 6}
   reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
   fmt.Println(slice1) // [4 5 6]
  

• Vispārējo funkciju definēšana: Valodas, piemēram, TypeScript nodrošināt vispārīgu veidu, jebkura, ko varat izmantot, lai turētu jebkura veida mainīgos. Lai gan Go nav aprīkots ar iebūvētu vispārīgu tipu, varat izmantot refleksiju, lai definētu vispārīgas funkcijas. Piemēram:

   // print the type of any value
   funcprintType(x reflect.Value) {
   fmt.Println("Value type:", x.Type())
   }
  

• Piekļuve struktūras tagiem: Tagi tiek izmantoti, lai Go struct laukiem pievienotu metadatus, un daudzas bibliotēkas tos izmanto, lai noteiktu un manipulētu ar katra lauka darbību. Struktūras tagiem var piekļūt tikai ar atspoguļojumu. Tālāk norādītais koda paraugs to parāda:

   type User struct {
   Name string`json:"name" required:"true"`
   }
   user := User{"John"}
   field, ok := reflect.TypeOf(user).Elem().FieldByName("Name")
   if !ok {
   fmt.Println("Field not found")
   }
   // print all tags, and value of "required"
   fmt.Println(field.Tag, field.Tag.Get("required"))
   // json:"name" required:"true" true
  

• Pārdomas par saskarnēm: Ir iespējams arī pārbaudīt, vai vērtība ievieš saskarni. Tas var būt noderīgi, ja nepieciešams veikt papildu pārbaudes, pamatojoties uz jūsu lietojumprogrammas prasībām un mērķiem. Tālāk redzamais kods parāda, kā atspoguļojums palīdz pārbaudīt saskarnes un noteikt to īpašības.

   var i interface{} = 3.142
   typeOfI := reflect.TypeOf(i)
   stringerInterfaceType := reflect.TypeOf(new(fmt.Stringer))
   // check if i implements the stringer interface
   impl := typeOfI.Implements(stringerInterfaceType.Elem())
   fmt.Println(impl) // false
  

Iepriekš minētie piemēri ir daži veidi, kā izmantot pārdomas savās reālajās Go programmās. The atspoguļot pakotne ir ļoti izturīga, un jūs varat uzzināt vairāk par tās iespējām oficiālajā Ej pārdomāt dokumentācija.

Kad izmantot pārdomas un ieteicamās darbības

Var būt vairāki scenāriji, kuros refleksija var šķist ideāla, taču ir svarīgi ņemt vērā, ka refleksijai ir savi kompromisi un tā var negatīvi ietekmēt programmu, ja to neizmanto atbilstoši.

Šeit ir dažas lietas, kas jāņem vērā saistībā ar refleksiju:

• Atspoguļošanu vajadzētu izmantot tikai tad, ja nevarat iepriekš noteikt objekta veidu savā programmā.
• Atspoguļošana var samazināt jūsu lietojumprogrammas veiktspēju, tāpēc jums nevajadzētu to izmantot darbībām, kas ir svarīgas veiktspējai.
• Atspoguļošana var ietekmēt arī jūsu koda lasāmību, tāpēc nevēlaties to izmest visur.
• Ņemot vērā pārdomas, kļūdas netiek fiksētas kompilēšanas laikā, tāpēc jūs, iespējams, pakļaujat savu lietojumprogrammu vairākām izpildlaika kļūdām.

Izmantojiet Reflection, kad nepieciešams

Reflection ir pieejams daudzās valodās, tostarp C# un JavaScript, un Go lieliski ievieš API. Galvenā Go pārdomu priekšrocība ir tā, ka varat atrisināt problēmas ar mazāku kodu, izmantojot bibliotēkas iespējas.

Tomēr tipa drošība ir ļoti svarīga, lai nodrošinātu uzticamu kodu, un ātrums ir vēl viens svarīgs faktors vienmērīgai lietotāja pieredzei. Šī iemesla dēļ jums vajadzētu izmantot pārdomas tikai pēc savu iespēju izvērtēšanas. Un tiecieties, lai jūsu kods būtu lasāms un optimāls.