Golang學習筆記（二）：類型、變量、常量
基本類型
1.基本類型列表
類型 長度 說明
bool 1 true/false,默認false, 不能把非0值當做true(不用數(shù)字代表true/false)
byte 1 uint8 別名
rune 4 int32別名。 代表一個unicode code point
int/unit 一來所運行的平臺，32bit/64bit
int8/uint8 1 -128 ~ 127; 0 ~ 255
int16/uint16 2 -32768 ~ 32767; 0 ~ 65535
int32/uint32 4 -21億 ~ 21億， 0 ~ 42億
int64/uint64 8
float32 4 精確到7位小數(shù),相當于c的float
float64 8 精確到15位小數(shù),相當于c的double
complex64 8
complex128 16
uintptr 足夠保存指針的32位、64位整數(shù),指針(可以存指針的整數(shù)型)
array 值類型,數(shù)組
struct 值類型,結構體
string 值類型,字符串類型，常用
slice 引用類型,切片
map 引用類型,字典
channel 引用類型,通道
interface 接口類型,接口
function 函數(shù)類型,函數(shù)
2.類型轉換
不支持隱式類型轉換，必須進行顯式類型轉換
轉換只發(fā)生在兩種互相兼容的類型之間: 各類int不允許相互賦值或操作，不然會在編譯時報錯
<type>(expression)
示例
package main
import "fmt"
func main(){
a := 0x1234
b := 1234.56
c := 256
fmt.Printf("%x\n", uint8(a))
fmt.Printf("%d\n", int(b))
fmt.Printf("%f\n", float64(c))
}
結果
34
1234
256.000000
3.類型別名
type t_str string
var b t_str = "a str"
4.類型默認值
聲明不賦值，類型零值，非空值,而是聲明后的默認值
bool: false
integers: 0
floats: 0.0
string: ""
pointers,functions,interfaces,slices,channels,maps: nil
保留字
break case chan const continue
default defer else fallthrough for
func go goto if import
interface map package range return
select struct switch type var
變量
1.變量聲明
//第一種，指定變量類型，聲明后若不賦值，使用默認值
var v_name v_type
v_name = value
//第二種，根據(jù)值自行判定變量類型
var v_name = value
//第三種，省略var, 注意 :=左側的變量不應該是已經聲明過的，否則會導致編譯錯誤.
v_name := value
e.g.
var a int = 10
var b = 10
c : = 10
示例：
package main
var a = 1234
var b string = "hello"
var c bool
func main(){
println(a, b, c)
}
結果：
1234 hello false
2.多變量聲明：
//類型相同多個變量, 非全局變量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要顯示聲明類型，自動推斷
vname1, vname2, vname3 := v1, v2, v3 //出現(xiàn)在:=左側的變量不應該是已經被聲明過的，否則會導致編譯錯誤
//類型不同多個變量, 全局變量, 局部變量不能使用這種方式
var (
vname1 v_type1
vname2 v_type2
)
示例：
package main
var x, y int
var ( //這種只能出現(xiàn)在全局變量中，函數(shù)體內不支持
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//這種不帶聲明格式的只能在函數(shù)體中出現(xiàn)
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
結果：
0 0 0 false 1 2 123 hello 123 hello
注意：
A.多變量賦值時，將先行計算所有左側變量的值，再進行賦值
i := 0
i, l[i] = 1, 2
//get i = 1， l[0] = 2
sc[0], sc[0] = 1, 2
//get sc[0] = 2
B.垃圾桶_
func test()(int, string) {
return 123, "abc"
}
a, _ := test()
C.已聲明但是沒有使用的變量會在編譯階段報錯，較Python 更為嚴格
常量
常量可以是字符，字符串，布爾或數(shù)字
常量賦值是編譯期的行為
1.常量聲明
在編譯階段就能確定下來的值,在運行時無法改變該值
常量可以定義為數(shù)值、布爾值或字符串等類型
const constantName = value
const Pi float32 = 3.1415926
const c_name [type] = value
const c_name1, c_name2 = value1, value2
const (
c_name1 = vluae1
c_name2 = value2
)
=右側，必須為常量或常量表達式，如果使用到了函數(shù)，必須為內置函數(shù)（編譯期行為）
const i = 10000
說明：
A.常量必須是編譯期能確定的Number(char/integer/float/complex)、String和bool
B.在定義常量數(shù)組時，如果不提供初始化值，則表示與上行常量類型，值，完全相同
const (
a = "abc"
b
)
//則 b = "abc"
C.常量可以用len(), cap(), unsafe.Sizeof()常量計算表達式的值. 常量表達式中，函數(shù)必須是內置函數(shù)，否則編譯不過
package main
import "unsafe"
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main(){
println(a, b, c)
}
結果： abc 3 16
枚舉
iota，特殊常量，可以認為是一個可以被編譯器修改的常量
在每一個const關鍵字出現(xiàn)時，被重置為0，然后再下一個const出現(xiàn)之前，每出現(xiàn)一次iota，其所代表的數(shù)字會自動增加1
不提供初始值，則表示使用上一行的表達式
1.聲明：
iota生成從0開始的自動增長枚舉值，意味著，多一個枚舉值，iota+=1，無論是否使用
基本語法
const (
a = 1
b = 2
)
const (
a = iota //0
b //1
c //2
)
const (
_ = iota
a //1
b //2
)
iota用法
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //獨立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢復計數(shù)
i //8
)
}
const (
x = iota // 0
y = iota // 1
z = iota // 2
w //省略，默認和前面一樣字面值 w = iota, 即3
)
const v = iota //遇到const關鍵字，iota重置
注意: 每行的變量數(shù)必須一致 const ( A, B = iota, iota C, D E, F )
func main() {
println(A,B,C,D,E,F)
}
//結果： 0 0 1 1 2 2 【各自增長】
運算符
Go運算符全部是從左到右結合的
不支持運算符重載
優(yōu)先級 運算符 說明
高 * / % << >> & &^(AND NOT)
+ - ! ^
== != < <= > >=
<- channel運算符
&&
低 ||
在go中，++ --為語句，而非表達式
package main
func main(){
i := 1
i ++
println(i)
b := i
println(b)
//syntax error: unexpected ++, expecting semicolon or newline or }
//c := i++
//意味著, ++/--不能出現(xiàn)在等號右側
}
指針
Go保留了指針， *T表示T對應的指針類型
如果包含包名， 則應該是 *.T
代表指針類型的符號 '*' 總是和類型放在一起，而不是緊挨著變量名
同樣支持指針的指針**T
1.聲明
var a, b *int
2.說明
操作符&取變量地址，用*透過指針變量間接訪問目標對象
默認值是nil,沒有NULL常量
不支持指針運算，不支持‘->'預算福，直接'.'選擇符操作指針目標對象成員
可以在unsafe.Pointer和任意類型指針間進行轉換
可以將unsafe.Pointer轉換為uintptr,然后變相做指針運算，uintptr可以轉換為整數(shù)
3.示例
package main
import "fmt"
type User struct {
Id int
Name string
}
func main(){
i := 100
var p *int = &i //取地址
println(*p) //取值
up := &User{1, "Jack"}
up.Id = 100 //直接取只針對想成員
fmt.Println(up)
u2 := *up //拷貝對象
u2.Name = "Tom"
fmt.Println(up, u2)
}
4.結果：
100
&{100 Jack}
&{100 Jack} {100 Tom}
分組聲明
import (
"fmt"
"os"
)
const (
i = 100 //首行必須有常量表達式
pi = 3.1415
)
var ( //全局變量可用，函數(shù)體內不支持
i int
pi float32
)
相關文章
這篇文章主要為大家詳細介紹了Go語言實現(xiàn)遍歷文件夾的相關方法，文中的示例代碼講解詳細，具有一定的參考價值，感興趣的小伙伴可以了解一下2023-05-05
這篇文章主要介紹了go語言channel實現(xiàn)多核并行化運行的方法,實例分析了channel實現(xiàn)多核并行化運行的技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-03-03
這篇文章主要介紹了go語言base64用法,實例分析了Go語言base64編碼的實用技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-02-02
這篇文章主要介紹了總結Golang四種不同的參數(shù)配置方式，文章圍繞主題展開詳細的內容戒殺，具有一定的參考價值，需要的小伙伴可以參考一下2022-09-09
關于golang?struct?中的?slice?無法原子賦值的問題
這篇文章主要介紹了為什么?golang?struct?中的?slice?無法原子賦值的問題，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2024-01-01
這篇文章主要介紹了go語言-在mac下brew升級golang，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-04-04
這篇文章主要介紹了快速掌握Go語言正/反向代理的相關資料,需要的朋友可以參考下2022-11-11
這篇文章主要介紹了golang為什么要統(tǒng)一錯誤處理，統(tǒng)一錯誤處理的目的是為了前端開發(fā)接收到后端的statuscode,之后便于前端邏輯上開發(fā)以及開發(fā)，下文具體操作過程需要的小伙伴可以參考一下2022-04-04
這篇文章主要為大家介紹了Golang官方限流器庫使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-08-08
這篇文章介紹了golang實現(xiàn)命令行程序使用幫助的方法，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-07-07