四、基础数据类型

1.布尔类型

类型名 bool
字面量true 和false
表示真假
逻辑运算 与&& 或|| 非!

package main

import "fmt"
func main() {
    //布尔类型
    //标识符bool
    //字面量:true/false
    //零值false
    var zero bool
    isBoy := false
    isGirl := true
    fmt.Println(zero, isBoy, isGirl)
    //真值表
    /*逻辑运算(与&&  或||  非!)
     */
    fmt.Println(true && true)
    fmt.Println(false && false)
    fmt.Println(false && true)
    fmt.Println(true && false)
    fmt.Println(true || true)
    fmt.Println(true || false)
    fmt.Println(false || true)
    fmt.Println(false || false)
    fmt.Println("!")
    fmt.Println(!true)
    fmt.Println(!false)
    //关系运算 =   !=
    //在go中 true 跟false 不能把0或1带入
    fmt.Println(1 == 1)
    fmt.Println(1 != 1)
    fmt.Printf("%T", true)
    //bool 占位 打印值是 %t
    fmt.Printf("%T,%t\n", false, false)
    fmt.Printf("%T,%s\n", "aa", "aa")
    //int占位符是%d
    fmt.Printf("%T,%d\n", 1, 1)
}

2.字符串

类型名string
字面量
（1）可解析
使用””双引号 里面可以解析特殊字符 如果要表示原来的本以 需要使用\转义
（2）原生的
``反引号 不可以解析特殊字符
（3）特殊字符
\n \t \r \f \v \a \b \等

操作
关系运算、算数运算（使用+来进行字符串连接）、赋值运算、索引（注意对于Unicode字符获取的数据并不是一个码点）、切片（name[start:end] 包含start不包含end）

函数
获取字符串长度 使用len 这里len获取的是字节数量
byte和rune类型转换为字符串 string

 package main

import "fmt"
func main() {
    //"" => 可解释字符串
    //`` => 原生字符串
    //特殊字符 \n \r \t \f  等等 这种换行符之类的
    var (
        name string = "b\nb"
        desc string = `a\na`
    )
    fmt.Println(name)
    //如果想要用可解释字符串定义"" 需要用\转义
    name = "b\\nb"
    fmt.Println(name)
    fmt.Println(desc)
    //操作
    //算数运算符: + (连接)
    fmt.Println("我叫" + "屈帅波")
    //""是字符串，''是字节byte或者rune类型
    //关系运算(==，!=,>,>=,<,<=)
    //字符串关系运算是第一个字母先比 如果能比较就是true或者false 如果比较不了那么第二个开始比
    //用的阿斯克码表做比较
    fmt.Println("aa" > "bb")
    fmt.Println("ac" > "ab")
    //赋值运算
    s := "我叫"
    s += "屈帅波"
    fmt.Println(s)
    //字符串定义内容必须只能为ascii
    //索引 0 -  n-1   (n为字符串长度)
    desc = "asbceasd"
    fmt.Printf("%T %c \n", desc[0], desc[0])
    //切片[start:end]   拿到的是 start至end-1
    fmt.Printf("%T %s \n", desc[0:3], desc[0:3])
    //做切片或者使用索引  只能使用ascii  如果不是 会乱码
    //len  取长度  算的是字节数量  这里也必须是ascii  如果不是的话 比如中文一个中文可能占3-4个字节
    fmt.Println(len(desc))
}

3.数值类型

（1）整数
类型名int/uint/byte/rune/uintptr
字面量 表示方法 十进制/八进制/十六进制
操作 算数运算/关系运算/位运算/赋值运算/类型转换

package main

import "fmt"
func main() {
    /*整数类型
      标识符 int/int* /unit/unit* /uintptr/byte/rune
      字面量 十进制 八进制0777= 7*8^2 + 7*8^1 +7*8^0  十六进制 0X 0-9  A-F
    */
    var age int = 31
    fmt.Printf("%T,%d\n", age, age)

    //操作
    //算术运算（+，-，*，/，%，++，--）
    //在go中整数除法运算 会直接取整例如 9/2 取4
    fmt.Println(1 + 2)
    fmt.Println(1 * 2)
    fmt.Println(3 - 10)
    fmt.Println(9 / 2)
    fmt.Println(2 / 3)
    fmt.Println(7 % 3)
    var a int = 1
    a++
    fmt.Println(a)
    a--
    fmt.Println(a)
    //关系运算(==,!=,>,<,>=,<=)
    //关系运算结果是一个bool值
    fmt.Println(2 == 2)
    fmt.Println(2 != 2)
    fmt.Println(2 > 2)
    fmt.Println(2 < 2)
    fmt.Println(2 >= 2)
    fmt.Println(2 <= 2)
    //位运算 二进制的运算 10 => 2
    //&与 |或  ^非  <<左移  >>有移   %^按位清空
    // 7/2 =>1 3/2=>1 1/2=>1 0    0111
    // 十进制2   二进制 0010
    //7&2  => 0111 & 0010 = 0010   相同位数 位1 则1 否则为0   0010换算十进制为2
    //7|2  => 0111 | 0010 = 0111   有1则为1  0111 换算十进制为7
    //7!2  => 0111 ^ 0010 = 0101   不同则为1其余为0   0101换算十进制为5
    //2<<1  => 0010 << 1  = 0100    往相反方向添0  这里左移指的是往右边添0  1表示1个0
    //2>>1  => 0010 >> 1  = 0001    往相反方向添0  这里右移指的是往左边添0  1表示1个0
    //7&^2  => 0111 &^ 0010 = 0101  按位清空 指的是 把相同位置清零
    fmt.Println(7 & 2)
    fmt.Println(7 | 2)
    fmt.Println(7 ^ 2)
    fmt.Println(2 << 1)
    fmt.Println(2 << 2)
    fmt.Println(2 >> 1)
    fmt.Println(7 &^ 2)
    //赋值运算(=,+=,-=,*=,/=,%=,&=,|=,^=,^=,<<=,>>=,&^=)
    //a+=b ==> a=a+b
    var age1, age2 int = 1, 2
    var age3 int
    fmt.Println(age1, age2, age3)
    age1 += age2
    fmt.Println(age1, age2)
    age2 %= age1
    fmt.Println(age1, age2)
    //int/uint/byte/rune/int*/uint*  之间如果要计算那么需要做类型转换
    var intA int = 10
    var intB int16 = 100
    intA += int(intB)
    fmt.Println(intA, intB)
    //大  转  小可能会出现溢出问题
    var intC int = 0XFFFF
    fmt.Println(intC, int8(intC), uint8(intC))

    //byte(字节),rune(码点)  也属于int 不过可以用字符来赋值
    var (
        c byte = 'A'
        w rune = '中'
    )
    fmt.Println(c, w)
    fmt.Printf("%T,%T\n", c, w)
    fmt.Printf("%c\n", c)
    fmt.Printf("%q %U\n", w, w)
    //fmt.Printf
    //%b 二进制 %o 八进制  %x 十六进制   %q 获取rune值  %U  码点
    //%v 如果记不清使用什么格式化值 就用%v
    //格式化转换
    fmt.Printf("%5d\n", 1)        //这里表示站5位 默认是空格   1第五位所以前面会有4个空格
    fmt.Printf("%05d\n", 1)       // 这里表示站5位 不够的0补充  1第五位所以前面会有4个0
    fmt.Printf("%-5d %d\n", 1, 2) //-表示左对齐 右边会空4个   默认是+ 为右对齐

}

（2）浮点数
类型名 float32/float64
字面量 十进制表示法1.1/科学计数法 1E-1
操作 算数运算/关系运算/赋值运算/类型转换（float64(name)）
类型转换需要注意 大转小可能会有溢出

package main

import "fmt"
func main() {
    //float32,float64 一般使用64  保存的位数不一样
    //字面量: 十进制表示法  科学计数法
    //M E N  => M*10 ^ N
    var hight float64 = 1.75
    fmt.Printf("%T %f\n", hight, hight)
    //操作
    //算数运算(+，-，*，/，--，++)
    //go float不支持%
    //浮点数不是精确存储，会有精度损耗 做运算的话精度损耗可能会变大
    fmt.Println(1.1 + 1.2)
    fmt.Println(1.1 - 1.2)
    fmt.Println(1.1 * 1.2)
    fmt.Println(1.1 / 1.2)
    //关系运算(>,<,>=,<=,) 因为有精度损耗 所以一般不做等于和不等于运算
    //赋值运算(=,+=,/=,-=,*=)
    fmt.Printf("%4.3f", 1.5555)
    //4.3表示 取4位 小数点后取3位
}

（3）复数

4.枚举类型

5.指针类型

用于存储变量在内存中的存储位置
获取变量的指针&name
var指定变量类型
int=> *int
string=>*string
bool => *bool
获取指针对应的值 *point

package main

import "fmt"
func main() {
    //指针
    var (
        a int = 2
        b int = a
    )
    //int指针 用*int 那么string 就是*string 以此类推  也可以用简短声明
    //变量的值存放在内存中，是一个内存地址，指针可以来拿到某个变量的内存地址 来做修改
    //占位符的话使用%p 打印指针，  %v用数据类型自己的格式化
    fmt.Println(a, b)
    var c *int = &a
    cc := &a
    fmt.Println(c, cc)
    *cc = 4
    fmt.Println(*c, *cc, a)
}