Skip to main content

Basic Syntax

Golang 

ไฟล์ Go ประกอบด้วยส่วนต่างๆ ต่อไปนี้:

ประกาศแพคเกจ
แพคเกจนำเข้า
ฟังก์ชั่น
คำสั่งและการแสดงออก

เช่น

package main
import ("fmt")

func main() {
  fmt.Println("Hello GDSC!")
}

Package

Package คือที่เก็บฟังก์ชันและหนึ่งแพ็คเกจสามารถมีไฟล์จำนวนมากที่คุณสามารถตั้งชื่อได้อย่างอิสระ

Import

Import คือนำเข้า Package จากข้างนอกเข้ามาใช้ใน file go ที่เราเขียนอยู่

Example:

import "fmt" --------------------------------> fmt is the name of a package
import "os" ---------------------------------> os is the name of a package
import "github.com/gopherguides/greet" ------> the underlined part is the path of the package

Import เรียกใช้ได้ 2 แบบ คือ Direct Import กับ Grouped Import

Example:

// Direct import:

// Single:
import "fmt"

// Multiple one-by-one:
import "fmt"
import "math"

// Grouped import:
import(
    "fmt"
    "math"
)

Variables

Go เป็นภาษาที่พิมพ์แบบคงที่ หมายความว่าคุณต้องประกาศประเภทตัวแปรเมื่อคุณประกาศตัวแปร และไม่สามารถเปลี่ยนแปลงได้ จุดนี้ทำให้ Golang ทำงานได้รวดเร็ว เนื่องจาก compiler ไม่จำเป็นต้องระบุประเภทตัวแปรในขณะ runtime 

package main

import "fmt"

const globalConstant = 2.72
const ExportedGlobalConstant = 3.14

func main() {
  var first string
  first = "This is first string"
  
  var second = "This is second string"
  
  third := "This is third string"
  
  fmt.Println(first, second, third)
}

มีสามวิธีในการประกาศตัวแปร จากตัวอย่างข้างต้น แบบแรกคือการประกาศโดยระบุประเภทให้กับตัวแปรด้วยตนเอง ส่วนแบบที่สองและสามคือการประกาศแบบไม่ระบุประเภทด้วยตนเอง แต่ใช้คำสั่งหลังเครื่องหมายเท่ากับกำหนดประเภทแทน สำหรับตัวที่สาม จะต้องมีเครื่องหมาย (:) เพื่อประกาศตัวแปร หากไม่มีเครื่องหมายทวิภาค คอมไพลเลอร์จะส่งข้อผิดพลาดหากคุณยังไม่เคยประกาศตัวแปรมาก่อน


Variables type
package main

import "fmt"

func main() {
  a := 1    // var a int
  b := 3.14 // var b float
  c := "hi" // var c string
  d := true // var d bool
  fmt.Println(a, b, c, d)

  e := []int{1, 2, 3} // slice
  e = append(e, 4)
  fmt.Println(e, len(e), e[0], e[1:3], e[1:], e[:2])
  
  f := make(map[string]int) // map
  f["one"] = 1
  f["two"] = 2
  fmt.Println(f, len(f), f["one"], f["three"])
}

Like other languages, Go has int, float, string, and boolean as primitive types.


Struct

ตัวแปรประเภทต่อไปคือ "struct" อนุญาตให้โปรแกรมเมอร์กำหนดประเภทข้อมูลใหม่ที่มีประเภทข้อมูลอื่น (เรียกว่าฟิลด์) ในตัวมันเอง แต่ละฟิลด์สามารถส่งออกได้โดยใช้กฎเดียวกันกับตัวแปรส่วนกลางซึ่งใช้อักษรตัวแรกของฟิลด์เป็นตัวพิมพ์ใหญ่ หมายความว่าจากฟิลด์ชื่อรหัสและอายุสามารถเข้าถึงได้โดยแพ็คเกจอื่น ๆ ในขณะที่ isAdmin ไม่สามารถเข้าถึงได้ ฟิลด์สามารถกำหนด "แท็ก" (`json:"name"`) เป็นข้อมูลเมตาสำหรับไลบรารีบางไลบรารี เช่น  JSON libraries (https://golang.org/pkg/encoding/json/) ที่ใช้ "แท็ก" เพื่อแมป Go ฟิลด์โครงสร้างและฟิลด์ JSON

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 คุณสามารถเรียกใช้ฟังก์ชันใด ๆ หลังจากคำสั่งเลื่อน ฟังก์ชั่นจะถูกเก็บไว้ในสแต็กและจะถูกเรียกใช้หลังจากที่ฟังก์ชันผู้เรียกกลับมา ดังที่คุณเห็นในตัวอย่าง มีการกลับลำดับของการเรียกใช้ฟังก์ชัน

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

image.png

  1. Name: ชื่อควรจะเป็น แบบ camelCase / CamelCase.
  2. Arguments: ฟังก์ชันสามารถรับargumentsเป็นศูนย์หรือมากกว่าได้ สำหรับargumentsที่อยู่ติดกันตั้งแต่ 2 รายการขึ้นไปที่มีประเภทเดียวกัน คุณสามารถกำหนดประเภทที่ด้านหลังของargumentsสุดท้ายได้ (เช่น "String" ในตัวอย่าง)
  3. Return Types: ฟังก์ชันสามารถคืนค่าเป็นศูนย์หรือมากกว่าได้ หากส่งคืนค่ามากกว่าหนึ่งค่า คุณต้องใส่วงเล็บปิด
  4. Body: It is a logic of a function.
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
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
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")
}
Back to top