golang

2进制10进制转换

一、基本

  • 不允许隐式类型转换

    常用集合

  • 基本声明使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    fmt.Printf("hello word" + "\n")
        // 声明字符串
        var str1 = "njdkanjkdns"
        fmt.Printf(str1 + "\n")
        // 声明字符串2
        var str2 string
        str2 = "ndsjak13132"
        fmt.Printf(str2 + "\n")
        // 声明字符串3
        var str3 string
        fmt.Printf(str3 + "\n")
        // 声明字符串4
        str4 := "1234fdsf"
        fmt.Printf(str4 + "\n")
        // 声明字符串5
        var (
            str5 string = "dajkdnsjk11"
        )
        fmt.Printf(str5 + "\n")
        // 标常用 var str3 string="1232"; str4:="12323";var str3,str4:="12323",'12323";

  • 变量交换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    // 二进制与方式变量交换（省内存）
        fmt.Println("二进制与方式变量交换（省内存））")
        var a int = 100
        var b int = 200
        a = a ^ b
        b = b ^ a
        a = a ^ b

        fmt.Println(a, b)
        // 变量交换（常规）
        fmt.Println("变量交换（常规）")
        var c int = 100
        var d int = 200
        c, d = d, c
        fmt.Println(c, d)

  • 匿名变量

    1
    2
    3
    4
    5
    // 匿名变量 （变量不被用到时会报错 所以用_来代替）
        fmt.Println("匿名变量")
        e, _ := 100, 200
        _, f := 100, 200
        fmt.Println(e, f)

  • 常量

    1
    2
    3
    4
    5

    // 常量
        const const1 int = 1
        fmt.Println("常量")
        fmt.Println("常量", const1)

  • 变量作用域
    全局变量和局部变量 函数题外 var声明 全局 函数体内如果有同名局部变量 则局部变量优先

  • 数组 ：
    初始化固定长度

    1
    2
    3
    4
    5
    6
    var tmpArr = [10]int{}
    var a [3]int
    a[0] = 1

    b := [3]int{1,2,3}
    c := [2][3]int{{1,2,4},{4,5,6}}

  • 切片：
    可变长度，容量不够按照2的倍数增长容量空间,共享存储结构 （len()获取元素个数，cap获取容量）

  • map:
    相当于js 的json对象 形式可以自定义k {“asd”:1,”qwe”:2}

    1
    2
    3
    4
    5
    6
    //声明
        m := map[string]int{"asd":1,"qwe":2}
        m1 := map[string]int{}
        m1["one"] = 1
        
        m2 := make(map[string]int,10)

  • 循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // 循环
        fmt.Println("循环")
        for i := 1; i <= 10; i++ {
            fmt.Println(i)
        }

    // for each 循环
        var tmpArr = [10]int{}
        tmpArr = [10]int{2, 3, 5, 5}
        tmpArr[4] = 1
        for i, x := range tmpArr {
            fmt.Println(i, x)
        }

  • 指针
    指针 1、指针存储 变量的内存地址 2、变量加&获取地址 3、指针前家* 获取指针指向的变量的值 4、修改指针变量的值，所有指向改内存的变量都会被修改

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    var ipa int = 312
    var ipInt *int       /* 指向整型*/
    var fpFloat *float32 /* 指向浮点型 */
    ipInt = &ipa
    *ipInt = 23
    fmt.Println(ipInt, fpFloat, ipa)

    // z指针数组
    var tmpArr5 = [3]int{1, 2, 3}
    var fpArr [3]*int
    for i := 0; i < 3; i++ {
        fpArr[i] = &tmpArr5[i]
    }
    fmt.Println(*fpArr[0], fpArr[0])

  • struct结构体

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //自定义数据结构类型
    type Result struct {
        Code    int    `json:"code_json"`
        Message string `json:"msg_json"`
    }
    type testp int

    var res1 = Result{Code: 123, Message: "qwe123"}
    fmt.Println(res1)
    var res1Json, err = json.Marshal(res1)
    fmt.Println("输出json后:", string(res1Json), err)
    /*
    也可以这么写
    if res1Json, err = json.Marshal(res1); err != nil{
        fmt.Println("输出json后报错了:", err)
    }
    fmt.Println("输出json后成功了:", string(res1Json))
    */

    var res2 Result
    err = json.Unmarshal(res1Json, &res2)
    fmt.Println("json解密后:", res2, err)