乐趣区

go学习笔记1

  1. 变量的定义

    • 只定义,不赋值
    // 会有初值
    var a int
    var s string
    • 定义和赋值
    var a int = 3
    var s string = "abs"
    #一次定义多个同类型的变量
    var a, b int = 3, 4
    • 系统判别类型
    var a, b, c, s = 2, 3, 4, "def"
    • 短格式
    c := 5
    a, b, s, d := 2, 3, "def", 5
    d = 6 
    • 在函数外部集中定义
    // 在函数外部不能使用短格式定义
    var (
        a = 3
        b = 4
        s = "hell"
    )
  2. 内建变量的类型

    • 分类
    bool,string
    (u)int,(u)int8|16|32|64,uintptr(指针)
    byte,rune(字符)
    float32|64,complex64|128(复数)
    • 强类型
    // 打印变量的类型
    func main() {
        var a int = 89
        b := 95
        fmt.Println("value of a is", a, "and b is", b)
        fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的类型和大小
        fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的类型和大小
    }
    • 数据类型的转换
    func main() {
        i := 55      //int
        j := 67.8    //float64
        sum := i + int(j) // 不同类型的数据不允许进行运算 这里需要强制转换
        var c int
        c = int(j) // 赋值也是一样
        fmt.Println(sum, c)
    }
  3. 常量

    • 定义
    func main() {
        const name = "mengyuan" // 不指定类型
        #const name string = "mengyuan" // 指定类型
        fmt.Printf("type %T value %v\n", name, name)
        const(
            a = 1
            s = "mengyuan"
        ) // 一次定义多个类型
    }
    • 注意
    // 因为是强类型语言
    // 赋值操作需要两边的类型一致 常量如果不指定类型的话就不需要注意
    func main() {
        const trueConst = true // 类型不确定
        type myBool bool
        var defaultBool bool = trueConst // 允许 在赋值时确定类型
        var customBool myBool = trueConst // 允许
        //defaultBool = customBool // 不允许
    
        fmt.Println(defaultBool, customBool)
    }
    • 枚举
    func main() {
        const(
            cpp = 0
            java = 1
            python = 2
            golang = 3
            js = 4
        )
        // 自增值枚举类型
        const(
            cpp = iota
            java
            python
            golang
            js
        )
    }
  4. if-else

    • 格式
    if condition {doing} else if condition {doing} else {doing}
    • 注意点
    // 判断奇偶
    func main() {
        if num := 10; num % 2 == 0 { // 可以连写 但是变量 num 的作用范围仅仅在 if 语句中
            fmt.Println("the number is even") 
        } else {//} 和 else 必须是在一行 不能换行
            fmt.Println("the number is odd")
        }
    }
  5. switch

    • 连写模式
    //num := 5
    switch num := 2; num { // num 的作用域在 switch
    case 1:
        fmt.Println("php")
    case 2:
        fmt.Println("python")
    case 3:
        fmt.Println("java")
    // case 3: case 不允许出现重复项
    //    fmt.Println("js")
    case 4:
        fmt.Println("cpp")
    case 5:
        fmt.Println("golang")
    default: // default 可以写在任何位置
        fmt.Println("default")
    }
    • 无表达式
    nums := 2
    switch {  // 相当于 switch true
    case nums <= 2: 
        fmt.Println("E")
    case nums <= 5:
        fmt.Println("D")
    case nums <= 6:
        fmt.Println("C")
    //case 3: case 不允许出现重复项
    //    fmt.Println("js")
    case nums <= 8:
        fmt.Println("B")
    case nums <= 10:
        fmt.Println("A")
    default:
        fmt.Println("default")
    }
    • 多表达式 (多种情况 一种处理方式)
    // 包含多个表达式
    numbers := 5
    switch numbers {
    case 2, 3, 4, 5:
        fmt.Println("the number <= 5")
    case 6, 7, 8, 9, 10:
        fmt.Println("the number <= 5")
    }
    • fallthrough 语句
    // 使用 fallthrough 语句可以在已经执行完成的 case 之后,把控制权转移到下一个 case 的执行代码中
    number := 5
    switch number {
    case 2:
        fmt.Println("E")
        fallthrough
    case 5:
        fmt.Println("D")
        fallthrough
    case 6:
        fmt.Println("C")
        fallthrough
    //case 3: case 不允许出现重复项
    //    fmt.Println("js")
    case 8:
        fmt.Println("B")
        fallthrough
    case 10:
        fmt.Println("A")
    }
  6. 循环

    • 标准示例
    // for 循环语句包括 初始条件 终止条件 post 语句 三部分
    //num := 10
    for i := 1; i <= 10; i++ {fmt.Println(i)
    }
    • continue 终止本次循环
    //num := 10
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {continue}
        fmt.Println(i)
    }
    • break 跳出整个循环
    //num := 10
    for i := 1; i <= 10; i++ {
        if i > 7 {break}
        fmt.Println(i)
    }
    • 模仿 while
    i := 1
    for i <= 10 {fmt.Println(i)
        i++
    }
    • 死循环
    for {fmt.Println("hello")
    }
  7. 函数

    • 定义
    func calculateBill(num int, price int) int {
        ret := num * price
        return ret
    }
    // 同类型的参数可以简写 返回值类型可以不写
    func calculateBill(num,price int) int {
        ret := num * price
        return ret
    }
    • 调用
    func main() {
        price, num := 4, 5// 定义变量
        ret := calculateBillSimple(num, price)// 调用
        fmt.Println(ret)
        // 空白符
        var a, _ = rectPropsName(2, 4)
        fmt.Printf("the area is %.2f \n", a)
    }
    • 多返回值
    // 多返回值
    func rectProps(length, width float64) (float64, float64) {
        var area = length * width
        var perimeter = (length + width) * 2
        return area, perimeter
    }
    • 命名返回值
    func rectPropsName(length, width float64) (area float64, perimeter float64) {
        area = length * width
        perimeter = (length + width) * 2
        return
    }
  8. 指针

    • 定义
    // 指针的典型例子
    var a int = 2
    var pa *int = &a
    *pa = 3
    fmt.Println(a)
    • 动态改变变量的值
    func swap(a, b *int) {*a, *b = *b, *a}
    func swapNew(a, b int) (int, int) {
        a, b = b, a
        return a, b
    }
    
    func main() {
        // 交换变量的值
        a, b := 3, 4
        //swap(&a, &b)
        a, b = swapNew(a, b)
        fmt.Println(a, b)
    }
  9. 搭建一个 web 服务

    • net/http 模块
    // 当然不支持高并发
    package main
    import ("net/http")
    func main() {http.Handle("/", http.FileServer(http.Dir(".")))
        http.ListenAndServe(":8080", nil)
    }
退出移动版