ตัวอย่างการหล่อ Golang

Tawxyang Kar Hlx Golang



กระบวนการเปลี่ยนประเภทข้อมูลของค่าจากประเภทหนึ่งไปเป็นอีกประเภทหนึ่งเรียกว่าการคัดแยกประเภท บางครั้งเรียกว่าการแปลงประเภท การหล่อประเภททำได้ใน Go โดยใช้การแปลงประเภทที่ชัดเจน Go รองรับการพิมพ์ที่แข็งแกร่ง ดังนั้น เมื่อแปลงระหว่างประเภท เราต้องระบุวัตถุประสงค์ของเราอย่างชัดเจน สิ่งนี้ส่งเสริมความปลอดภัยของประเภทและลดความน่าจะเป็นของข้อผิดพลาดในการพิมพ์ ในบทความนี้ เราจะสำรวจเกี่ยวกับการแคสต์ประเภทต่างๆ ใน ​​Go

ตัวอย่างที่ 1: Golang Basic Type Casting

เรามาเริ่มกันที่ตัวอย่างการแคสต์โดยตรงและพื้นฐานใน Go เนื่องจากเราต้องการการแคสต์แบบพิมพ์เพื่อแก้ไขประเภทของตัวแปรได้ทุกที่

บรรจุุภัณฑ์ หลัก
นำเข้า (
'เอฟเอ็มที'
)
ฟังก์ชั่น หลัก () {
เคยเป็น x นานาชาติ = 31
และ := float64 ( x )
เอฟเอ็มที . พิมพ์ ( และ )
}

ในที่นี้ เราจะเริ่มด้วยฟังก์ชันหลักโดยการประกาศตัวแปรชื่อ “x” ประเภท “int” และกำหนดด้วยค่า 31 จากนั้นจึงประกาศตัวแปร “y” โดยใช้โอเปอเรเตอร์กำหนดชวเลข “:=” ประเภทของ 'y' ถูกกำหนดโดยอัตโนมัติจากนิพจน์ทางด้านขวา ซึ่งเป็นผลลัพธ์ของการแปลง 'x' เป็น 'float64' ดังนั้น ในโปรแกรมนี้ ค่าของ 'x' จะถูกแปลงเป็น 'float64' และกำหนดให้เป็น 'y'







ผลลัพธ์ที่ได้รับจากการแคสต์พื้นฐานใน Go จะแสดงดังต่อไปนี้:





ตัวอย่างที่ 2: Golang Implicit Type Casting

ไม่อนุญาตให้ส่งประเภทโดยนัยระหว่างประเภทต่างๆ Go บังคับใช้การพิมพ์ที่รัดกุม ซึ่งหมายความว่าเราไม่สามารถกำหนดหรือใช้ค่าของประเภทหนึ่งเป็นประเภทอื่นได้โดยตรงโดยไม่มีการแปลงอย่างชัดเจน ต่อไปนี้ เราพยายามดำเนินการส่งโดยปริยายซึ่งสร้างข้อยกเว้นโดย Go:





บรรจุุภัณฑ์ หลัก
นำเข้า 'เอฟเอ็มที'
ฟังก์ชั่น หลัก () {
เคยเป็น จำนวนเต็ม นานาชาติ = 9 . 08
เอฟเอ็มที . พิมพ์ฉ ( 'จำนวนเต็มคือ %g' , จำนวนเต็ม )
}

นี่คือโค้ดที่ขึ้นต้นด้วยฟังก์ชัน main() ซึ่งมีการประกาศตัวแปร 'จำนวนเต็ม' ด้วยประเภท 'int' ค่าที่กำหนดให้กับตัวแปร “จำนวนเต็ม” คือ 9.08 ซึ่งเป็นเลขทศนิยม เนื่องจากเราพยายามกำหนดค่าทศนิยมโดยตรงให้กับตัวแปรจำนวนเต็ม จึงส่งผลให้เกิดข้อผิดพลาดประเภทไม่ตรงกัน จากนั้น เราใช้ฟังก์ชัน “printf” จากแพ็คเกจ “fmt” เพื่อพิมพ์ค่าของตัวแปร “จำนวนเต็ม” โดยใช้ตัวระบุรูปแบบ “%g”

ตามที่คาดไว้ Golang ไม่ยอมรับการร่ายประเภทโดยนัย การส่งประเภทโดยนัยก่อนหน้านี้ทำให้เกิดข้อผิดพลาดต่อไปนี้:



ตัวอย่างที่ 3: Golang Explicit Type Casting

การแปลงประเภทที่ชัดเจนช่วยให้เราสามารถแปลงค่าระหว่างประเภทที่เข้ากันได้อย่างปลอดภัยในขณะที่ระบุเจตนาอย่างชัดเจน ช่วยให้มั่นใจได้ว่าเราทราบการแปลงประเภทและช่วยป้องกันข้อผิดพลาดของประเภทโดยไม่ตั้งใจ พิจารณาการร่ายอย่างชัดเจนต่อไปนี้:

บรรจุุภัณฑ์ หลัก
นำเข้า 'เอฟเอ็มที'

ฟังก์ชั่น หลัก () {
เคยเป็น floatVal ลอย32 = 6 . 75
เคยเป็น intVal นานาชาติ = นานาชาติ ( floatVal )
เอฟเอ็มที . พิมพ์ฉ ( 'ค่าลอยตัวคือ %g \n ' , floatVal )
เอฟเอ็มที . พิมพ์ฉ ( 'ค่าจำนวนเต็มคือ %d' , intVal )
}

ที่นี่ ตัวแปร “floatVal” ถูกสร้างขึ้นด้วยประเภท “float32” และถูกกำหนดให้เป็นค่า “6.75” จากนั้นจึงประกาศตัวแปร “intVal” ด้วยประเภท “int” ในการกำหนดค่าของ floatVal ให้กับ intVal จะใช้การแปลงประเภท ในการแปลง floatVal เป็นค่าจำนวนเต็ม ฟังก์ชัน 'int' จะถูกใช้โดยมี floatVal เป็นอินพุต หลังจากนั้น “fmt.Printf(“Float Value is %g\n”, floatVal)” พิมพ์ค่าของ floatVal โดยใช้ตัวระบุรูปแบบ %g ซึ่งเหมาะสำหรับการพิมพ์ค่าทศนิยม ในขณะที่บรรทัดโค้ด “fmt.Printf(“ค่าจำนวนเต็มคือ %d”, intVal)” จะพิมพ์ค่าของ intVal โดยใช้ตัวระบุรูปแบบ %d ซึ่งเหมาะสำหรับการพิมพ์ค่าจำนวนเต็ม

ผลลัพธ์ต่อไปนี้สร้างค่าสำหรับทั้ง floatVal และ intVal หลังจากส่ง:

ตัวอย่างที่ 4: การหล่อแบบ Golang เพื่อรับค่าเฉลี่ย

ต่อไป เราทำการคัดเลือกเพื่อให้ได้จำนวนเฉลี่ยจากค่าที่กำหนด มาดูซอร์สโค้ดที่ให้ไว้ดังต่อไปนี้:

บรรจุุภัณฑ์ หลัก
นำเข้า 'เอฟเอ็มที'
ฟังก์ชั่น หลัก () {
เคยเป็น ทั้งหมด นานาชาติ = 900
เคยเป็น มายนัมเบอร์ นานาชาติ = ยี่สิบ
เคยเป็น เฉลี่ย ลอย32
เฉลี่ย = ลอย32 ( ทั้งหมด ) / ลอย32 ( มายนัมเบอร์ )
เอฟเอ็มที . พิมพ์ฉ ( 'ค่าเฉลี่ย = %f \n ' , เฉลี่ย )
}

ในขั้นแรก เราประกาศตัวแปรสามตัว “ผลรวม” เป็นตัวแปรจำนวนเต็มซึ่งกำหนดค่าเริ่มต้นเป็น 900 ส่วน “MyNumber” เป็นตัวแปรจำนวนเต็มซึ่งกำหนดค่าเริ่มต้นเป็น 20 จากนั้นค่าเฉลี่ยที่คำนวณได้จะถูกจัดเก็บไว้ในตัวแปร “ค่าเฉลี่ย” float32 จากนั้นจะมีการกำหนดสูตรค่าเฉลี่ยเพื่อทำการคำนวณ เพื่อให้แน่ใจว่าการหารเสร็จสิ้นเป็นการหารทศนิยม ค่าของ 'total' และ 'MyNumber' จะถูกแปลงเป็น float32 โดยใช้การแปลงประเภท ค่าเฉลี่ยที่คำนวณได้ถูกกำหนดให้กับตัวแปร 'ค่าเฉลี่ย' สุดท้าย สตริงรูปแบบ “%f\n” ที่ใช้ในฟังก์ชัน “printf” ระบุว่าควรพิมพ์ค่าทศนิยม แล้วตามด้วยอักขระขึ้นบรรทัดใหม่

ค่าผลลัพธ์ที่เป็นค่าเฉลี่ยจะถูกดึงมาหลังจากระบุประเภทการหล่อในรหัสก่อนหน้า:

ตัวอย่างที่ 5: Golang Int และ String Type Casting

นอกจากนี้ Go ยังมีการส่งระหว่างประเภท Int และ String เราสามารถทำได้โดยใช้ฟังก์ชันของแพ็คเกจ strconv

บรรจุุภัณฑ์ หลัก
นำเข้า (
'เอฟเอ็มที'
'สตริคอน'
)
ฟังก์ชั่น หลัก () {
เคยเป็น สตริง สตริง = '1999'
ใน , _ := สตริคอน . รถพ่วง ( )
เอฟเอ็มที . พิมพ์ ( ใน )
เคยเป็น จำนวนเต็ม นานาชาติ = 2542
ถึงStr := สตริคอน . จมน้ำ ( จำนวนเต็ม )

เอฟเอ็มที . พิมพ์ ( ถึงStr )
}

นี่คือโค้ดที่ขึ้นต้นด้วยการประกาศตัวแปรสองตัว “str” เป็นตัวแปรสตริงที่กำหนดค่าเริ่มต้นเป็น “1999” และ “จำนวนเต็ม” เป็นตัวแปรจำนวนเต็มซึ่งกำหนดค่าเริ่มต้นเป็น “1999” หลังจากนั้น ฟังก์ชัน “strconv.Atoi()” จะใช้ในการแปลงสตริง “str” เป็นค่าจำนวนเต็ม ค่าที่ส่งคืนของ 'v' แสดงถึงจำนวนเต็มที่ถูกแปลงแล้ว และตัวระบุ '_' ที่ว่างเปล่าจะถูกใช้เพื่อละเว้นข้อผิดพลาดที่อาจเกิดขึ้นซึ่งส่งคืนโดย Atoi()

ถัดไป ใช้ฟังก์ชัน strconv.Itoa() เพื่อแปลงจำนวนเต็มเป็นค่าสตริง ค่าที่ส่งคืนซึ่งเป็น 'toStr' แสดงถึงสตริงที่แปลงแล้ว

ผลลัพธ์แสดงการแปลงจากสตริง '1999' เป็นจำนวนเต็มและกลับเป็นสตริงที่สร้างค่าดั้งเดิมของ '1999':

ตัวอย่างที่ 6: การส่งประเภท Golang ระหว่างสตริงและไบต์

ยิ่งไปกว่านั้น การแคสต์ใน Go สามารถทำได้ทั้งแบบสตริงและแบบไบต์ รหัสต่อไปนี้แสดงให้เห็นถึงการแปลงระหว่างสตริงและชิ้นส่วนไบต์:

บรรจุุภัณฑ์ หลัก
นำเข้า (
'เอฟเอ็มที'
)
ฟังก์ชั่น หลัก () {
เคยเป็น ลึกลับ สตริง = 'สวัสดี'
เคยเป็น ข1 [] ไบต์ = [] ไบต์ ( myStr )
เอฟเอ็มที . พิมพ์ ( ข1 )
toString := สตริง ( ข1 )
เอฟเอ็มที . พิมพ์ ( toString )
}

ในขั้นแรก ตัวแปรจะถูกประกาศเป็น “myStr” และ “b1” ซึ่งจะเริ่มต้นด้วยค่าบางอย่าง จากนั้น นิพจน์ []byte(myStr) จะแปลงสตริง “myStr” เป็นชิ้นไบต์โดยใช้การแปลงประเภท กำหนดชิ้นไบต์ที่เป็นผลลัพธ์ให้กับตัวแปร 'b1' หลังจากนั้น นิพจน์ “string(b1)” จะแปลง byte ชิ้น b1 กลับเป็นสตริงโดยใช้การแปลงประเภท กำหนดสตริงผลลัพธ์ให้กับตัวแปร 'toString'

เอาต์พุตแสดงการแปลงระหว่างสตริง 'Hey There' และการแสดงชิ้นส่วนไบต์ที่สอดคล้องกันดังต่อไปนี้:

ตัวอย่างที่ 7: การหล่อแบบ Golang เพื่อรับค่ารากที่สอง

ตอนนี้เราทำการคัดเลือกใน Go เพื่อค้นหาผลลัพธ์ของสแควร์รูท รหัสถูกวางไว้ดังนี้:

บรรจุุภัณฑ์ หลัก
นำเข้า (
'เอฟเอ็มที'
'คณิตศาสตร์'
)
ฟังก์ชั่น หลัก () {
เคยเป็น นานาชาติ = 177
เคยเป็น ตร.น float64
ตร.น = คณิตศาสตร์ . ตร ( float64 ( ))
เอฟเอ็มที . พิมพ์ฉ ( 'รากที่สองของ %d คือ %.2f \n ' , , ตร.น )
}

ที่นี่ตัวแปร 'n' ถูกประกาศเป็น int และกำหนดค่าเป็น '144' ตัวแปร “SqrtN” ถูกประกาศเป็น float64 และเก็บค่ารากที่สองที่คำนวณได้ของ “n” จากนั้นจึงปรับใช้ฟังก์ชัน math.Sqrt() เพื่อคำนวณรากที่สองของ “n” เนื่องจาก math.Sqrt() ต้องการอาร์กิวเมนต์ float64 และค่าของ “n” จะถูกแปลงเป็น float64 โดยใช้ float64(n) หลังจากนั้น การเรียกสตริงรูปแบบ “Square root of %d is %.2f\n” ในฟังก์ชัน “printf” ซึ่งระบุค่าจำนวนเต็ม (%d) และค่าทศนิยม (%.2f) ตัวระบุความแม่นยำ '.2' ใน '%.2f' ช่วยให้มั่นใจได้ว่ารากที่สองพิมพ์ด้วยทศนิยมสองตำแหน่ง

ดึงข้อมูลเอาต์พุตต่อไปนี้ซึ่งระบุรากที่สองของค่าที่กำหนด:

บทสรุป

การแคสติ้งใน Go นั้นถูกกล่าวถึงด้วยตัวอย่างที่แตกต่างกันซึ่งสามารถดำเนินการได้ทั้งหมด โปรดทราบว่าใน Go การเรียงพิมพ์เป็นแบบชัดเจนซึ่งบังคับใช้การพิมพ์ที่รัดกุมและส่งเสริมความชัดเจนและความน่าเชื่อถือของโค้ด