字元串表達式計算(a+b/(a-b))的思路與實踐

来源:https://www.cnblogs.com/morang/archive/2023/10/31/csharp-eval.html
-Advertisement-
Play Games

前言 為滿足業務需要，需要為項目中自定義模板添加一個計算欄位的組件，通過設置字元串表達式，使用時在改變表達式其中一個欄位的數據時，自動計算另外一個欄位的值。 本篇為上篇，介紹原理，簡單實現一個工具，輸入字元串表達式，解析其中的參數，輸入參數計算結果。 下篇將基於此封裝實現對Mongo查詢語法的封裝， ...


前言

為滿足業務需要，需要為項目中自定義模板添加一個計算欄位的組件，通過設置字元串表達式，使用時在改變表達式其中一個欄位的數據時，自動計算另外一個欄位的值。

本篇為上篇，介紹原理，簡單實現一個工具，輸入字元串表達式，解析其中的參數，輸入參數計算結果。

下篇將基於此封裝實現對Mongo查詢語法的封裝，通過addFields的方式轉換表達式，後續等封裝成NuGet包再分享

實現如下所示

輸入 1+1  輸出 2
輸入 a+1 參數a:1 輸出 2
輸入 (a+1)*b 輸入a:1,b:1 輸出 2
輸入 (a+1-(2+a)*3/3)/a+3 輸入a:1 輸出 2

實現思路

想要實現上面這個功能，需要先瞭解諸如 (a+1-(2+a)*3/3)/a+3 這個是什麼？

維基百科：中綴表示法（或中綴記法）是一個通用的算術或邏輯公式表示方法， 操作符是以中綴形式處於操作數的中間（例：3 + 4）。與首碼表達式（例：+ 3 4 ）或尾碼表達式（例：3 4 + ）相比，中綴表達式不容易被電腦解析邏輯優先順序，但仍被許多程式語言使用，因為它符合大多數自然語言的寫法。

首碼表示法 （+ 3 4 ）也叫 波蘭表示法

尾碼表示法 （3 4 + ）也叫 逆波蘭表示法

在維基百科的說明中，也給出了和其相關的另外兩種表示法，以及用於把中綴表達式轉換到尾碼表達式或樹的演算法：調度場演算法 ，如下圖所示

實現代碼

找了很多的開源項目，最終基於 qinfengzhu/Evaluator ，實現了上述功能。

調用代碼

using Evaluator;
using System.Text.RegularExpressions;

Console.WriteLine("字元串表達式計算工具");
EvalTest();

void EvalTest()
{
    Console.WriteLine("----------------------------------------------------");
    var parse = new EvalParser();
    Console.Write("請輸入表達式：");//a+b*3/5+a
    var evalStr = Console.ReadLine();
    if (string.IsNullOrEmpty(evalStr))
    {
        Console.WriteLine("Game Over");
        return;
    }
    //解析其中的變數並讓用戶輸入
    var matchs = Regex.Matches(evalStr, @"\b[\w$]+\b");
    var paramsDic = new Dictionary<string, object>();
    //預定義參數
    paramsDic.Add("now_year", DateTime.Now.Year);
    paramsDic.Add("now_month", DateTime.Now.Month);
    paramsDic.Add("now_day", DateTime.Now.Day);
    foreach (Match match in matchs)
    {
        if (decimal.TryParse(match.Value, out decimal kp))
            continue;
        if (!paramsDic.ContainsKey(match.Value))
        {
            Console.Write($"請輸入數字變數【{match.Value}】：");
            var paramValue = Console.ReadLine();
            decimal dvalue;
            while (!decimal.TryParse(paramValue, out dvalue))
            {
                Console.WriteLine($"輸入有誤，請輸入數字變數【{match.Value}】：");
                paramValue = Console.ReadLine();
            }
            paramsDic.Add(match.Value, dvalue);
        }
    }
    var result = parse.EvalNumber(evalStr, paramsDic);
    Console.WriteLine($"結果：{result}");
    EvalTest();
}

EvalParser 類的實現

通過上面調用代碼可以看到，核心的計算類是 EvalParser ，調用其 EvalNumber 進行計算

EvalNumber 實現

  • EvalNumber 方法,主要分為3步

    • 第一步將表達式解析轉換到隊列中，即將 中綴表達式，轉換成尾碼表達式
    • 第二步將隊列中的表達式加入表達式棧中
    • 第三步使用表達式樹進行計算

  • 返回值處理

    • 已知的錯誤有除以0和溢出的異常，所以直接捕獲返回null，也可以在計算除數的時候判斷值為0就直接返回null，
    • 精度處理

  • EvalNumber 計算核心代碼

    • /// <summary>
/// 計算表達式的計算結果
/// </summary>
/// <param name="expression">表達式</param>
/// <param name="dynamicObject">動態對象</param>
/// <param name="precision">精度 預設2</param>
/// <returns>計算的結果</returns>
public decimal? EvalNumber(string expression, Dictionary<string, object> dynamicObject, int precision = 2)
{
    var values = dynamicObject ?? new Dictionary<string, object>();
    //中綴表達式，轉換成尾碼表達式併入列
    var queue = ParserInfixExpression(expression, values);
    var cacheStack = new Stack<Expression>();
    while (queue.Count > 0)
    {
        var item = queue.Dequeue();
        if (item.ItemType == EItemType.Value && item.IsConstant)
        {
            var itemExpression = Expression.Constant(item.Value);
            cacheStack.Push(itemExpression);
            continue;
        }
        if (item.ItemType == EItemType.Value && !item.IsConstant)
        {
            var propertyName = item.Content.Trim();
            //將參數替換回來
            propertyName = PreReplaceTextToOprator(propertyName, values);
            //參數為空的情況
            if (!values.ContainsKey(propertyName) || values[propertyName] == null || !decimal.TryParse(values[propertyName].ToString(), out decimal propertyValue))
                return null;
            //var propertyValue = decimal.Parse(values[propertyName].ToString());
            var itemExpression = Expression.Constant(propertyValue);
            cacheStack.Push(itemExpression);
        }
        if (item.ItemType == EItemType.Operator)
        {
            if (cacheStack.Count <= 1)
                continue;
            Expression firstParamterExpression = Expression.Empty();
            Expression secondParamterExpression = Expression.Empty();
            switch (item.Content[0])
            {
                case EvalParser.AddOprator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var addExpression = Expression.Add(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(addExpression);
                    break;
                case EvalParser.DivOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var divExpression = Expression.Divide(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(divExpression);
                    break;
                case EvalParser.MulOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var mulExpression = Expression.Multiply(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(mulExpression);
                    break;
                case EvalParser.SubOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var subExpression = Expression.Subtract(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(subExpression);
                    break;
                case EvalParser.LBraceOperator:
                case EvalParser.RBraceOperator:
                    continue;
                default:
                    throw new Exception("計算公式錯誤");
            }
        }
    }
    if (cacheStack.Count == 0)
        return null;
    var lambdaExpression = Expression.Lambda<Func<decimal>>(cacheStack.Pop());
    try
    {
        // 除0 溢出
        var value = lambdaExpression.Compile()();
        return Math.Round(value, precision);
    }
    catch (Exception ex)
    {
        //System.OverflowException
        //System.DivideByZeroException
        if (ex is DivideByZeroException
            || ex is OverflowException)
            return null;
        throw ex;
    }
}

ParserInfixExpression 實現

  • 在EvalNumber 方法的第一步調用了 ParserInfixExpression 方法來進行表達式的預處理

    • PreReplaceOpratorToText 如果變數中帶有一些計算符號(+-*/())，通過這個方法轉換臨時變數，在獲取值的時候再轉換回來

      • 
/// <summary>
/// 符號轉換字典
/// </summary>
private static Dictionary<char, string> OperatorToTextDic = new Dictionary<char, string>()
{
    { '+', "_JIA_" },
    { '-', "_JIAN_" },
    { '/', "_CHENG_" },
    { '*', "_CHU_" },
    { '(', "_ZKH_" },
    { ')', "_YKH_" }
};
/// <summary>
/// 預處理參數符號轉文本
/// </summary>
/// <param name="expression"></param>
/// <param name="dynamicObject"></param>
/// <returns></returns>
public string PreReplaceOpratorToText(string expression, Dictionary<string, object> dynamicObject)
{
    //如果是參數裡面包含了括弧,將其中的參數替換成特殊字元
    var existOperatorKeys = dynamicObject.Keys.Where(s => OperatorToTextDic.Keys.Any(s2 => s.Contains(s2))).ToList();
    //存在特殊字元變數的
    if (existOperatorKeys.Any())
    {
        //將符號替換成字母
        foreach (var s in existOperatorKeys)
        {
            var newKey = s;
            foreach (var s2 in OperatorToTextDic)
            {
                newKey = newKey.Replace(s2.Key.ToString(), s2.Value);
            }
            expression = expression.Replace(s, newKey);
        }
    }
    return expression;
}

    • PreParserInfixExpression 計算嵌套(),以及先行計算純數字，主要是在後面轉換為mongo語法的時候用到，讓純數字計算在記憶體中運行而不是資料庫中計算

      • /// <summary>
/// 預處理計算表達式
/// </summary>
/// <param name="expression">表達式</param>
/// <param name="dynamicObject">參數</param>
/// <param name="isCompile">是否是編譯</param>
/// <returns></returns>
public string PreParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isCompile = false)
{
    expression = expression.Trim();
    string pattern = @"((.*?))";
    Match match = Regex.Match(expression, pattern);
    if (match.Success && match.Groups.Count > 1)
    {
        var constText = match.Groups[0].Value;
        var constValue = match.Groups[1].Value;
        string numPattern = @"(([\s|0-9|+-*/|.]+))";
        //純數字計算 或者 不是編譯預約
        if (Regex.IsMatch(constText, numPattern) || !isCompile)
        {
            var evalValue = EvalNumber(constValue, dynamicObject);
            if (evalValue == null)
                return string.Empty;
            var replaceText = evalValue.ToString();
            expression = expression.Replace(constText, replaceText);
        }
        else if (isCompile)
        {
            //編譯計算
            var completeText = Compile(constValue, dynamicObject).ToString();
            //臨時參數Key
            var tempPramKey = "temp_" + Guid.NewGuid().ToString("n");
            dynamicObject.Add(tempPramKey, completeText);
            expression = expression.Replace(constText, tempPramKey);
        }
        else
        {
            return expression;
        }
        return PreParserInfixExpression(expression, dynamicObject, isCompile);
    }
    return expression;
}

  • ParserInfixExpression 表達式轉換核心代碼

    • /// <summary>
/// 轉換表達式
/// </summary>
/// <param name="expression"></param>
/// <param name="dynamicObject"></param>
/// <param name="isComplete"></param>
/// <returns></returns>
public Queue<EvalItem> ParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isComplete = false)
{
    var queue = new Queue<EvalItem>();
    if (string.IsNullOrEmpty(expression))
        return queue;
    expression = PreReplaceOpratorToText(expression, dynamicObject);
    expression = PreParserInfixExpression(expression, dynamicObject, isComplete);
    if (string.IsNullOrEmpty(expression))
        return queue;
    var operatorStack = new Stack<OperatorChar>();

    int index = 0;
    int itemLength = 0;
    //當第一個字元為+或者-的時候
    char firstChar = expression[0];
    if (firstChar == AddOprator || firstChar == SubOperator)
    {
        expression = string.Concat("0", expression);
    }
    int expressionLength = expression.Length;
    using (var scanner = new StringReader(expression))
    {
        string operatorPreItem = string.Empty;
        while (scanner.Peek() > -1)
        {
            char currentChar = (char)scanner.Read();
            switch (currentChar)
            {
                case AddOprator:
                case SubOperator:
                case DivOperator:
                case MulOperator:
                case LBraceOperator:
                case RBraceOperator:
                    //直接把數字壓入到隊列中
                    operatorPreItem = expression.Substring(index, itemLength);
                    if (operatorPreItem != "")
                    {
                        var numberItem = new EvalItem(EItemType.Value, operatorPreItem);
                        queue.Enqueue(numberItem);
                    }
                    index = index + itemLength + 1;
                    itemLength = -1;
                    //當前操作符
                    var currentOperChar = new OperatorChar() { Operator = currentChar };
                    if (operatorStack.Count == 0)
                    {
                        operatorStack.Push(currentOperChar);
                        break;
                    }
                    //處理當前操作符與操作字元棧進出
                    var topOperator = operatorStack.Peek();
                    //若當前操作符為(或者棧頂元素為(則直接入棧
                    if (currentOperChar == LBraceOperatorChar || topOperator == LBraceOperatorChar)
                    {
                        operatorStack.Push(currentOperChar);
                        break;
                    }
                    //若當前操作符為),則棧頂元素順序輸出到隊列,至到棧頂元素(輸出為止,單(不進入隊列,它自己也不進入隊列
                    if (currentOperChar == RBraceOperatorChar)
                    {
                        while (operatorStack.Count > 0)
                        {
                            if (operatorStack.Peek() != LBraceOperatorChar)
                            {
                                var operatorItem = new EvalItem(EItemType.Operator, operatorStack.Pop().GetContent());
                                queue.Enqueue(operatorItem);
                            }
                            else
                            {
                                break;
                            }
                        }
                        if (operatorStack.Count > 0 && operatorStack.Peek() == RBraceOperatorChar)
                        {
                            operatorStack.Pop();
                        }
                        break;
                    }
                    //若棧頂元素優先順序高於當前元素，則棧頂元素輸出到隊列,當前元素入棧
                    if (topOperator.Level > currentOperChar.Level || topOperator.Level == currentOperChar.Level)
                    {
                        var topActualOperator = operatorStack.Pop();
                        var operatorItem = new EvalItem(EItemType.Operator, topActualOperator.GetContent());
                        queue.Enqueue(operatorItem);

                        while (operatorStack.Count > 0)
                        {
                            var tempTop = operatorStack.Peek();
                            if (tempTop.Level > currentOperChar.Level || tempTop.Level == currentOperChar.Level)
                            {
                                var topTemp = operatorStack.Pop();
                                var operatorTempItem = new EvalItem(EItemType.Operator, topTemp.GetContent());
                                queue.Enqueue(operatorTempItem);
                            }
                            else
                            {
                                break;
                            }
                        }
                        operatorStack.Push(currentOperChar);
                    }
                    //噹噹前元素小於棧頂元素的時候，當前元素直接入棧
                    else
                    {
                        operatorStack.Push(currentOperChar);
                    }
                    break;
                default:
                    break;
            }
            itemLength++;
        }
    }
    //剩餘無符號的字元串
    if (index < expressionLength)
    {
        string lastNumber = expression.Substring(index, expressionLength - index);
        var lastNumberItem = new EvalItem(EItemType.Value, lastNumber);
        queue.Enqueue(lastNumberItem);
    }
    //彈出棧中所有操作符號
    if (operatorStack.Count > 0)
    {
        while (operatorStack.Count != 0)
        {
            var topOperator = operatorStack.Pop();
            var operatorItem = new EvalItem(EItemType.Operator, topOperator.GetContent());
            queue.Enqueue(operatorItem);
        }
    }
    return queue;
}

EvalDate 實現指定日期類型輸出

因項目需要，需要將當前日期，當前時間加入預設變數，並支持加入計算公式中，計算的結果也可以選擇是日期或者數值。

需要實現這個功能，需要先定義好，時間如何計算，我們將日期時間轉換成時間戳來進行轉換後參與計算，計算完成後再轉換成日期即可。

所以只需要在上面的數值計算包裹一層就可以得到日期的計算結果

  • EvalDate 核心代碼

    • /// <summary>
/// 計算表達式的日期結果
/// </summary>
/// <param name="expression">表達式</param>
/// <param name="dynamicObject">動態對象</param>
/// <returns>計算的結果</returns>
public DateTime? EvalDate(string expression, Dictionary<string, object> dynamicObject)
{
    var dateNumValue = EvalNumber(expression, dynamicObject);
    if (dateNumValue == null)
        return null;
    if (long.TryParse(dateNumValue.ToString(), out long dateNum))
    {
        return JsTimeToDateTime(dateNum);
    }
    return null;
}

/// <summary>
/// 毫秒級時間戳轉成 DateTime
/// </summary>
/// <param name="unixTimestamp"></param>
/// <returns></returns>
private DateTime JsTimeToDateTime(long unixTimestamp)
{
    return DateTimeOffset.FromUnixTimeMilliseconds(unixTimestamp).LocalDateTime;
}

代碼中的數據定義

其他數據定義 OperatorChar EvalItem EItemType CharExtension 可以查看完整demo

相關說明

後語

期間找了很多開源項目參考，需求的獨特性，最終是實現了功能

整個計算欄位的實現花了3周時間，終於是順利上線。

沉迷學習，無法自拔。

作者：易墨
Github：yimogit
純靜態工具站點：metools
說明：歡迎拍磚,不足之處還望園友們指出;
迷茫大概是因為想的太多做的太少。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Gradle8.4構建SpringBoot多模塊項目
    Gradle8.4構建SpringBoot多模塊項目 一、基本 1、版本 這個版本是Jdk8最後一個SpringBoot版本 軟體 版本 Gradle 8.4 SpringBoot 2.7.15 JDK 8 2、Gradle基本介紹 2.1、使用Wrapper方式構建 好處：統一gradle的版本 ...
  • 為了簡寫這行代碼，我竟使用靜態和動態編譯技術
    背景 在我們系統中有這麼一個需求，業務方會通過mq將一些用戶信息傳給我們，我們的服務處理完後，再將信息轉發給子系統。mq的內容如下： @Data public class Person { //第一部分 private Integer countryId; private Integer compa ...
  • 你居然還去伺服器上撈日誌，搭個日誌收集系統難道不香麽！
    1 ELK日誌系統 經典的ELK架構或現被稱為Elastic Stack。Elastic Stack架構為Elasticsearch + Logstash + Kibana + Beats的組合： Beats負責日誌的採集 Logstash負責做日誌的聚合和處理 ES作為日誌的存儲和搜索系統 Kib ...
  • 記一次老商家端應用記憶體突然飈高原因分析
    一、排查過程 問題發現是因為當時接到了記憶體UMP報警信息，如下： 通過查看PFinder發現記憶體一直在增長，沒有停止跡象，觸發fullGC也並沒有下降趨勢： 當機立斷，先立即去NP上摘除了此台機器流量，然後繼續觀察，發現記憶體依然在不斷增長。 隨即查看故障分析，並沒有得到有效信息： 因為流量已經摘除， ...
  • 代碼生成器 CodeBuilder 3.2 正式版發佈
    CodeBuilder是一款強大的代碼生成工具，目前發佈了 3.2 版本，大家可以前去下載體驗 官方主頁。 1、多種數據源 基於 ADO.NET 的數據驅動 Power Designer PDManer DbSchema Swagger 這幾種數據源基本上已經覆蓋了我們常用的數據環境了，如果你有能力 ...
  • 300元到手啦-阿裡云云工開物計劃 阿裡雲要給所有中國高校在讀大學生每人送一臺雲伺服器
    300元到手啦-阿裡云云工開物計劃 阿裡雲要給所有中國高校在讀大學生每人送一臺雲伺服器 先放鏈接： 點擊進入 優惠券適用於以下場景 阿裡雲預付費通用，增量帶寬，降級，阿裡雲按量付費賬單，新購，續費，轉正，帶寬補償，試用，轉換訂單，更換操作系統，擴容，升級，換購 必須是在校大學生且完成認證，認證跟著指 ...
  • Apollo 配置中心的部署與使用經驗
    Apollo 特點：成熟，穩定 支持管理多環境/多集群/多命名空間的配置 配置修改發佈實時（1s）通知到應用程式 支持許可權控制、配置繼承，版本管理，灰度發佈，使用監控等 ...
  • TerraMoursGPT V1.0 開發總結
    TerraMoursGPT V1.0 開發總結 TerraMoursGPT V1.0 是之前gpt項目基於TerraMours後端框架的重構，實現用戶登陸和基於SK的多語言模型聊天、基於chatgpt和SD的多模型圖片生成等功能。管理端實現數據看板、聊天記錄管理，圖片記錄管理、用戶管理、系統配置等。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類