ตัวแปร (Variable) ภาษา Go

Go variable แสดงวิธีการทำงานกับตัวแปรใน Golang โดยค่าอื่นๆที่อยู่ในโปรแกรมเรานั้นส่วนใหญ่เก็บค่าแบบ static เราไม่สามารถเปลี่ยนแปลงได้ แต่ Variable นั้นค่อนข้างที่จะเป็น dynamic สามารถกำหนดค่า ดึงค่าแม้กะทั้งใช้ตัวเดิมซ้ำได้

ข้อกำหนดเบื้องต้น

ข้อกำหนดสำหรับบทความนี้คือ คุณต้องติดตั้ง Go บนคอมพิวเตอร์ของคุณตามบทความ ติดตั้ง Go และ ทดสอบ Hello World  มาก่อน

ตัวแปรใน Go (Variables in Go)

ตัวแปร (variable) ใช้เพื่อเก็บค่า เป็นป้ายกำกับที่กำหนดให้กับค่า Go ใช้ var เพื่อประกาศรายการตัวแปร นอกจากนี้เรายังสามารถใช้ การกำหนดตัวแปรแบบสั้น (Shorthand) := เพื่อประกาศตัวแปรได้เช่นกัน

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

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

ประกาศตัวแปรพร้อมกำหนดค่า

ประกาศตัวแปรพร้อมกำหนดค่า Long declaration ใช้คำว่า var นำหน้าตามด้วย ชื่อ ตามด้วย Type

ในตัวอย่างโค้ด เราประกาศและเริ่มต้นตัวแปร 2 ตัว ต่อมาเราพิมพ์

package main

import "fmt"

func main() {

    var i int = 1
    var w float64 = 12.5

    fmt.Println(i, w)
}

• บรรทัดที่ 7 เป็นการประกาศตัวแปรชื่อ i ชนิดของข้อมูลเป็น int ตัวเลขจำนวนเต็ม พร้อมกำหนดค่าให้เท่ากับ 1
• บรรทัดที่ 8 เป็นการประกาศตัวแปรชื่อ w ชนิดของข้อมูลเป็น float64 ตัวเลขทศนิยม พร้อมกำหนดค่าให้เท่ากับ 12.5
  
  

ประกาศตัวแปรหลายตัว

Go declare multiple variables ด้วย var เราสามารถประกาศตัวแปรหลายตัวพร้อมกันได้ ตัวอย่างแสดงวิธีการประกาศตัวแปรหลายตัวด้วย var

package main

import (
    "fmt"
)

func main() {

    var i, j, k = 1, 2, 3

    var (
        name       = "John Doe"
        occupation = "gardener"
    )

    fmt.Println(i, j, k)
    fmt.Printf("%s is a %s\n", name, occupation)
}

กำหนด type ให้โดยอัตโนมัติ (Go type inference)

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

ackage main

import (
    "fmt"
    "reflect"
)

func main() {

    var name = "John Doe"
    var age = 34

    fmt.Println(reflect.TypeOf(name))
    fmt.Println(reflect.TypeOf(age))

    fmt.Printf("%s is %d years old\n", name, age)
}

เพื่อให้การคาดคะเนทำงาน ตัวแปรต้องได้รับการเตรียมข้อมูลเบื้องต้น

var name = "John Doe"
var age = 34

ด้วยความช่วยเหลือของฟังก์ชัน TypeOf จากแพ็คเกจ reflect เราพิมพ์ชนิดของข้อมูลของตัวแปรทั้งสอง

fmt.Println(reflect.TypeOf(name))
fmt.Println(reflect.TypeOf(age))

การประกาศตัวแปรแบบสั้น

ด้วยเครื่องหมาย := ทำให้เราสามารถประกาศตัวแปรพร้อมกำหนดค่าอย่างสั้นได้ง่ายๆ การประกาศตัวแปรแบบสั้น (Shorthand) ซึ่งการประกาศตัวแปรแบบนี้จะนิยมและเห็นบ่อยที่สุด

ตัวอย่างประกาศตัวแปรสองตัวด้วย shorhand notation

package main

import "fmt"

func main() {

    name := "John Doe"
    age := 34

    fmt.Println("%s is %d years old", name, age)
}

ค่าเริ่มต้นตัวแปร

ในภาษา GO ถ้าประกาศตัวแปรแล้วไม่มีการกำหนดค่าให้ ตัวภาษา Go จะกำหนดค่าเป็น Default ให้ เพื่อให้โปรแกรมมีความถูกต้องมากที่สุดและป้องกัน error ที่เกิดจากค่า nil ซึ่งแต่ละ Type มีค่า Default แตกต่างกันเช่น ตัวแปรที่ประกาศโดยไม่มีค่าเริ่มต้นที่ชัดเจนจะได้รับเป็น zero value:

• type int default 0
• type float default 0.00
• type string default “”
• type bool default fales

package main

import "fmt"

func main() {

    var age int
    var isPresent bool
    var name string
    var weight float64

    fmt.Println(age, isPresent, name, weight)
}

ตัวแปร 4 ตัวในตัวอย่างโค้ดจะได้รับค่าเริ่มต้น เป็น zero value

ขอบเขตตัวแปร

ขอบเขตของตัวแปร คือ ขอบเขตของโค้ดที่สามารถอ้างอิงตัวแปรได้ ในตัวอย่างโค้ด เรามี 2 ตัวแปรที่กำหนดไว้

package main

import "fmt"

var word string = "falcon"

func main() {

    i := 12

    fmt.Println(word)
    fmt.Println(i)

    test()
}

func test() {

    fmt.Println(word)
}

ตัวแปร word ถูกกำหนดในขอบเขต global มองเห็นได้ทั้งใน main และฟังก์ชั่น test

var word string = "falcon"

ตัวแปร i มีขอบเขต local มองเห็นได้เฉพาะในฟังก์ชัน main เท่านั้น

func main() {

    i := 12
...

credit : https://zetcode.com/