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,4var a,b,c,d  =1,2,3,4a,b,c,d:  =1,2,3,4}
func main(){var a,_,c,d int =1,2,3,4var a,b,c,d  =1,2,3,4a,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,3e,f     //使用上行表达式 必须个数一样
)
//同时定义多个常量
const i,j,k=1,"2","3"func main() {// fmt.Println(bb);fmt.Println(length)     //3fmt.Println(num)        //3fmt.Println(c);    //2fmt.Println(d);         //3fmt.Println(e);         //2fmt.Println(f);    //3
}

package main
import  (
"fmt"
)
const(A="A"  BC=iotaDE=iotaf='A'  //内部使用 _f
)
const(G=iota
)
func main() {fmt.Println(A)  //Afmt.Println(B)  //Afmt.Println(C)  //2fmt.Println(D)  //3fmt.Println(E)  //4fmt.Println(f)  //65fmt.Println(G)  //0
}

func main() {fmt.Println(^2)  //-3  此时为一元运算符fmt.Println(1^2)  // 3  此时为二元运算符fmt.Println(!true); //falsefmt.Println(1<<10);  //1024fmt.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)KBMBGB
)func main() {fmt.Println(B)   //1fmt.Println(KB)  //1024fmt.Println(MB)  //1.048576e+06fmt.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
}