type User struct {
    ID   int // ID 作为唯一标识 (ID相同则认为是同一个元素)
    Name string
}

old := []User{
    {ID: 1, Name: "a"}, // only in old
    {ID: 2, Name: "b"}, // 重复
}

new := []User{
    {ID: 2, Name: "c"}, // 重复
    {ID: 3, Name: "d"}, // only in new
}

c := []User{
    {ID: 1, Name: "a"}, // only in old
    {ID: 2, Name: "c"}, // 重复 (保留 new 中的)
    {ID: 3, Name: "d"}, // only in new
}

package main

import "fmt"

type User struct {
    ID   int
    Name string
}

// contains Check if an element exists in a slice.
//  keyFunc is used to uniquely identify the elements.
func contains(slice []any, item any, keyFunc func(any) any) bool {
    for _, element := range slice {
        if keyFunc(element) == keyFunc(item) {
            return true
        }
    }
    return false
}

// mergeSlices Merges two slices and removes duplicates.
//
//  keyFunc  is used to uniquely identify the elements.
//  if an element exists in both old and new, the element in new takes precedence.
//  old and new are assumed to have no duplicate elements.
// The order is not guaranteed.
func MergeSlices(old, new []any, keyFunc func(any) any) []any {
    var merged []any

    // copy new to merged
    merged = append(merged, new...)

    for _, item := range old {
        if !contains(merged, item, keyFunc) {
            merged = append(merged, item)
        }
    }

    return merged
}

func main() {
    old := []any{
        User{ID: 1, Name: "a"},
        User{ID: 2, Name: "b"}, // 重複
    }
    new := []any{
        User{ID: 2, Name: "c"}, // 重複
        User{ID: 3, Name: "d"},
    }

    mergedUsers := MergeSlices(old, new, func(item any) any {
        return item.(User).ID
    })
    fmt.Printf("Merged Users:%+v", mergedUsers) // Merged Users:[ {ID:1 Name:a} {ID:2 Name:c} {ID:3 Name:d}]
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    str := "abc世界"
    fmt.Println(utf8.RuneCountInString(str)) // 5
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    emojiWorld := "🌍"
    fmt.Println(utf8.RuneCountInString(emojiWorld)) // 1  ✅ 没有问题

    emojiHand := "👉"
    fmt.Println(utf8.RuneCountInString(emojiHand)) // 1  ✅ 没有问题

    emojiHandBlack := "👉🏿"
    fmt.Println(utf8.RuneCountInString(emojiHandBlack)) // 2 ❌ 有问题 期望是 1。 同一种 emoji，但是不同的皮肤颜色的字符数不一样

    emojiOne := "1️⃣"
    fmt.Println(utf8.RuneCountInString(emojiOne)) // 3 ❌ 有问题 期望是 1。
}

package main

import (
    "fmt"

    "github.com/rivo/uniseg"
)

func main() {
    emojiWorld := "🌍"
    fmt.Println(uniseg.GraphemeClusterCount(emojiWorld)) // 1  ✅ 没有问题

    emojiHand := "👉"
    fmt.Println(uniseg.GraphemeClusterCount(emojiHand)) // 1  ✅ 没有问题

    emojiHandBlack := "👉🏿"
    fmt.Println(uniseg.GraphemeClusterCount(emojiHandBlack)) // 1  ✅ 没有问题

    emojiOne := "1️⃣"
    fmt.Println(uniseg.GraphemeClusterCount(emojiOne)) // 1  ✅ 没有问题
}

    template := "http://{{host}}/?q={{query}}&foo={{bar}}{{bar}}"
    t := fasttemplate.New(template, "{{", "}}")
    s := t.ExecuteString(map[string]interface{}{
        "host":  "google.com",
        "query": url.QueryEscape("hello=world"),
        "bar":   "foobar",
    })
    fmt.Printf("%s", s)

    // Output:
    // http://google.com/?q=hello%3Dworld&foo=foobarfoobar

    template := "Hello, [user]! You won [prize]!!! [foobar]"
    t, err := fasttemplate.NewTemplate(template, "[", "]")
    if err != nil {
        log.Fatalf("unexpected error when parsing template: %s", err)
    }
    s := t.ExecuteFuncString(func(w io.Writer, tag string) (int, error) {
        switch tag {
        case "user":
            return w.Write([]byte("John"))
        case "prize":
            return w.Write([]byte("$100500"))
        default:
            return w.Write([]byte(fmt.Sprintf("[unknown tag %q]", tag)))
        }
    })
    fmt.Printf("%s", s)

    // Output:
    // Hello, John! You won $100500!!! [unknown tag "foobar"]