Golang เรียนนรู้ Syntax ต่าง ๆ ของ GO EP2

Sharing is caring!

Variables and Declarations

ตัวแปร และการประกาศค่า หลัก ๆ
  • ที่เห็นได้ชัดเจน จะมี 2 รูปแบบ คือกำหนด type ชัดเจน เช่น var s1 string และให้แปลง type ให้ตามข้อมูลที่ assign เริ่มต้น เช่น var s1 = “poolsawat.com” // จะได้ type string
  • การกำหนดค่าหลาย ๆ ค่า ก็สามารถ assings แบบนี้ var i, j int = 1, 2 ได้เช่นกัน
  • การประกาศค่าแบบสั้น ด้วย s1 := “poolsawat.com”
  • อื่น ๆ ตามโค๊ดตัวอย่างข้างล่าง
// Variables and Declarations
// Go Playground: https://play.golang.org/p/PKdAxUp8mNT
package main
import "fmt"
func main() {
    // Syntax: var var_name type
    var s1 string
    s1 = "Learning Go!"
    fmt.Println(s1) // printing string s1
    //** TYPE INFERENCE **//
    // Go deduces automatically the type of the variable by looking at the initial value (bool, int, string etc)
    var k int = 6 // not necessary to say the type (int). It is inferred from the literal on the right side of =
    var i = 5     // type int
    var j = 5.6   // type float64
    // printing i, j and k
    fmt.Println("i:", i, "j:", j, "k:", k)
    // ii == jj  // -> error: cannot assign float to int (Go is a strong typed language)
    // declaring and initializing a new variable of type string (type inference)
    var s2 = "Go!"
    _ = s2 //in Go each variable must be used or there is a compile-time error
    // _ is the Blank Identifier and mutes the error of unused variables
    // _ can be only on the left hand side of the = operator
    // multiple assignments
    var ii, jj int
    ii, jj = 5, 8 // -> tuple assignment. It allows several variables to be assigned at once
    // swapping two variables using multiple assignments
    ii, jj = jj, ii
    fmt.Println(ii, jj)
    //** Short Declaration (works only in Block Scope!) **//
    // := (colon equals syntax) used only when declaring a new variable (or at least a new variable)
    // := tells go we are going to create a new variable and go figures out what type it will be
    s3 := "Learning golang!"
    _ = s3
    // can't use short declaration at Package Scope (outside main() or other function)
    // all statements at package scope must start with a Go keyword (package, var, import, func etc)
    // multiple short declaration
    car, cost := "Audi", 50000
    fmt.Println(car, cost)
    // redeclaration with short declaration syntax
    // at least one variable must be NEW on the left side of :=
    var deleted = false
    deleted, file := true, "a.txt"
    _, _ = deleted, file
    // expressions in short declarations are allowed
    sum := 5 + 2.5
    // multiple declaration is good for readability
    var (
        age       float64
        firstName string
        gender    bool
    _, _, _ = age, firstName, gender
    // a concise way to declare multiple variables that have the same type
    var a, b int
    _, _ = a, b

Types and Zero Values

ชนิดของตัวแปร และค่า 0 (ศูนย์)

  • ตัวอย่าง type ของ GO เช่น string, int, float และอื่น ๆ เพิ่มเติม
  • หากไม่ initial value ให้ GO จะ set default value ให้ int // initialized with 0, float //initialized with 0.0,bool //initialized with false และ string //initialized with empty string
  • การตรวจสอบ type ของตัวแปร สามารถทำได้หลายวิธี 1 ในวิธีที่ง่าย คือ %T ตัวอย่าง fmt.Printf(“The type of name is: %T\n”, name)
// Types and Zero Values
// Go Playground: https://play.golang.org/p/zItROROXi64
package main
import "fmt"
func main() {
    // you must provide a type for each variable you declare or Go should be able to infer it
    var a int = 10
    var b = 15.5      // type inference (deduction)
    c := "Gopher"     // short declaration, type inference
    _, _, _ = a, b, c // Blank Identifier (_) to get rid of unused variable error
    // Go is a Statically and Strong Typed Programming Language
    // a = 3.14 -> error. A variable cannot change it's type
    // a = b    -> error. It's not allowed to assign a type to another type
    //** ZERO VALUES **//
    // An uninitialized variable or empty variable  will get the so called ZERO VALUE
    // The zero-value mechanism of Go ensures that a variable always holds a well defined value of its type
    var value int                         // initialized with 0
    var price float64                     // initialized with 0.0
    var name string                       // initialized with empty string -> ""
    var done bool                         // initialized with false
    fmt.Println(value, price, name, done) // -> 0 0.0 ""  false

Comments and Naming Convention

การ comment code และการตั้งชื่อตัวแปร และค่าอื่น ๆ
  • comment บรรทัดเดียว จะใช้ // my code un use
  • comments หลาย ๆ บรรทัด /* my code un use multi lines */
  • การตั้งชื่อไม่ควรยาวเกินความจำเป็น ต้องสื่อกับหน้าที่ของชนิดนั้น ๆ และต้องง่านต่อการดูในภายหลัง
  • ไม่ควรตั้งชื่อที่ใช้ _ (underscore) ในการตั้งชื่อ
// Comments and Naming Conventions in Go
// Go Playground: https://play.golang.org/p/pprI80SPMkS
package main
//** COMMENTS **//
// this is a single line comment
 This is a block comment.
 a := 10
var name = "John Wick" // inline comment
// Naming Conventions are important for code readability and maintainability.
// use short, concise names especially in shorter scopes
// common names for common types:
var s string   //string
var i int      //index
var num int    //number
var msg string //message
var v string   //value
var err error  //error value
var done bool  //bool, has been done?
// use mixedCase a.k.a camelCase instead of snake_case (variables and  functions)
var maxValue = 100  // recommended (camelCase)
var max_value = 100 // not recommended (snake_case)
// recommended
func writeToFile() {
// not recommended
func write_to_file() {
// write acronyms in all caps
var writeToDB = true // recommended
var writeToDb = true // not recommended
func main() {
    // use fewer letters, don’t be too verbose especially in smaller scopes
    var packetsReceived int // NOT OK, too verbose
    var n int               // OK
    _, _ = packetsReceived, n
    // an uppercase first letter has special significance to go (it will be exported in other packages)