go基礎資料型別 (Elementary Data Type)與運算子

標籤：

GO基本類型
1.布爾(bool)
長度:1位元組
取值範圍:true,false
注意事項:不可用數字代表true或false
2.整型(int/uint)
根據平台 肯能為32位或64位
3. 8位整型:int8/uint8
長度:1位元組
取值範圍:-128~127/0~255
4.位元組型 :byte(uint8別名)
5. 16位整型：int16/uint16
長度:2位元組
取值範圍:-32768~32767/0~65535
6. 32位整型:int32(rune)/uint32
長度:4位元組
取值範圍:-2^32/2~2^32/2-1/0~2^32-1
7. 64位整型:int64/uint64
長度:8位元組
取值範圍:-2^64/2~2^64/2-1/0~2^64-1
8. 浮點型:float32/float64
長度:4/8 位元組
小數位:精確到7/15小數位
9. 複數:complex64/complex128
長度:8/16位元組
10. 足夠儲存指標的32位或64位整數型:uintptr
其它實值型別
array,struct,string
參考型別
slice,map,chan
介面類型
interface
函數類型
func

類型的零值
零值並不等於空值,而是當變數被聲明為某種類型後的預設值
通常情況下實值型別的預設值為0,bool為false,string為空白字串
類型別名
type(
byte int8
文本 string
)
var b 文本

 

單個變數的聲明與賦值
變數聲明格式:var 變數名稱 變數類型
變數賦值格式:變數名稱=運算式
聲明的同時賦值:var 變數名稱 變數類型=運算式
var a int
a=123
var b int=231
//以上的格式可省略變數類型,由系統推斷
var c=321
//變數的聲明與賦值最簡寫法
d:=456

 

多個變數的聲明和賦值
全域變數的聲明可使用var()的方式簡寫
全域變數的聲明不可省略 var,但可以使用並行方式
所有的變數都可以使用類型推斷
局部變數不可以使用var()方式簡寫,只能使用並行方式
var (
//常規方式
a="ajax"
//使用並行方式及推斷
s,b=1,2
)

函數體內

 func main(){        var a,b,c,d int =1,2,3,4        var a,b,c,d  =1,2,3,4        a,b,c,d:  =1,2,3,4 }func main(){        var a,_,c,d int =1,2,3,4        var a,b,c,d  =1,2,3,4        a,b,c,d:  =1,2,3,4}

變數的類型轉換
go中不存在隱式轉換,所有類型轉換必須顯式聲明
轉換隻能發生在2種相互相容的類型之間
類型轉換格式
<ValueA>[:]=<TypeOfValueA>(<ValueB>)
var a float32=1.1
b:=int(a)
//以下類型轉換 無法通過編譯
var c bool=true //只有true,false 邏輯類型
d:=int(c)

常量的定義 常量的值在編譯時間就已經確定 常量的定義格式與變數基本相同 等號右側必須是常量或者常量運算式 常量運算式中的函數必須是內建的函數 常量的初始化規則與枚舉 在定義常量組(注意必須是常量組)時,如果不提供初始值,則表示使用上行的運算式 使用相同的運算式不代表具有相同的值 iota是常量的計數器,從0開始,組中每定義1個常量自動遞增1 通過初始化規則與iotal可以達到枚舉效果 每遇到一個const關鍵字,iota就會重設為0

package mainimport  ("fmt")const a int =1const b=‘A‘//const bb //報錯const( text="123" length=len(text) num)const(        c,d=2,3        e,f     //使用上行運算式 必須個數一樣)//同時定義多個常量const i,j,k=1,"2","3"func main() {        // fmt.Println(bb);        fmt.Println(length)     //3        fmt.Println(num)        //3        fmt.Println(c);    //2        fmt.Println(d);         //3        fmt.Println(e);         //2        fmt.Println(f);    //3}

package mainimport  ("fmt")const(        A="A"          B        C=iota        D        E=iota        f=‘A‘  //內部使用 _f)const( G=iota)func main() {        fmt.Println(A)  //A        fmt.Println(B)  //A        fmt.Println(C)  //2        fmt.Println(D)  //3        fmt.Println(E)  //4        fmt.Println(f)  //65        fmt.Println(G)  //0}

運算子 Go中的運算子都是從左至右結合 優先順序(高->低) ^ 　　 !  (一元運算子) *  　　/　　 %　　 <<　　 >>　　 & 　　&^ +　　 - 　　 |　　 ^　　 (二元運算子) == 　　 !=　　 <  　　<= 　　 >= 　　 > <- 　　 (專用於channel) && ||

func main() {        fmt.Println(^2)  //-3  此時為一元運算子        fmt.Println(1^2)  // 3  此時為二元運算子        fmt.Println(!true); //false        fmt.Println(1<<10);  //1024        fmt.Println(1>>10);//0        }

package mainimport  ("fmt")/**5= 010111=10115&11=0001=1 (均為1得1)5|11=1111=15 (有一個為1 得1)5^11=1110=14 (有且只有1個為1 才成立)5&^11=0100=4 （第二個數為1,把第一個數相應位置改為0,結果為改過的第一個數的值）4&^8=0100=401001000**/func main() {        fmt.Println(5&11)          fmt.Println(5|11)            fmt.Println(5^11)        fmt.Println(5&^11)        fmt.Println(4&^8)}

常量的iota與<<<實現電腦儲存單位的枚舉

package mainimport  ("fmt")const(        B float64=1<<(iota*10)        KB        MB        GB)func main() {        fmt.Println(B)   //1        fmt.Println(KB)  //1024        fmt.Println(MB)  //1.048576e+06        fmt.Println(GB)  //1.073741824e+09}

指標
GO雖然保留了指標,但與其它程式設計語言不同的是,Go中不支援指標運算以及 "->" 運算子,
而直接採用"." 選擇符來操作指標目標對象的成員
操作符 "&" 取變數地址 ,使用"*" 通過指標間接訪問目標對象
預設值為nil而非NULL
-----------------

package mainimport ("fmt")func main() {a:=1var p *int=&afmt.Println(p) //0xc082002228fmt.Println(*p) //1}

 

go基礎資料型別 (Elementary Data Type)與運算子