golang学习笔记-3

package main

import "fmt"

//编一个可执行的程序，必须 func main， main()入门函数

// go语言函数外的语句只能以关键字开头

var name = "哪吒"

var age int

//流程控制是一门语言的经脉

func main() {

    //函数内部定义的变量必须使用

    // age := 19

    // if age > 18{

    //  fmt.Println("澳门首家线上赌场开业了")

    // }else{

    //  fmt.Println("该写暑假作业了")

    // }

    if age := 19; age > 35 { //局部变量，作用域

        fmt.Println("人到中年")

    } else if age > 18 {

        fmt.Println("青年")

    } else {

        fmt.Println("好好学习")

    }

    //golang只有for循环

    for i := 0; i < 10; i++ {

        fmt.Println(i)

    }

    //变种1

    var i = 5

    for ; i < 10; i++ {

        fmt.Print(i)

    }

    //无限循环

    // for {

    // }

    //for range 数组，切片，管道，map，字符串

    //数组、切片、字符串返回索引和值， map返回键和值 3 通道 channel返回通道内的值

    //Switch case

    s := "hello 沙河"

    for i, v := range s {

        fmt.Printf("%d, %c\n", i, v)

    }

    for i := 1; i < 10; i++ {

        for j := 1; j <= i; j++ {

            fmt.Printf("%d*%d=%d\t", i, j, i*j)

        }

        fmt.Println()

    }

    //go install 先编译，后拷贝

    //go语言文件基础语法

    //.go 。go build -o "xxx.exe"

    //多行注释

    /*asdf*/

    //变量，三种方式，1  var name string 2 name := 3 var name="沙河哪吒"

    // 函数内部专属： name3 := "沙河小王子"

    //匿名变量，哑元变量。 当有些数据必须有变量接收，又不使用它，用 _ 接收

    //常量

    const PI2 = 3.1415926

    //两个要点

    //1 iota在const关键字出现时将被重置为0  2 const中每新增一行常量声明，iota累加1

    //整型，无符号整形 uint8,uint16,uint32,uint64

    // 带符号整形 int8,int16,int32,int64

    // int 具体是32 还是64 看操作系统

    //upintptr 无符号整形，存放一个指针

    //go语言中无法直接定义二进制数

    var f1 = 1.214

    fmt.Printf("%T\n", f1)

    var f2 = float32(1.233)

    fmt.Printf("%T\n", f2)

    //浮点数 默认 float64

    //byte  rune 类型都是类型别名

    for i := 0; i < 10; i++ {

        if i == 5 {

            break

        }

        fmt.Println(i)

    }

    fmt.Println("over")

    for i := 0; i < 10; i++ {

        if i == 5 {

            continue

        }

        fmt.Println(i)

    }

    finger := 3

    switch finger {

    case 1:

        fmt.Println("大拇指")

        fallthrough

    case 2:

        fmt.Println("食指")

    case 3:

        fmt.Println("中指")

        goto breakTag

    case 4:

        fmt.Println("无名指")

    case 5:

        fmt.Println("小拇指")

    default:

        fmt.Println("无效")

    }

    fmt.Println("sssssssssssssss")

breakTag:

    fmt.Println("safdds")

    //算术运算符

    var (

        a = 5

        b = 2

    )

    fmt.Println(a+b, a*b, a-b, a%b, a/b)

    a++ //单独的语句，不能放在=的右边赋值

    b--

    fmt.Println(a, b)

    //关系运算符

    fmt.Println(a == b, a > b, a < b, a != b, a<<b, b<<a, a>>b, b>>a)

    var name, age = "jack", 22

    if age > 18 && name != "jack" {

        fmt.Println("苦逼上班的")

    } else if age > 18 && name == "jack" {

        fmt.Println("家里有矿")

    } else {

        fmt.Println("真羡慕他么爽，不用上班")

    }

    //not 取反，

    var isMarried = false

    fmt.Println(isMarried, !isMarried)

    // 5: 101  2:10

    fmt.Println(5&2, 5|2, 5^2, 5<<1, 1<<10, (1<<10)<<10)

    var m = int8(1)

    fmt.Println(m << 5)

    // 192.168.1.1

    //权限，

    //赋值运算符，用来给变量赋值

    var x int

    x = 10

    x += 1

    x -= 1

    x *= 2

    x /= 2

    x %= 2

    x <<= 2

    x &= 2

    x |= 2

    fmt.Println(x)

    //复合数据类型，数组，类似容器，同一数据类型元素的集合，声明时确定，运行时可修改数组成员，数组大小不可变

    //必须指定存放元素的类型和长度,数组的长度是数组类型的一部分

    //var a1 [3]bool

    //a1[0],a1[1],a1[2]=false,true,false

    var a1 = [3]bool{true, true, false}

    for i, v := range a1 {

        fmt.Printf("%T,%v,%d\n", i, v, len(a1))

    }

    //数组的初始化,默认元素都是零值(false, 0, "")

    fmt.Println(a1)

    //初始值自动推断数组的长度

    a100 := [...]int{0, 1, 2, 4, 12, 13, 14}

    fmt.Println(len(a100))

    //根据索引来初始化

    a3 := [5]int{0: 1, 4: 2}

    fmt.Println(a3)

    city := [...]string{"北京", "上海", "深圳"}

    for i := 0; i < len(city); i++ {

        fmt.Println(city[i])

    }

    for i, v := range city {

        fmt.Println(i, v)

    }

    //多维数组

    //[[1,2,3],[2,3]]

    //var a4 [3][2]int //三个元素，每个元素有2个数组

    //**问题：**碰到golint 提示redundant type from array, slice, or map composite literal。

    // 数组、切片或映射复合文字中的冗余类型。

    a4 := [3][2]int{

        // [2]int{1, 2},

        // [2]int{3, 4},

        // [2]int{5, 6},

        0: {1, 2},

        1: {3, 4},

        2: {5, 6},

    }

    var foo = map[int][]int{

        0: {1, 2},

        1: {1, 2},

    }

    fmt.Println(a4)

    //多维数组的遍历

    for _, v1 := range a4 {

        fmt.Println(v1)

        for _, v2 := range v1 {

            fmt.Println(v2)

        }

    }

    for k, v := range foo {

        fmt.Println("map", k, v)

    }

    //数组是值类型

    b1 := [3]int{1, 2, 3}

    b2 := b1 //ctrl+c, ctrl+v

    b2[2] = 100

    fmt.Println(b1, b2)

    //数组支持 ==  != 操作符，因为内存总是被初始化过的

    // [n]*T 表示指针数组， *[n]T表示数组指针

    b3 := [...]int{1, 3, 5, 7, 8}

    var count int = 0

    for _, v := range b3 {

        count += v

    }

    fmt.Println("count==", count)

    valueI := 8

    for i := 0; i < len(b3); i++ {

        for j := i + 1; j < len(b3); j++ {

            if b3[i]+b3[j] == valueI {

                fmt.Printf("(%d,%d)\n", i, j)

            }

        }

    }

    //切片，slice

    //数组的长度是固定的，是类型的一部分，有很多局限性。

    //是一个拥有相同类型元素的可变长度的序列，属于数组类型做的一组封装，非常灵活，自动扩容

    //引用类型，内部结构包含地址，长度，容量，用于快速的操作一块数据集合

    var s1 []int //定义一个存放int类型元素的切片

    var s2 []string

    fmt.Println(s1, s2)

    var c = []bool{false, true}

    var s3 = []int{1, 2, 3}

    var s4 = []string{"沙河", "张江", "平山村"}

    fmt.Println(c, s3, s4, len(s4), cap(s4))

    fmt.Println(s1 == nil, s2 == nil)

    //  s4=append(s4,"hello")

    s5 := [...]int{1, 3, 5, 7, 9, 11, 13}

    s6 := s5[:4] //基于一个数组切割，左闭右开

    fmt.Println(s6)

    fmt.Println(s5[1:], s5[:])

    //切片的容量是指底层数组的容量

    s7 := s5[:5]

    s8 := s5[2:5]

    //切片的容量底层数组从切片的第一个元素到最后的元素数量

    fmt.Printf("len(s7):%d,cap(s7):%d,%v\n", len(s7), cap(s7), s7)

    fmt.Printf("len(s8):%d,cap(s8):%d\n", len(s8), cap(s8))

    //切片再切片

    s9 := s7[4:]

    fmt.Printf("len(s9):%d,cap(s9):%d,%v\n", len(s9), cap(s9), s9)

    s10 := s5[3:]

    s11 := s10[2:]

    fmt.Printf("len(s11):%d,cap(s11):%d,%v\n", len(s11), cap(s11), s11)

    //切片是个引用类型，都指向了底层的具体的一个数组

    s5[6] = 1300 //修改了底层数组的值

    fmt.Println("s10:", s10, "s11", s11)

    fmt.Println("s")

    //make函数创建切片

    

    

}

func arraySum(s [3]int) int {

    sum := 0

    for _, v := range s {

        sum += v

    }

    return sum

}