วิธีการใช้ค่าคงที่ใน Golang

Constant หรือ Const ใน Golangคืออะไร ? นี่คือสิ่งที่คุณจำเป็นต้องทราบเกี่ยวกับการใช้ค่าคงที่ใน Go

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

วิธีประกาศ:ค่าคงที่จะถูกประกาศเหมือนกับตัวแปร แต่ใช้คำสำคัญ const เป็นคำนำหน้าในการประกาศค่าคงที่ด้วยชนิดข้อมูลที่เฉพาะเจาะจง ไม่สามารถประกาศค่าคงที่ได้โดยใช้รูปแบบ “: = ”

ตัวอย่างเช่น:

package main

import "fmt"

const PI = 3.14

func main() 
{
	const GFG = "Quantrimang"
	fmt.Println("Hello", GFG)

	fmt.Println("Happy", PI, "Day")

	const Correct= true
	fmt.Println("Go rules?", Correct)
}

ผลลัพธ์:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

สิ่งที่ควรรู้เกี่ยวกับค่าคงที่ใน Golang

ค่าคงที่ตัวเลขแบบไม่มีชนิดและมีชนิด

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

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

นี่คือรายการค่าคงที่ในภาษา Go:

• ค่าคงที่ (ค่าคงที่จำนวนเต็ม, ค่าคงที่ไดนามิก, ค่าคงที่เชิงซ้อน)
• สายอักขระ
• ค่าคงที่บูลีน

ค่าคงที่ของตัวเลข

ค่าคงที่ตัวเลขคือค่าที่มีความแม่นยำสูง เนื่องจาก Go เป็นภาษาที่มีการระบุชนิดข้อมูลแบบคงที่ จึงไม่อนุญาตให้มีการดำเนินการที่รวมชนิดข้อมูลตัวเลขเข้าด้วยกัน คุณไม่สามารถfloat64เพิ่มintหรือint32แม้แต่int. อย่างไรก็ตาม การเขียน1e6*time.Secondหรือmath.Exp(1)หรือ แม้กระทั่ง1<>ยัง คงถูกต้องอยู่ ใน Go ค่าคงที่นั้นแตกต่างจากตัวแปร ตรงที่มีการทำงานเหมือนตัวเลขทั่วไป

ค่าคงที่ตัวเลขมีสามประเภท:

1. จำนวนเต็ม
2. จุดลอยตัว
3. ซับซ้อน

ค่าคงที่จำนวนเต็ม:

• คำนำหน้าระบุฐาน: 0x หรือ 0X สำหรับเลขฐานสิบหก 0 สำหรับเลขฐานแปด และไม่มีค่าใดๆ สำหรับเลขฐานสิบ
• ตัวเลขจำนวนเต็มสามารถมีคำต่อท้ายที่เป็นการผสมกันของ U (ตัวพิมพ์ใหญ่) และ L (ตัวพิมพ์เล็ก) สำหรับอักขระไม่มีเครื่องหมายและอักขระยาว ตามลำดับ
• มันสามารถเป็นค่าคงที่เลขฐานสิบ ฐานแปด หรือฐานสิบหกได้
• int สามารถเก็บข้อมูลจำนวนเต็ม ได้สูงสุด 64 บิตหรือบางครั้งอาจน้อยกว่านั้น

ต่อไปนี้เป็นตัวอย่างค่าคงที่จำนวนเต็ม:

85 /* thập phân */
0213 /* bát phân */
0x4b /* thập lục phân */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
212 /* Hợp lệ */
215u /* Hợp lệ */
0xFeeL /* Hợp lệ */
078 /* Không hợp lệ: 8 không phải là chữ số bát phân */
032UU /* Không hợp lệ: không thể lặp lại hậu tố */

ค่าคงที่เชิงซ้อน:

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

ตัวอย่างเช่น:

(0.0, 0.0) (-123.456E+30, 987.654E-29)

ค่าคงที่ชนิดไดนามิก:

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

ตัวอย่างเช่น:

3.14159 /* Hợp lệ */
314159E-5L /* Hợp lệ */
510E /* Không hợp lệ: số mũ không đầy đủ */
210f /* Không hợp lệ: không có số thập phân hoặc số mũ */
.e55 /* Không hợp lệ: thiếu số nguyên hoặc phân số */

สายอักขระ

• Go รองรับสตริงตัวอักษรสองประเภท คือ” ”(รูปแบบเครื่องหมายคำพูดคู่) และ‘ ‘(รูปแบบเครื่องหมายคำพูดย้อนกลับ)
• สตริงสามารถต่อกันด้วย ตัวดำเนินการ+และ+=
• สตริงประกอบด้วยอักขระที่คล้ายกับอักขระตัวอักษร เช่น อักขระธรรมดา ลำดับการหลบหนี และอักขระสากล และนี่คือตัวละครที่ไม่มีสไตล์
• ค่าศูนย์ของประเภทสตริงเป็นสตริงว่างซึ่งสามารถแสดงด้วย” ”หรือ”เป็นตัวอักษรได้
• สามารถเปรียบเทียบประเภทสตริงทั้งหมดได้โดยใช้ตัวดำเนินการเช่น==และ!=(เพื่อเปรียบเทียบประเภทที่คล้ายกัน)

รูปแบบประโยค :

kiểu _string struct {
các phần tử *byte // các byte cơ bản
len int // số byte
}

ตัวอย่างเช่น:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

ที่นี่ทั้งสามข้อความนี้เหมือนกัน นั่นคือไม่มีประเภทเฉพาะเจาะจงใดๆ

ตัวอย่างเช่น:

package main

import "fmt"

func main()
{
	const A = "GFG"
	var B = "GeeksforGeeks"
	
	// Chuỗi Concat.
	var helloWorld = A+ " " + B
	helloWorld += "!"
	fmt.Println(helloWorld) 
	
	// Chuỗi so sánh.
	fmt.Println(A == "GFG") 
	fmt.Println(B < a)="">

ผลลัพธ์:

GFG Quantrimang!
true
false

ความซับซ้อนของเวลา: O(1)
พื้นที่เสริม: O(1)

ค่าคงที่บูลีน

ค่าคงที่แบบบูลีนจะคล้ายกับค่าคงที่แบบสตริง ใช้กฎเดียวกันกับค่าคงที่ของสตริง ความแตกต่างเพียงอย่างเดียวคือมี const สองอัน โดยไม่มี type trueและfalse.

package main

import "fmt"

const Pi = 3.14

func main() 
{
	const trueConst = true
	
	// Định nghĩa kiểu bằng từ khóa type
	type myBool bool 
	var defaultBool = trueConst // được phép
	var customBool myBool = trueConst // được phép
	
	// defaultBool = customBool // không được phép
	fmt.Println(defaultBool)
	fmt.Println(customBool) 
}

ผลลัพธ์:

true
true

ความซับซ้อนของเวลา: O(1)
พื้นที่เสริม: O(1)

ค่าคงที่ใน Go: Go มีค่าคงที่อักขระ สตริง บูลีน และตัวเลข Const ประกาศค่าคงที่ คำสั่งconstสามารถเกิดขึ้นได้เมื่อมีตัวแปร และดำเนินการทางคณิตศาสตร์โดยไม่มีความแม่นยำคงที่

// Minh họa hằng số bằng cách dùng go.
package main

import (
	"fmt"
	"math"
)

const s string = "Quantrimang"

func main() {
	fmt.Println(s)

	const n = 5

	const d = 3e10 / n
	fmt.Println(d)

	fmt.Println(int64(d))

	fmt.Println(math.Sin(n))
}

ผลลัพธ์:

Quantrimang
6e+09
6000000000
-0.9589242746631385

ความซับซ้อนของเวลา: O(1)
พื้นที่เสริม: O(1)

หากคุณต้องการกำหนดค่าคงที่หลายค่าในคราวเดียว คุณสามารถทำได้โดยใช้บล็อกวงเล็บดังแสดงด้านล่าง

package main

import "fmt"

const (
	GFG	 = "Quantrimang"
	Correct = true
	Pi	 = 3.14
)

// Hàm chính
func main() {

	fmt.Println("value of GFG : ", GFG)

	fmt.Println("value of Correct : ", Correct)

	fmt.Println("value of Pi : ", Pi)
}

ผลลัพธ์:

value of GFG :  Quantrimang
value of Correct :  true
value of Pi :  3.14