Go語言特點及基本資料型別使用詳解

2022-03-21 19:01:06

一、Golang 簡介

Golang（又稱為 Go）是 Google 公司開發出的一種靜態強型別、編譯型、並行型，並具有垃圾回收功能的程式語言。

1.Go 語言的特點

Go 語言保證了既能夠達到靜態編譯語言的安全和效能，又達到了動態開發語言維護的高效率，使用一個表示式來形容 Go 語言：Go = C + Python，說明 Go 語言既有 C 靜態語言程式的執行速度，又能達到 Python 動態語言的快速開發。

1）從 C 語言中繼承了很多理念，包括表示式語法，控制結構，基礎資料型別，呼叫引數傳值，指標等等，也保留了和 C 語言一樣的編譯執行方式及弱化的指標。

func testPtr(num *int) {
    *num = 20
}

2）引入包的概念，用於組織程式結構，Go 語言的一個檔案都要歸於一個包，而不能單獨存在。

package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}

3）垃圾回收機制，記憶體自動回收，不需要開發人員管理。

4）天然並行：從語言層面上支援並行，實現簡單；goroutine 輕量級執行緒，可實現大並行處理，高效利用多核；基於 CPS 並行模型實現。

5）吸收了管道通訊機制，形成 Go 語言特有的管道 Channel，通過管道 Channel，我們可以實現不同 goroute 間的互相通訊。

6）函數可以返回多個值：

func getSumAndSub(sum int,sub int) (int,int) {
    Sum := sum + sub
    Sub := sum - sub
    return Sum,Sub
}

7）新的創新，比如：Slice 切片，Defer 延時執行等。

2.Golang 的變數作用域

區域性變數：在函數內部定義的變數，作用域僅限於函數內部（首字母是大寫的也不行）

全域性變數：在函數外部定義的變數，作用域在整個包都有效。

但是當變數在程式碼塊中定義時，比如 if for 中，那麼這個變數的作用域就在該程式碼塊中有效。

還有一個就是：賦值語句是不能定義在函數體外的，如：這種 name := "zhangsan"，我們換成 var name string = "zhangsan" 即可。

3.Golang 執行流程的兩種方式

先編譯，在執行： go build -o Hello.exe test.go（編譯完後可以到處執行，但是編譯後檔案會較大）

直接執行： go run test.go（直接執行，速度相對來說要比先編譯的較慢，需要依賴 Go 環境）

PS：Go 語言定義的變數或者 import 包，如果沒有使用放到，程式碼是不能編譯通過的。

二、Golang 的基本操作

1.在 Linux 上安裝 Golang 語言開發包

1）安裝 Golang 軟體包

[root@localhost ~]# wget https://golang.google.cn/dl/go1.17.3.linux-amd64.tar.gz
[root@localhost ~]# tar xf go1.17.3.linux-amd64.tar.gz -C /usr/local/
[root@localhost ~]# ln -s /usr/local/go/bin/* /usr/bin/
[root@localhost ~]# go version
go version go1.17.3 linux/amd64

2）設定 Golang 的開發環境

[root@localhost ~]# mkdir -p ~/Go-Test/src						# Golang 的原始碼目錄
[root@localhost ~]# mkdir -p ~/Go-Test/pkg						# Golang 編譯後生成的庫檔案
[root@localhost ~]# mkdir -p ~/Go-Test/bin						# Golang 編譯後生成的可執行檔案

[root@localhost ~]# cat <<END >> ~/.bashrc
export GOROOT=/usr/local/go
export GOPATH=~/Go-Test
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
END
[root@localhost ~]# source ~/.bashrc
[root@localhost ~]# go env							# 檢視 Go 的環境變數是否修改檔案中目錄

3）編寫 Go 程式碼進行驗證

[root@localhost ~]# cat <<END > Hello.go
package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}
END
[root@localhost ~]# go run Hello.go
Hello World

2.Golang 變數的基本使用

package main
import "fmt"
func main() {
    var Count int						// 定義一個變數 (宣告變數)
    Count = 188 						// 給定義的變數進行賦值
    fmt.Println("Count:",Count)
}

Golang 變數的三種使用方式：

1）指定變數型別（宣告後若不賦值，則使用預設值）

func main() {
    var Count int						// int 型別的預設值為 0
    fmt.Println(Count)
}

2）根據自行判定變數型別（型別推導：簡單來說就是讓 Go 編譯器進行自主判斷）

func main() {
    var Count = 18.88
    fmt.Printf("Count 的值=%v,Count 的型別=%T",Count,Count)
}

3）直接使用 := 進行賦值（:= 表示宣告並賦值）

func main() {
    name := "zhangsan"
    fmt.Println(name)
}

在區域中的資料值可以在同一型別範圍內不斷變化：

func main() {
    // 當定義多個相同名稱的變數時. Go 便會獲取最後一個變數的變數值
    // 需要注意的是隻能是同型別的 (比如說 int 型別就不能替換成 string)
    var sum = 188
    // PS: 在同一區域中的變數名不能重複宣告. 也就是說在同一區域中的同一個變數名只能宣告一次
    sum = 288
    fmt.Println(sum)
}

Golang 中 + 的使用：

func main() {
    var Sum = 188
    var Sub = 18
    Result := Sum + Sub
    fmt.Println(Result)					// 當變數為整數時. 做的便是加法運算
    1 := "Hello"
    2 := "World"
    3 := 1 + 2
    fmt.Println(3)						// 當變數為字串時. 做的便是拼接操作
}

3.Golang 中整數的型別

型別	有無符號	佔用儲存空間	備註
int	有	32 位系統 4 個位元組，64 位系統 8 個位元組
uint	無	32 位系統 4 個位元組，64 位系統 8 個位元組
rune	有	與 int32 等價	主要用於處理 Unicode 碼
byte	無	與 uint8 等價	主要用於儲存字元

有符號合無符號最大的區別就是，有符號支援負數，而無符號則是隻支援正數。
bit 和 byte 的區別：bit 是計算機中最小的儲存單位，而 byte 則是計算機中的基本儲存單元（1 btye = 8 bit）

Go 語言的字元使用的是 UTF-8 的字元編碼，查詢編碼地址為：查詢編碼地址

在 Go 中，字元的本質是一個整數，直接輸出時，會列印出字元對應的 UTF-8 編碼的碼值。

func main() {
    var str string = "張三"
    fmt.Println("str 對應的 Unicode 碼為:",[]byte(str))			// 需要使用 []byte 來進行轉換
}

4.Golang 基本資料型別的預設值

資料型別	預設值
整形	`0`
浮點型	`0`
字串	`" "`
布林型別	`false`

常見的值型別和參照型別：

值型別：基本資料型別（int float bool string），陣列和結構體（struct）

參照型別：指標、slice 切片、map、channel 管道、interface 介面等等都是參照型別。

值型別和參照型別的使用特點：

值型別：變數直接儲存值，記憶體通常在棧中分配。

參照型別：變數儲存的是一個地址，這個地址對應的空間才是真正儲存的資料（值），記憶體通常在堆上分配。

當沒有任何變數參照這個地址時，這個地址對應的資料空間就成為了一個垃圾，由 GC 來進行回收。

5.基本資料型別轉換為 String 型別

第一種方式：

package main
import "fmt"
func main() {
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var D byte = 'Z'						// byte 只能定義單個字元
    var str string							// 定義一個空的字串
    // Sprintf 用於格式化輸出字串
    str = fmt.Sprintf("%d",A)
    fmt.Printf("str type is %T str=%qn",str,str)
    str = fmt.Sprintf("%f",B)
    fmt.Printf("str type is %T str=%qn",str,str)
    str = fmt.Sprintf("%t",C)
    fmt.Printf("str type is %T str=%qn",str,str)
    str = fmt.Sprintf("%c",D)
    fmt.Printf("str type is %T str=%qn",str,str)
}

第二種方式：

package main
import (
    "fmt"
    // strconv 包用於實現基本資料型別和其字串表示的相互轉換
    "strconv"
)
func main() {
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var str string
    str = strconv.FormatInt(int64(A),10)
    fmt.Printf("str type is %T str=%qn",str,str)
    str = strconv.FormatFloat(B,'f',2,64)			// 'f' 表示格式. 2 表示小數位保留兩位. 64 表示這個小數點是 float64
    fmt.Printf("str type is %T str=%qn",str,str)
    str = strconv.FormatBool(C)
    fmt.Printf("str type is %T str=%qn",str,str)
}

以上就是Go語言特點及基本資料型別使用詳解的詳細內容，更多關於Go語言特點及基本資料型別的資料請關注it145.com其它相關文章！