Go語言特點及基本數據類型怎么使用

這篇文章主要介紹“Go語言特點及基本數據類型怎么使用”，在日常操作中，相信很多人在Go語言特點及基本數據類型怎么使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Go語言特點及基本數據類型怎么使用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

一、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 中整數的類型

• 有符號合無符號最大的區別就是，有符號支持負數，而無符號則是只支持正數。

• 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 基本數據類型的默認值

常見的值類型和引用類型：

值類型： 基本數據類型（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=%q\n",str,str)
    str = fmt.Sprintf("%f",B)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = fmt.Sprintf("%t",C)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = fmt.Sprintf("%c",D)
    fmt.Printf("str type is %T str=%q\n",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=%q\n",str,str)
    str = strconv.FormatFloat(B,'f',2,64)			// 'f' 表示格式. 2 表示小數位保留兩位. 64 表示這個小數點是 float64
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = strconv.FormatBool(C)
    fmt.Printf("str type is %T str=%q\n",str,str)
}

到此，關于“Go語言特點及基本數據類型怎么使用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！