Go实战训练学习笔记----循环与条件语句实战，简化业务逻辑代码

gofunc ProcessOrder(order *Order) error {
    if order != nil {
        if order.Status == "pending" {
            if order.Amount > 0 {
                if order.User != nil {
                    if order.User.Level == "vip" {
                        order.Discount = 0.8
                    } else {
                        if order.User.Level == "new" {
                            order.Discount = 0.9
                        } else {
                            order.Discount = 1.0
                        }
                    }
                    return nil
                } else {
                    return errors.New("user is nil")
                }
            } else {
                return errors.New("invalid amount")
            }
        } else {
            return errors.New("invalid status")
        }
    } else {
        return errors.New("order is nil")
    }
}

gofunc ProcessOrder(order *Order) error {
    // 卫语句：逐层拦截，不满足就退出
    if order == nil {
        return errors.New("order is nil")
    }
    if order.Status != "pending" {
        return errors.New("invalid status")
    }
    if order.Amount <= 0 {
        return errors.New("invalid amount")
    }
    if order.User == nil {
        return errors.New("user is nil")
    }

    // ✅ 主逻辑：没有任何嵌套，一目了然
    switch order.User.Level {
    case "vip":
        order.Discount = 0.8
    case "new":
        order.Discount = 0.9
    default:
        order.Discount = 1.0
    }
    return nil
}

govar discount float64
if level == "vip" {
    discount = 0.8
} else if level == "new" {
    discount = 0.9
} else if level == "member" {
    discount = 0.95
} else {
    discount = 1.0
}

govar discounts = map[string]float64{
    "vip":    0.8,
    "new":    0.9,
    "member": 0.95,
}

discount := discounts[level]
if discount == 0 {
    discount = 1.0 // 默认值
}

godiscount := map[string]float64{
    "vip": 0.8, "new": 0.9, "member": 0.95,
}[level]

if discount == 0 {
    discount = 1.0
}

go// 场景：计算所有 VIP 用户的订单总额
var total float64
for i := 0; i < len(orders); i++ {
    if orders[i].User.Level == "vip" {
        total += orders[i].Amount
    }
}

gototal := 0.0
for _, o := range orders {
    if o.User.Level == "vip" {
        total += o.Amount
    }
}

gofunc Sum(orders []Order, filter func(Order) bool) float64 {
    var total float64
    for _, o := range orders {
        if filter(o) {
            total += o.Amount
        }
    }
    return total
}

// 调用
vipTotal := Sum(orders, func(o Order) bool {
    return o.User.Level == "vip"
})

goimport "slices"

vipOrders := slices.DeleteFunc(orders, func(o Order) bool {
    return o.User.Level != "vip"
})

vipTotal := slices.SumFunc(vipOrders, func(o Order) float64 {
    return o.Amount
})

gofunc HandlePayment(p Payment) error {
    switch p.Type {
    case "alipay":
        return handleAlipay(p)
    case "wechat":
        return handleWechat(p)
    case "bank":
        return handleBank(p)
    case "crypto":
        return handleCrypto(p)
    default:
        return errors.New("unknown type")
    }
}

gotype Handler func(Payment) error

var paymentHandlers = map[string]Handler{
    "alipay":  handleAlipay,
    "wechat":  handleWechat,
    "bank":    handleBank,
    "crypto":  handleCrypto,
}

func HandlePayment(p Payment) error {
    handler, ok := paymentHandlers[p.Type]
    if !ok {
        return errors.New("unknown payment type: " + p.Type)
    }
    return handler(p)
}

gofunc CalculatePrice(order *Order) float64 {
    if order.User.Level == "vip" {
        if order.Amount > 1000 {
            return order.Amount * 0.7
        }
        return order.Amount * 0.8
    } else if order.User.Level == "new" {
        return order.Amount * 0.9
    }
    return order.Amount
}

gotype PricingStrategy interface {
    Calculate(amount float64) float64
}

type VIPStrategy struct{}
func (s VIPStrategy) Calculate(a float64) float64 {
    if a > 1000 {
        return a * 0.7
    }
    return a * 0.8
}

type NewUserStrategy struct{}
func (s NewUserStrategy) Calculate(a float64) float64 {
    return a * 0.9
}

type RegularStrategy struct{}
func (s RegularStrategy) Calculate(a float64) float64 {
    return a
}

var strategyMap = map[string]PricingStrategy{
    "vip":   VIPStrategy{},
    "new":   NewUserStrategy{},
    "regular": RegularStrategy{},
}

func CalculatePrice(order *Order) float64 {
    s := strategyMap[order.User.Level]
    return s.Calculate(order.Amount)
}

gofunc WaitReady(ch chan bool) {
    for {
        select {
        case <-ch:
            return
        default:
            time.Sleep(100 * time.Millisecond)
        }
    }
}

gofunc WaitAny(ready chan bool, timeout <-chan time.Time) error {
    select {
    case <-ready:
        return nil
    case <-timeout:
        return errors.New("timeout")
    }
}

goselect {
case result := <-taskChan:
    return result
case <-ctx.Done():
    return ctx.Err()
case <-time.After(5 * time.Second):
    return errors.New("timeout")
}