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!
