Variable กับ Go

Variable (ตัวแปร) คืออะไร ?

Variable คือ ตัวแทนของการเก็บข้อมูล โดยจะกำหนดผ่านชื่อที่มีการตั้งเอาไว้

โดยวิธีการตั้งชื่อตัวแปรของภาษา go โดยทั่วไปนั้นก็เหมือนกับภาษาอื่นๆประกอบด้วยตัวอักษรหรือตัว "_" แต่ห้ามเว้นวรรคออกมา

• ทั่วไป มักจะตั้งชื่อเป็น camelCase = ตัวเล็กขึ้นต้นและแต่ละคำตามด้วยตัวใหญ่ขึ้นต้น เช่น firstName, lastName, userAddress เป็นต้น
• กฎของการตั้งชื่อตัวแปรคือ ใน scope 1 function จะ "ต้อง" มีชื่อตัวแปรได้เพียง 1 ชื่อเท่านั้น (ชื่อตัวแปรจะซ้ำกันไม่ได้) และ ชื่อตัวแปร ต้องไม่มี reserve word (คำต้องห้าม หรือคำที่เกี่ยวข้องกับคำสั่งของภาษา) เนื่องจากจะทำให้ภาษาไม่สามารถแปลงสิ่งนั้นออกมาเป็นตัวแปรได้

วิธีประกาศตัวแปร และ ประเภทของ Variable

วิธีการประกาศตัวแปรใน go มีหลากหลายวิธี แต่วิธีการพื้นฐานที่สุดคือ

วิธีที่ 1 แบบประกาศ type ปกติ

var <ชื่อตัวแปร> <ประเภทตัวแปร>;

โดย

• <ชื่อตัวแปร> คือ ชื่อที่เป็นตัวแทนของตัวแปร
• <ประเภทตัวแปร> คือ ประเภทของข้อมูลที่จะเก็บในตัวแปร

ประเภทของข้อมูลที่สามารถเก็บได้ใน Go นั้น ตัวพื้นฐานจะประกอบด้วย

1. Boolean เก็บค่าความจริงโดย

• true จะเป็นจริง
• false จะเป็นเท็จ

2. Numeric เก็บค่าตัวเลขโดยตัวเลขก็จะมีหลากหลายประเภทแต่จะแบ่งออกเป็น 2 ประเภทใหญ่ๆที่ใช้บ่อยคือ

• Integer คือตัวเลขประเภทจำนวนเต็ม ได้แก่ int8, int16, int32, int64, int (ขึ้นอยู่กับขนาดของตัวเลขที่จะเก็บ) หรือ uint ในกรณีที่จะไม่เก็บตัวเลขติดลบ
• Float คือตัวเลขทศนิยม ได้แก่ float32, float64

3. String เก็บข้อมูลตัวอักษรหรือชุดของตัวอักษร (ข้อความ) ประกาศเป็น string

ตัวอย่าง

• หากเราต้องการตัวแปรเก็บชื่อจริง = เก็บเป็น string เราจะต้องประกาศเป็น

var fullname string;

วิธีที่ 2 แบบประกาศ type ปกติ + มีค่าเริ่มต้น

แต่หากต้องการต้องการค่าเริ่มต้นให้กับตัวแปร จะต้องประกาศเป็น

var <ชื่อตัวแปร> <ประเภทตัวแปร> = "ค่าเริ่มต้น";

เช่น

• หากเราต้องการตัวแปรเก็บชื่อจริง โดยเก็บค่าเริ่มต้นเป็น mikelopster ไว้ จะต้องประกาศเป็น

var fullname string = "mikelopster";

วิธีที่ 3 แบบประกาศแบบไม่ประกาศ type แต่มีค่าเริ่มต้น

var <ชื่อตัวแปร> = "ค่าเริ่มต้น";

เช่นกับตัวอย่างเดียวกันกับวิธีที่ 2 ก็สามารถย่อได้เป็น

var fullname = "mikelopster";

วิธีที่ 4 แบบประกาศแบบไม่ประกาศ var แต่มีค่าเริ่มต้น (shorthand)

และวิธีการประกาศแบบสุดท้ายคือการประกาศแบบ shorthand คือ เหลือเพียงแค่

<ชื่อตัวแปร> := "ค่าเริ่มต้น";

แต่กดการใช้จะเหมือน var คือเป็นการสร้างตัวแปรใหม่ = ไม่สามารถใช้กับตัวแปรเดิมได้

จากตัวอย่างด้านบนก็จะเหลือเพียง

fullname := "mikelopster";

ตัวอย่างการประกาศตัวแปรทุกประเภท และการ reassign

นี่คือประเภท Basic ทั้งหมดของ Go เดี๋ยวเราจะค่อยๆเรียนรู้ Data type ประเภทอื่นๆเพิ่มเติมมา

package main

import "fmt"

func main() {
  var booleanVar bool = true
  var intVar int = 10
  var floatVar float64 = 3.14
  var stringVar string = "Hello Go"

  fmt.Println("Boolean:", booleanVar)
  fmt.Println("Integer:", intVar)
  fmt.Println("Float:", floatVar)
  fmt.Println("String:", stringVar)
}

ผลลัพธ์

โดยตัวแปรนั้นสามารถ reassign (แทนค่าใหม่) ได้เสมอ โดยใช้เพียงสัญลักษณ์ = ในการแทนค่าใหม่เข้าไป เช่น

package main

import "fmt"

func main() {
  var stringVar string = "Hello Go"
  fmt.Println("String:", stringVar)

  stringVar = "Hello mikelopster"
   fmt.Println("String:", stringVar)
}

ผลลัพธ์

Operator

Operator คือ symbol (สัญลักษณ์) พิเศษที่ใช้สำหรับดำเนินการ (operation) ระหว่าง variable (ตัวแปร) และ value (ค่าของตัวแปร) โดยปกติ จะมีพื้นฐานที่ควรรู้จักทั้งหมด 3 ตัวคือ

1. Arithmetic Operators คือ operator สำหรับการดำเนินการทางคณิตศาสตร์

• ประกอบด้วย + (บวก), - (ลบ), * (คูณ), / (หาร), % (modulus หรือ mod แบบสั้นๆ)

ตัวอย่างการใช้งาน

a := 10
b := 3
fmt.Println(a + b) // 13
fmt.Println(a - b) // 7
fmt.Println(a * b) // 30
fmt.Println(a / b) // 3
fmt.Println(a % b) // 1

2. Relational Operators คือ operator สำหรับการเปรียบเทียบ และคืนค่ากลับออกมาเป็น boolean

• โดยปกติ จะประกอบไปด้วย == (เท่ากับ), != (ไม่เท่ากับ), < (น้อยกว่า), <= (น้อยกว่าหรือเท่ากับ), > (มากกว่า), >= (มากกว่าหรือเท่ากับ)
• เราจะพูดกันอย่างละเอียดในหัวข้อถัดไปพร้อมกับ control statement

fmt.Println(a == b) // false
fmt.Println(a != b) // true
fmt.Println(a > b)  // true
fmt.Println(a < b)  // false
fmt.Println(a >= b) // true
fmt.Println(a <= b) // false

3. Logical Operators คือ operator ที่ใช้สำหรับรวม condition

• โดยปกติ จะประกอบไปด้วย && (และ), || (หรือ), ! (ไม่ / นิเสธ)
• เราจะพูดกันอย่างละเอียดในหัวข้อถัดไปพร้อมกับ control statement

c := true
d := false
fmt.Println(c && d) // false
fmt.Println(c || d) // true
fmt.Println(!c)     // false

โดยการใช้ operator นั้นนอกจากสามารถดำเนินการแล้วแสดงผลออกมา สามารถทำ operation เพื่อนำใส่ตัวแปรใหม่ได้เช่นเดียวกัน เช่น

a := 5
b := 10
c := a + b // c ก็จะทำการเก็บ 15 เอาไว้