การสะท้อนกลับใน Golang ช่วยให้โปรแกรมตรวจสอบและแก้ไขโครงสร้างข้อมูล ประเภท และค่าในขณะรันไทม์ มีชุดของฟังก์ชันที่ช่วยให้เราตรวจสอบประเภทและค่าของตัวแปรใดๆ ขณะรันไทม์ สร้างอินสแตนซ์ใหม่ของประเภท และแก้ไขค่าของตัวแปรที่มีอยู่ บทความนี้ครอบคลุมฟังก์ชันต่างๆ ของ Golang ในแพ็คเกจการสะท้อน
สารบัญ
- สะท้อนแพ็คเกจใน Go
- สะท้อน คัดลอก () ฟังก์ชัน
- ฟังก์ชัน reflect.DeepEqual()
- ฟังก์ชัน reflect.Swapper()
- ฟังก์ชัน reflect.TypeOf()
- สะท้อน.ValueOf() ฟังก์ชัน
- บทสรุป
Go เป็นภาษาที่พิมพ์แบบสแตติก ดังนั้นต้องทราบประเภทของตัวแปรในขณะคอมไพล์ อย่างไรก็ตาม ในบางสถานการณ์ อาจจำเป็นต้องจัดการกับค่าที่ไม่สามารถกำหนดประเภทได้จนกว่าโปรแกรมจะทำงาน
ตัวอย่างเช่น เราอาจต้องเขียนฟังก์ชันที่สามารถทำงานกับอาร์กิวเมนต์ประเภทต่างๆ ได้ หรือเราอาจต้องทำให้เป็นอนุกรมและแยกซีเรียลไลซ์ข้อมูลประเภทที่ไม่รู้จัก นี่คือที่ที่ใช้แพ็คเกจสะท้อนใน Golang
สะท้อนแพ็คเกจใน Go
แพ็คเกจสะท้อนมีชุดของฟังก์ชันที่ช่วยให้เราตรวจสอบและจัดการค่าที่รันไทม์ได้ โดยไม่คำนึงถึงประเภท ด้วยฟังก์ชันเหล่านี้ เราสามารถรับข้อมูลเกี่ยวกับประเภทและค่าของตัวแปรใดๆ สร้างอินสแตนซ์ประเภทใหม่ และแก้ไขค่าของตัวแปรที่มีอยู่
แพ็คเกจสะท้อนแสงใน Golang มีสองประเภท: ประเภทและมูลค่า ประเภทแสดงถึงประเภท Go เช่น int, string หรือโครงสร้างที่กำหนดเอง ค่าแสดงถึงค่าของประเภทเฉพาะ เช่น 42 หรือ “สวัสดี”
แพ็คเกจสะท้อนยังมีชุดของฟังก์ชันที่ช่วยให้เราได้วัตถุประเภทและค่าจากตัวแปร ตัวอย่างเช่น ฟังก์ชัน reflect.TypeOf() ส่งคืนวัตถุ Type ที่แสดงประเภทของตัวแปร ในขณะที่ฟังก์ชัน
ในส่วนต่อไปนี้ เราจะสำรวจฟังก์ชันที่ใช้กันทั่วไปในแพ็คเกจการสะท้อน
สะท้อน คัดลอก () ฟังก์ชัน
ฟังก์ชัน reflect.Copy() ของแพ็คเกจ reflect ใช้เพื่อคัดลอกค่าของชิ้นหนึ่งไปยังอีกชิ้นหนึ่ง ใช้สองพารามิเตอร์ dst และ src ซึ่งทั้งสองค่าต้องเป็นค่าสไลซ์ที่มีองค์ประกอบประเภทเดียวกัน ฟังก์ชันคัดลอกค่าจากชิ้น src ไปยังชิ้น dst และส่งคืนจำนวนองค์ประกอบที่ถูกคัดลอก
ฟังก์ชัน reflect.Copy() แสดงให้เห็นในตัวอย่างต่อไปนี้:
บรรจุุภัณฑ์ หลักนำเข้า (
'เอฟเอ็มที'
'สะท้อน'
)
ฟังก์ชั่น หลัก () {
src := [] นานาชาติ { 1 , 2 , 3 , 4 , 5 }
วันที่ := ทำ ([] นานาชาติ , เท่านั้น ( src ))
น := สะท้อน . สำเนา ( สะท้อน . มูลค่าของ ( วันที่ ), สะท้อน . มูลค่าของ ( src ))
เอฟเอ็มที . พิมพ์ ( น ) // เอาต์พุต: 5
เอฟเอ็มที . พิมพ์ ( วันที่ ) // เอาต์พุต: [1 2 3 4 5]
}
ในตัวอย่างนี้ เราสร้าง src ชิ้นต้นทางด้วยค่าจำนวนเต็ม และชิ้นปลายทาง dst ที่มีความยาวเท่ากับ src จากนั้นเราเรียก reflect.Copy() เพื่อคัดลอกค่าจาก src ไปยัง dst และพิมพ์จำนวนองค์ประกอบที่ถูกคัดลอก (n) และเนื้อหาของชิ้น dst
ฟังก์ชัน reflect.DeepEqual()
ฟังก์ชัน reflect.DeepEqual() ของแพ็คเกจการสะท้อนใช้เพื่อเปรียบเทียบค่าสองค่าเพื่อความเท่าเทียมกัน ฟังก์ชันนี้มีพารามิเตอร์อินพุตสองตัวคือ a และ b ซึ่งทั้งสองค่าสามารถเป็นค่าประเภทใดก็ได้ ฟังก์ชันจะส่งกลับค่าจริงหาก a และ b เท่ากันอย่างลึก หมายความว่าค่าพื้นฐานจะเท่ากันแบบวนซ้ำ มิฉะนั้นจะกลายเป็นเท็จ
ตัวอย่างต่อไปนี้แสดงวิธีใช้ reflect.DeepEqual():
บรรจุุภัณฑ์ หลักนำเข้า (
'เอฟเอ็มที'
'สะท้อน'
)
ฟังก์ชั่น หลัก () {
ก := [] นานาชาติ { 1 , 2 , 3 }
ข := [] นานาชาติ { 1 , 2 , 3 }
ถ้า สะท้อน . DeepEqual ( ก , ข ) {
เอฟเอ็มที . พิมพ์ ( 'a และ b เท่ากัน' )
} อื่น {
เอฟเอ็มที . พิมพ์ ( 'a และ b ไม่เท่ากัน' )
}
}
ในตัวอย่างนี้ เราสร้างสองส่วน a และ b ที่มีค่าจำนวนเต็มเท่ากัน จากนั้นเราเรียก reflect.DeepEqual() เพื่อเปรียบเทียบความเท่าเทียมกันของ a และ b แล้วพิมพ์ผลลัพธ์ออกมา
ฟังก์ชัน reflect.Swapper()
ฟังก์ชัน reflect.Swapper() ของแพ็คเกจ reflect ใช้เพื่อส่งคืนฟังก์ชันที่สามารถสลับองค์ประกอบของชิ้น ใช้พารามิเตอร์เดียว v ซึ่งต้องเป็นค่าสไลซ์ ฟังก์ชันส่งคืนฟังก์ชันที่รับพารามิเตอร์จำนวนเต็มสองตัว คือ i และ j และสลับองค์ประกอบของชิ้นที่ตำแหน่ง i และ j
การใช้งาน reflect.Swapper() สามารถแสดงให้เห็นได้จากตัวอย่างต่อไปนี้:
บรรจุุภัณฑ์ หลักนำเข้า (
'เอฟเอ็มที'
'สะท้อน'
)
ฟังก์ชั่น หลัก () {
ส := [] นานาชาติ { 1 , 2 , 3 , 4 , 5 }
แลกเปลี่ยน := สะท้อน . สลับ ( ส )
แลกเปลี่ยน ( 1 , 3 )
เอฟเอ็มที . พิมพ์ ( ส ) // เอาต์พุต: [1 4 3 2 5]
}
ในตัวอย่างนี้ เราสร้างสไลซ์ชื่อ s ด้วยค่าจำนวนเต็ม จากนั้นเราเรียก reflect.Swapper() เพื่อรับฟังก์ชัน swap ที่สามารถสลับองค์ประกอบของชิ้นได้ เราใช้ swap เพื่อสลับองค์ประกอบที่ตำแหน่ง 1 และ 3 ของส่วน s และพิมพ์ผลลัพธ์
ฟังก์ชัน reflect.TypeOf()
การสะท้อน TypeOf() ใช้เพื่อรับประเภทของค่า ฟังก์ชันนี้ยอมรับพารามิเตอร์ 'v' ตัวเดียวที่สามารถเป็นประเภทหรือค่าใดก็ได้ ฟังก์ชันส่งคืนค่า reflect.Type ที่แสดงถึงประเภทของค่า
การใช้ reflect.TypeOf() สามารถแสดงให้เห็นได้จากตัวอย่างต่อไปนี้:
บรรจุุภัณฑ์ หลักนำเข้า (
'เอฟเอ็มที'
'สะท้อน'
)
ฟังก์ชั่น หลัก () {
เคยเป็น x float64 = 3 . 14
ที := สะท้อน . ประเภทของ ( x )
เอฟเอ็มที . พิมพ์ ( ที ) // เอาต์พุต: float64
}
ในตัวอย่างนี้ เราสร้างตัวแปร float64 x ด้วยค่า 3.14 จากนั้นเราเรียก reflect.TypeOf() เพื่อรับประเภทของ x และเก็บผลลัพธ์ไว้ในตัวแปร reflect.Type t เราพิมพ์ค่าของ t ซึ่งก็คือ float64
สะท้อน.ValueOf() ฟังก์ชัน
reflect.ValueOf() สามารถรับ reflect.Value แทนค่าของค่าได้ ใช้พารามิเตอร์ v ตัวเดียว ซึ่งสามารถเป็นค่าประเภทใดก็ได้ ฟังก์ชันส่งคืนค่าสะท้อนกลับค่าที่แสดงถึงค่าของพารามิเตอร์อินพุต
การใช้ reflect.ValueOf() สามารถแสดงให้เห็นได้จากตัวอย่างต่อไปนี้:
บรรจุุภัณฑ์ หลักนำเข้า (
'เอฟเอ็มที'
'สะท้อน'
)
ฟังก์ชั่น หลัก () {
เคยเป็น x float64 = 3 . 14
ใน := สะท้อน . มูลค่าของ ( x )
เอฟเอ็มที . พิมพ์ ( ใน ) // เอาต์พุต: 3.14
}
ในตัวอย่างนี้ เราสร้างตัวแปร float64 x ด้วยค่า 3.14 จากนั้นเราเรียก reflect.ValueOf() เพื่อรับการแทนค่าการสะท้อนของ x และเก็บผลลัพธ์ไว้ในตัวแปรค่าสะท้อน v เราพิมพ์ค่าของ v ซึ่งก็คือ 3.14
แพ็คเกจสะท้อนแสงมีฟังก์ชันมากมายนอกเหนือจากที่กล่าวมา และนี่เป็นเพียงตัวอย่างบางส่วนเท่านั้น ด้วยการใช้ฟังก์ชันที่จัดเตรียมโดยแพ็คเกจการสะท้อน เราสามารถสร้างโค้ดที่สามารถทำงานกับค่าประเภทใดก็ได้ โดยไม่จำเป็นต้องทราบประเภทในขณะคอมไพล์
บทสรุป
การสะท้อนกลับใน Golang ช่วยให้โปรแกรมตรวจสอบและแก้ไขโครงสร้างข้อมูล ประเภท และค่าในขณะรันไทม์ ดำเนินการผ่านแพ็คเกจการสะท้อน ซึ่งมีฟังก์ชันในการตรวจสอบและจัดการประเภทและค่าต่างๆ การสะท้อนกลับมีประโยชน์อย่างยิ่งเมื่อทำงานกับอินเทอร์เฟซ ประเภทที่ไม่รู้จัก หรือเมื่อคุณต้องการใช้ฟังก์ชันทั่วไป บทความนี้กล่าวถึงพื้นฐานของการสะท้อนใน Golang รวมถึงแพ็คเกจการสะท้อน ประเภทและค่าสะท้อน และประเภทและค่าไดนามิก