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)
|
常量的定义 常量的值在编译时就已经确定 常量的初始化规则与枚举 |
package main import ( "fmt" ) const a int =1 const 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 main import ( "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 }
|
运算符 |
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 main import ( "fmt" ) /** 5= 0101 11=1011 5&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=4 0100 1000 **/ func main() { fmt.Println(5&11) fmt.Println(5|11) fmt.Println(5^11) fmt.Println(5&^11) fmt.Println(4&^8) }
常量的iota与<<<实现计算机存储单位的枚举
package main import ( "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 main import ( "fmt" ) func main() { a:=1 var p *int=&a fmt.Println(p) //0xc082002228 fmt.Println(*p) //1 }