Go语言中运算符作为变量：原理与实现策略

package main

import (
    "fmt"
)

// 定义一个自定义类型来表示操作符，增加类型安全性
type Operator string

// 定义操作符常量
const (
    Add Operator = "+"
    Sub Operator = "-"
    Mul Operator = "*"
    Div Operator = "/"
)

// DoOperation 函数根据传入的操作符执行相应的运算
func DoOperation(a, b int, op Operator) (int, error) {
    switch op {
    case Add:
        return a + b, nil
    case Sub:
        return a - b, nil
    case Mul:
        return a * b, nil
    case Div:
        if b == 0 {
            return 0, fmt.Errorf("division by zero is not allowed")
        }
        return a / b, nil
    default:
        return 0, fmt.Errorf("unknown operator: %s", op)
    }
}

func main() {
    // 使用操作符常量进行运算
    resultAdd, err := DoOperation(10, 5, Add)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("10 %s 5 = %d\n", Add, resultAdd) // Output: 10 + 5 = 15
    }

    resultDiv, err := DoOperation(20, 4, Div)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("20 %s 4 = %d\n", Div, resultDiv) // Output: 20 / 4 = 5
    }

    resultInvalid, err := DoOperation(10, 0, Div)
    if err != nil {
        fmt.Println("Error:", err) // Output: Error: division by zero is not allowed
    } else {
        fmt.Printf("10 %s 0 = %d\n", Div, resultInvalid)
    }
}

package main

import (
    "fmt"
)

// 定义一个函数类型，表示接受两个int参数并返回一个int结果的二元操作
type BinaryOperation func(int, int) int

// 定义具体的二元操作函数
func AddFunc(a, b int) int { return a + b }
func SubFunc(a, b int) int { return a - b }
func MulFunc(a, b int) int { return a * b }

// 注意：除法操作需要特殊处理零除，可以返回(int, error)或在函数内部panic
func DivFunc(a, b int) int {
    if b == 0 {
        panic("division by zero") // 在实际应用中，更推荐返回 (int, error)
    }
    return a / b
}

// ExecuteOperation 函数接受两个操作数和一个BinaryOperation类型的函数作为参数
func ExecuteOperation(a, b int, op BinaryOperation) int {
    return op(a, b)
}

func main() {
    // 将预定义的函数作为变量赋值，然后传递
    var myAdd BinaryOperation = AddFunc
    fmt.Printf("10 + 5 = %d\n", ExecuteOperation(10, 5, myAdd)) // Output: 10 + 5 = 15

    // 直接传递预定义的函数
    fmt.Printf("10 * 5 = %d\n", ExecuteOperation(10, 5, MulFunc)) // Output: 10 * 5 = 50

    // 传递匿名函数作为操作
    fmt.Printf("10 - 5 = %d\n", ExecuteOperation(10, 5, func(x, y int) int { return x - y })) // Output: 10 - 5 = 5

    // 对于可能出错的DivFunc，需要额外的错误处理逻辑
    // 例如：
    // type SafeBinaryOperation func(int, int) (int, error)
    // func SafeDivFunc(a, b int) (int, error) { ... }
    // func ExecuteSafeOperation(a, b int, op SafeBinaryOperation) (int, error) { ... }
    // try { ExecuteOperation(10, 0, DivFunc) } catch (panic) { ... }
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Caught panic: %v\n", r) // Output: Caught panic: division by zero
        }
    }()
    fmt.Printf("10 / 0 = %d\n", ExecuteOperation(10, 0, DivFunc)) // This line will panic
}