golang笔记03

一、输入和输出

1、输出

使用fmt包：输入、输出

/*
输出：
	Print():打印
	Printf()：格式化输出
	Println()：打印后换行
	
	常用格式化占位符：
	%v:原样输出
	%T：打印数据类型
	%t:bool类型
	%s:字符串
	%f:浮点数
	%d：十进制
	%b:二进制
	%o:八进制
	%x,%X:十六进制（0-9/a-f/A-F）
	%c：打印字符
	%p:打印地址
*/
package main
import "fmt"
func main() {
	var a int8
	a=11
	fmt.Printf("%T   %d   %p",a,a,&a)
}

2、输入

使用fmt/bufio包：输入、输出

/*
fmt包
var a int
var b int
Scan(&a,&b)
Scanln(&a,&b)
Scanf("%d%d",&a,&b)
*/

//可以读取一整行数据
package main
import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	var a string
	reader := bufio.NewReader(os.Stdin)
	//括号里面可以写在哪个数值停止例图
	a, _ = reader.ReadString('\n')
	fmt.Println(a)
}

二、程序流程结构

1、if相关语句

if语句之间可以互相嵌套使用
1、if语句
语法格式：
if 布尔表达式{
	/*在布尔表达式为true时执行*/
}

2、if else 语句
语法格式：
if 布尔表达式{
	/*在布尔表达式为true时执行*/
}else{
    /*在布尔表达式为false时执行*/
}

3、if else if else语句
语法格式：
if 布尔表达式{
	/*在布尔表达式为true时执行*/
}else if 布尔表达式{
    /*在布尔表达式1为false时执行，布尔表达式2为true*/
}else{
    /*上面所有表达式都为false时执行*/
}

4、if的特殊写法，在if条件中声明一个变量，再进行判断，这个变量作用域只能在if语句中使用
语法格式：
if statement;condition{
    
}

例子1：
package main
import "fmt"
func main() {
	if age :=9;age>=18{
		fmt.Println("成年了")
	}else if age<10{
		fmt.Println("太小了")
	}else{
		fmt.Println("未成年")
	}
}
输出结果：太小了

例子2：
package main
import "fmt"
func main() {
	age :=18
	if age>=18{
		fmt.Println("成年了")
	}

	if age<18{
		fmt.Println("未成年")
	}else{
		fmt.Println("成年人")
	}

	if age<18&&age>10{
		fmt.Println("可以出去玩了")
	}else if age<=10{
		fmt.Println("太小了")
	}else{
		fmt.Println("长大了")
	}
}
运行结果：
成年了
成年人
长大了

2、switch相关

语法格式1：数值类型和变量类型需要保持一致
switch 变量(任何数据类型){
    case 数值1,数值2...:分支1(任意满足一个数值即可执行分支语句)
    case 数值2:分支2
    ....
    default:
}
语法格式2：(数值类型只能为bool)
switch {
    case 数值1:分支1
    case 数值2:分支2
    ....
    default:
}

语法格式3：(同if)
switch 初始化语句;变量{
    case 数值1:分支1
    case 数值2:分支2
    ....
    default:
}

注意事项：
1、switch可以作用在其他类型上，case后的数据必须和switch作用的数据类型一致
2、case是无序的
3、case后的数量是唯一的
4、default语句可有可无
5、break强制结束，如果在case末尾加上break,则该switch语句在执行完成这个case之后就直接跳出switc语句
6、fallthrough 穿透case，只能放在每个case的最后一行，当有fallthrough的case匹配成功时，它的下一个case不需要条件匹配，就	    可以执行

例子1：
package main
import "fmt"
func main() {
	fmt.Println("输入目前季度：")
	var num int
	fmt.Scanln(&num)
	switch num {
	case 1:
		fmt.Println("第一季度")
	case 2:
		fmt.Println("第二季度")
	case 3:
		fmt.Println("第三季度")
	case 4:
		fmt.Println("第四季度")
	default:
		fmt.Println("输入错误")
	}
}

例子2：
package main
import "fmt"
func main() {
	fmt.Println("年龄：")
	var age int
	fmt.Scan(&age)
	switch {
	case age>=18:fmt.Println("成年了")
	default:
		fmt.Println("未成年")
	}
}

三、循环语句

/*
标准写法：
for循环：某些代码会被多次的执行
语法：
	for 表达式1;表达式2;表达式3{
		循环体
	}
执行顺序：
表达式1：只执行一次，惯用于变量的初始化
表达式2：bool类型，循环体的条件
循环体
表示3：跟在循环体的后面执行，惯用于变量的变化

其他写法：
1、省略表达式1和表达式3
for 表达式2{}
2、同时省略三个表达式
for{}//无限循环
3、省略表达式1或者3
for ;表达式2；表达式3{}
*/
package main
import "fmt"
func main() {
	for i:=1;i<5;i++{
		fmt.Println("打印")
	}
}

四、break和continue

break：跳出当前的循环体。break语句用于在结束其正常执行之前突然终止for循环。

continue：跳出当前循环的一次循环。continue语句用于跳过for循环的迭代。在continue语句后面的for循环中所以的代码将不执行。循环将继续到下一个迭代

//打印100以内的素数
package main
import (
	"fmt"
	"math"
)
func main() {

	for i:=2;i<=100;i++{
		flag :=true
		for j:=2; j<=int(math.Sqrt(float64(i)));j++{//判断到根号i就可以，不需要到i的前一个
			if i%j==0{
				flag=false
				break
			}
		}
		if flag{
			fmt.Print(i," ")
		}
	}
}

五、goto语句

goto：可以无条件地转移到过程中指定的行
语法结构：
goto label
...
...
label:statement;

例子1：
package main
import "fmt"
func main() {
	/*go语句*/
	var a=10
	LOOP:
		for a<20{
			if a==15{//当a=15的时候重新跳到for循环开始位置
				a+=1
				goto LOOP
			}
			fmt.Println("a的值为",a)
			a++
		}
}

六、生成随机数

package main
import (
	"fmt"
	"math/rand"
	"time"
)
func main() {
	/*
	生成随机数random:
		伪随机数，根据一定的算法公式算出来的
	math/rand
	*/
	//整型范围的随机数
	num1 :=rand.Int()
	fmt.Println(num1)

	//取[0,10)之间的随机数
	num:=rand.Intn(100)//[0,10)
	fmt.Println(num)

	//将种子设置成时间戳,种子数不同每次运行生成的随机数不同
	rand.Seed(time.Now().UnixNano())
	num2 :=rand.Intn(100)
	fmt.Println(num2)

	//取[3,100)之间的随机数
	rand.Seed(time.Now().UnixNano())
	num3:=rand.Intn(100)+3
	fmt.Println(num3)
}