golang 深拷贝、浅拷贝、list转string、切片 转 数组、string 转 数组、基本类型转换、反射、字符串比较、判断指针

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")
	}
}