面试题：Go语言不定参数函数在接口实现中的应用

package main

import (
    "fmt"
)

// 定义接口
type Processor interface {
    Process(args ...interface{}) interface{}
}

// 定义第一个结构体
type IntProcessor struct{}

// IntProcessor 实现 Processor 接口
func (ip IntProcessor) Process(args ...interface{}) interface{} {
    sum := 0
    for _, arg := range args {
        if num, ok := arg.(int); ok {
            sum += num
        }
    }
    return sum
}

// 定义第二个结构体
type StringProcessor struct{}

// StringProcessor 实现 Processor 接口
func (sp StringProcessor) Process(args ...interface{}) interface{} {
    result := ""
    for _, arg := range args {
        if str, ok := arg.(string); ok {
            result += str
        }
    }
    return result
}

// 使用不定参数的优势
// 1. 灵活性：可以接受不同数量和类型的参数，无需为每种参数组合定义不同的方法。
// 2. 代码简洁：减少方法重载的数量，使代码结构更清晰。

// 使用不定参数需要注意的地方
// 1. 类型断言的复杂性：需要在运行时进行类型断言，增加了代码的复杂性和出错的可能性。
// 2. 可读性：过多的不定参数可能会降低代码的可读性，特别是在处理多种类型时。
// 3. 性能：类型断言和动态类型检查会带来一定的性能开销。

在Go语言中，以上代码展示了如何定义接口、结构体并实现接口方法，以及分析了不定参数的优势和注意点。在其他语言如Python中，本身支持动态类型，实现方式会略有不同，但核心思想类似：

from typing import List, Union

# 定义接口（Python中通过抽象基类和抽象方法模拟接口概念，这里简化直接使用注释说明）
# 接口定义一个接受不定参数的方法
class Processor:
    def process(self, *args) -> Union[int, str]:
        pass

# 定义第一个结构体
class IntProcessor(Processor):
    def process(self, *args) -> Union[int, str]:
        sum_num = 0
        for arg in args:
            if isinstance(arg, int):
                sum_num += arg
        return sum_num

# 定义第二个结构体
class StringProcessor(Processor):
    def process(self, *args) -> Union[int, str]:
        result = ""
        for arg in args:
            if isinstance(arg, str):
                result += arg
        return result


# 使用不定参数的优势
# 1. 灵活性：可以接受不同数量和类型的参数，使函数更加通用。
# 2. 代码简洁：无需为每种参数组合定义不同的函数。

# 使用不定参数需要注意的地方
# 1. 类型检查复杂性：需要在运行时进行类型检查，可能导致错误不易排查。
# 2. 可读性：参数类型和数量不明确，可能使代码可读性变差。
# 3. 兼容性：可能影响代码在不同环境下的兼容性。

星途面试题库

面试题：Go语言不定参数函数在接口实现中的应用

知识考点

面试题答案