golang学习笔记

1、interface 转 string,int,float64

func interface2String(inter interface{}) {

    switch inter.(type) {

    case string:
        fmt.Println("string", inter.(string))
        break
    case int:
        fmt.Println("int", inter.(int))
        break
    case float64:
        fmt.Println("float64", inter.(float64))
        break
    }

}

func main() {
    interface2String("jack")
    interface2String(1)
    interface2String(12.223)
}

2、运用反射查看变量数据类型

import (
    "fmt"
    "reflect"
)
fmt.Println("type:", reflect.TypeOf(x))

 3、json字符串转json对象然后转集合+类型断言访问

a、字符串直接解析

package main

import (
    "fmt"
    "encoding/json"
    "reflect"
)

func main(){
    newPostData := make(map[string]interface{})
    var postData = `{"id":123}`
    // 字符串转字符串集合
    b := []byte(postData)
    err := json.Unmarshal(b, &newPostData)
    if err != nil {
        
    }
    fmt.Println("type:", reflect.TypeOf(newPostData))
    /*输出json */
    for aa := range newPostData {
        fmt.Println("type:", reflect.TypeOf(newPostData[aa]))
        fmt.Println(newPostData[aa])
    }
    // json字符串转map集合
    new_json_two := make(map[string]interface{})
    // 定json，由此可以看出会被解析为一个 map[string]interface{} ,首先获取耳机
    json_two := `{"type":[{"id":123,"name":"jack"}]}`
    err = json.Unmarshal([]byte(json_two), &new_json_two)
    if err != nil {
    }
    /*输出json */
    for idx := range new_json_two {
        fmt.Println(new_json_two[idx])
        fmt.Println("new_json_two type is:", reflect.TypeOf(new_json_two[idx]))//数组
        // []interface{}
           fmt.Println(new_json_two[idx])
           // 输出
        switch vv := new_json_two[idx].(type) {
            case string:
                // 字符串
                fmt.Println(vv)
            case float64:
                // 数字
                fmt.Println(vv)
            case bool:
                // 布尔值
                fmt.Println(vv)
            case map[string]interface{}:
                // 集合
                fmt.Println(vv)
                for i, j := range vv {
                    fmt.Println(i,":",j)
                }
            case []interface{}:
                // 数组
                fmt.Println(vv)
                for i, j := range vv {
                    fmt.Println(i, ":", j)
                    fmt.Println("type:", reflect.TypeOf(j))
                    fmt.Println(j)
                    showDetail(j)
                    // interface转为map
                    var tmp = j.(map[string]interface{})
                       for ii,jj := range tmp {
                        fmt.Println(jj,tmp[ii])
                    }
                }
            default:
                // nil
                fmt.Println(vv)
        }
    }
}

func showDetail(item interface{}){
    switch vv := item.(type) {
        case string:
            // 字符串
            fmt.Println(vv)
        case float64:
            // 数字
            fmt.Println(vv)
        case bool:
            // 布尔值
            fmt.Println(vv)
        case map[string]interface{}:
            // 集合
            fmt.Println(vv)
            for i, j := range vv {
                fmt.Println("map[string]interface{}",i,j)
                fmt.Println(vv[i])
            }
        case []interface{}:
            // 数组
            fmt.Println(vv)
            for i, j := range vv {
                fmt.Println(i, ":", j)
                fmt.Println("type:", reflect.TypeOf(j))
                fmt.Println(j)
                // for ii := range j {
                    // fmt.Println(j[ii].(string))
                // }
            }
        default:
            // nil
            fmt.Println(vv)
    }
}

b、json文件读取后解析

{
    "id": 1,
    "content": "hello world",
    "author": {
        "id": 2,
        "name": "userA"
    },
    "published": true,
    "label": [],
    "nextPost": null,
    "comments": [{
            "id": 3,
            "content": "good post1",
            "author": "userB"
        },
        {
            "id": 4,
            "content": "good post2",
            "author": "userC"
        }
    ]
}

package main

import (
    "fmt"
    "encoding/json"
    "os"
    "io/ioutil"
)

func main() {
    // 读取json数据
    fh, err := os.Open("a.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fh.Close()
    jsonData, err := ioutil.ReadAll(fh)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    // 解析json数据到interface{}
    var unknown interface{}
    err = json.Unmarshal(jsonData, &unknown)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 进行断言，并switch匹配
    m := unknown.(map[string]interface{})
    for k, v := range m {
        switch vv := v.(type) {
        case string:
            // 字符串
            fmt.Println(k, ":", vv)
        case float64:
            // 数字
            fmt.Println(k, "：", vv)
        case bool:
            // 布尔值
            fmt.Println(k, ":", vv)
        case map[string]interface{}:
            // 集合
            fmt.Println(k, ":", vv)
            for i, j := range vv {
                fmt.Println(i,": ",j)
            }
        case []interface{}:
            // 数组
            fmt.Println(k, "：", vv)
            for key, value := range vv {
                fmt.Println(key, ": ", value)
            }
        default:
            // nil
            fmt.Println(k, ":", vv)
        }
    }
}

参考地址    https://blog.csdn.net/qq_36178899/article/details/84869079

 4、golang笔记 - strconv的用法

 https://juejin.im/post/5c18d0c2e51d45270f53fc1d

 https://www.cnblogs.com/yaowen/p/8353444.html

5、格式转换

比如 float64 的整数转为整数字符串

strconv.FormatFloat(item["id"].(float64), 'f', -1, 64)

https://www.jb51.net/article/119164.htm