Tất tần tật những định nghĩa căn bản trong Golang

Căn bản trong Golang, các định nghĩa, khái niệm về kiểu dữ liệu, các hàm và câu điều kiện luôn là những vấn đề mà những bạn mới bắt đầu tìm hiểu về Golang phải nắm rõ. Hôm nay mình sẽ giới thiệu nhanh qua tất cả định nghĩa căn bản nhất đi kèm với code mẫu để các bạn có khái nhìn tổng quát với ngôn ngữ lập trình đang “hot” tại thời điểm hiện nay.

Nếu hiện tại bạn vẫn đang phân vân có nên học Golang chưa thì hãy đọc qua bài viết này của mình để quyết định nhé: https://huynhphuchuy.com/golang/nhung-ly-do-khien-ban-muon-hoc-golang-ngay-va-luon/

Mình sẽ đi lần lượt qua những khái niệm sau:

• Go là gì?
• Cài đặt và cấu hình
• Chương trình đầu tiên
• Kiểu, biến và phạm vi
• Arrays , Slices và Maps
• If-else và switch
• Loops
• Hàm và Closures
• Structure và Interfaces

Go là gì?

Go chỉ là một ngôn ngữ lập trình khác thui mà. Tuy nhiên lý do mà hiện nay Go đang dần trở nên phổ biến hơn bởi vì hiệu suất của Go không khác với C hay C++. Go giúp cho việc lập trình những microservices trở nên đơn giản và hiệu quả hơn rất nhiều. Chính vì vậy mình đã dần hứng thú với Go và sử dụng trong các dự án gần đây.

Cài đặt và cấu hình

Các bạn ghé thăm trang chủ Golang Website và tải nó về. Trên windows thì cài đặt nó ở C:\Go cho thuận tiện và trên Mac thì /usr/local/go. Cần phải có sự chuẩn bị cần thiết trước khi bắt tay vào coding.

IDE: Mình sử dụng Visual Studio Code cho việc lập trình Go và nhiều ngôn ngữ khác.

GOPATH 

Biến môi trường GOPATH chỉ định vị trí workspace của bạn. Đây là biến môi trường duy nhất mà bạn phải thiết lập trước khi bắt đầu code.

Chương trình đầu tiên

Tạo một file đặt tên là main.go

// Chuương trình chính cần khai báo package main
package main

// import một package để sử dụng
import "fmt"

func main() {
 // Println is function of fmt package
 fmt.Println("Hello Friends")
}

Chạy thử nó sử dụng lệnh # go run main.go

=============================================
kết quả:
Hello Friends

=============================================

Bạn cũng có thể chạy nó online trên <a href="https://tour.golang.org/welcome/1">@Go Tour</a>.

Kiểu, Biến và Phạm vi

Numbers

• Integers ( uint8, uint16, uint32, uint64, int8, int16, int32 and int64 )
• Float  : Go có 2 kiểu float như sau: float32 và float64

Strings

• “Huy” , “Friends” là string trong Golang .

Booleans

• true và false là 2 trạng thái của boolean

Biến

Biến trong Golang cũng giống như những ngôn ngữ khác. Nhưng cách biểu hiện lại khác. Biến được khai báo như sau:

var variableName variableType

Ví dụ:

package main

import "fmt"

func main() {
    // Khái báo biến và gán
    var myInt int = 10
    
    // Tự động nhận kiểu biến
    myInt2 := 20

    var myStr string = "Hello"

    myStr2:= "World"

    fmt.Println(myInt + myInt2)
    // Nối 2 chuỗi
    fmt.Println(myStr + myStr2)
}

Kết quả:
30
Hello World

Phạm vi của biến

package main 

import "fmt" 

// Biến global 
var x string = "Hello World Global" 

func main() 
{ 
    fmt.Println(x) f() 
} 

func f() 
{ 
    // Biến local
    var x string = "Hello World Local" 
    fmt.Println(x) 
}

Arrays và Slices

var a [4]int // Mảng số nguyên có size 4

<strong>b := [2]string{"Penn", "Teller"} // Mảng c</strong>huỗi

Mảng trong Go cũng giống những ngôn ngữ khác, chỉ khác cách khai báo.

package main

import "fmt"


func main(){
       // Mảng
       var intarray [4]int
       intarray[0] = 1
       intarray[1] = 2
       intarray[2] = 3
       intarray[3] = 4
       fmt.Println(intarray)

       b := [2]string{"test1", "test2"}
       fmt.Println(b)
       b[0] = "new_test"
       fmt.Println(b)
}

Kết quả:

[1 2 3 4]

Ví dụ về Slices 

package main

import "fmt"


func main(){
 // Mảng
 var intarray [4]int
 intarray[0] = 1
 intarray[1] = 2
 intarray[2] = 3
 intarray[3] = 4
 fmt.Println(intarray)

 // Cắt mảng từ index 1 đến 3 
 b := intarray[1:3]
 fmt.Println(b)

}

Maps trong Golang

Chúng còn được gọi là dictionaries, ví dụ mẫu dưới đây sẽ giúp các bạn hiểu rõ hơn về Map – một thuộc tính quan trọng vs căn bản trong Golang:

package main

import "fmt"

func main(){

       a := make(map[string]string)
       a["Myname"] = "Huy"
       a["MyJob"] = "No Job"

       fmt.Println(a)
       fmt.Println(a["Myname"])
       fmt.Println(a["MyJob"])
       // Kiểm tra không tồn tại
       fmt.Println(a["Noval"])

}

If-else

package main

import "fmt"

func main() {

       // Ví dụ căn bản nhất.
       if 7%2 == 0 {
              fmt.Println("7 is even")
       } else {
              fmt.Println("7 is odd")
       }

       // `if` mà ko cần `else`
       if 8%4 == 0 {
              fmt.Println("8 is divisible by 4")
       }

       // Có thể gán trong câu điều kiện
       if num := 9; num < 0 {
              fmt.Println(num, "is negative")
       } else if num < 10 {
              fmt.Println(num, "has 1 digit")
       } else {
              fmt.Println(num, "has multiple digits")
       }

       name := "rajni"

       if name == "rajni" {
              fmt.Println("Hi Huy")
       } else {
              fmt.Println("Bye Huy")
       }
}

kết quả:
7 is odd
8 is divisible by 4
9 has 1 digit
Hi Huy

Switch-Case

package main

import "fmt"
import "time"

func main() {

       // Ví dụ căn bản
       i := 2
       fmt.Print("Write ", i, " as ")
       switch i {
       case 1:
              fmt.Println("one")
       case 2:
              fmt.Println("two")
       case 3:
              fmt.Println("three")
       }


       switch time.Now().Weekday() {
       
       case time.Saturday, time.Sunday:
              fmt.Println("It's the weekend")
       default:
              fmt.Println("It's a weekday")
       }

       // `switch` với điều kiện
       t := time.Now()
       switch {
       case t.Hour() < 12:
              fmt.Println("It's before noon")
       default:
              fmt.Println("It's after noon")
       }

       // Gán một biến trong câu điều kiện switch
       whatAmI := func(i interface{}) {
              switch t := i.(type) {
              case bool:
                     fmt.Println("I'm a bool")
              case int:
                     fmt.Println("I'm an int")
              default:
                     fmt.Printf("Don't know type %T\n", t)
              }
       }
       whatAmI(true)
       whatAmI(1)
       whatAmI("hey")
}

Loops

package main

import "fmt"

func main() {

       // Vòng `for` đơn giản
       i := 1
       for i <= 3 {
              fmt.Println(i)
              i = i + 1
       }

       // Vòng `for` đầy đủ
       for j := 7; j <= 9; j++ {
              fmt.Println(j)
       }

       // `for` này sử dụng cho trường hợp lặp vô hạn
       for {
              fmt.Println("loop")
              break
       }

       // Sử dụng `continue` để chuyển sang giá trị kế tiếp
       for n := 0; n <= 5; n++ {
              if n%2 == 0 {
                     continue
              }
              fmt.Println(n)
       }
}

Hàm trong Golang

package main

import "fmt"

// Hàm này sẽ nhận 2 giá trị kiểu `int` và trả về tổng
func plus(a int, b int) int {
       return a + b
}

// Định nghĩa kiểu dữ liệu cho nhiều tham số đầu vào cùng lúc
func plusPlus(a, b, c int) int {
       return a + b + c
}

func main() {

       // Gọi hàm ^^
       res := plus(1, 2)
       fmt.Println("1+2 =", res)

       res = plusPlus(1, 2, 3)
       fmt.Println("1+2+3 =", res)
}

Closures

Closures giống như lambdas ở một số ngôn ngữ lập trình khác

package main

import "fmt"

// Hàm `intSeq` trả về một hàm khác
func intSeq() func() int {
       i := 0
       return func() int {
              i += 1
              return i
       }
}

func main() {

       // Gọi hàm `intSeq` và gán kết quả trả về cho `nextInt`.
       nextInt := intSeq()

       // Tiếp tục gọi hàm `nextInt `
       fmt.Println(nextInt())
       fmt.Println(nextInt())
       fmt.Println(nextInt())

       // Gán và gọi một lần nữa để kiểm tra kết quả
       newInts := intSeq()
       fmt.Println(newInts())
}

Struct trong Golang

// Go _structs_ are dùng để định nghĩa một tập các trường

package main

import "fmt"

// This `person` struct type has `name` and `age` fields.
type person struct {
       name string
       age  int
}

func main() {

       // Tạo một struct mới.
       fmt.Println(person{"Bob", 20})

       // Có thể định nghĩa đầy đủ như này.
       fmt.Println(person{name: "Alice", age: .30})

       // Những trường không có sẽ nhận giá trị rỗng hoặc 0.
       fmt.Println(person{name: "Fred"})

       // `&` để chỉ định con trỏ đến struct.
       fmt.Println(&person{name: "Ann", age: 40})

       // Truy xuất giá trị của một trường trong struct.
       s := person{name: "Sean", age: 50}
       fmt.Println(s.name)

       // Tương tự với con trỏ struct
       sp := &s
       fmt.Println(sp.age)

       // Struct có thể thay đổi giá trị
       sp.age = 51
       fmt.Println(sp.age)
}

Phương thức trong Golang

// Go hỗ trợ định nghĩa _methods_ cho struct.

package main

import "fmt"

type rect struct {
       width, height int
}

// Phương thức `area` là một _receiver_ of `*rect`.
func (r *rect) area() int {
       return r.width * r.height
}

// Phương thức có thể được định nghĩa cho giá trị lẫn con trỏ
func (r rect) perim() int {
       return 2*r.width + 2*r.height
}

func main() {
       r := rect{width: 10, height: 5}

       // Gọi 2 phương thức trên.
       fmt.Println("area: ", r.area())
       fmt.Println("perim:", r.perim())

       // Go tự động chuyển đổi giá trị và con trỏ trong lời gọi phương thức
       rp := &r
       fmt.Println("area: ", rp.area())
       fmt.Println("perim:", rp.perim())
}

Interfaces

// _Interfaces_ là một tập hợp các phương thức

package main

import "fmt"
import "math"

// Đây là interface cơ bản của một khối hình học.
type geometry interface {
       area() float64
       perim() float64
}

// Chúng ta hãy định nghĩa các thuộc tính bên trong các struct
// `rect` và `circle`.
type rect struct {
       width, height float64
}
type circle struct {
       radius float64
}

// Định nghĩa các phương thức cho hình chữ nhật
func (r rect) area() float64 {
       return r.width * r.height
}
func (r rect) perim() float64 {
       return 2*r.width + 2*r.height
}

// Các phương thức cho hình tròn `circle`.
func (c circle) area() float64 {
       return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
       return 2 * math.Pi * c.radius
}

func measure(g geometry) {
       fmt.Println(g)
       fmt.Println(g.area())
       fmt.Println(g.perim())
}

func main() {
       r := rect{width: 3, height: 4}
       c := circle{radius: 5}

       // `circle` và`rect` struct đều
       // implement `geometry` interface vì thế chúng ta có thể sử dụng
       // thể hiện của
       // những struct này như là tham số của `measure`.
       measure(r)
       measure(c)
}

Đến đây là xong những phần căn bản trong Golang, khái niệm tổng quan nhất của Golang. Các bạn cố gắng nắm vững những khái niệm này để chúng ta có thể bắt đầu vào lập trình mà không gặp nhiều khó khăn, trở ngại.

Hẹn gặp lại các bạn trong các bài viết sắp tới!