Go学习笔记2

五、数据类型

5.复杂数据类型

1.指针

指针就是内存地址
*赋值：var ptr int = &age

1. func main(){
2.         var age int = 18
3.         //&符号+变量 就可以获取这个变量内存的地址
4.         fmt.Println(&age) //0xc0000a2058
5.         //定义一个指针变量：
6.         //var代表要声明一个变量
7.         //ptr 指针变量的名字
8.         //ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）
9.         //&age就是一个地址，是ptr变量的具体的值
10.         var ptr *int = &age
11.         fmt.Println(ptr)
12.         fmt.Println("ptr本身这个存储空间的地址为：",&ptr)
13.         //想获取ptr这个指针或者这个地址指向的那个数据：
14.         fmt.Printf("ptr指向的数值为：%v",*ptr) //ptr指向的数值为：18
15. }

复制代码

取值：*ptr = 21
总结：最重要的就是两个符号：
1.& 取内存地址
2.* 根据地址取值
指针细节

【1】可以通过指针改变指向值

1. func main(){
2.         var num int = 10
3.         fmt.Println(num)
4.         var ptr *int = &num
5.             // 改变值为20
6.         *ptr = 20
7.         fmt.Println(num)
8. }

复制代码

【2】指针变量接收的一定是地址值

【3】指针变量的地址不可以不匹配

PS:*float32意味着这个指针指向的是float32类型的数据，但是&num对应的是int类型的不可以。
【4】基本数据类型（又叫值类型），都有对应的指针类型,形式为数据类型，
比如int的对应的指针就是int, float32对应的指针类型就是*float32。依次类推。
6.标识符的使用

标识符定义规则：

四个注意：不可以以数字开头，严格区分大小写，不能包含空格，不可以使用Go中的保留关键字
起名规则：
（1）包名：尽量保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，和标准库不要冲突
1.为什么之前在定义源文件的时候，一般我们都用package main 包 ？
main包是一个程序的入口包，所以你main函数它所在的包建议定义为main包，如果不定义为main包，那么就不能得到可执行文件。
（2）变量名、函数名、常量名 : 采用驼峰法。
（3）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问;
注意：
import导入语句通常放在文件开头包声明语句的下面。
导入的包名需要使用双引号包裹起来。
包名是从$GOPATH/src/后开始计算的，使用/进行路径分隔。
需要配置一个环境变量：GOPATH
并且需要：go env -w GO111MODULE=off

外部包使用
六、运算符

1.算数运算符

算术运算符：+ ，-，*，/，%，++，--

1. package main
2. import "fmt"
3. func main(){
4.         //+加号：
5.         //1.正数 2.相加操作  3.字符串拼接
6.         var n1 int = +10
7.         fmt.Println(n1)
8.         var n2 int = 4 + 7
9.         fmt.Println(n2)
10.         var s1 string = "abc" + "def"
11.         fmt.Println(s1)
12.         // /除号：
13.         fmt.Println(10/3) //两个int类型数据运算，结果一定为整数类型
14.         fmt.Println(10.0/3)//浮点类型参与运算，结果为浮点类型
15.         // % 取模  等价公式： a%b=a-a/b*b
16.         fmt.Println(10%3) // 10%3= 10-10/3*3 = 1
17.         fmt.Println(-10%3)
18.         fmt.Println(10%-3)
19.         fmt.Println(-10%-3)
20.         //++自增操作：
21.         var a int = 10
22.         a++
23.         fmt.Println(a)
24.         a--
25.         fmt.Println(a)
26.         //++ 自增 加1操作，--自减，减1操作
27.         //go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
28.         //go语言里，++，--只能在变量的后面，不能写在变量的前面 --a  ++a  错误写法
29. }

复制代码

2.赋值运算符

1. package main
2. import "fmt"
3. func main(){
4.         var num1 int = 10
5.         fmt.Println(num1)
6.         var num2 int = (10 + 20) % 3 + 3 - 7   //=右侧的值运算清楚后，再赋值给=的左侧
7.         fmt.Println(num2)
8.         var num3 int = 10
9.         num3 += 20 //等价num3 = num3 + 20;
10.         fmt.Println(num3)
11. }

复制代码

3.关系运算符


关系运算符:==,!=,>, =，9)        fmt.Println(5=9)        fmt.Println(5提高运算效率        fmt.Println(true&&true)        fmt.Println(true&&false)        fmt.Println(false&&true)        fmt.Println(false&&false)        //或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true        //也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，直接结果就是true -->提高运算效率        fmt.Println(true||true)        fmt.Println(true||false)        fmt.Println(false||true)        fmt.Println(false||false)        //非逻辑：取相反的结果：        fmt.Println(!true)        fmt.Println(!false)}[/code]5.优先级

为了提高优先级，可以加（）

6.获取用户终端输入

要传入地址变量，因为scan内部是值改变，只有传入地址变量，才能影响到地址变量的值

1. package main
2. import "fmt"
3. func main(){
4.         fmt.Println(5==9)//判断左右两侧的值是否相等，相等返回true，不相等返回的是false， ==不是=
5.         fmt.Println(5!=9)//判断不等于
6.         fmt.Println(5>9)
7.         fmt.Println(5<9)
8.         fmt.Println(5>=9)
9.         fmt.Println(5<=9)
10. }

复制代码

七、流程控制

1.if

1. package main
2. import "fmt"
3. func main(){
4.         //与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
5.         //也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，直接结果就是false  -->提高运算效率
6.         fmt.Println(true&&true)
7.         fmt.Println(true&&false)
8.         fmt.Println(false&&true)
9.         fmt.Println(false&&false)
10.         //或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
11.         //也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，直接结果就是true -->提高运算效率
12.         fmt.Println(true||true)
13.         fmt.Println(true||false)
14.         fmt.Println(false||true)
15.         fmt.Println(false||false)
16.         //非逻辑：取相反的结果：
17.         fmt.Println(!true)
18.         fmt.Println(!false)
19. }

复制代码

当条件表达式为ture时，就会执行得的代码。
条件表达式左右的()可以不写，也建议不写
if和表达式中间，一定要有空格
在Golang中，{}是必须有的,就算你只写一行代码。

1. package main
2. import "fmt"
3. func main(){
4.         //实现功能：键盘录入学生的年龄，姓名，成绩，是否是VIP
5.         //方式1：Scanln
6.         var age int
7.         // fmt.Println("请录入学生的年龄：")
8.         //传入age的地址的目的：在Scanln函数中，对地址中的值进行改变的时候，实际外面的age被影响了
9.         //fmt.Scanln(&age)//录入数据的时候，类型一定要匹配，因为底层会自动判定类型的
10.         var name string
11.         // fmt.Println("请录入学生的姓名：")
12.         // fmt.Scanln(&name)
13.         var score float32
14.         // fmt.Println("请录入学生的成绩：")
15.         // fmt.Scanln(&score)
16.         var isVIP bool
17.         // fmt.Println("请录入学生是否为VIP：")
18.         // fmt.Scanln(&isVIP)
19.         //将上述数据在控制台打印输出：
20.         //fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
21.         //方式2：Scanf
22.         fmt.Println("请录入学生的年龄，姓名，成绩，是否是VIP，使用空格进行分隔")
23.         fmt.Scanf("%d %s %f %t",&age,&name,&score,&isVIP)
24.         //将上述数据在控制台打印输出：
25.         fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
26. }

复制代码

1. if 条件表达式 {
2.   逻辑代码
3. }

复制代码

2.Switch

1. if 条件表达式 {
2.    逻辑代码1
3. } else {
4.    逻辑代码2
5. }

复制代码

注意

switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
case后面的值如果是常量值(字面量)，则要求不能重复
case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
case后面可以带多个值，使用逗号间隔。比如 case 值1,值2...
  case后面不需要带break
default语句不是必须的，位置也是随意的。
switch后也可以不带表达式，当做if分支来使用
switch后也可以直接声明/定义一个变量，分号结束，不推荐
switch穿透，利用fallthrough关键字，如果在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透。
3.for循环

for的初始表达式 不能用var定义变量的形式，要用:=

1. if 条件表达式1 {
2.     逻辑代码1
3. } else if 条件表达式2 {
4.     逻辑代码2
5. }
6. .......
7. else {
8.                 逻辑代码n
9. }

复制代码

[code]var sum int = 0        for i := 1 ; i