防御性编程与进攻性编程详解：提升代码质量的双重策略

package main

import (
	"errors"
	"fmt"
)

// 定义一个函数，用于处理用户输入
func ProcessInput(input string) (string, error) {
	if len(input) == 0 {
		return "", errors.New("input cannot be empty")
	}
	// 假设我们期望的输入长度不超过1000个字符
	if len(input) > 1000 {
		return "", errors.New("input is too long")
	}
	// 处理输入...
	return input, nil
}

func main() {
	input := "用户输入的数据"
	output, err := ProcessInput(input)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Processed input:", output)
	}
}

package main

import (
	"fmt"
)

// 定义一个枚举类型，表示交通信号灯的颜色
type TrafficLightColor int

const (
	TRAFFICLIGHT_RED TrafficLightColor = iota
	TRAFFICLIGHT_YELLOW
	TRAFFICLIGHT_GREEN
)

// 使用断言来确保只处理预期的枚举值
func TrafficLightColorName(c TrafficLightColor) string {
	switch c {
	case TRAFFICLIGHT_RED:
		return "red"
	case TRAFFICLIGHT_YELLOW:
		return "yellow"
	case TRAFFICLIGHT_GREEN:
		return "green"
	default:
		panic("invalid traffic light color")
	}
}

func main() {
	color := TRAFFICLIGHT_RED
	fmt.Println("The traffic light color is:", TrafficLightColorName(color))
}

# 在方法的开头进行空值检查
def process_data(data):
    if data is None:
        raise ValueError("No data provided!")
    # ... 处理数据

// 使用const声明不可变变量
const MAX_SIZE = 100;

// 只在提前知道未来会有修改时，再使用let
let currentSize = MAX_SIZE;

// TypeScript中使用类型注解
function greet(name: string): string {
  return `Hello, ${name}!`;
}

// 确保参数大于0
function calculateArea(radius) {
  if (radius <= 0) {
    throw new Error("Radius must be greater than zero.");
  }
  return Math.PI * radius * radius;
}

function connectToServer(url) {
  if (!url) {
    throw new Error("URL cannot be empty!");
  }
  // 尝试连接到服务器
  // ...
}

function calculateSquareRoot(number) {
  if (number < 0) {
    throw new Error("Cannot calculate square root of a negative number.");
  }
  return Math.sqrt(number);
}

try {
  const result = calculateSquareRoot(-1);
} catch (error) {
  console.error("An error occurred:", error.message);
}

// exponentialBackoff 会根据重试次数计算退避时间，并在重试前等待
func exponentialBackoff(retryCount int) {
    backoff := time.Duration(math.Pow(2, float64(retryCount))) * time.Second
    fmt.Printf("Waiting %v before retrying...\n", backoff)
    time.Sleep(backoff)
}

func main() {
    maxRetries := 5
    for i := 0; i < maxRetries; i++ {
        // 这里是你的重试逻辑
        // ...

        // 如果需要重试，调用退避策略
        exponentialBackoff(i)
    }
}

# 一个简单的幂等操作示例
def process_payment(payment_id, amount):
    if is_payment_processed(payment_id):
        return "Payment already processed."
    # 处理支付逻辑
    # ...
    mark_payment_as_processed(payment_id)
    return "Payment processed."

# 使用with语句自动管理资源
with open('file.txt', 'r') as f:
    # ...