golang去重、去除零值链式调用

Question

//去重int64切片的零值
func RemoveNonZero(slice []int64) []int64 {
    ids := make([]int64,0)
    for i,count :=0, len(slice);i < count;i++{
        if slice[i] >0{
            ids = append(ids,slice[i])
        }
    }

    return ids
}

//对int64排序去重
func RemoveDuplicatesInt64(ids []int64) int {
    if len(ids) < 1{
        return 0
    }

    sort.Slice(ids, func(i, j int) bool {
        return ids[i] < ids[j]
    })

    j := 1
    for i := 1; i < len(ids); i++ {
        if ids[i] != ids[i-1] {
            ids[j] = ids[i]
            j++
        }
    }

    return j
}


我有以上的两个函数，大部分情况下先去除零值，再去重，我想把他搞成链式调用，但也有可能是分开调用。比如RemoveNonZero().RemoveDuplicatesInt64()，也有可能是单独调用，比如RemoveDuplicatesInt64()或者RemoveNonZero()，应该怎么封装？

Answer 1

让【宝码香车】来帮您解答，本回答参考DeepSeek编写，并整理提供。

如果答案让您满意，请采纳、点赞、关注，非常感谢！
.
每日一句正能量，让它带给您好心情：每一个不曾放弃的瞬间，都在为未来积蓄力量。
.

我来帮你封装成支持链式调用的形式。你可以创建一个自定义类型并为其定义方法来实现链式操作。

package main


import "sort"


// 定义自定义类型
type Int64Slice []int64


// 去重int64切片的零值
func (s Int64Slice) RemoveNonZero() Int64Slice {
    ids := make([]int64, 0)
    for i, count := 0, len(s); i < count; i++ {
        if s[i] > 0 {
            ids = append(ids, s[i])
        }
    }
    return ids
}


// 对int64排序去重
func (s Int64Slice) RemoveDuplicatesInt64() Int64Slice {
    if len(s) < 1 {
        return s
    }


    // 创建副本避免修改原切片
    ids := make([]int64, len(s))
    copy(ids, s)
    
    sort.Slice(ids, func(i, j int) bool {
        return ids[i] < ids[j]
    })


    j := 1
    for i := 1; i < len(ids); i++ {
        if ids[i] != ids[i-1] {
            ids[j] = ids[i]
            j++
        }
    }


    return ids[:j]
}


// 为了方便使用，提供转换函数
func ToInt64Slice(slice []int64) Int64Slice {
    return Int64Slice(slice)
}


// 转换回普通切片
func (s Int64Slice) ToSlice() []int64 {
    return []int64(s)
}

使用示例：

func main() {
    slice := []int64{1, 0, 2, 3, 0, 2, 1, 4}
    
    // 链式调用：先去零值再去重
    result1 := ToInt64Slice(slice).RemoveNonZero().RemoveDuplicatesInt64().ToSlice()
    fmt.Println(result1) // [1 2 3 4]
    
    // 单独调用去零值
    result2 := ToInt64Slice(slice).RemoveNonZero().ToSlice()
    fmt.Println(result2) // [1 2 3 2 1 4]
    
    // 单独调用去重
    result3 := ToInt64Slice(slice).RemoveDuplicatesInt64().ToSlice()
    fmt.Println(result3) // [0 1 2 3 4]
    
    // 也可以直接转换后链式调用
    var int64Slice Int64Slice = slice
    result4 := int64Slice.RemoveNonZero().RemoveDuplicatesInt64().ToSlice()
    fmt.Println(result4) // [1 2 3 4]
}

如果你希望保持原有的函数形式，同时支持链式调用，可以这样修改：

// 原有的独立函数保持不变
func RemoveNonZero(slice []int64) []int64 {
    ids := make([]int64, 0)
    for i, count := 0, len(slice); i < count; i++ {
        if slice[i] > 0 {
            ids = append(ids, slice[i])
        }
    }
    return ids
}


// 为自定义类型添加方法支持链式调用
func (s Int64Slice) RemoveNonZero() Int64Slice {
    return ToInt64Slice(RemoveNonZero(s))
}


func RemoveDuplicatesInt64(ids []int64) []int64 {
    if len(ids) < 1 {
        return ids
    }


    result := make([]int64, len(ids))
    copy(result, ids)
    
    sort.Slice(result, func(i, j int) bool {
        return result[i] < result[j]
    })


    j := 1
    for i := 1; i < len(result); i++ {
        if result[i] != result[i-1] {
            result[j] = result[i]
            j++
        }
    }


    return result[:j]
}


func (s Int64Slice) RemoveDuplicatesInt64() Int64Slice {
    return ToInt64Slice(RemoveDuplicatesInt64(s))
}

这样你就可以同时使用传统的函数调用方式和新的链式调用方式了。