go 学习-1

社区：https://studygolang.com/
文档：https://studygolang.com/pkgdoc
爬虫：http://go-colly.org/
https://blog.csdn.net/caib1109/article/details/75578974

package main

//1导入包
//import "fmt"

import (
    "fmt"
    "reflect"
    _ "time"
)

func test() int {
    return 1000
}

func foo(a string, b int) int {

    return 100

}

//返回两个值
func foo2(a int, b int) (int, int) {
    return 200, 300
}

func foo3(a int, b int) (int, string) {
    return 400, "aaa"
}

//返回值可以有名称
func foo4(a int, b int) (r1 int, r2 int) {
    r1 = 500
    r2 = 600
    return
}

func foo5(a int, b int) (int, int) {

    return 700, 800
}

//  const 没有枚举，可以用const加iota方式来实现枚举
const (
    //每一行iota都会增加1，第一行为0
    x = iota
    y
    z
    xx = 10 * iota
    yy
    zz = 10 * iota
)

const (
    a, b = iota + 1, iota + 2 //0+1,0+2
    c, d                      //1+1,1+2
    e, f                      //2+1,2+2
    g, h = iota * 2, iota * 3 //3*2,3*3
    i, k                      //4*2,4*3
)

type myint int //给int 数据类型取别名  myint

type Maker struct {
    name string
    age  int
}

func isFile(value bool) int {
    if value == true {
        return 0
    } else {
        return 1
    }
}
func printArr1(arr [4]int) {
    arr[2] = 100
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }
}

func printArr2(arr []int) {
    arr[2] = 999
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }
}

//函数类型 func (string,int)(string,int)
func foota(a string, b int) (string, int) {
    return "1", 1
}
func add(a int, b int) int {
    return a + b
}

func myfunc(a int, b int, op func(int, int) int) (int, int) {
    return op(a, b), op(a, b*2)
}

func PrintMaker(maker Maker) {
    maker.name = "xxxx"
    maker.age = 10
    fmt.Println(maker)
}

func PrintMaker1(maker *Maker) {
    maker.name = "uuuuuuuuu"
    maker.age = 10
    fmt.Println(maker)
}

func test01() {
    fmt.Println("----------------【1】变量定义的方式---------------")
    //2变量定义的方式
    var maker int //---------1
    var ret int

    var maker1 int = 10 //---2

    var maker2 = 20 //-------3一旦初始化，不能改变这个变量的数据类型

    maker3 := 30 //----------4一旦初始化，不能改变这个变量的数据类型  自动推导变量

    fmt.Println(maker)
    fmt.Println(maker1)
    fmt.Println(maker2)
    fmt.Println(maker3)

    name := "赵日天" //这种定义只能 用在局部变量
    fmt.Println(name)
    fmt.Println("is =", reflect.TypeOf(name))
    ret = test()
    fmt.Println("test 返回:", ret)

}

func test02() {
    fmt.Println("-------- ----- 【2】-函数的使用------------------")
    tmp := foo("aaa", 1)
    fmt.Println(tmp)

    ret1, ret2 := foo2(1, 1)
    fmt.Println(ret1)
    fmt.Println(ret2)

    ret3, ret4 := foo3(1, 1)
    fmt.Println(ret3)
    fmt.Println(ret4)

    ret5, ret6 := foo4(1, 1)
    fmt.Println(ret5)
    fmt.Println(ret6)
    fmt.Println("-------- ----- 【3】-匿名变量  丢弃数据不处理，
    配合函数返回值 才有优势------------------")
    //匿名变量  丢弃数据不处理，配合函数返回值 才有优势
    //如果函数返回两个值，必须用两个变量来接，可以使用匿名变量
    _, ret7 := foo5(1, 1)
    fmt.Println(ret7)
    //const 关键字，修饰变量 内容不可修改
    //const a int = 10
    //const b int = 20
    //fmt.Println(a)
    //fmt.Println(b)
可以用const加iota方式来实现枚举----------")
    //  const 没有枚举，可以用const加iota方式来实现枚举
    fmt.Println("x=", x, "y=", y, "z=", z)
    fmt.Println("xx=", xx, "yy=", yy, "zz=", zz)
    fmt.Println("a=", a)
    fmt.Println("b=", b)
    fmt.Println("c=", c)
    fmt.Println("d=", d)
    fmt.Println("e=", e)
    fmt.Println("f=", f)

    fmt.Println("g=", g)
    fmt.Println("h=", h)
    fmt.Println("i=", i)
    fmt.Println("k=", k)
    fmt.Println("--------【5】----判断语句---------------")
    var b bool = true
    if b == true {
        fmt.Println("b==true")
    } else {
        fmt.Println("b==false")
    }

    if ret := isFile(false); ret == 0 {
        fmt.Println("ret=", ret)
    } else {
        fmt.Println("ret=", ret)
    }

    fmt.Println("----------【6】-------swith语句---------------")
    var sore int = 100
    var lens string

    switch sore {
    case 90:
        lens = "90"
    case 100:
        lens = "100"
    default:
        lens = "other"
    }
    fmt.Println(lens)

    switch {
    case sore > 100:
        lens = "sore>100"
    case sore < 100:
        lens = "sore<100"
    }
    fmt.Println(lens)

    fmt.Println("-----------【7】---------go指针-------------")
    var vara int = 10
    var varb int = 20
    var p *int
    p = &vara
    *p = 30

    varb = 40
    varc := 50
    fmt.Println(vara)
    fmt.Println(varb)
    fmt.Println(varc)

    var pp **int
    pp = &p
    **pp = 100
    fmt.Println(vara)

    fmt.Println("--------【8】----for 的用法-------------")
    //定义数组
    myarr := []int{11, 2, 33, 44, 55}

    fmt.Println("---------------for c语言用法-----------")
    for i := 0; i < len(myarr); i++ {
        fmt.Println(myarr[i])
    }
    fmt.Println("---------------go 用法 range---------------")
    for _, val := range myarr {
        fmt.Println(val)
    }
    fmt.Println("------------go 没有while  for while 用法-----")
    n := 20
    for n > 0 {
        fmt.Println(n)
        n--
    }
    //死循环
    //  for {
    //      fmt.Println("ssssssss")
    //      time.Sleep(time.Millisecond * 1000)
    //  }

    fmt.Println("=--------【9】-----goto defer----------------")
    defer fmt.Println("这个代码会在函数结束时执行11111")
    defer fmt.Println("这个代码会在函数结束时执行2222")
    fmt.Println("111111111")
    goto END
    fmt.Println("222222222")
END:
    fmt.Println("233333333")

    fmt.Println("---------【10】---------数组和-    数组传参数--------------------")

    var myarray [10]int //开辟空间，没有赋值，默认是0

    //myarray1 和 myarray2是不同的数据类型
    for i := 0; i < len(myarray); i++ {
        fmt.Println(myarray[i])
    }

    var myarray1 = [4]int{1, 2, 3, 4} // [4]int 类型
    var myarray2 = []int{5, 6, 7, 8}  // []int 类型

    fmt.Println("marray1 is type", reflect.TypeOf(myarray1))
    fmt.Println("marray2 is type", reflect.TypeOf(myarray2))

    //数组传参数
    printArr1(myarray1) //值传递
    fmt.Println("---------------")
    for i := 0; i < len(myarray1); i++ {
        fmt.Println(myarray1[i])
    }
    fmt.Println("---------------")
    printArr2(myarray2) //相当于 地址传递  引用
    fmt.Println("---------------")
    for i := 0; i < len(myarray2); i++ {
        fmt.Println(myarray2[i])
    }

}

func test03() {
    fmt.Println("-----------【11】------函数值和函数类型-------------------")
    fmt.Println("add is type", reflect.TypeOf(add))
    //ret, ret2 := myfunc(1, 2, add)
    //fmt.Println(ret)
    //fmt.Println(ret2)
    fmt.Println(myfunc(10, 20, add))

    fmt.Println("------------【12】-----匿名函数-------------------")

    doublevalue := func(x int) int {
        return x * 2
    }
    ret := doublevalue(110)
    fmt.Println(ret)

    func(x int, y int) int {
        fmt.Println(x + y)
        return 1
    }(1111, 8888) // 匿名函数 后面添加() 调用函数

    hah := func(x int, y int) int { //hah  接收返回值
        return x + y
    }(100, 200) // 匿名函数 后面添加() 调用函数
    fmt.Println(hah)

    fmt.Println("----------【13】------结构体--------------------")

    var aaa myint = 10

    fmt.Println(a)

    var myMaker Maker // 声明一个变量
    myMaker.name = "赵日天"
    myMaker.age = 17

    fmt.Println(myMaker)
    fmt.Printf("%+v\n", myMaker)
    fmt.Println(aaa)

    fmt.Println("--------【14】------结构体 传参-----------------")
    PrintMaker1(&myMaker) //引用
    fmt.Println(myMaker)
    PrintMaker(myMaker) //值传递
    fmt.Println(myMaker)

}

func main() {
    test01()
    test02()
    test03()

}

----------------【1】变量定义的方式---------------
0
10
20
30
赵日天
is = string
test 返回: 1000
-------- ----- 【2】-函数的使用------------------
100
200
300
400
aaa
500
600
-------- ----- 【3】-匿名变量  丢弃数据不处理，配合函数返回值 才有优势------------------
800
-------- ----- 【4】const 没有枚举，可以用const加iota方式来实现枚举----------
x= 0 y= 1 z= 2
xx= 30 yy= 40 zz= 50
a= 1
b= 2
c= 2
d= 3
e= 3
f= 4
g= 6
h= 9
i= 8
k= 12
--------【5】----判断语句---------------
b==true
ret= 1
----------【6】-------swith语句---------------
100
100
-----------【7】---------go指针-------------
30
40
50
100
--------【8】----for 的用法-------------
---------------for c语言用法-----------
11
2
33
44
55
---------------go 用法 range---------------
11
2
33
44
55
------------go 没有while  for while 用法-----
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
=--------【9】-----goto defer----------------
111111111
233333333
---------【10】---------数组和-    数组传参数--------------------
0
0
0
0
0
0
0
0
0
0
marray1 is type [4]int
marray2 is type []int
1
2
100
4
---------------
1
2
3
4
---------------
5
6
999
8
---------------
5
6
999
8
这个代码会在函数结束时执行2222
这个代码会在函数结束时执行11111
-----------【11】------函数值和函数类型-------------------
add is type func(int, int) int
30 50
------------【12】-----匿名函数-------------------
220
9999
300
----------【13】------结构体--------------------
1
{赵日天 17}
{name:赵日天 age:17}
10
--------【14】------结构体 传参-----------------
&{uuuuuuuuu 10}
{uuuuuuuuu 10}
{xxxx 10}
{uuuuuuuuu 10}