3 常量与变量

include

1. 数据基本类型
2. 单个变量的声明与赋值
3. 多个变量声明与赋值
4. 变量的类型转换
5. 小练习：

数据基本类型

1. bool值
   1.1. 长度为1
   1.2. 取值范围：true，false
   1.3. 注意事项：不可以用数字代表true或false

2. 整型 int/uint
   2.1. 根据运行平台可能为32或者64位来决定
   2.2. uint是无符号数字，也就是从0开始的数，没有正负之分。int是有符号的，一个字节的数需要一位来存储符号，而uint就是不需要存储符号的

3. 8位整型
   3.1. 长度： 1 字节
   3.2. 取值范围： -128~127/0~255

4. 字节型
   4.1. byte（uint8别名）

5. 16位整型 int16/uint16
   5.1. 长度：2字节
   5.2. 取值范围： -32768~32767/0-65535
   

6. 32位整型 int32(rune)/uint3
   6.1. 长度：4字节
   6.2. 取值范围： -1^32/2~2^32/2-11/0~2^32-1

7. 64位整型 int64/uint64
   7.1. 长度：8字节
   7.2. 取值范围： -2^64/2~2^64/2-1/0~2^64-1

8. 浮点型 float32/float64
   8.1. 长度：4/8字节
   8.2. 小数位： 精确到7/15小数位

9. 复数：complex64/complex128
   9.1. 长度：8/16字节

10. 其他类型： array，struc，string
11. 引用类型：slice,map,chan
12. 接口类型：interface
13. 函数类型：func
14. 足够保存指针的32位或者64位的整数型：uintptr
15. 类型零值： 零值并不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值类型的默认值为0，bool为false，string为空字符串

16. 类型别名：

关于零值我们看看下面的代码：

var a int
var b float32
var h bool
var x string 
var v [1]int  // 数组
var v1 [1]byte  
var v2 [1]bool
var v3 []int // 数组切片
var v4 struct {
    f int
}
var v6 *int  // 指针
var v7 map[string]int    // map , key 为string类型，value为int类型
var v8 func(a int)int

[32]byte   // 长度为32的数组，每个元素为一个字节
[2*N] struct { x,y int32} // 复杂类型数组
[1000]*float64  // 复杂类型数组
[3][5]int  //二维数组,3行五列的数组
[2][2][2]float64     // 等同于[2]([2][2]float64)

fmt.Println(a, b, h, x, v) 
fmt.Println(v1, v2)

打印结果如下：

0 0 false  [0]
[0] [false]

由此可以得出：

• int,float32的零值都为0
• bool的零值为false
• string的零值默认为空，所以不打印
• byte、int列表零值为0
• bool列表零值为false

Go语言的字符串和字符符转义

单个变量的声明与赋值

• 变量的声明格式： var 变量名称 变量类型
• 变量的赋值格式： 变量名称 = 表达式
• 声明的同时赋值：var 变量名称 [变量类型] = 表达式

请看代码例子：

func main() {
    var b int   
    b = 1234
    var a = 3   // 变量的赋值格式： 变量名称 = 表达式
    c := "Leo"  // 等同于 var 变量名称 = 变量值
    var cc int = 123
    fmt.Println(b, a, c)
}

多个变量声明与赋值

• 全局变量的声明可以使用var()的方式进行简写
• 全局变量的声明不可以省略var,但是可以使用并行的方式，也就是说全局变量只能使用var d int这样的形式来定义。
• 所有变量都可以使用类型推断。
• 局部变量不可以使用var()的方式简写，只能使用并行的方式。

var (
    aaa ="hello"  // 常规方式
    ss,bb = 11,22   // 使用并行方式以及类型推断
)
var a,b,c,d int  // 多个变量的声明
a,b,c,d = 1,2,3,4   // 多个变量的赋值
var e，f,g,h int = 5,6,7,8  // 多个变量声明的同时赋值
var i,j,k,l = 9,10,11,12  // 省略变量类型，由系统推断
i,m,n,o :=13,14,15,16   // 多个变量声明与赋值的最简写法

变量的类型转换

• go中不存在隐式转换，所有类型转换必须是显式声明
• 转换只能发生在两种互相兼容的类型之间
• 类型转换的格式：
  

var a float32 = 1.6
b := int(a)  // 打印结果是1 ，不存在四舍五入的
    
var a float32 = 1.1
b := int(a)   // 打印结果是1

// 错误的转换
var c bool = true
d := int(c)


var n int16 = 23
var m int32
var a byte
fmt.Printf("%c\n", a)
m = n   类型不一样，所以不能够直接等于号赋值,所以会报错
m = int32(n)    这样转换才正确
fmt.Println(m, n)

字符串类型

1. 双引号与单引号的区别
   1.1. 单引号是针对字符的，字符也就是一个字
   1.2. 双引号是针对字符串的。
   1.3. 反撇号是保留字符串原有格式，不会转义\t,\n等字符

text := "\"what's that ?\",he said"  // 可解析的字符串字面量
text2 := 'a' // 原生的字符,打印的话使用fmt.Printf("%c",text2)
b := `hehehe \n \nasdfasdfasdf   
asdfasdfasfjjkl  \t \n asdfasdfasf`    // 反撇号，保留原有格式不会被转义

2.字符串的拼接、追加与比较

t := "what the fuck are you doing" +
    "shit ,did you see what i do?" // 字符串串级联方式1，通过加号来拼接
    
    
b := `hehehe \n \nasdfasdfasdf
asdfasdfasfjjkl  \t \n asdfasdfasf`

c := "aaaa"

he := fmt.Sprintf("%s %s", b, c)   // 第二种方法，通过Sprintf来拼接的
    
t += "and you ?" // 字符串追加

fmt.Println("Leo" < "haha", "lucy" == "jack")  // 字符串比较

小练习1：

请看下面的代码，思考打印出来的会是神马？

package main

import (
    "fmt"
)

func main() {

    var a int = 65
    b := string(a)

    fmt.Println(b)
}

如果你认为打印出来的结果是65，那么就错了，因为计算机存储的任何东西本质都是数字，因此此函属认为我们需要的是使用数字65表示文本A，类似于python下的chr()方法，吧数字转为ASCII码对应的字符。
那么要把数字转换为真正的字符串类型的65该怎么做? 使用strconv模块里的Itoa方法即可

package main

import (
    "fmt"
    "strconv"
)

func main() {

    var a int = 65
    b := strconv.Itoa(a)

    fmt.Println(b)
}

练习2，反转字符串，git地址

比如输入“hello World”，那么输出结果就是反转后的结果

// reverserStr
package main

import (
    "fmt"
)

func main() {
    a := "Hello World!"
    lenA := len(a)
    var b string
    for i := 1; i <= lenA; i++ {
        b = string(b) + string(a[lenA-i])
    }
    fmt.Printf("%s", b)
}