golang 深拷贝
package main
import (
"container/list"
"encoding/json"
"fmt"
"reflect"
"strconv"
"strings"
)
type UserInfo struct {
ID int64 `json:"id"`
Name string `json:"name"`
}
func main() {
fmt.Println("开始执行")
// funcCopy()
// funcCollection()
// typeConversion()
//funcArray()
funcStruct()
}
/*
深浅拷贝：
深拷贝：拷贝数据的副本，对原始数据没有影响
值类型的数据，默认都是深拷贝
int, float,string,bool,array,struct
浅拷贝：拷贝的是数据的地址，
引用类型的数据，默认都是浅拷贝
slice,map,function
*/
func funcCopy() {
//深拷贝
s2 := []int{1, 2, 3, 4}
s3 := []int{7, 8, 9}
copy(s2, s3)
//浅拷贝
s4 := [4]int{1, 2, 3, 4}
s5 := &s4
fmt.Println(s4, s5)
}
func StringToRuneArr(s string, arr []rune) {
src := []rune(s)
for i, v := range src {
if i >= len(arr) {
break
}
arr[i] = v
}
}
//github.com/jianfengye/collection
func funcCollection() {
// 数组 转 list
// list或者数组 转 string
lists := list.New()
arrays := [...]int{1, 2, 3}
str1 := strings.Replace(strings.Trim(fmt.Sprint(arrays), "[]"), " ", ",", -1)
str2 := strings.Replace(strings.Trim(fmt.Sprint(lists), "[]"), " ", ",", -1)
fmt.Println(str1, str2)
// string 转 list
// list的对象 for循环
//切片 转 数组
a := [...]int{1, 2, 3}
s := make([]int, 3)
fmt.Println(copy(s, a[:2]))
fmt.Println(s)
}
func funcArray() {
// string 转 数组
str := "ABCDEF"
var arr [6]rune
StringToRuneArr(str, arr[:])
fmt.Printf("%v", arr)
// 数组 转 string
fmt.Println(string(arr[:]))
}
func typeConversion() {
// string 转 byte
s := "hello"
var a []byte
a = []byte(s)
// string 转 rune
var b []rune
b = []rune(s)
fmt.Println(a, b)
// int 转 string
var i int = 10
str1 := strconv.Itoa(i)
str2 := fmt.Sprintf("%d", i)
fmt.Println(str1, str2)
// string 转 int
i, err := strconv.Atoi(str2)
if err != nil {
fmt.Println("类型转换失败:", err)
}
//int64 转 string 第二个参数为基数
var i64 int64 = 10
str3 := strconv.FormatInt(i64, 10)
// string 转换为 int64
//第二参数为基数，后面为位数，可以转换为int32，int64等
i64, error := strconv.ParseInt(str3, 10, 64)
if error != nil {
fmt.Println("类型转换失败:", error)
}
}
func funcStruct() {
str := `{"id": 1, "name": "xiong"}`
var userInfo UserInfo
// 将字符串反解析为结构体
json.Unmarshal([]byte(str), &userInfo)
fmt.Println(userInfo)
var d map[string]interface{}
// 将字符串反解析为字典
json.Unmarshal([]byte(str), &d)
fmt.Println(d)
// 将结构体解析为字符串
b, e := json.Marshal(userInfo)
fmt.Println(e)
fmt.Println(string(b))
}
// 反射
func funcReflect() {
rv := []interface{}{"hi", 42, func() {}}
for _, v := range rv {
switch v := reflect.ValueOf(v); v.Kind() {
case reflect.String:
fmt.Println(v.String())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fmt.Println(v.Int())
default:
fmt.Printf("unhandled kind %s", v.Kind())
}
}
}
//判断字符串是否相等
func funcEqual() {
fmt.Println("go" == "go")
fmt.Println("GO" == "go")
fmt.Println(strings.Compare("GO", "go"))
fmt.Println(strings.Compare("go", "go"))
fmt.Println(strings.EqualFold("GO", "go"))
}
// 字符串转布尔值
func ConvertStringToBool(str string) bool {
return strings.ToLower(str) == "true"
}
//布尔值转字符串
func ConvertBoolToString(b bool) string {
if b {
return "true"
}
return "false"
}
/**
判断是否为指针
*/
func IsStructPtr(t reflect.Type) bool {
return t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct
}
//判断数组是否为空
func isArray() {
var arr []string
if arr == nil {
fmt.Println("this is null")
}
if len(arr) > 0 {
fmt.Println("len arr > 0")
} else {
fmt.Println("len this is null")
}
if arr[0] != "" {
fmt.Println("arr 0 != null")
} else {
fmt.Println("[0] this is null")
}
}