Go语言学习(一)整体概况与发展前景

Go语言简介

我的第一个go程序

package main
import "fmt"
func main(){
	fmt.Print("Hello Go")
}

推荐使用go run + 文件名启动

开发使用的IDE推荐使用Goland，我为了和学习视频一致就先用vscode开发了

基本变量与类型

这么多整数类型，使用的时候该如何选择呢？Golang程序中整型变量在使用时，
遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型

算术运算符

package main
//算术运算符
import "fmt"
func main(){
	//+号
	//1.正数 2.相加操作  3.字符串拼接
	var n1 int = +10
	fmt.Println(n1)
	var n2 int = 4 + 7
	fmt.Println(n2)
    var s1 string = "abc" + "asdas"
	fmt.Println(s1)

	//除号
	fmt.Println(10/3)//两个int类型数据运算，结果一定为整数类型
	fmt.Println(10.0/3)//浮点类型参与运算，结果为浮点类型

	fmt.Println("------------------")

	// % 取模  等价公式：a%b=a-a/b*b
	fmt.Println(10%3)
	fmt.Println(-10%3)
	fmt.Println(10%-3)
	fmt.Println(-10%-3)

	//++自增操作：
	var a int = 10
	a++
	fmt.Println(a)
	//++自增 +1操作 --自减，减1操作
	//go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
	//而且只能写在变量的后面，不能写在变量的前面，--a  ++a 错误写法
}

package main

import "fmt"
func main(){
	var num1 int = 10
	fmt.Println(num1)
	var num2 int = (10 + 20) % 3 + 3 - 7 //  =右侧的值运算清楚后，再赋值给=的左侧
	fmt.Println(num2)

	var num3 int = 10
	num3 += 20
	fmt.Println(num3)

	//练习：交换两个数的值并输出结果：
	var a int = 8
	var b int = 4
	fmt.Printf("a = %v,b = %v", a,b)
	fmt.Println()
	//交换：
	//引入一个中间变量
	var t int
	t = a
	a = b
	b = t
	fmt.Printf("a = %v,b = %v", a,b)

	fmt.Println(5==9)
	fmt.Println(5!=9)
	fmt.Println(5>9)
    fmt.Println(5<9)
	fmt.Println(5>=9)
    fmt.Println(5<=9)
	//与逻辑：&& 两个数值/表达式只要有一侧是false，结果一定为false
	//也叫短路与：只要第一个数值/表达式的结果是false，
	//那么后面的表达式等就不用运算了，直接结果就是false  --> 提高运算效率 
	fmt.Println(true&&true)
    fmt.Println(true&&false)

	//或逻辑： || 两个数值/表达式只要有一侧是true，结果一定为true
	//也叫短路或 只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，
	//直接结果就是true  --> 提高运算效率
	fmt.Println(true||true)
    fmt.Println(true||false)
	
}

package main
import "fmt"
func main(){
	var age int = 18
	fmt.Println("age对应的存储空间的地址为：" ,&age)//0xc0000ba058
	
	var ptr *int = &age
	fmt.Println(ptr)
	fmt.Println("ptr这个指针指向的具体数值为：",*ptr)

}

流程控制

package main

import "fmt"
func main() {
	//实现功能：如果口罩的库存小于30个，提示：库存不足
	// var count int = 100
	// //单分支
	// if count < 30 {
	// 	fmt.Println("对不起，口罩存量不足")
	// }

	if count := 20; count < 30 {
		fmt.Println("对不起，口罩存量不足")
	}
}

package main

import "fmt"
func main() {
	var count int = 20
	if count < 30 {
		fmt.Println("库存不足")
	} else {
		fmt.Println("库存充足")
	}
}

package main

import "fmt"
func main(){
	//实现功能：根据给出的学生分数，判断学生的等级
	//A >= 90  B >= 80  C >= 70 D >= 60 E < 60
	//可以使用多个单分支拼凑出多个选择 但是即使走了其中一种 也判断了所有的情况 效率较低
	//多分支: 如果已经走了一个分支了，那么下面的分支就不会再去判断执行了
	var score int = 96
	if score >= 90 {
		fmt.Println("您的成绩为A级别")
	} else if score >= 80 {
		fmt.Println("您的成绩为B级别")
	} else if score >= 70 {
		fmt.Println("您的成绩为C级别")
	} else if score >= 60 {
		fmt.Println("您的成绩为D级别")
	} else {
		fmt.Println("您的成绩为E级别")
	}//建议保证else的存在，只有有了else才会真正 起到多选一 的效果
	
}

switch

package main

import "fmt"
func main() {
	var score int = 87
	//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码
	//default是用来"兜底的一个分支"，其它case分支都不走的情况下就会走default分支
	//default分支可以放在任意位置上，不一定非要放在最后
	
	//switch后是一个表达式(即：常量值、变量、一个有返回值的函数等都可以)
	//switch穿透，利用fallthrough关键字，如果在case语句块后增加fallthrough，
	//则会继续执行下一个case，也叫switch穿透
	switch score/10 {
		//case后面的值如果是常量值(字面量)，则要求不能重复
		case 10 : 
			fmt.Println("您的等级为A级")
		//case后的各个值的数据类型，必须和switch的表达式数据类型一致
		case 9 :
			fmt.Println("您的等级为B级")
		//case后面可以带多个值，使用都好间隔。比如case值1，值2...	
		case 8 :
			fmt.Println("您的等级为C级")
			fallthrough
		case 7 :
			fmt.Println("您的等级为D级")
		case 6 : 
			fmt.Println("您的等级为E级")
		default :
			fmt.Println("您的成绩有误")
	}

}

for循环

package main

import "fmt"
func main() {
	//实现一个功能，求和：1+2+3+4+5
	var sum int = 0
	for i := 1 ; i <= 5 ; i++ {
		sum += i
	}

	fmt.Println(sum)
	//for循环的语法格式
	/*
	for 初始表达式; 布尔表达式(条件判断) ; 迭代因子 {
            循环体; --> 反复执行的内容
        }
        fmt.Println(sum)
	}
	注意：for的初始表达式 不能用var定义变量的形式，要用:=
	for循环实际就是让程序员写代码的效率高了，但是底层该怎么执行还是怎么执行的
	底层效率没有提高，只是程序员写代码简洁了	
	.
	*/

}