ในบทความนี้ เราจะสำรวจวิธีการกำหนด ค่าเริ่มต้น สำหรับฟิลด์ struct ใน Golang
ฟิลด์โครงสร้างคืออะไร?
ประการแรก จำเป็นต้องเข้าใจแนวคิดของ เขตข้อมูลโครงสร้าง . เดอะ เขตข้อมูลโครงสร้าง เป็นตัวแปรที่จัดกลุ่มในรูปแบบ a โครงสร้าง วัตถุ. แต่ละ ฟิลด์โครงสร้าง มีชื่อและประเภทข้อมูล ตัวอย่างเช่น โครงสร้างที่แสดงถึงบุคคลอาจมีฟิลด์ เช่น ชื่อ อายุ และเพศ
จะกำหนดค่าเริ่มต้นสำหรับฟิลด์โครงสร้างใน Golang ได้อย่างไร
ค่าเริ่มต้น สามารถกำหนดให้ฟิลด์ struct ใน Go ได้โดยใช้:
- ค่าศูนย์เริ่มต้น
- คอนสตรัคเตอร์
- ตัวอักษรโครงสร้าง
- ค่าฟิลด์เริ่มต้น
1: ค่าศูนย์เริ่มต้น
ใน Go การกำหนดค่าเริ่มต้นให้กับฟิลด์ struct สามารถทำได้ด้วย ' ค่าศูนย์ ' คุณสมบัติ. คุณลักษณะนี้จะกำหนดค่าเริ่มต้นโดยอัตโนมัติเป็น “ 0 ' หรือ ' เท็จ ” ไปยังทุกฟิลด์ที่ไม่ได้กำหนดค่าเริ่มต้น ขึ้นอยู่กับชนิดข้อมูล ซึ่งหมายความว่าคุณไม่จำเป็นต้องตั้งค่าเริ่มต้นอย่างชัดเจนสำหรับแต่ละฟิลด์ในโครงสร้าง เนื่องจาก Go จะทำเพื่อคุณ
คุณลักษณะนี้มีประโยชน์เมื่อต้องจัดการกับโครงสร้างขนาดใหญ่ที่มีฟิลด์จำนวนมาก เนื่องจากช่วยประหยัดเวลาและความพยายามในการตั้งค่าเริ่มต้นสำหรับแต่ละฟิลด์ด้วยตนเอง
นี่คือตัวอย่างที่ใช้ค่าศูนย์เพื่อกำหนดค่าเริ่มต้นสำหรับฟิลด์ struct:
แพคเกจหลักนำเข้า 'เอฟเอ็มที'
พิมพ์ โครงสร้างบุคคล {
ชื่อ สตริง
อายุ int
ความสูงลอย64
IsMale บูล
}
ฟังก์ชั่นหลัก ( ) {
p1 := บุคคล { ชื่อ: 'จอห์น' , อายุ: 30 }
fmt.Println ( p1.ชื่อ )
fmt.Println ( p1.อายุ )
fmt.Println ( p1.ความสูง )
fmt.Println ( p1.IsMale )
}
รหัสด้านบนกำหนดบุคคล โครงสร้าง ด้วยฟิลด์สี่ฟิลด์: ชื่อ อายุ ส่วนสูง และ IsMale ซึ่งทั้งหมดเป็นประเภทข้อมูลบูล จากนั้น เราสร้างอินสแตนซ์ใหม่ของคลาส Person, p1 และเริ่มต้นฟิลด์บางฟิลด์โดยใช้ตัวอักษร struct เพื่อระบุชื่อและค่าของฟิลด์ เดอะ ค่าศูนย์เริ่มต้น สำหรับฟิลด์ที่ไม่ได้ตั้งค่าอย่างชัดเจนระหว่างการเริ่มต้นจะแสดงขึ้นเมื่อคุณพิมพ์ค่าของฟิลด์โดยใช้ fmt.Println .
เอาต์พุต
2: ตัวสร้าง
โดยเขียนก ตัวสร้าง ฟังก์ชันสำหรับ struct คุณยังสามารถให้ค่าเริ่มต้นแก่ฟิลด์ struct ใน Golang เดอะ ตัวสร้าง ฟังก์ชันสร้างอินสแตนซ์ใหม่ของโครงสร้างและตั้งค่าเริ่มต้นสำหรับฟิลด์ของมัน วิธีนี้ช่วยประหยัดแรงและเวลา โดยเฉพาะอย่างยิ่งเมื่อมีปฏิสัมพันธ์กับโครงสร้างขนาดใหญ่ที่มีฟิลด์จำนวนมาก
นี่คือตัวอย่างวิธีกำหนด a ตัวสร้าง ฟังก์ชันที่มีค่าฟิลด์เริ่มต้นสำหรับโครงสร้าง:
แพคเกจหลักนำเข้า 'เอฟเอ็มที'
พิมพ์ โครงสร้างบุคคล {
ชื่อ สตริง
อายุ int
สตริงที่อยู่
}
ฟังก์ชั่น NewPerson ( ) * บุคคล {
กลับ & บุคคล {
ชื่อ: “จอห์น โด” ,
อายุ: 30 ,
ที่อยู่: '123 ถนนหลัก' ,
}
}
ฟังก์ชั่นหลัก ( ) {
p := คนใหม่ ( )
fmt.Println ( น. ชื่อ, น. อายุ, น. ที่อยู่ )
}
ในโค้ดข้างต้น ก บุคคล struct ถูกกำหนด เช่นเดียวกับการ ใหม่บุคคล () ฟังก์ชันซึ่งสร้างอินสแตนซ์ใหม่ของ บุคคล โครงสร้างที่มีค่าเริ่มต้นที่กำหนดไว้ล่วงหน้า เราโทร ใหม่บุคคล () ใน หลัก() เพื่อสร้างอินสแตนซ์บุคคลใหม่ด้วย ค่าฟิลด์เริ่มต้น แล้วเราจะพิมพ์ค่าของฟิลด์ของอินสแตนซ์นั้นออกมา
เอาต์พุต
3: โครงสร้างตัวอักษร
ใน Golang คุณสามารถตั้งค่าเริ่มต้นสำหรับฟิลด์ struct โดยใช้ โครงสร้างตัวอักษร เช่นกัน. เพียงสร้างอินสแตนซ์ใหม่ของโครงสร้างและตั้งค่าสำหรับแต่ละฟิลด์ที่จำเป็นต้องเริ่มต้น ถ้าคุณต้องการตั้งค่าเริ่มต้นสำหรับฟิลด์ที่คุณไม่ได้กำหนดค่าเริ่มต้นอย่างชัดเจน คุณสามารถใช้คุณลักษณะค่าศูนย์ได้
นี่คือตัวอย่างวิธีการใช้งาน โครงสร้างตัวอักษร ในการตั้งค่าฟิลด์เริ่มต้นสำหรับโครงสร้าง:
แพคเกจหลักนำเข้า 'เอฟเอ็มที'
พิมพ์ โครงสร้างบุคคล {
ชื่อ สตริง
อายุ int
สตริงที่อยู่
}
ฟังก์ชั่นหลัก ( ) {
p := บุคคล {
ชื่อ: “จอห์น โด” ,
อายุ: 30 ,
}
fmt.Println ( น. ชื่อ, น. อายุ, น. ที่อยู่ )
}
ในโค้ดด้านบน เรากำหนด a บุคคล struct ในตัวอย่างนี้และสร้างอินสแตนซ์ใหม่โดยใช้ค่าลิเทอรัลของ struct และค่าดีฟอลต์สำหรับฟิลด์ ใหม่ บุคคล อินสแตนซ์ถูกสร้างขึ้นใน main() โดยมีค่าฟิลด์บางค่าถูกเติมและค่าอื่นๆ เว้นว่างไว้ ตั้งแต่ ที่อยู่ ฟิลด์นี้ไม่ได้เริ่มต้น แต่จะได้รับสตริงว่างที่เป็นค่าเริ่มต้นสำหรับฟิลด์นี้ สุดท้าย เราจะพิมพ์ค่าฟิลด์ของอินสแตนซ์บุคคล
เอาต์พุต
4: ค่าฟิลด์เริ่มต้น
มอบหมาย ค่าเริ่มต้น ถึง เขตข้อมูลโครงสร้าง ใน Go เป็นกระบวนการที่ไม่ซับซ้อน เดอะ ค่าเริ่มต้น สำหรับฟิลด์ struct สามารถตั้งค่าได้โดยใช้ไวยากรณ์ fieldName:defaultValue . ตัวอย่างเช่น พิจารณาคำนิยามโครงสร้างต่อไปนี้:
พิมพ์ โครงสร้างบุคคล {สตริงชื่อ
ช่วงอายุ
สตริงเพศ
}
มอบหมาย ค่าเริ่มต้น สำหรับฟิลด์ของโครงสร้างนี้ เราสามารถใช้ไวยากรณ์ต่อไปนี้:
p := บุคคล {ชื่อ: “จอห์น โด” ,
อายุ: 30 ,
เพศ: 'ชาย' ,
}
ในตัวอย่างข้างต้นเราได้กำหนดให้ ค่าเริ่มต้น ไปยังฟิลด์ของโครงสร้างบุคคล หากเราละเว้นค่าใด ๆ ระหว่างการเริ่มต้น ค่าเริ่มต้น จะใช้แทน ตัวอย่างเช่น ถ้าเราเริ่มต้นบุคคลวัตถุเช่นนี้:
p := บุคคล {ชื่อ: “เจน โด” ,
}
วัตถุบุคคลที่เกิดขึ้นจะมี ค่าเริ่มต้น สำหรับฟิลด์อายุและเพศ ซึ่งเป็น 0 และสตริงว่าง ตามลำดับ
นี่คือรหัสที่สมบูรณ์ที่แสดงกระบวนการข้างต้น:
แพคเกจหลักนำเข้า 'เอฟเอ็มที'
พิมพ์ โครงสร้างบุคคล {
ชื่อ สตริง
อายุ int
สตริงเพศ
}
ฟังก์ชั่นหลัก ( ) {
p1 := บุคคล {
ชื่อ: “จอห์น โด” ,
อายุ: 30 ,
เพศ: 'ชาย' ,
}
fmt.Println ( หน้า 1 )
p2 := บุคคล {
ชื่อ: 'เจเรมี' ,
}
fmt.Println ( พี 2 )
}
ในตัวอย่างข้างต้น เราสร้างโครงสร้างบุคคลที่มีสามฟิลด์: ชื่อ int แทนอายุ และเพศ สตริงแทนเพศ จากนั้น ไวยากรณ์การกำหนดค่าเริ่มต้นของ struct จะใช้เพื่อสร้างอินสแตนซ์บุคคลสองรายการ ได้แก่ p1 และ p2 p1 เริ่มต้นด้วยค่า 'John Doe' สำหรับชื่อ '30' สำหรับอายุ และ 'ชาย' สำหรับเพศ ซึ่งเป็นค่าทั้งหมดที่มีการระบุอย่างชัดแจ้ง เนื่องจากเราไม่ได้ให้ค่าสำหรับอายุและเพศ ระบบจะกำหนดค่าเริ่มต้นเป็น 0 และสตริงว่างตามลำดับ p2 เริ่มต้นด้วยฟิลด์ชื่อเท่านั้น
เอาต์พุต
บทสรุป
มอบหมาย ค่าเริ่มต้น ใน Go เป็นส่วนสำคัญของการเขียนโปรแกรมด้วยภาษานี้ ช่วยให้มั่นใจได้ว่าทุกอินสแตนซ์ struct ที่สร้างขึ้นมีข้อมูลเริ่มต้นที่กำหนดให้กับมัน ด้วยการใช้วิธีการใด ๆ ที่อธิบายไว้ข้างต้น นักพัฒนาสามารถตั้งค่า ค่าเริ่มต้น ของเขตข้อมูล struct ได้อย่างมีประสิทธิภาพ