案例：
Golang 變量使用的三種方式
-
第一種：指定變量類型，聲明后若不賦值，使用默認(rèn)值
- Golang 的變量如果沒有賦初值，編譯器會使用默認(rèn)值
- 比如 int 默認(rèn)值 0, string 默認(rèn)值為空串, 小數(shù)默認(rèn)為 0
-
第二種：根據(jù)值自行判定變量類型(類型推導(dǎo)) , 不使用默認(rèn)值
-
第三種：省略 var
- 注意 :=左側(cè)的變量不應(yīng)該是已經(jīng)聲明過的，否則會導(dǎo)致編譯錯誤
- 注意 :=左側(cè)的變量不應(yīng)該是已經(jīng)聲明過的，否則會導(dǎo)致編譯錯誤
-
第四種: 多變量聲明
- 在編程中，有時我們需要一次性聲明多個變量，Golang 也提供這樣的語法
- 在編程中，有時我們需要一次性聲明多個變量，Golang 也提供這樣的語法
變量的聲明，初始化和賦值
程序中 + 號的使用
package main
import "fmt"
//演示golang中+的使用
func main() {
var i = 1
var j = 2
var r = i + j //做加法運算
fmt.Println("r=", r)
var str1 = "hello "
var str2 = "world"
var res = str1 + str2 //做拼接操作
fmt.Println("res=", res)
}
- 當(dāng)左右兩邊都是數(shù)值型時，則做加法運算
- 當(dāng)左右兩邊都是字符串，則做字符串拼接
- 不可以一個是字符, 一個是其他類型
- 不可以一個是字符, 一個是其他類型
數(shù)據(jù)類型的基本介紹
整數(shù)類型
- 簡單的說，就是用于存放整數(shù)值的，比如 0, -1, 2345 等等。
int 的無符號的類型：
int 的其它類型的說明:
整型的使用細(xì)節(jié)
-
Golang 各整數(shù)類型分：有符號和無符號，int uint 的大小和系統(tǒng)有關(guān)。
-
Golang 的整型默認(rèn)聲明為 int 型
-
如何在程序查看某個變量的字節(jié)大小和數(shù)據(jù)類型 （使用較多）
-
Golang 程序中整型變量在使用時，遵守保小不保大的原則
- 即：在保證程序正確運行下，盡量使用占用空間小的數(shù)據(jù)類型。
- 即：在保證程序正確運行下，盡量使用占用空間小的數(shù)據(jù)類型。
-
bit: 計算機中的最小存儲單位。
-
byte:計算機中基本存儲單元。
- [二進(jìn)制再詳細(xì)說] 1byte = 8 bit
小數(shù)類型/浮點型
- 小數(shù)類型就是用于存放小數(shù)的，比如 1.2 0.23 -1.911
小數(shù)類型分類
對上圖的說明:
- 關(guān)于浮點數(shù)在機器中存放形式的簡單說明,浮點數(shù)=符號位+指數(shù)位+尾數(shù)位
- 說明：浮點數(shù)都是有符號的
var price float32 = 89.12
fmt.Println("price=", price)
var num1 float32 = -0.00089
var num2 float64 = -7809656.09
fmt.Println("num1=", num1, "num2=", num2)
- 尾數(shù)部分可能丟失，造成精度損失。 -123.0000901
//尾數(shù)部分可能丟失，造成精度損失。 -123.0000901
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3=", num3, "num4=", num4)
說明：float64 的精度比 float32 的要準(zhǔn)確.
說明：如果我們要保存一個精度高的數(shù)，則應(yīng)該選用 float64
- 浮點型的存儲分為三部分：符號位+指數(shù)位+尾數(shù)位 在存儲過程中，精度會有丟失
- 一般出現(xiàn)在尾數(shù)也就是小數(shù)的時候丟失精度
浮點型使用細(xì)節(jié)
- Golang 浮點類型有固定的范圍和字段長度，不受具體 OS(操作系統(tǒng))的影響。
- Golang 的浮點型默認(rèn)聲明為 float64 類型。
- 也就是最大的范圍
//Golang 的浮點型默認(rèn)聲明為float64 類型
var num5 = 1.1
fmt.Printf("num5的數(shù)據(jù)類型是 %T \n", num5)
- 浮點型常量有兩種表示形式
- 十進(jìn)制數(shù)形式：如：5.12 .512 (必須有小數(shù)點）
- 科學(xué)計數(shù)法形式:如：
- 5.1234e2 = 5.12 * 10 的 2 次方
- 5.12E-2 = 5.12/10 的 2 次方
//十進(jìn)制數(shù)形式：如：5.12 .512 (必須有小數(shù)點）
num6 := 5.12
num7 := .123 //=> 0.123
fmt.Println("num6=", num6, "num7=", num7)
//科學(xué)計數(shù)法形式
num8 := 5.1234e2 // ? 5.1234 * 10的2次方
num9 := 5.1234E2 // ? 5.1234 * 10的2次方 shift+alt+向下的箭頭
num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)
- 通常情況下，應(yīng)該使用 float64 ，因為它比 float32 更精確。
- [開發(fā)中，推薦使用 float64]
字符類型
- Golang 中沒有專門的字符類型，如果要存儲單個字符(字母)，一般使用 byte 來保存。
- 字符串就是一串固定長度的字符連接起來的字符序列。
- Go 的字符串是由單個字節(jié)連接起來的。
- 也就是說對于傳統(tǒng)的字符串是由字符組成的，而 Go 的字符串不同，它是由字節(jié)組成的。
- 也就是我們不能用正常的方式打印字符串, 正常的方式打印的字符串是碼值
- 也就是我們不能用正常的方式打印字符串, 正常的方式打印的字符串是碼值
var c1 int = '北'
fmt.Println("c1=", c1, unsafe.Sizeof(c1))
var c1 = '北'
fmt.Printf("c1=%c", c1)
對上面代碼說明
- 如果我們保存的字符在 ASCII 表的,比如[0-1, a-z,A-Z…]直接可以保存到 byte
- 如果我們保存的字符對應(yīng)碼值大于 255,這時我們可以考慮使用 int 類型保存
- 如果我們需要按照字符的方式輸出，這時我們需要格式化輸出
- 即 fmt.Printf(“%c”, c1)
字符類型使用細(xì)節(jié)
- 字符常量是用單引號(‘’)括起來的單個字符。
- 例如：var c1 byte = ‘a(chǎn)’
- var c2 int = ‘中’ var c3 byte = ‘9’ 2)
- Go 中允許使用轉(zhuǎn)義字符 '\’來將其后的字符轉(zhuǎn)變?yōu)樘厥庾址统Ａ俊?/li>
- 例如：var c3 char = ‘\n’ // '\n’表示換行符
- Go 語 言 的 字 符 使 用 UTF-8 編碼，如果想查詢字符對應(yīng)的utf8 碼值
- http://www.mytju.com/classcode/tools/encode_utf8.asp
- 英文字母-1 個字節(jié) 漢字-3 個字節(jié)
- 在 Go 中，字符的本質(zhì)是一個整數(shù)，直接輸出時，是該字符對應(yīng)的 UTF-8 編碼的碼值。
- 可以直接給某個變量賦一個數(shù)字，然后按格式化輸出時%c，會輸出該數(shù)字對應(yīng)的 unicode 字符
var c1 = 22269
fmt.Printf("c1=%c", c1)
- 字符類型是可以進(jìn)行運算的，相當(dāng)于一個整數(shù)，因為它都對應(yīng)有 Unicode 碼
- 注意是單引號的
- 注意是單引號的
字符類型本質(zhì)探討
- 字符型 存儲到 計算機中，需要將字符對應(yīng)的碼值（整數(shù)）找出來
- 存儲：字符—>對應(yīng)碼值---->二進(jìn)制–>存儲
- 讀?。憾M(jìn)制----> 碼值 ----> 字符 --> 讀取
- 字符和碼值的對應(yīng)關(guān)系是通過字符編碼表決定的(是規(guī)定好)
- Go 語言的編碼都統(tǒng)一成了utf-8。非常的方便很統(tǒng)一，再也沒有編碼亂碼的困擾了
布爾類型
- 布爾類型也叫 bool 類型，bool 類型數(shù)據(jù)只允許取值 true 和 false
- bool 類型占 1 個字節(jié)。
- bool 類型適于邏輯運算，一般用于程序流程控制
//演示golang中bool類型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事項
//1. bool類型占用存儲空間是1個字節(jié)
fmt.Println("b 的占用空間 =", unsafe.Sizeof(b) )
//2. bool類型只能取true或者false
}
string 類型
- 字符串就是一串固定長度的字符連接起來的字符序列。
- Go 的字符串是由單個字節(jié)連接起來的。
- Go 語言的字符串的字節(jié)使用 UTF-8 編碼標(biāo)識 Unicode 文本
//string的基本使用
var address string = "北京長城 110 hello world!"
fmt.Println(address)
string 使用注意事項和細(xì)節(jié)
- Go 語言的字符串的字節(jié)使用 UTF-8 編碼標(biāo)識 Unicode 文本
- 這樣 Golang 統(tǒng)一使用 UTF-8 編碼,中文亂碼問題不會再困擾程序員。
- 字符串一旦賦值了，字符串就不能修改了：在 Go 中字符串是不可變的。
//字符串一旦賦值了，字符串就不能修改了：在Go中字符串是不可變的
var str = “hello”
str[0] = ‘a(chǎn)’ //這里就不能去修改str的內(nèi)容，即go中的字符串是不可變的。
字符串的兩種表示形式
- 雙引號, 會識別轉(zhuǎn)義字符
//輸出源代碼等效果 【案例演示】
str2 := "abc\nabc"
fmt.Println(str2)
- 反引號，以字符串的原生形式輸出，包括換行和特殊字符，可以實現(xiàn)防止攻擊、輸出源代碼等效果
//使用的反引號 ``
str3 := `
package main
import (
"fmt"
"unsafe"
)
//演示golang中bool類型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事項
//1. bool類型占用存儲空間是1個字節(jié)
fmt.Println("b 的占用空間 =", unsafe.Sizeof(b) )
//2. bool類型只能取true或者false
}
`
fmt.Println(str3)
- 字符串拼接方式
//字符串拼接方式
var str = "hello " + "world"
str += " haha!"
fmt.Println(str)
- 當(dāng)一行字符串太長時，需要使用到多行字符串，可以如下處理
//當(dāng)一個拼接的操作很長時，可以分行寫,但是注意，需要將+保留在上一行
str4 := "hello " + "world" + "hello " + "world" + "hello " +
"world" + "hello " + "world" + "hello " + "world" +
"hello " + "world"
fmt.Println(str4)
基本數(shù)據(jù)類型的默認(rèn)值
在 go 中，數(shù)據(jù)類型都有一個默認(rèn)值，當(dāng)程序員沒有賦值時，就會保留默認(rèn)值，在 go 中，默認(rèn)值 又叫零值。
var a int // 0
var b float32 // 0
var c float64 // 0
var isMarried bool // false
var name string // ""
//這里的%v 表示按照變量的值輸出
fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v", a, b, c, isMarried, name)
基本數(shù)據(jù)類型的相互轉(zhuǎn)換
Golang 和 java / c 不同，Go 在不同類型的變量之間賦值時需要顯式轉(zhuǎn)換。也就是說 Golang 中數(shù) 據(jù)類型不能自動轉(zhuǎn)換。
基本語法
- 表達(dá)式 T(v) 將值 v 轉(zhuǎn)換為類型 T
- T: 就是數(shù)據(jù)類型，比如 int32，int64，float32 等等
- v: 就是需要轉(zhuǎn)換的變量
var i int32 = 100
//希望將 i => float
var n1 float32 = float32(i)
var n2 int8 = int8(i)
var n3 int64 = int64(i) //低精度->高精度
fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i ,n1, n2, n3)
基本數(shù)據(jù)類型相互轉(zhuǎn)換的注意事項
- Go 中，數(shù)據(jù)類型的轉(zhuǎn)換可以是從 表示范圍小–>表示范圍大，也可以 范圍大—>范圍小
- 被轉(zhuǎn)換的是變量存儲的數(shù)據(jù)(即值)，變量本身的數(shù)據(jù)類型并沒有變化！
var i int32 = 100
//被轉(zhuǎn)換的是變量存儲的數(shù)據(jù)(即值)，變量本身的數(shù)據(jù)類型并沒有變化
fmt.Printf("i type is %T\n", i) // int32
- 在轉(zhuǎn)換中，比如將 int64 轉(zhuǎn)成 int8 【-128—127】 ，編譯時不會報錯，只是轉(zhuǎn)換的結(jié)果是按 溢出處理，和我們希望的結(jié)果不一樣。
- 因此在轉(zhuǎn)換時，需要考慮范圍
//在轉(zhuǎn)換中，比如將 int64 轉(zhuǎn)成 int8 【-128---127】 ，編譯時不會報錯，
//只是轉(zhuǎn)換的結(jié)果是按溢出處理，和我們希望的結(jié)果不一樣
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2=", num2)
數(shù)據(jù)類型和 string 的轉(zhuǎn)換
- 方式 1：fmt.Sprintf(“%參數(shù)”, 表達(dá)式)
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
var myChar byte = 'h'
var str string //空的str
//使用第一種方式來轉(zhuǎn)換 fmt.Sprintf方法
str = fmt.Sprintf("%d", num1)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%t", b)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T str=%q\n", str, str)
- 方式 2：使用 strconv 包的函數(shù)
var num3 int = 99
var num4 float64 = 23.456
var b2 bool = true
str = strconv.FormatInt(int64(num3), 10)
fmt.Printf("str type %T str=%q\n", str, str)
// strconv.FormatFloat(num4, 'f', 10, 64)
// 說明： 'f' 格式 10：表示小數(shù)位保留10位 64 :表示這個小數(shù)是float64
str = strconv.FormatFloat(num4, 'f', 10, 64)
fmt.Printf("str type %T str=%q\n", str, str)
str = strconv.FormatBool(b2)
fmt.Printf("str type %T str=%q\n", str, str)
//strconv包中有一個函數(shù)Itoa
var num5 int64 = 4567
str = strconv.Itoa(int(num5))
fmt.Printf("str type %T str=%q\n", str, str)
string 類型轉(zhuǎn)基本數(shù)據(jù)類型
- 使用時 strconv 包的函數(shù)
var str string = "true"
var b bool
b, _ = strconv.ParseBool(str)
fmt.Printf("b type %T b=%v\n", b, b)
var str2 string = "1234590"
var n1 int64
var n2 int
n1, _ = strconv.ParseInt(str2, 10, 64)
n2 = int(n1)
fmt.Printf("n1 type %T n1=%v\n", n1, n1)
fmt.Printf("n2 type %T n2=%v\n", n2, n2)
var str3 string = "123.456"
var f1 float64
f1, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("f1 type %T f1=%v\n", f1, f1)
string 轉(zhuǎn)基本數(shù)據(jù)類型的注意事項
- 在將 String 類型轉(zhuǎn)成 基本數(shù)據(jù)類型時，要確保 String 類型能夠轉(zhuǎn)成有效的數(shù)據(jù)
- 比如 我們可以 把 “123” , 轉(zhuǎn)成一個整數(shù)，但是不能把 “hello” 轉(zhuǎn)成一個整數(shù)，
- 如果這樣做，Golang 直接將其轉(zhuǎn)成 0
- 其它類型也是一樣的道理. float => 0 bool => false
//注意：
var str4 string = "hello"
var n3 int64 = 11
n3, _ = strconv.ParseInt(str4, 10, 64)
fmt.Printf("n3 type %T n3=%v\n", n3, n3)
指針
-
基本數(shù)據(jù)類型，變量存的就是值，也叫值類型
-
獲取變量的地址，用&
- 比如： var num int, 獲取 num 的地址：&num
- 比如： var num int, 獲取 num 的地址：&num
-
指針類型，指針變量存的是一個地址，這個地址指向的空間存的才是值
- 比如：var ptr *int = &num
- 比如：var ptr *int = &num
//基本數(shù)據(jù)類型在內(nèi)存布局
var i int = 20
// i 的地址是什么,&i
fmt.Println("i的地址=", &i)
//下面的 var ptr *int = &i
//1. ptr 是一個指針變量
//2. ptr 的類型 *int
//3. ptr 本身的值&i
var ptr *int = &i
fmt.Printf("ptr=%v\n", ptr)
fmt.Printf("ptr 的地址=%v", &ptr)
fmt.Printf("ptr 指向的值=%v", *ptr)
-
獲取指針類型所指向的值，使用：*，比如：var ptr int, 使用ptr 獲取 ptr 指向的值
- fmt.Printf(“ptr 指向的值=%v”, *ptr)
- fmt.Printf(“ptr 指向的值=%v”, *ptr)
-
寫一個程序，獲取一個 int 變量 num 的地址，并顯示到終端
-
將 num 的地址賦給指針 ptr , 并通過 ptr 去修改 num 的值
指針的使用細(xì)節(jié)
- 值類型，都有對應(yīng)的指針類型， 形式為 *數(shù)據(jù)類型
- 比如 int 的對應(yīng)的指針就是 *int, float32 對應(yīng)的指針類型就是 *float32
- 值類型包括：基本數(shù)據(jù)類型 int 系列, float 系列, bool, string 、數(shù)組和結(jié)構(gòu)體 struct
值類型和引用類型
-
值類型：基本數(shù)據(jù)類型 int 系列, float 系列, bool, string 、數(shù)組和結(jié)構(gòu)體 struct
-
引用類型：指針、slice 切片、map、管道 channel、interface 等都是引用類型
值類型和引用類型的使用特點 -
值類型：變量直接存儲值，內(nèi)存通常在棧中分配
-
引用類型：變量存儲的是一個地址，這個地址對應(yīng)的空間才真正存儲數(shù)據(jù)(值)
-
內(nèi)存通常在堆上分配，當(dāng)沒有任何變量引用這個地址時，該地址對應(yīng)的數(shù)據(jù)空間就成為一個垃圾，由 GC 來回收
文章來源：http://www.zghlxwxcb.cn/news/detail-501599.html -
內(nèi)存的棧區(qū)和堆區(qū)示意圖
文章來源地址http://www.zghlxwxcb.cn/news/detail-501599.html
到了這里，關(guān)于Golang -＞ Golang 變量的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
