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)