GO語言入門 - 台部落

GO語言入門

原創

beyond_champion

2020-02-22 19:06

GO語言概述

什麼是GO語言

Go（又稱Golang）是Google開發的一種靜態強類型、編譯型、併發型，並具有垃圾回收功能的編程語言

GO語言特性

語法接近C，但對於變量的聲明有所不同
支持垃圾回收功能
不包括：枚舉、異常處理、繼承、泛型、斷言、虛函數等功能
增加了切片（Slice）型、併發、管道、垃圾回收、接口（Interface）等特性的語言級支持

GO三大紀律

每行程序結束後不需要撰寫分號（;）
大括號（{）不能夠換行放置
if判斷式和for循環不需要以小括號包裹起來

GO語言體系結構(GOPATH目錄下各文件夾用途)

src存放源代碼
pkg存放編譯後生成的文件
bin存放編譯後生成的可執行文件

GO語言開發基礎

GO數據類型

布爾型
數值型
字符串型
Go的字符串是由單個字節連接起來的，字符串的字節使用UTF-8編碼標識Unicode文本
派生類型
數組類型、切片類型、Map類型
指針類型（Pointer）、結構化類型（struct）、Channel類型
函數類型、接口類型（interface）

GO變量聲明

指定變量類型，如果沒有初始化，則變量默認爲零值
類型在後面
不加分號
變量聲明後必須使用，不然報錯，go變量拒絕浪費(常量不使用不會報錯)
佔位符，使用下劃線 _ 定義

常量

iota 特殊常量，可以認爲是一個可以被編譯器修改的常量
常量中的數據類型只可以是布爾型、數字型（整數型、浮點型和複數）和字符串型
常量定義使用const關鍵字

方法

方法如果被外部類調用，首字母要大寫

    var v name v type 
	var a int
	var b, c float32
	var d bool
	var e = "Shanghai"
	ff := 1234

for循環

(go語言只有for循環，沒有while沒有do while)

	//無線循環for
	for{
	    // 無限循環執行部分
	}

	//普通for
	for i:=0;i<5;i++ {
		fmt.Print(i)
	}

	//相當於while的for
	i := 0
	for i<5 {
		fmt.Println(i)
		i++
	}

GO語言字符串

strings包

	str2 := strings.ToUpper(str1)
	fmt.Println(str2)

strconv包

	a := 100

	str1 := strconv.Itoa(a)
	fmt.Println(str1)

	fmt.Println(reflect.TypeOf(str1))
	fmt.Println(reflect.TypeOf(a))

接口interface

接口interface是個萬能類型，不只用於接口
可以定義一個通用的模型，如汽車接口，可以實現爲寶馬、奧迪

結構體

結構體使用struct和type定義
結構體名字首字母大寫

go語言切片

go語言切片是對數組的抽象
append和copy，增加slice容量

go語言異常處理

defer
panic
recover

go通道

通道（channel）是用來傳遞數據的一個數據結構
通道用於兩個goroutine之間通過傳遞一個指定類型的值來同步運行和通訊
操作符<-用於指定通道方向發送或接收
如果未指定方向，則爲雙向通道

go 併發

go語言支持併發需要通過go關鍵字來開啓goroutine
goroutine是輕量級線程，調度由Golang運行時進行管理

GO語言示例

示例1：方法加go後執行順序不固定，體現出併發的效果

package main

import (
	"fmt"
	"time"
)

func Hello(){
	fmt.Println("Hello")
}

func DelayP(){
	for i:=0;i<5;i++ {
		fmt.Println(i)
		time.Sleep(time.Microsecond)
	}
}

func main() {
	go Hello()
	//Hello()
	//DelayP()
	go DelayP()
	time.Sleep(6 * time.Second)
	fmt.Println("End of program!")
}

示例2：

package main

import (
	"fmt"
	"time"
)

var echo chan string
var receive chan string

func Echo(){
	time.Sleep(time.Second * 2)
	echo <- "Arthur Beyond"
}

func Receive() {
	time.Sleep(time.Second * 2)
	temp := <- echo
	receive <- temp
}

func main() {
	echo = make(chan string)
	receive = make(chan string)

	go Echo()
	go Receive()

	getStr := <- receive
	fmt.Println("in main function")
	fmt.Println(getStr)
}

示例3：

package main

import (
	"fmt"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"
)
func consumer(stop <-chan bool) {
	for {
		select {
		case <-stop:
			fmt.Println("exit sub goroutine")
			return
		default:
			fmt.Println("running...")
			time.Sleep(500 * time.Millisecond)
		}
	}
}
func main() {
	stop := make(chan bool)
	var wg sync.WaitGroup
	// Spawn example consumers
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(stop <-chan bool) {
			defer wg.Done()
			consumer(stop)
		}(stop)
	}
	waitForSignal()
	close(stop)
	fmt.Println("stopping all jobs!")
	wg.Wait()
}
func waitForSignal() {
	sigs := make(chan os.Signal)
	signal.Notify(sigs, os.Interrupt)
	signal.Notify(sigs, syscall.SIGTERM)
	<-sigs
}