package main
import (
"fmt"
"math/rand"
"runtime"
"strconv"
"time"
)
//import . "fmt" 这种导入方式 调用函数无需通过包名
//给包起别名
//import io "fmt"
//忽略此包
//import _ "fmt"
import (
"os"
)
func main1() {
a1()
a2()
a3()
//a4()
a5()
a6()
aif()
aswitch()
afor()
arang()
agoto()
}
//定义变量
func a1() {
//声明变量,声明的变量必须要使用
var a int
a = 10
var b, c int
fmt.Println("a == ", a, b, c)
//自动推到类型,必须初始化,通过初始化确定类型
d := 30
//打印变量类型
fmt.Printf("变量类型: %T\n", d)
}
func a2() {
//多重初始化
a, b, c := 10, 20, 30
fmt.Printf("a = %d,b = %d,c = %d\n", a, b, c)
//交换变量
a, b = b, a
fmt.Printf("a = %d,b = %d,c = %d\n", a, b, c)
//匿名变量,丢弃数据不处理,匿名变量配合函数返回值使用
var tmp int
tmp, _ = a, b
fmt.Printf("a = %d, tmp = %d\n", a, tmp)
}
func a3() {
//常量
const a int = 10
fmt.Println(a)
var b int
var c float64
b, c = 10, 3.14
fmt.Printf("b = %d c = %f\n", b, c)
//iota 常量自动生成器,每隔一行自动累加1,同一行,值一样
//iote 给常量赋值使用
const (
d = iota
e, f = iota, iota
)
fmt.Printf("d = %d, e = %d,f = %d\n", d, e, f)
const (
n1 = iota
n2
n3
)
fmt.Printf("n1 = %d, n2 = %d,n2 = %d\n", n1, n2, n2)
//iote 遇到 const重置为0
const g = iota
fmt.Println(g)
}
func a4() {
//输入
var a int
fmt.Println("请输入a变量")
//阻塞等待用户输入
fmt.Scanf("%d", &a)
fmt.Println("a = ", a)
fmt.Println("请再次输入a变量")
fmt.Scan(&a)
fmt.Println("a = ", a)
afor()
}
func a5() {
//类型转换
//bool 不能转换成整型,整型也不能转换成bool类型,这种不能转换的类型叫不兼容类型
var flag bool = true
fmt.Println(flag)
var ch byte = 'a'
var t int
t = int(ch)
fmt.Println(t)
}
func a6() {
//类型别名
type bigint int64
var a bigint
a = 10
fmt.Printf("%T", a)
type (
long int64
char byte
)
}
func aif() {
s := 'a'
if s == 'a' {
fmt.Println("满足条件")
} else {
fmt.Println("else")
}
//if 和初始化语句一起使用
if a := 10; a == 10 {
fmt.Println("if 和初始化语句一起使用")
}
}
func aswitch() {
// 默认包含 break ,关键字 fallthrough 用于case穿透
num := 1
switch num {
case 1:
fmt.Println("1")
fallthrough
case 2:
fmt.Println("2")
case 3:
fmt.Println("3")
default:
fmt.Println("default")
}
//和if一样支持初始化语句
switch num1 := 1; num1 {
case 1:
fmt.Println("1")
fallthrough
case 2:
fmt.Println("2")
case 3:
fmt.Println("3")
default:
fmt.Println("default")
}
//case后面可以写条件
scorc := 85
switch {
case scorc > 85:
fmt.Println("优秀")
case scorc <= 85:
fmt.Println("一般")
}
//可以写多个
switch scorc {
case 1, 2, 3:
fmt.Println("1,2,3")
case 5:
fmt.Println("5")
}
}
func afor() {
sum := 0
for i := 0; i <= 100; i++ {
sum += i
}
fmt.Println(sum)
//死循环
for {
fmt.Println("死循环")
break
}
}
func arang() {
//迭代
str := "abc"
for i, data := range str {
fmt.Println(i, " ", data)
}
//第二个返回值默认丢弃
for i := range str {
fmt.Println(i, )
}
}
func agoto() {
//goto 可以用在任何地方,但是不能跨函数使用
goto End //goto 后面跟一个标签,标签名称,是自定义的
fmt.Println("aaa")
End:
fmt.Println("bbb")
}
//函数,不能重载
func afunc(a int, b int) {
}
func bfunc(a, b int) {
}
//不定参数,参数数量不确定
func cfunc(a ...int) {
for i := 0; i < len(a); i++ {
}
for i, data := range a {
fmt.Println(i, " ", data)
}
}
//不定参数调用
func dfunc(a ...int) {
cfunc(a...)
//从初始位置到第二个传递到后面
cfunc(a[:2]...)
//从第二个位置开始,后面的参数传递过去
cfunc(a[2:]...)
}
//一个返回值
func efunc() int {
return 0
}
//给返回值起一个名称,go 推荐写法
func ffunc() (test int) {
return 0;
}
//直接给返回值赋值,然后直接返回
func gfunc() (res int) {
res = 0
return
}
//返回多个值,go 官方推荐
func hfunc() (a int, b int, c int) {
return 0, 0, 0
}
//函数权限,函数首字母小写 函数为private函数,函数首字母大写为public
//函数类型
type FuncType func(int, int) int
func add(a int, b int) int {
return a + b
}
func afunctype() {
var a FuncType
a = add
sum := a(1, 2)
fmt.Println(sum)
}
//匿名函数
func funca() {
f1 := func() {
}
f1()
//匿名函数调用
func() {
}();
}
//闭包中使用的参数不销毁
func funcb() func() int {
var x int
x++
return func() int {
return x * x
}
}
//闭包函数调用
func funcc() {
f := funcb()
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
}
//defer 关键字,延迟调用
func funcd() {
//不论中间发生什么错误,defer都能被调用,多个defer时 先声明的后执行
defer fmt.Println("结束时执行")
fmt.Println("函数中")
}
//获取命令行参数
func main2() {
list := os.Args
fmt.Println(len(list))
}
//导入包后 会先执行包中 init() 函数
func main3() {
//指针,指针没有赋值值为nil
var p *int
var a int = 10
p = &a
fmt.Println(*p)
//指针赋值
var p1 *int
p1 = new(int)
fmt.Println(*p1)
}
func main4() {
//数组,数组的元素个数必须是常量
var ids [10]int
for i, data := range ids {
fmt.Println("i=", i, " data=", data)
}
//初始化
var array [5]int = [5]int{1, 2, 3, 4}
for i, data := range array {
fmt.Println("i=", i, " data=", data)
}
//指定下标初始化
a1 := [5]int{2: 2, 4: 4}
fmt.Println(a1)
//数组比较
b1 := [3]int{1, 2, 3}
b2 := [3]int{1, 2}
if b1 == b2 {
fmt.Println("数组相同")
} else {
fmt.Println("数组不相同")
}
//数组作为参数传递时,会将数组拷贝一份传递过去,所以需要改变数组中的值的时候,传递指针
arraytest(&a1)
}
func arraytest(p *[5]int) {
fmt.Println(*p)
}
func main5() {
//随机数
//1.设置种子,种子一样,每次产生的随机数都一样
rand.Seed(111);
for i := 0; i < 10; i++ {
ra := rand.Int();
fmt.Println(ra)
}
//限制随机数范围
for i := 0; i < 10; i++ {
ra := rand.Intn(100);
fmt.Println(ra)
}
}
func main6() {
//切片,切片和数组的区别就是数组声明时要指定长度,切片不需要指定长度
array := [...]int{1, 2, 3, 4, 5, 6}
//三个参数, 起点,终点,容量
slice := array[1:3:4]
fmt.Println(slice)
//创建切片
//借助make函数,参数 切片类型,长度,容量,容量可以不写,不指定时和长度一样
s := make([]int, 5, 10)
fmt.Println(s)
//复制操作
s1 := array[:]
fmt.Println(s1)
//切片任然指向原来的数组,改变值之后,原先切片也会被改变
//添加元素
s = append(s, 1);
fmt.Println(s)
//复制
src := []int{1, 2}
res := []int{1, 1, 1, 1}
copy(res, src)
fmt.Println(res)
}
func main7() {
//map
var m1 map[int]string
fmt.Println(m1)
m2 := make(map[int]string)
m2[1] = "aaa"
fmt.Println(m2)
//指定长度,会自动扩容
m3 := make(map[int]string, 10)
fmt.Println(m3)
//初始化
m4 := map[int]string{1: "1", 2: "2"}
fmt.Println(m4)
//遍历
for key, val := range m4 {
fmt.Println("key = ", key, " val = ", val)
}
//判断值是否存在
val, ok := m4[1]
if ok {
fmt.Println(val)
} else {
fmt.Println("key 不存在")
}
//删除指定key
delete(m4, 1)
fmt.Println(m4)
}
type User struct {
id int
name string
sex byte
age int
}
type Student struct {
User
num int
}
func main8() {
//结构体
var user User = User{};
fmt.Println(user)
//初始化
var user1 User = User{1, "姓名", 'm', 10};
fmt.Println(user1)
var student Student = Student{User{1, "姓名", 'm', 10}, 1}
fmt.Println(student)
//初始化指定成员
var user2 User = User{name: "a"};
fmt.Println(user2)
//操作参数
user2.id = 5
fmt.Println(user2)
//比较
if user1 == user2 {
fmt.Println("相等")
} else {
fmt.Println("不相等")
}
}
//为结构体绑定函数,这里的接受者不能是指针
func (me User) setAge(age int) {
me.age = age;
}
func (me *User) setAge1(age int) {
me.age = age;
}
func main9() {
a := make([]interface{}, 3)
a[0] = 1
a[1] = "aaa"
a[2] = 'c'
if val, ok := a[0].(int); ok {
fmt.Println(val)
} else {
fmt.Println("类型不符合")
}
}
func main10() {
//异常操作
//中断函数
//panic("aaaaaaaaaaaa)
defer func() {
//用来恢复错误
//recover()
//打印错误信息
fmt.Println(recover())
}()
}
func main11() {
//字符串操作
bytes := make([]byte, 0, 1024)
bytes = strconv.AppendBool(bytes, true)
//追加整数,以10进制方式追加
bytes = strconv.AppendInt(bytes, 12, 10)
bytes = strconv.AppendBool(bytes, true)
//其他类型转换为字符串
var str string
str = strconv.FormatBool(false)
str = strconv.Itoa(1111)
fmt.Println(str)
// 字符串转其他类型
flag, _ := strconv.ParseBool("true")
fmt.Println(flag)
}
func main12() {
//文件
//设备文件 屏幕啊,键盘啊......
//磁盘文件
//标准设备文件,默认已经打开,用户可以直接使用
os.Stdout.WriteString("aaaaaaaa")
}
func newTask() {
for {
fmt.Println("newTask")
time.Sleep(time.Second)
}
}
//数据同步
var ch = make(chan int)
func main13() {
//创建一个协成,如果主线程退出,协成也会退出
go newTask()
//让出时间片,先让别的协成先执行,等其他协成执行完,在回来执行此协成
runtime.Gosched()
//设置使用cpu的最大核心数,返回之前使用的最大数
n := runtime.GOMAXPROCS(1)
fmt.Println(n)
//终止所在协成
runtime.Goexit()
//数据给管道
ch <- 66
//从管道取数据,如果管道没有数据就会阻塞
var a = <-ch
fmt.Println(a)
//关闭管道,管道关闭之后数据不可写入,但是任然可以读取
close(ch)
ch1 := make(chan int)
//双向管道能隐式转换成单方向的管道
var writeCh chan<- int = ch1 //只能写,不能读
var readCh <-chan int = ch1 //只能读,不能写
writeCh <- 1
var aint = <-readCh
fmt.Println(aint)
for {
fmt.Println("main")
time.Sleep(time.Second)
}
}
func main() {
ch := make(chan int)
//监听管道流动方向,每一个case都是一个io操作
select {
case <-ch:
case ch <- 1:
default:
}
}