Basic Syntax

Struct

ตัวแปรStruct คือชนิดตของข้อมูลอีกรูปแบบหนึ่ง ซึ่งมีความคล้ายกับ Object โดยผู้เขียนสามารถใส่ข้อมูล (field) เข้าไปคือ "struct" อนุญาตให้โปรแกรมเมอร์ละกำหนดชนิดตของ field นัวแปรข้อมูลใหม่ที่มีชนิดตัวแปรข้อมูลอื่น (เรียกว่าฟิลๆ ได์) ในตัวมันเอง้

แต่ละฟิลด์ field สามารถส่งออกได้โดยใช้กฎเดียวกันกับตัวแปรส่วนกลางซึ่ง คือการใช้อักษรตัวแรกของฟิลด์เป็นตัวพิมพ์ใหญ่ ซึ่งหมายความว่าจากตัวอย่างฟิด้านลด์ชื่อรหัสาง filed Name และอายุ Age สามารถเข้าถึงได้โดยแพ็คเกจอื่น ๆ ในขณะที่ isAdmin ไม่สามารถเข้าถึงได้

Field สามารถกำหนด

แท็ก เพื่อบอกข้อมูลเกี่ยวกับของ field นั้นๆ เช่น (`json:"name"`) เป็นข้อมูล meta (ข้อมูลที่ใช้อธิบายรายละเอียดของข้อมตาูล) สำหรับไลบรารี library บางไลบรารี library เช่น  JSON libraries (https://golang.org/pkg/encoding/json/) ที่ใช้ "แท็ก" เพื่อแมเปลี่ยนจาก Gomap ฟิลด์โครงสร้างและฟิลด์ไปเป็น JSON หรือ จาก JSON เป็น map

package main

import "fmt"

type Person struct{
  Name    string `json:"name"`
  Age     int    `json:"age"`
  isAdmin bool
}

func main() {
  p := Person{
    Name:    "Mike",
    Age:     16,
    isAdmin: false,
  }
  fmt.Println(p, p.Name, p.Age, p.isAdmin)
}

Type Conversion

package main

import (
  "fmt"
  "strconv"
  "reflect"
)

func main() {
  a := 3.14
  b := int(a)
  fmt.Println(b, reflect.TypeOf(b))
  
  c := "12.34"
  d, _ := strconv.ParseFloat(c, 64)
  fmt.Println(d, reflect.TypeOf(d))
  
  e := false
  f := fmt.Sprint(e)
  fmt.Println(f, reflect.TypeOf(f))
}

Control Flow Statements

Conditions

package main

import "fmt"

func main() {
  // if, else
  a := 5
  if a > 3 {
    a = a - 3
  } else if a == 3 {
    a = 0
  } else {
    a = a + 3
  }
  fmt.Println(a)
  
  // switch, case
  b := "NO"
  switch b {
  case "YES":
    b = "Y"
  case "NO":
    b = "N"
  default:
    b = "X"
  }
  fmt.Println(b)
}

Loop

package main

import "fmt"

func main() {
  // for
  c := 3
  for i := 0; i < c; i++ {
    fmt.Print(i, " ")
  }
  fmt.Println()
  
  // replace while with for
  for c > 0 {
    fmt.Print(c, " ")
    c--
  }
  fmt.Println()

  // for with range
  d := []int{0, 1, 1, 2, 3, 5, 8}
  for _, i := range d {
    fmt.Print(i, " ")
  }
  fmt.Println()
}

Defer

คำสั่ง "defer" เป็นคำสั่งพิเศษใน Go คุณสามารถเรียกใช้ฟังก์ชันใด ๆ หลังจากคำสั่งเลื่อนผ่านไป ฟังก์ชั่นจะถูกเก็บไว้ในสแต็ก stack และจะถูกเรียกใช้หลังจากที่ฟังก์ชันผู้เรียกกลับมา return ดังที่คุณเห็นในตัวอย่าง มีการกลับลำดับของการเรียกใช้ฟังก์ชัน

package main

import "fmt"

func main() {
  f()
}

func f() (int, error) {
  defer fmt.Println("DEFER 1")
  defer fmt.Println("DEFER 2")
  defer fmt.Println("DEFER 3")
  fmt.Println("BODY")
  return fmt.Println("RETURN")
}

Functions

Function components

Go function มีโครงสร้าง 4 ส่วนดังนี้:

1. Name: ชื่อของฟังก์ชัน ควรจะตั้งเป็น แบบ camelCase / CamelCase.
2. Arguments: ฟังก์ชันสามารถรับ arguments เป็นศูนย์หรือไมา่รับ arguments กกว่า็ได้ สำหรับ arguments ที่อยู่ติดกันตั้งแต่ 2 รายการขึ้นไปที่มีชนิดตัวแปรเดียวกัน คุณสามารถกำหนดชนิดตัวแปรที่ด้านหลังของargumentsส argument สุดท้ายได้ (เช่น "String" ในตัวอย่าง)
3. Return Types: ฟังก์ชันสามารถคืนค่าเป็นศูนย์หรือไมา่กกว่า็ได้ หากส่งคืนค่ามากกว่าหนึ่งค่า คุณจะต้องใส่ชนิดของค่าที่จะคืนกลับไปทั้งหมดในวงเล็บปิด
4. Body: การทำงานของฟังก์ชั่นเรา

Name Return Values

เราสามารถเซ็ต ั้งชื่อตัวแปรที่เราจะ return ค่าออกไปได้ โดยที่ไม่ต้องใส่ตัวแปรนั้นไว้ line ในบรรทัดเดียวกับ return

Example:

package main

import "fmt"

func main() {
  fmt.Println(threeTimes("Thank You GDSC"))
}

func threeTimes(msg string) (tMsg string) {
  tMsg = msg + ", " + msg + ", " + msg
  return
}

Exported / Unexported Functions

จากตัวอย่างด้านล่างจะเห็นว่า Sum เป็น exported function เพราะว่าชื่อฟังก์ชันตัวแรกเป็นตัวพิมพ์ใหญ่ แต่ factorial เป็น unexported function

package main

import "fmt"

func main() {
  s := Sum(10)
  f := factorial(10)
  fmt.Println(s, f)
}

func Sum(n int) int { // exported function
  sum := 0
  for i := 1; i <= n; i++ {
     sum += i
  }
  return sum
}

func factorial(n int) int { // unexported function
  fac := 1
  for i := 1; i <= n; i++ {
    fac *= 1
  }
  return fac
}

Anonymous Functions

คือฟังก์ชันที่ไม่มีชื่อ และถูกเรียกใช้เลยผ่านการประกาศตัวแปร

package main

import "fmt"

func main() {
  a := 1
  b := 1
  c := func(x int) int {
    b *= 2
    return x * 2
  }(a)
  fmt.Println(a, b, c)
}

func mainAnother() {
  myFunc := func(x int) int {
    return x * x
  }
  fmt.Println(myFunc(2), myFunc(3))
}

Blank Identifiers (_)

คือตัวแปรที่ไม่ถูกนำมาใช้ และค่าของ blank identifier จะไม่ถูกอ่าน

ประโยชน์ของ blank identifier คือ ถ้าประกาศตัวแปรมาหลายตัว แต่ไม่ได้ถูกใช้ครบทุกตัวจะ error ทำให้มีการใช้ blank identifier แทน เพื่อให้ compiler มองข้ามตัวแปรนั้นที่ไม่ได้ถูกนำมาใช้

package main

import "fmt"

func main() {
  x, _ := evenOnly(10)
  fmt.Println(x)
}

func evenOnly(n int) (int, error) {
  if n%2 == 0 {
    return n / 2, nil
  }
  return 0, fmt.Errorf("not even")
}