（基础篇）go常用使用场景一

一、循环

循环两种方式，这两个实现的效果是一样的，都是循环根据数组长度下标做判断：

var categoryListSt []string
for i,value := range categoryList{
    if i == len(categoryList)-1{
    categoryListSt = append(categoryListSt, "'"+value+"'")
    }else{
    categoryListSt = append(categoryListSt, "'"+value+"'"+",")
    }
}
for i := 0; i < len(categoryList); i++ {
        if i == len(categoryList)-1{
            categoryListSt = append(categoryListSt, "'"+categoryList[i]+"'")
        }else{
            categoryListSt = append(categoryListSt, "'"+categoryList[i]+"'"+",")
        }
    }

二、处理字符串：

//上面就是string的list
//字符串的拼接
result := strings.Join(categoryListSt, "")
​
//字符串可以和[]byte切片互相转换
b := []byte{'H', 'e', 'l', 'l', 'o'}  
s := string(b)  
fmt.Println(s) // 输出: Hello
s := "Hello"  
b := []byte(s)  
fmt.Println(b) // 输出: [72 101 108 108 111]

三、json的数据处理：

jsonData := `  
     {  
     "name": "John",  
     "age": 30,  
     "email": "john@example.com",  
     "info": [{  
     "address": "KK-123 Main St",  
     "phone": "555-1234"  
     }]
     }  
    `
​
    // 定义map来存储解析后的数据
    var data map[string]interface{}
​
    // 解析JSON数据到map中
    err := json.Unmarshal([]byte(jsonData), &data)
    if err != nil {
        fmt.Println("解析JSON失败:", err)
        return
    }
​
    // 访问二级嵌套字段
    //address := data["info"].(map[string]interface{})["address"].(string)
    //phone := data["info"].(map[string]interface{})["phone"].(string)
    address := data["info"].([]interface{})[0].(map[string]interface{})["address"].(string)
    phone := data["info"].([]interface{})[0].(map[string]interface{})["phone"].(string)
    fmt.Println("地址:", address)
    fmt.Println("电话:", phone)

---------------------------------------------------------------
//第二种实现方式
type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
    Info  []struct {
        Address string `json:"address"`
        Phone   string `json:"phone"`
    } `json:"info"`
}
​

jsonData := `  
     {
     "name": "John",
     "age": 30,
     "email": "john@example.com",
     "info": [{
     "address": "KK-123 Main St",
     "phone": "555-1234"
     }]
     }  
    `
​
    // 定义结构体
    var person Person
​
    // 解析JSON数据到结构体中
    err := json.Unmarshal([]byte(jsonData), &person)
    if err != nil {
        fmt.Println("解析JSON失败:", err)
        return
    }
​
    // 访问二级嵌套字段
    address := person.Info[0].Address
    phone := person.Info[0].Phone
​
    fmt.Println("地址:", address)
    fmt.Println("电话:", phone)

---------------------------------------------------------------
//第三种实现方式
jsonData := `  
     {
     "name": "John",
     "age": 30,
     "email": "john@example.com",
     "info": [{
     "address": "KK-123 Main St",
     "phone": "555-1234"
     }]
     }  
    `
​
    // 定义map来存储解析后的数据
    var data map[string]interface{}
​
    // 解析JSON数据到map中
    err := json.Unmarshal([]byte(jsonData), &data)
    if err != nil {
        fmt.Println("解析JSON失败:", err)
        return
    }
​
    // 访问二级嵌套字段
    infoArray, ok := data["info"].([]interface{})
    if !ok || len(infoArray) == 0 {
        fmt.Println("解析info字段失败")
        return
    }
​
    info := infoArray[0].(map[string]interface{})
    address, addressOk := info["address"].(string)
    phone, phoneOk := info["phone"].(string)
​
    if !addressOk || !phoneOk {
        fmt.Println("解析address或phone字段失败")
        return
    }
​
    fmt.Println("地址:", address)
    fmt.Println("电话:", phone)

四、接口类型转换样例：

// 将不同类型的值存储在空接口中
    var myInterface interface{}
    myInterface = 42
​
    // 使用类型断言获取原始类型的值
    if intValue, ok := myInterface.(int); ok {
        fmt.Println("原始类型是int:", intValue)
    } else {
        fmt.Println("无法转换为int")
    }
​
    // 尝试使用错误的类型断言
    if stringValue, ok := myInterface.(string); ok {
        fmt.Println("原始类型是string:", stringValue)
    } else {
        fmt.Println("无法转换为string")
    }
​
    // 类型断言的另一种写法，可以在一行中判断和获取值
    if floatValue, ok := myInterface.(float64); ok {
        fmt.Println("原始类型是float64:", floatValue)
    } else {
        fmt.Println("无法转换为float64")
    }
​
    // 使用switch语句进行多重类型判断
    switch value := myInterface.(type) {
    case int:
        fmt.Println("原始类型是int:", value)
    case string:
        fmt.Println("原始类型是string:", value)
    case float64:
        fmt.Println("原始类型是float64:", value)
    default:
        fmt.Println("未知类型")
    }

导包

1、go get -u github.com/gin-gonic/gin
2、go mod tidy