一： 切片合并

注意： 基于go 实现 php 部份函数： 

github.com/Echo-Mr-Pengw/go-to-php/str

golang中使用gorm写入time.Time的类型时间问题

https://cloud.tencent.com/developer/article/2401442

定义一个切片类型的结构体：

// 定义一个切征模型

type MyModel struct {

gorm.Model

Asset []string `gorm:"type:json"` // 假设这是一个字符串数组

MedicalStrategyParams []string `gorm:"type:json"` // 假设这也是一个字符串数组

}

[golang]字符串拼接

https://developer.aliyun.com/article/1579386

golang项目中如何实现级联查询

https://blog.csdn.net/weixin_51261234/article/details/129014674

package main

import (
	"fmt"
)

func main() {
	// 定义三个不同类型的切片
	slice1 := []int{1, 2, 3}
	slice2 := []string{"a", "b", "c"}
	slice3 := []float64{1.1, 2.2, 3.3}

	// 使用空接口创建一个新的切片，用于存储所有类型的元素
	var mergedSlice []interface{}

	// 将第一个切片的元素添加到mergedSlice中
	for _, v := range slice1 {
		mergedSlice = append(mergedSlice, v)
	}
	// 将第二个切片的元素添加到mergedSlice中
	for _, v := range slice2 {
		mergedSlice = append(mergedSlice, v)
	}
	// 将第三个切片的元素添加到mergedSlice中
	for _, v := range slice3 {
		mergedSlice = append(mergedSlice, v)
	}

	// 打印合并后的切片
	fmt.Println(mergedSlice)
}


// 第二种处理模式：

// 使用空接口创建一个新的切片，用于存储所有类型的元素
	var mergedSlice []interface{}

// 访问特定类型的元素
for _, v := range mergedSlice {
	switch val := v.(type) {
	case int:
		fmt.Println("int:", val)
	case string:
		fmt.Println("string:", val)
	case float64:
		fmt.Println("float64:", val)
	default:
		fmt.Println("unknown type")
	}
}


type MixedType struct {
    Value interface{} // 存储任何类型的值
    Type  string      // 存储值的类型名称，便于后续处理和类型断言
}

二：切片声明处理

var mySlice1 []int = []int{1, 2, 3}
	fmt.Println(mySlice1) // 输出: [1 2 3]

	// 使用make函数创建切片并初始化
	mySlice2 := make([]int, 3) // 长度为3，初始化为0值
	fmt.Println(mySlice2)      // 输出: [0 0 0]

	// 使用append添加元素到切片中
	mySlice2 = append(mySlice2, 6, 5) // 现在长度为5，包含[0,0,0,6,5]
	fmt.Println(mySlice2)             // 输出: [0 0 0 4 5]
	s1 := make([]int, 0, 5)
	fmt.Println("最后输出s1的结果是：", s1)

三：切片元素是否存在一个切片中

import (
	"strconv"
)
 
func InSlice(value interface{}, list []string) bool {
	switch value.(type) {
	case int:
		value = strconv.Itoa(value.(int)) // value.(int)表示断言：value是一个int
	case uint:
		value = strconv.Itoa(int(value.(uint))) // int(type)表示强类型转换：将uint转为int
	case float64:
		value = strconv.FormatFloat(value.(float64), 'f', -1, 64) // 将float64转为string
	case float32:
		value = strconv.FormatFloat(float64(value.(float32)), 'f', -1, 32) // 将float32先转为float64再转为string
	}
 
	for _, el := range list {
		if el == value {
			return true
		}
	}
	return false
}

//  也可以使用 切片转换成 map ,再进行查找 
// 开始部份

package main

import (
	"fmt"
)

type Person struct {
	ID   string
	Name string
}

func main() {
	people := []Person{
		{"1", "Alice"},
		{"2", "Bob"},
		{"3", "Charlie"},
	}

	// 使用map的键类型和值类型与Person的ID和Name相匹配
	peopleMap := make(map[string]string)
	for _, person := range people {
		peopleMap[person.ID] = person.Name
	}

	fmt.Println(peopleMap) // 输出: map[1:Alice 2:Bob 3:Charlie]
}


value, ok := myMap[key]
if !ok {
    // 键不存在
} else {
    // 键存在，value是对应的值
}

// 第二种方法：

if value, exists := myMap[key]; exists {
    // 键存在，value是对应的值
} else {
    // 键不存在
}



示例2：将包含单一元素的切片转换为map（使用索引作为键）
如果你想使用切片的索引作为map的键，可以将索引直接用作键。

package main

import (
	"fmt"
)

func main() {
	names := []string{"Alice", "Bob", "Charlie"}

	// 使用map的键类型为int（索引），值类型为string（元素）
	namesMap := make(map[int]string)
	for index, name := range names {
		namesMap[index] = name
	}

	fmt.Println(namesMap) // 输出: map[0:Alice 1:Bob 2:Charlie]
}


示例3：将切片转换为不同类型的map（例如，将结构体切片转换为另一个结构体的map）

package main

import (
	"fmt"
)

type Person struct {
	ID   string
	Name string
}

type PersonInfo struct {
	FullName string // 假设我们想存储全名信息，例如 Name + " " + Surname
}

func main() {
	people := []Person{
		{"1", "Alice"},
		{"2", "Bob"},
	}

	// 创建一个map，其值为PersonInfo类型的新结构体，包含全名信息。
	peopleInfoMap := make(map[string]PersonInfo) // 使用ID作为键，因为它是唯一的标识符。
	for _, person := range people {
		peopleInfoMap[person.ID] = PersonInfo{FullName: person.Name + " Doe"} // 假设Surname是 Doe，仅为示例。
	}

	fmt.Println(peopleInfoMap) // 输出: map[1:{Alice Doe} 2:{Bob Doe}]
}

四：去除切片中的空值

func FilterSlice(list []string) (result []string) {
	for _, value := range list {
		if value != "" {
			result = append(result, value)
		}
	}
	return
}

五：去除切片中的重复值

func UniqueSlice(list []string) (result []string) {
	// 存储每个元素的数量
	countEle := make(map[string]int)
	for _, value := range list {
		countEle[value] += 1
		if countEle[value] > 1 {
			continue
		}
		result = append(result, value)
	}
	return
}

六：将多个同类型切片合并成一个切片

func MergeSlice(list ...[]string) (result []string) {
	for _, value := range list {
		for _, v := range value {
			result = append(result, v)
		}
	}
	return
}

七：将多个map合并成一个map

和切片的合并一样。如果合并的map中键有重复，则后面的键值会覆盖前面的。小白需要注意的是，map使用前需要初始化。

另外，如果方法要传固定参数，固定参数需要放到可变参数前面。

func MergeMap(mapList ...map[string]string) map[string]string {
	result := make(map[string]string)
	for _, value := range mapList {
		for k, v := range value {
			result[k] = v
		}
	}
	return result
}

八：用于合并两个go map

package main
 
import "fmt"
 
// MergeMaps 创建一个新的 map 用于保存合并后的值。返回新的 map。
func MergeMaps(destMap, sourceMap map[string]interface{}) map[string]interface{} {
	newMap := make(map[string]interface{})
 
    // 将目标 map 的元素复制到新 map 中
	for key, value := range destMap {
		newMap[key] = value
	}
 
	// 将源 map 中的元素合并到新 map 中
	for key, value := range sourceMap {
		newMap[key] = value
	}
 
	return newMap
}
 
func main() {
	map1 := map[string]interface{}{"key1": "value1", "key2": "value2"}
	map2 := map[string]interface{}{"key2": "new value2", "key3": "value3"}
 
	result := MergeMaps(map1, map2)
 
	fmt.Println(result) // Output: map[key1:value1 key2:new value2 key3:value3]
}

九：

十：