文章目錄
- 變量定義
- 1. 整數類型
- 2. 浮點類型
- 3. 字符類型
- 4. 布爾類型
- 5. 字符串類型
- 5.1 字符串的本質
- 5.2 常用字符串處理函數(strings包)
- 5.3 修改字符串的方式
- 6. 數據默認值
- 7. 類型轉換
變量定義
代碼如下：
package mainimport "fmt"var i1 = 1000
var i2 intvar(i5 = "hello"i6 = "world"
)func main(){var i intfmt.Println("i = ", i)i = 10fmt.Println("i = ", i)var num = 10.01 fmt.Println("num = ", num)num = 100.01 fmt.Println("num = ", num)Name := "MikeSun"fmt.Println("Name = ", Name)var n1 , n2 , n3 intfmt.Println("n1 = ", n1, "n2 = ", n2, "n3 = ", n3)var n4 , name1 , n5 = 100, "MikeSun", 200fmt.Println("n4 = ", n4, "name1 = ", name1, "n5 = ", n5)n6, name2, n7 := 1000, "joke", 2000fmt.Println("n6 = ", n6, "name2 = ", name2, "n7 = ", n7)fmt.Println("i1 = ", i1, "i2 = ", i2)fmt.Println("i5、i6 = ", i5, i6)
}
1、從main函數上面的全局變量開始分析：
全局變量定義，定義時不聲明類型，只定義數值，自動分配類型：
var i1 = 1000
全局變量定義：
var i2 int
全局變量定義，同時定義多個對象：
var(
i5 = “hello”
i6 = “world”
)
2、再來看main函數中的變量定義方式
定義變量不賦值：
var i int
3、對已定義的變量賦值：
i = 10
4、定義變量，不聲明類型，默認匹配類型：
var num = 10.01
5、定義并且賦值：
Name := “MikeSun”
上面代碼等價于
var Name string
Name = “MikeSun”
6、一次定義多個變量
var n1 , n2 , n3 int
7、一次性定義多個變量并且賦值
var n4 , name1 , n5 = 100, “MikeSun”, 200
8、一次性定義多個變量并且賦值
n6, name2, n7 := 1000, “joke”, 2000
1. 整數類型
| 類型 | 位數 | 取值范圍 | 說明 |
|---|---|---|---|
| int | 32/64 | -231 到 231-1（32位）或 -2?3 到 2?3-1（64位） | 平臺相關，32位或64位取決于系統 |
| int8 | 8 | -128 到 127 | 8位有符號整數 |
| int16 | 16 | -32,768 到 32,767 | 16位有符號整數 |
| int32 | 32 | -2,147,483,648 到 2,147,483,647 | 32位有符號整數（同 rune） |
| int64 | 64 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 32位有符號整數 |
| int | 32/64 | 0 到 232-1（32位）或 0 到 2??-1（64位） | 平臺相關，32位或64位取決于系統 |
| uint8 | 8 | -128 到 127 | 8位無符號整數（同byte） |
| uint16 | 16 | -32,768 到 32,767 | 16位無符號整數 |
| uint32 | 32 | -2,147,483,648 到 2,147,483,647 | 32位無符號整數 |
| uint64 | 64 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 32位無符號整數 |
| byte | 8 | -128 到 127 | uint8 的別名，用于字節數據 |
| rune | 32 | -2,147,483,648 到 2,147,483,647 | int32 的別名，表示 Unicode 碼點 |
2. 浮點類型
| 類型 | 位數 | 取值范圍（近似） | 精度 | 說明 |
|---|---|---|---|---|
| float32 | 32 | ±1.18e?3? 到 ±3.4e3? | 6-7位小數 | 單精度浮點數，占用4字節 |
| float64 | 64 | ±2.23e?3?? 到 ±1.8e3?? | 15-16位小數 | 雙精度浮點數，占用8字節 |
| 代碼示例如下： | ||||
| 下面代碼有介紹科學計數法、省略整數部分寫法。 |
package main
import ("fmt""reflect"
)func main(){var price float32 = 89.12fmt.Println("price = ", price)var num1 float32 = -0.00089var num2 float64 = -7809656.09fmt.Println("num1 = ", num1, "num2 = ", num2)//尾部部分精度丟失，造成精度損失var num3 float32 = -123.0000901var num4 float64 = -123.0000901fmt.Println("num3 = ", num3, "num4 = ", num4)//Golang的浮點類型默認聲明為float64 類型var num5 = 1.1fmt.Println("typeof num5 is ", reflect.TypeOf(num5))//十進制數形式：如：5.12 .512（必須有小數點）num6 := 5.12num7 := .123fmt.Println("num6 = ", num6, "num7 = ", num7)//科學計數法num8 := 5.1234e2num9 := 5.1234E2num10 := 5.1234E-2fmt.Println("num8 = ", num8, "num9 = ", num9, "num10 = ", num10)
}
3. 字符類型
Go語言統一使用Unicode編碼。
字符類型的本質就是一個整數型，一個整數對應Unicode中的一個字符，從而可以使用特地的輸出格式輸出，如%c。
Unicode編碼是包含ASCII碼的，所以前面的256個字符仍然可以當作ASCII碼來輸出或轉換。
package mainimport ("fmt"
)func main(){var c1 byte = 'a'var c2 byte = '0'fmt.Println("c1 = ", c1)fmt.Println("c2 = ", c2)// 要輸出ASCII值必須要格式化輸出fmt.Printf("c1 = %c c2 = %c", c1, c2)var c3 int = '孫'fmt.Printf("c3 = %c c3 = %d", c3, c3)var c4 int = 22269fmt.Printf("\nc4 = %c", c4)var c5 int = 65fmt.Printf("\nc5 = %c", c5)
}運行結果：
c1 = 97
c2 = 48
c1 = a c2 = 0c3 = 孫 c3 = 23385
c4 = 國
c5 = A
4. 布爾類型
代碼示例如下：
package main
import ("fmt""unsafe"
)func main(){var bflag = falsefmt.Println("bflag = ", bflag)//注意事項//1.bool類型占用存儲空間是1個字節fmt.Println("bflag 的占用空間 = ", unsafe.Sizeof(bflag))//2.bool類型只能取true或者false
}運行結果：
bflag = false
bflag 的占用空間 = 1
注意：
1、bool類型不能參加±運算，可以參加邏輯運算。
| 運算符 | 說明 | 示例 |
|---|---|---|
| && | 邏輯與（AND） | true && false → false |
| || | 邏輯或（OR） | true |
| ! | 邏輯非（NOT） | !true → false |
| 錯誤示例： |
b := true
// fmt.Println(b + 1) // 錯誤：bool 不能參與數學運算
2、Go 是強類型語言，其他類型不能隱式轉為 bool
// 錯誤示例
i := 1
if i { // 編譯錯誤：non-bool i (type int) used as if conditionfmt.Println("True")
}
3、必須顯式比較
b := true
// fmt.Println(b + 1) // 錯誤：bool 不能參與數學運算
5. 字符串類型
5.1 字符串的本質
1、底層結構：Go 的字符串是一個 只讀的字節切片（[]byte），存儲的是 UTF-8 編碼的 Unicode 字符。
2、不可變性：字符串一旦創建，內容不可修改（若需修改需轉為 []byte 或 []rune）。
代碼示例如下：
package mainimport ("fmt""reflect"
)//演示golang中string 的類型使用
func main(){var str1 = "北京歡迎您"fmt.Println("1、", str1)fmt.Println("sizeof(strl) is", len(str1))fmt.Println("typeof(strl) is", reflect.TypeOf(str1))// 字符串拼接方式str1 += "為您開天辟地"fmt.Println("2、", str1)// 字符串拼接需要換行的時候，需要將操作符，例如+，保留在上面一行否則報錯str1 += "hello" + "world" +"666"fmt.Println("3、", str1)// 反引號引用無需轉義，原樣輸出str1 = `var str1 = "北京歡迎您"fmt.Println("1、", str1)fmt.Println("sizeof(strl) is", len(str1))fmt.Println("typeof(strl) is", reflect.TypeOf(str1))`fmt.Println("4、", str1)// str1[0] = 'A'
}運行結果：
1、 北京歡迎您
sizeof(strl) is 15
typeof(strl) is string
2、 北京歡迎您為您開天辟地
3、 北京歡迎您為您開天辟地helloworld666
4、var str1 = "北京歡迎您"fmt.Println("1、", str1)fmt.Println("sizeof(strl) is", len(str1))fmt.Println("typeof(strl) is", reflect.TypeOf(str1))
5.2 常用字符串處理函數(strings包)
| 函數 | 說明 | 示例 |
|---|---|---|
| strings.Contains(s, substr) | 檢查是否包含子串 | Contains(“Hello”, “ell”) → true |
| strings.HasPrefix(s, prefix) | 檢查是否以某前綴開頭 | HasPrefix(“Go”, “G”) → true |
| strings.HasSuffix(s, suffix) | 檢查是否以某后綴結尾 | HasSuffix(“World”, “ld”) → true |
| strings.Split(s, sep) | 按分隔符拆分字符串 | Split(“a,b,c”, “,”) → [“a”,“b”,“c”] |
| strings.Join(slice, sep) | 將字符串切片連接 | Join([]string{“a”,“b”}, “-”) → “a-b” |
| strings.ToUpper(s) | 轉為大寫 | ToUpper(“go”) → “GO” |
| strings.ToLower(s) | 轉為小寫 | ToLower(“GO”) → “go” |
| strings.TrimSpace(s) | 去除首尾空白字符 | TrimSpace(" Hi ") → “Hi” |
5.3 修改字符串的方式
若需頻繁操作字節/字符，可先轉為 []byte 或 []rune：
s := "Hello"
bytes := []byte(s)
bytes[0] = 'h' // 修改后轉回字符串
s = string(bytes) // "hello"
6. 數據默認值
Go語言數據默認值均為0（字符串空，nil，false均為0的別名）。
| 類型 | 默認值（零值） | 說明 |
|---|---|---|
| 整數類型 | 0 | 包括 int, int8, int16, int32, int64, uint, uint8 等。 |
| 浮點類型 | 0.0 | 包括 float32, float64。 |
| 布爾類型 | false | bool 類型的零值。 |
| 字符串類型 | “” | （空字符串） |
| 指針類型 | nil | 所有指針（如 *int, *string）的零值。 |
| 引用類型 | nil | 包括 slice（切片）、map（映射）、channel（通道）、func（函數）。 |
| 結構體類型 | 所有字段的零值 | 結構體的每個字段會遞歸初始化為其類型的零值。 |
| 數組類型 | 所有元素為對應零值 | 如 var arr [3]int 的零值是 [0, 0, 0]。 |
| 接口類型 | nil | 接口變量在未賦值時的零值。 |
| 錯誤類型 | nil | error 類型的零值。 |
| 代碼示例： |
package mainimport ("fmt"
)func main(){var a int // 0var b float32 // 0var c float64 // 0var d bool // flasevar name string // ""//%v 表示按照變量的值輸出fmt.Printf("a = %v, b = %v, c = %v, d = %v, name = %v", a, b, c, d, name)
}運行結果：
a = 0, b = 0, c = 0, d = false, name =
7. 類型轉換
Go語言在不同類型的變量之間賦值時需要顯示轉換。也就是說Go語言數據類型不會自動轉換。
1、強制類型轉換既可以從小范圍數據類型轉換到大范圍數據類型(上行轉換)、也可以從大范圍數據類型轉換到小范圍數據類型(下行轉換)
2、被轉換的是變量存儲的數據(數值),變量本身的數據類型并沒有發生改變
3、在轉換中，可能出現意想不到的結果，特別是下行轉換的時候。
示例代碼如下：
從代碼很容易看出轉換語法：type(var)，這里需要注意，和C語言不同，C語言是(type)var。
當轉換溢出時，數據會錯誤。
如int64的變量轉換為int8，則需要取余256.（網上某個培訓班網課說無法計算，實際是可計算的，數據溢出之后從0開始，是一個循環）
package mainimport ("fmt"
)func main(){var i int32 = 100var n1 float32 = float32(i)var n2 int8 = int8(i)var n3 int64 = int64(i)fmt.Printf("i = %v n1 = %v n2 = %v n3 = %v", i, n1, n2, n3)// 被轉換的是變量的數據，而不是變量的類型fmt.Printf("i type is %T", i)var num1 int64 = 999999var num2 int8 = int8(num1)fmt.Println("num2 = ", num2)num1 = 257num2 = int8(num1)fmt.Println("num2 = ", num2)
}
