完成

golang-learning/10-projects/01-calculator/calculator/calculator.go

@@ -0,0 +1,290 @@
+/*
+calculator.go - 计算器核心逻辑
+实现了基本的四则运算和括号运算功能
+*/
+
+package calculator
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Calculator 接口定义了计算器的基本功能
+type Calculator interface {
+	Calculate(expression string) (float64, error)
+	GetHistory() []HistoryRecord
+	ClearHistory()
+}
+
+// BasicCalculator 基本计算器实现
+type BasicCalculator struct {
+	history []HistoryRecord
+}
+
+// NewCalculator 创建新的计算器实例
+func NewCalculator() Calculator {
+	return &BasicCalculator{
+		history: make([]HistoryRecord, 0),
+	}
+}
+
+// Calculate 计算数学表达式
+func (c *BasicCalculator) Calculate(expression string) (float64, error) {
+	// 清理输入
+	expr := strings.ReplaceAll(expression, " ", "")
+	if expr == "" {
+		return 0, fmt.Errorf("表达式不能为空")
+	}
+
+	// 验证表达式
+	if err := c.validateExpression(expr); err != nil {
+		return 0, err
+	}
+
+	// 解析和计算
+	result, err := c.evaluateExpression(expr)
+	if err != nil {
+		return 0, err
+	}
+
+	// 添加到历史记录
+	c.addToHistory(expression, result)
+
+	return result, nil
+}
+
+// GetHistory 获取计算历史
+func (c *BasicCalculator) GetHistory() []HistoryRecord {
+	// 返回历史记录的副本
+	history := make([]HistoryRecord, len(c.history))
+	copy(history, c.history)
+	return history
+}
+
+// ClearHistory 清空历史记录
+func (c *BasicCalculator) ClearHistory() {
+	c.history = make([]HistoryRecord, 0)
+}
+
+// validateExpression 验证表达式的有效性
+func (c *BasicCalculator) validateExpression(expr string) error {
+	if len(expr) == 0 {
+		return fmt.Errorf("表达式不能为空")
+	}
+
+	// 检查括号匹配
+	parentheses := 0
+	for _, char := range expr {
+		switch char {
+		case '(':
+			parentheses++
+		case ')':
+			parentheses--
+			if parentheses < 0 {
+				return fmt.Errorf("括号不匹配")
+			}
+		}
+	}
+
+	if parentheses != 0 {
+		return fmt.Errorf("括号不匹配")
+	}
+
+	// 检查有效字符
+	validChars := "0123456789+-*/.() "
+	for _, char := range expr {
+		if !strings.ContainsRune(validChars, char) {
+			return fmt.Errorf("包含无效字符: %c", char)
+		}
+	}
+
+	// 检查连续运算符
+	operators := "+-*/"
+	for i := 0; i < len(expr)-1; i++ {
+		if strings.ContainsRune(operators, rune(expr[i])) &&
+			strings.ContainsRune(operators, rune(expr[i+1])) {
+			return fmt.Errorf("连续的运算符")
+		}
+	}
+
+	return nil
+}
+
+// evaluateExpression 计算表达式的值
+func (c *BasicCalculator) evaluateExpression(expr string) (float64, error) {
+	// 处理括号
+	for strings.Contains(expr, "(") {
+		// 找到最内层的括号
+		start := -1
+		for i, char := range expr {
+			if char == '(' {
+				start = i
+			} else if char == ')' {
+				if start == -1 {
+					return 0, fmt.Errorf("括号不匹配")
+				}
+
+				// 计算括号内的表达式
+				subExpr := expr[start+1 : i]
+				subResult, err := c.evaluateSimpleExpression(subExpr)
+				if err != nil {
+					return 0, err
+				}
+
+				// 替换括号表达式为结果
+				expr = expr[:start] + fmt.Sprintf("%g", subResult) + expr[i+1:]
+				break
+			}
+		}
+	}
+
+	// 计算简单表达式（无括号）
+	return c.evaluateSimpleExpression(expr)
+}
+
+// evaluateSimpleExpression 计算简单表达式（无括号）
+func (c *BasicCalculator) evaluateSimpleExpression(expr string) (float64, error) {
+	if expr == "" {
+		return 0, fmt.Errorf("空表达式")
+	}
+
+	// 解析表达式为标记
+	tokens, err := c.tokenize(expr)
+	if err != nil {
+		return 0, err
+	}
+
+	if len(tokens) == 0 {
+		return 0, fmt.Errorf("空表达式")
+	}
+
+	// 如果只有一个标记，直接返回数值
+	if len(tokens) == 1 {
+		return strconv.ParseFloat(tokens[0], 64)
+	}
+
+	// 先处理乘法和除法
+	for i := 1; i < len(tokens); i += 2 {
+		if i >= len(tokens) {
+			break
+		}
+
+		operator := tokens[i]
+		if operator == "*" || operator == "/" {
+			left, err := strconv.ParseFloat(tokens[i-1], 64)
+			if err != nil {
+				return 0, fmt.Errorf("无效的数字: %s", tokens[i-1])
+			}
+
+			right, err := strconv.ParseFloat(tokens[i+1], 64)
+			if err != nil {
+				return 0, fmt.Errorf("无效的数字: %s", tokens[i+1])
+			}
+
+			var result float64
+			if operator == "*" {
+				result = left * right
+			} else {
+				if right == 0 {
+					return 0, fmt.Errorf("除零错误")
+				}
+				result = left / right
+			}
+
+			// 替换三个标记为结果
+			newTokens := make([]string, 0, len(tokens)-2)
+			newTokens = append(newTokens, tokens[:i-1]...)
+			newTokens = append(newTokens, fmt.Sprintf("%g", result))
+			newTokens = append(newTokens, tokens[i+2:]...)
+			tokens = newTokens
+			i -= 2 // 调整索引
+		}
+	}
+
+	// 再处理加法和减法
+	result, err := strconv.ParseFloat(tokens[0], 64)
+	if err != nil {
+		return 0, fmt.Errorf("无效的数字: %s", tokens[0])
+	}
+
+	for i := 1; i < len(tokens); i += 2 {
+		if i+1 >= len(tokens) {
+			break
+		}
+
+		operator := tokens[i]
+		operand, err := strconv.ParseFloat(tokens[i+1], 64)
+		if err != nil {
+			return 0, fmt.Errorf("无效的数字: %s", tokens[i+1])
+		}
+
+		switch operator {
+		case "+":
+			result += operand
+		case "-":
+			result -= operand
+		default:
+			return 0, fmt.Errorf("未知的运算符: %s", operator)
+		}
+	}
+
+	return result, nil
+}
+
+// tokenize 将表达式分解为标记
+func (c *BasicCalculator) tokenize(expr string) ([]string, error) {
+	var tokens []string
+	var current strings.Builder
+
+	for i, char := range expr {
+		switch char {
+		case '+', '-', '*', '/':
+			// 处理负号
+			if char == '-' && (i == 0 || expr[i-1] == '(' || strings.ContainsRune("+-*/", rune(expr[i-1]))) {
+				current.WriteRune(char)
+				continue
+			}
+
+			// 保存当前数字
+			if current.Len() > 0 {
+				tokens = append(tokens, current.String())
+				current.Reset()
+			}
+
+			// 保存运算符
+			tokens = append(tokens, string(char))
+
+		case ' ':
+			// 忽略空格
+			continue
+
+		default:
+			// 数字或小数点
+			current.WriteRune(char)
+		}
+	}
+
+	// 保存最后的数字
+	if current.Len() > 0 {
+		tokens = append(tokens, current.String())
+	}
+
+	return tokens, nil
+}
+
+// addToHistory 添加计算记录到历史
+func (c *BasicCalculator) addToHistory(expression string, result float64) {
+	record := HistoryRecord{
+		Expression: expression,
+		Result:     result,
+	}
+	c.history = append(c.history, record)
+
+	// 限制历史记录数量
+	const maxHistory = 100
+	if len(c.history) > maxHistory {
+		c.history = c.history[len(c.history)-maxHistory:]
+	}
+}