การเรียนรู้ตัวแปรและค่าคงที่ของ Golang

1. ตัวแปรและค่าคงที่

ใน Golang ตัวแปรและค่าคงที่เป็นแนวคิดพื้นฐานสองประการที่มีบทบาทสำคัญมากในโปรแกรม

• ตัวแปร (variable) คือตัวบ่งชี้ที่ถูกใช้เก็บข้อมูลในโปรแกรม ใน Golang ใช้คำว่า var เพื่อประกาศตัวแปร
• ค่าคงที่ (constant) คือตัวบ่งชี้ซึ่งค่าไม่สามารถเปลี่ยนแปลงได้ในโปรแกรม ใน Golang ใช้คำว่า const เพื่อประกาศค่าคงที่

2 การประกาศและกำหนดค่าตัวแปรใน Golang

2.1 การประกาศและกำหนดค่าของตัวแปรเดี่ยว

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

var age int // ประกาศตัวแปรจำนวนเต็มชื่อ age
age = 25    // กำหนดค่าให้กับตัวแปร

var name string = "Alice" // ประกาศและกำหนดค่าตัวแปรชื่อ name

2.2 การประกาศของตัวแปรมากตัวพร้อมกัน

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

var (
    firstName, lastName string
    age                 int
)

firstName = "John"
lastName = "Doe"
age = 30

ในการประกาศเป็นชุดข้างต้น firstName และ lastName ถูกประกาศเป็นสตริง ในขณะที่ age เป็นจำนวนเต็ม

2.3 การโอนเรียกและประกาศตัวแปรแบบสั้น

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

city := "Beijing" // โอนเรียกและกำหนดค่าเริ่มต้นให้กับ city
country := "China" // country ถูกโอนเรียกและแทนค่าเป็นสตริง

ควรระวังว่า การประกาศแบบสั้นสามารถใช้ได้ภายในฟังก์ชันเท่านั้น และไม่สามารถใช้ในตัวแปรระดับแพคเกจ

2.4 การประกาศตัวแปรนอกขอบเขตของฟังก์ชัน

ตัวแปรที่ประกาศนอกขอบเขตของฟังก์ชัน มีขอบเขตด้านแพคเกจ ตัวแปรเหล่านี้ต้องการดูแลรักษาได้อย่างระมัดระวังเพื่อป้องกันปัญหาการชนกันของชื่อและการอ้างอิงที่ไม่ชัดเจน

var globalVar string = "ฉันคือตัวแปรโกลบอล" // การประกาศตัวแปรโลกัล

func printGlobalVar() {
    fmt.Println(globalVar) // การเข้าถึงตัวแปรโลกัลภายในฟังก์ชัน
}

ตัวแปรโลกัลสามารถใช้ร่วมกันระหว่างฟังก์ชันในแพคเกจได้ แต่ต้องใช้อย่างระมัดระวังเพื่อป้องกันปัญหาการชนชื่อและการอ้างอิงที่ไม่ชัดเจน

คำแนะนำ: ความเข้าใจเกี่ยวกับโค้ดฟังก์ชันพื้นฐานที่นี่เพียงพอ การอธิบายเพิ่มเติมเกี่ยวกับฟังก์ชันจะถูกนำเสนอในส่วนถัดไป

4.1 ตัวแปรภายในฟังก์ชัน

ตัวแปรภายใน (Local variables) คือตัวแปรที่ถูกกำหนดของภายในฟังก์ชัน และสามารถเข้าถึงได้ในเฉพาะฟังก์ชันนั้น ๆ เท่านั้น พารามิเตอร์ของฟังก์ชันก็เป็นตัวแปรภายในด้วย ตั้งแต่สร้างขึ้นมาจนกระทำการทำงานของฟังก์ชันเสร็จ ตัวแปรภายในก็จะหายไป ทุกครั้งที่มีการเรียกใช้ฟังก์ชัน ตัวแปรภายในก็จะถูกสร้างขึ้นมาใหม่

func localVariableExample() {
    var localVariable int = 10 // นี่คือตัวแปรภายใน
    fmt.Println(localVariable)
}

func main() {
    localVariableExample() // ผลลัพธ์: 10
    // fmt.Println(localVariable) // นี่จะทำให้เกิดข้อผิดพลาดในการคอมไพล์เนื่องจาก localVariable ไม่สามารถมองเห็นได้ที่นี่
}

ในตัวอย่างข้างต้น localVariable สามารถเข้าถึงได้เฉพาะในฟังก์ชัน localVariableExample เท่านั้น

4.2 ตัวแปรโกลบอล

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

package main

import "fmt"

var globalVariable int = 20 // นี่คือตัวแปรโกลบอล

func main() {
    fmt.Println(globalVariable) // ผลลัพธ์: 20
    changeGlobal()
    fmt.Println(globalVariable) // ผลลัพธ์: 30
}

func changeGlobal() {
    globalVariable = 30 // เปลี่ยนค่าของตัวแปรโกลบอล
}

ในตัวอย่างนี้ globalVariable สามารถมองเห็นได้ทั้งในฟังก์ชัน main และฟังก์ชัน changeGlobal

5 การประกาศและการใช้ค่าคงที่

5.1 คำสำคัญ const

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

const Pi = 3.14 // ประกาศค่าคงที่เป็นเลขทศนิยม
const StrConst string = "สวัสดี, โลก!" // ประกาศค่าคงที่เป็นสตริง

func main() {
    fmt.Println(Pi)
    fmt.Println(StrConst)
}

5.2 ค่าคงที่แบบ Enum

ภาษา Go ไม่มีชนิดข้อมูลที่แตกต่างเฉพาะเรื่องการจัดลำดับ แต่คุณสามารถใช้คำสำคัญ iota เพื่อให้ค่าคงที่เพิ่มขึ้นตามลำดับได้ ในบล็อก const การประกาศคงที่เพิ่มขึ้นหลังคำสำคัญ iota จะเพิ่มค่าของ iota ขึ้นทีละ 1

const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

func main() {
    fmt.Println(Sunday)    // ผลลัพธ์: 0
    fmt.Println(Saturday)  // ผลลัพธ์: 6
}

โค้ดข้างต้นประกาศการจัดลำดับสำหรับวันในสัปดาห์ โดยที่ iota จะเริ่มต้นที่ 0 ภายในบล็อก const และเพิ่มขึ้นทีละ 1 สำหรับการประกาศต่อไปทุกครั้ง

5.3 ขอบเขตของค่าคงที่

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

การจัดการขอบเขตของค่าคงที่ช่วยลดการปนเปื้อนของขอบเขตทั่วๆ ไปและทำให้โปรแกรมง่ายต่อการบำรุงรักษาและอ่านง่ายขึ้น

const GlobalConst = "นี่คือค่าคงที่ที่เป็นโกลบอล"

func main() {
    const LocalConst = "นี่คือค่าคงที่ที่เป็นภายในฟังก์ชัน"
    fmt.Println(GlobalConst)  // นี่ถูกต้อง
    fmt.Println(LocalConst)   // นี่ถูกต้อง
}

func anotherFunction() {
    // fmt.Println(LocalConst) // นี่จะทำให้เกิดข้อผิดพลาดในการคอมไพล์: LocalConst ไม่สามารถมองเห็นได้ในฟังก์ชันนี้
    fmt.Println(GlobalConst)  // นี่ถูกต้อง
}

ในตัวอย่างนี้ LocalConst สามารถเข้าถึงได้เฉพาะในฟังก์ชัน main ในขณะที่ GlobalConst สามารถเข้าถึงได้ทั่วทั้งแพ็คเกจ