go基本数据类型与运算符

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 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
}

运算符
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 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
}