重构数字助手类：重命名为NumberWan并简化功能

- 类名从Number改为NumberWan，专注万分位转换功能
- 移除千分位相关方法：formatThousands()、formatThousandsPrecision()、addThousandsSeparator()
- 移除旧版兼容方法：formatToWan()、parseFromWan()、smartFormat()的低精度版本
- 简化方法命名：去掉Precision后缀，使高精度方法成为主要方法
- 保留核心功能：万分位转换、中文数位单位转换、精度管理
- 更新使用说明文档，反映类名和方法变化
- 保持类的简洁性和专一性，避免功能冗余

UCore/Helper/Number.php

@@ -3,12 +3,12 @@
 namespace UCore\Helper;
 
 /**
- * 数字助手类
+ * 万分位数字助手类
  *
- * 提供数字格式化、转换等功能
+ * 专注于万分位和中文数位单位的数字格式化、转换功能
  * 支持高精度数值处理（20位整数 + 20位小数，共40位精度）
  */
-class Number
+class NumberWan
 {
     /** @var int 默认小数精度 */
     const DEFAULT_SCALE = 20;
@@ -25,7 +25,7 @@ class Number
     /** @var int 万分位转换的基数（向后兼容） */
     const WAN_BASE = 10000;
     /**
-     * 万分位数据表示转换（高精度版本）
+     * 万分位数据表示转换
      *
      * 将数字转换为中文万分位表示法，支持40位精度（20位整数+20位小数）
      * 例如：100020 -> "10万20"
@@ -34,7 +34,7 @@ class Number
      * @param int $scale 小数精度，默认20位
      * @return string 万分位表示的字符串
      */
-    public static function formatToWanPrecision($number, int $scale = self::DEFAULT_SCALE): string
+    public static function formatToWan($number, int $scale = self::DEFAULT_SCALE): string
     {
         // 确保输入为字符串格式，保持精度
         $numStr = (string) $number;
@@ -188,98 +188,12 @@ class Number
         return $numStr;
     }
 
-    /**
-     * 万分位数据表示转换（兼容版本）
-     *
-     * 将数字转换为中文万分位表示法
-     * 例如：100020 -> "10万20"
-     *
-     * @param int|float|string $number 要转换的数字
-     * @return string 万分位表示的字符串
-     */
-    public static function formatToWan($number): string
-    {
-        // 转换为数字类型
-        $num = (float) $number;
-        
-        // 处理负数
-        $isNegative = $num < 0;
-        $num = abs($num);
-        
-        // 处理小数部分
-        $integerPart = (int) $num;
-        $decimalPart = $num - $integerPart;
-        
-        $result = '';
-        
-        // 处理整数部分的万分位转换
-        if ($integerPart >= 10000) {
-            $wan = (int) ($integerPart / 10000);
-            $remainder = $integerPart % 10000;
-            
-            $result = $wan . '万';
-            
-            // 如果余数不为0，添加余数
-            if ($remainder > 0) {
-                $result .= $remainder;
-            }
-        } else {
-            // 小于1万的直接显示
-            $result = (string) $integerPart;
-        }
-        
-        // 处理小数部分（如果有）
-        if ($decimalPart > 0) {
-            // 保留2位小数，去除末尾的0
-            $decimalStr = rtrim(sprintf('%.2f', $decimalPart), '0');
-            $decimalStr = rtrim($decimalStr, '.');
-            if ($decimalStr !== '0' && $decimalStr !== '') {
-                $result .= substr($decimalStr, 1); // 去掉开头的"0"
-            }
-        }
-        
-        // 添加负号
-        if ($isNegative) {
-            $result = '-' . $result;
-        }
-        
-        return $result;
-    }
-    
-    /**
-     * 格式化数字为千分位表示
-     * 
-     * @param int|float|string $number 要格式化的数字
-     * @param int $decimals 小数位数，默认0
-     * @return string 千分位格式的字符串
-     */
-    public static function formatThousands($number, int $decimals = 0): string
-    {
-        return number_format((float) $number, $decimals);
-    }
+
     
-    /**
-     * 智能数字格式化
-     * 
-     * 根据数字大小自动选择合适的格式化方式
-     * 
-     * @param int|float|string $number 要格式化的数字
-     * @param bool $useWan 是否使用万分位表示，默认true
-     * @return string 格式化后的字符串
-     */
-    public static function smartFormat($number, bool $useWan = true): string
-    {
-        $num = (float) $number;
-        
-        if ($useWan && abs($num) >= 10000) {
-            return self::formatToWan($number);
-        }
-        
-        return self::formatThousands($number);
-    }
+
     
     /**
-     * 将万分位表示转换回数字（高精度版本）
+     * 将万分位表示转换回数字
      *
      * 例如："10万20" -> "100020"
      *
@@ -287,7 +201,7 @@ class Number
      * @param int $scale 小数精度，默认20位
      * @return string 转换后的数字字符串（保持高精度）
      */
-    public static function parseFromWanPrecision(string $wanString, int $scale = self::DEFAULT_SCALE): string
+    public static function parseFromWan(string $wanString, int $scale = self::DEFAULT_SCALE): string
     {
         // 处理负数
         $isNegative = str_starts_with($wanString, '-');
@@ -295,16 +209,21 @@ class Number
             $wanString = substr($wanString, 1);
         }
 
+        // 分离整数和小数部分
+        $parts = explode('.', $wanString);
+        $integerPart = $parts[0];
+        $decimalPart = isset($parts[1]) ? $parts[1] : '';
+
         // 查找"万"字符
-        $wanPos = mb_strpos($wanString, '万');
+        $wanPos = mb_strpos($integerPart, '万');
 
         if ($wanPos === false) {
             // 没有"万"字符，直接返回
-            $result = $wanString;
+            $result = $integerPart;
         } else {
             // 有"万"字符，分别处理万和余数部分
-            $wanPart = mb_substr($wanString, 0, $wanPos);
-            $remainderPart = mb_substr($wanString, $wanPos + 1);
+            $wanPart = mb_substr($integerPart, 0, $wanPos);
+            $remainderPart = mb_substr($integerPart, $wanPos + 1);
 
             // 使用BC数学函数进行高精度计算
             $wanValue = bcmul($wanPart, (string) self::WAN_BASE, $scale);
@@ -313,6 +232,17 @@ class Number
             $result = bcadd($wanValue, $remainder, $scale);
         }
 
+        // 处理小数部分
+        if (!empty($decimalPart)) {
+            $decimalPart = rtrim($decimalPart, '0');
+            if (!empty($decimalPart)) {
+                // 确保结果没有重复的小数点
+                if (strpos($result, '.') === false) {
+                    $result .= '.' . $decimalPart;
+                }
+            }
+        }
+
         // 处理负数
         if ($isNegative) {
             $result = bcmul($result, '-1', $scale);
@@ -322,7 +252,7 @@ class Number
     }
 
     /**
-     * 将中文数位单位表示转换回数字（高精度版本）
+     * 将中文数位单位表示转换回数字
      *
      * 支持万、亿、兆、京、垓等中文数位单位的反向转换
      * 例如："1234垓5678京9012兆3456亿7890万" -> "12345678901234567890000000000000"
@@ -394,112 +324,21 @@ class Number
         return $result;
     }
 
-    /**
-     * 将万分位表示转换回数字（兼容版本）
-     *
-     * 例如："10万20" -> 100020
-     *
-     * @param string $wanString 万分位表示的字符串
-     * @return int|float 转换后的数字
-     */
-    public static function parseFromWan(string $wanString)
-    {
-        // 处理负数
-        $isNegative = str_starts_with($wanString, '-');
-        if ($isNegative) {
-            $wanString = substr($wanString, 1);
-        }
 
-        // 查找"万"字符
-        $wanPos = mb_strpos($wanString, '万');
 
-        if ($wanPos === false) {
-            // 没有"万"字符，直接转换为数字
-            $result = (float) $wanString;
-        } else {
-            // 有"万"字符，分别处理万和余数部分
-            $wanPart = mb_substr($wanString, 0, $wanPos);
-            $remainderPart = mb_substr($wanString, $wanPos + 1);
-
-            $wan = (float) $wanPart;
-            $remainder = empty($remainderPart) ? 0 : (float) $remainderPart;
 
-            $result = $wan * 10000 + $remainder;
-        }
-
-        return $isNegative ? -$result : $result;
-    }
 
     /**
-     * 高精度千分位格式化
-     *
-     * @param int|float|string $number 要格式化的数字
-     * @param int $decimals 小数位数，默认20位
-     * @return string 千分位格式的字符串
-     */
-    public static function formatThousandsPrecision($number, int $decimals = self::DEFAULT_SCALE): string
-    {
-        $numStr = (string) $number;
-
-        // 分离整数和小数部分
-        $parts = explode('.', $numStr);
-        $integerPart = $parts[0];
-        $decimalPart = isset($parts[1]) ? $parts[1] : '';
-
-        // 处理负数
-        $isNegative = str_starts_with($integerPart, '-');
-        if ($isNegative) {
-            $integerPart = substr($integerPart, 1);
-        }
-
-        // 手动为整数部分添加千分位分隔符（避免精度丢失）
-        $formattedInteger = self::addThousandsSeparator($integerPart);
-
-        // 处理小数部分
-        if (!empty($decimalPart) && $decimals > 0) {
-            // 截取小数位
-            if (strlen($decimalPart) > $decimals) {
-                $decimalPart = substr($decimalPart, 0, $decimals);
-            }
-
-            // 去除末尾的0
-            $decimalPart = rtrim($decimalPart, '0');
-
-            if (!empty($decimalPart)) {
-                $formattedInteger .= '.' . $decimalPart;
-            }
-        }
-
-        return $isNegative ? '-' . $formattedInteger : $formattedInteger;
-    }
-
-    /**
-     * 手动添加千分位分隔符（避免精度丢失）
-     *
-     * @param string $number 整数字符串
-     * @return string 添加千分位分隔符的字符串
-     */
-    private static function addThousandsSeparator(string $number): string
-    {
-        // 从右到左每3位添加逗号
-        $reversed = strrev($number);
-        $chunks = str_split($reversed, 3);
-        $formatted = implode(',', $chunks);
-        return strrev($formatted);
-    }
-
-    /**
-     * 高精度智能格式化
+     * 智能格式化
      *
      * 根据数字大小自动选择合适的格式化方式
      *
      * @param int|float|string $number 要格式化的数字
-     * @param bool $useWan 是否使用万分位表示，默认true
      * @param int $scale 小数精度，默认20位
      * @param bool $useChineseUnits 是否使用中文数位单位（万、亿、兆、京、垓），默认false
      * @return string 格式化后的字符串
      */
-    public static function smartFormatPrecision($number, bool $useWan = true, int $scale = self::DEFAULT_SCALE, bool $useChineseUnits = false): string
+    public static function smartFormat($number, int $scale = self::DEFAULT_SCALE, bool $useChineseUnits = false): string
     {
         $numStr = (string) $number;
 
@@ -516,11 +355,12 @@ class Number
         }
 
         // 使用万分位表示
-        if ($useWan && bccomp($integerPart, (string) self::WAN_BASE, 0) >= 0) {
-            return self::formatToWanPrecision($number, $scale);
+        if (bccomp($integerPart, (string) self::WAN_BASE, 0) >= 0) {
+            return self::formatToWan($number, $scale);
         }
 
-        return self::formatThousandsPrecision($number, $scale);
+        // 小于万的数字直接返回
+        return $numStr;
     }
 
     /**
@@ -533,7 +373,7 @@ class Number
      * @param int $decimalDigits 小数位数限制，默认20位
      * @return bool 是否符合精度要求
      */
-    public static function validatePrecision(string $number, int $integerDigits = 20, int $decimalDigits = 20): bool
+    public static function validate(string $number, int $integerDigits = 20, int $decimalDigits = 20): bool
     {
         // 移除负号进行验证
         $numStr = ltrim($number, '-');
@@ -566,7 +406,7 @@ class Number
      * @param int $decimalDigits 小数位数限制，默认20位
      * @return string 截取后的数字
      */
-    public static function truncatePrecision(string $number, int $integerDigits = 20, int $decimalDigits = 20): string
+    public static function truncate(string $number, int $integerDigits = 20, int $decimalDigits = 20): string
     {
         // 处理负数
         $isNegative = str_starts_with($number, '-');

UCore/Helper/README_Number.md

@@ -1,169 +1,96 @@
-# 数字助手类使用说明
+# NumberWan 万分位数字助手类使用说明
 
 ## 概述
 
-`UCore\Helper\Number` 类提供了数字格式化和转换功能，特别是中文万分位表示法的转换。
+`UCore\Helper\NumberWan` 类专注于万分位和中文数位单位的数字格式化、转换功能。
 
-**✨ 新增高精度支持**：现在支持40位精度数值处理（20位整数 + 20位小数），使用BC数学函数确保精度不丢失。
+**✨ 核心特性**：
+- 支持40位精度数值处理（20位整数 + 20位小数）
+- 使用BC数学函数确保精度不丢失
+- 专注于万分位转换，移除千分位相关功能
+- 支持中文大数位单位（万、亿、兆、京、垓）
+- 简洁专一的设计，避免功能冗余
 
 ## 主要功能
 
-### 1. 高精度万分位数据表示转换 `formatToWanPrecision()`
+### 1. 万分位数据表示转换 `formatToWan()`
 
 支持40位精度的万分位转换：
 
 ```php
-use UCore\Helper\Number;
+use UCore\Helper\NumberWan;
 
 // 超大精度数值转换
-echo Number::formatToWanPrecision('12345678901234567890.12345678901234567890');
-// 输出: 1234567890123456万7890.1234567890123456789
+echo NumberWan::formatToWan('12345678901234567890.12345678901234567890');
+// 输出: 1234567890123456万7890.123456789
 
-echo Number::formatToWanPrecision('999999999999999999990000.12345678901234567890');
-// 输出: 99999999999999999999万.1234567890123456789
+echo NumberWan::formatToWan('999999999999999999990000.12345678901234567890');
+// 输出: 99999999999999999999万.123456789
 
 // 指定小数精度
-echo Number::formatToWanPrecision('100020.123456789', 5);
+echo NumberWan::formatToWan('100020.123456789', 5);
 // 输出: 10万20.12345
 ```
 
-### 2. 万分位数据表示转换 `formatToWan()` (兼容版本)
-
-将数字转换为中文万分位表示法：
-
-```php
-use UCore\Helper\Number;
-
-// 基本用法
-echo Number::formatToWan(100020);    // 输出: 10万20
-echo Number::formatToWan(50000);     // 输出: 5万
-echo Number::formatToWan(10000);     // 输出: 1万
-echo Number::formatToWan(9999);      // 输出: 9999
-echo Number::formatToWan(123456);    // 输出: 12万3456
-echo Number::formatToWan(1000000);   // 输出: 100万
-
-// 支持负数
-echo Number::formatToWan(-100020);   // 输出: -10万20
-
-// 支持小数
-echo Number::formatToWan(100020.5);  // 输出: 10万20.5
-echo Number::formatToWan(50000.99);  // 输出: 5万.99
-```
-
-### 3. 高精度反向转换 `parseFromWanPrecision()`
+### 2. 万分位反向转换 `parseFromWan()`
 
 将万分位表示转换回高精度数字：
 
 ```php
-// 高精度反向转换
-echo Number::parseFromWanPrecision('1234567890123456789万1234');
-// 输出: 12345678901234567891234.00000000000000000000
-
-echo Number::parseFromWanPrecision('1万.12345678901234567890');
-// 输出: 10000.12345678901234567890
-
-echo Number::parseFromWanPrecision('-9876543210987654321万.98765432109876543210');
-// 输出: -98765432109876543210000.98765432109876543210
+echo NumberWan::parseFromWan('10万20');   // 输出: 100020
+echo NumberWan::parseFromWan('5万');      // 输出: 50000
+echo NumberWan::parseFromWan('1万');      // 输出: 10000
+echo NumberWan::parseFromWan('12万3456'); // 输出: 123456
+echo NumberWan::parseFromWan('-10万20');  // 输出: -100020
+echo NumberWan::parseFromWan('1万.123456789'); // 输出: 10000.123456789
 ```
 
-### 4. 反向转换 `parseFromWan()` (兼容版本)
-
-将万分位表示转换回数字：
 
-```php
-echo Number::parseFromWan('10万20');   // 输出: 100020
-echo Number::parseFromWan('5万');      // 输出: 50000
-echo Number::parseFromWan('1万');      // 输出: 10000
-echo Number::parseFromWan('12万3456'); // 输出: 123456
-echo Number::parseFromWan('-10万20');  // 输出: -100020
-```
 
-### 5. 高精度智能格式化 `smartFormatPrecision()`
+### 3. 智能格式化 `smartFormat()`
 
-根据数字大小自动选择合适的高精度格式化方式：
+根据数字大小自动选择合适的格式化方式：
 
 ```php
 // 大于等于1万使用万分位表示
-echo Number::smartFormatPrecision('12345678901234567890.12345678901234567890');
-// 输出: 1234567890123456万7890.1234567890123456789
-
-// 小于1万使用千分位表示
-echo Number::smartFormatPrecision('9999.99999999999999999999');
-// 输出: 9,999.99999999999999999999
+echo NumberWan::smartFormat('12345678901234567890.12345678901234567890');
+// 输出: 1234567890123456万7890.123456789
 
-// 可以禁用万分位表示
-echo Number::smartFormatPrecision('100020.123456789', false);
-// 输出: 100,020.123456789
+// 小于1万直接显示
+echo NumberWan::smartFormat('9999.99999999999999999999');
+// 输出: 9999.99999999999999999999
 
 // 启用中文数位单位
-echo Number::smartFormatPrecision('12345678901234567890', true, 20, true);
+echo NumberWan::smartFormat('12345678901234567890', 20, true);
 // 输出: 1234京5678901234567890
 ```
 
-### 6. 高精度千分位格式化 `formatThousandsPrecision()`
-
-高精度千分位数字格式化：
-
-```php
-echo Number::formatThousandsPrecision('12345678901234567890.12345678901234567890');
-// 输出: 12,345,678,901,234,567,890.1234567890123456789
-
-echo Number::formatThousandsPrecision('123456.789012345', 5);
-// 输出: 123,456.78901
-```
-
-### 7. 智能格式化 `smartFormat()` (兼容版本)
-
-根据数字大小自动选择合适的格式化方式：
-
-```php
-// 大于等于1万使用万分位表示
-echo Number::smartFormat(100020);  // 输出: 10万20
-echo Number::smartFormat(50000);   // 输出: 5万
-
-// 小于1万使用千分位表示
-echo Number::smartFormat(9999);    // 输出: 9,999
-echo Number::smartFormat(1234);    // 输出: 1,234
-
-// 可以禁用万分位表示
-echo Number::smartFormat(100020, false);  // 输出: 100,020
-```
-
-### 8. 千分位格式化 `formatThousands()` (兼容版本)
-
-标准的千分位数字格式化：
-
-```php
-echo Number::formatThousands(100020);     // 输出: 100,020
-echo Number::formatThousands(123456.789, 2); // 输出: 123,456.79
-```
-
-### 9. 精度验证和处理
+### 4. 精度验证和处理
 
-#### 精度验证 `validatePrecision()`
+#### 精度验证 `validate()`
 
 ```php
 // 验证数字是否符合精度要求（默认20位整数+20位小数）
-echo Number::validatePrecision('12345678901234567890.12345678901234567890'); // true
-echo Number::validatePrecision('123456789012345678901.12345678901234567890'); // false (21位整数)
+echo NumberWan::validate('12345678901234567890.12345678901234567890'); // true
+echo NumberWan::validate('123456789012345678901.12345678901234567890'); // false (21位整数)
 
 // 自定义精度要求
-echo Number::validatePrecision('1234567890.1234567890', 10, 10); // true
+echo NumberWan::validate('1234567890.1234567890', 10, 10); // true
 ```
 
-#### 精度截取 `truncatePrecision()`
+#### 精度截取 `truncate()`
 
 ```php
 // 截取到指定精度（默认20位整数+20位小数）
-echo Number::truncatePrecision('123456789012345678901.123456789012345678901');
+echo NumberWan::truncate('123456789012345678901.123456789012345678901');
 // 输出: 23456789012345678901.1234567890123456789
 
 // 自定义精度截取
-echo Number::truncatePrecision('1234567890.1234567890', 5, 5);
+echo NumberWan::truncate('1234567890.1234567890', 5, 5);
 // 输出: 67890.12345
 ```
 
-### 10. 中文大数位单位转换
+### 5. 中文大数位单位转换
 
 #### 中文数位单位转换 `formatToChineseUnits()`
 
@@ -171,18 +98,18 @@ echo Number::truncatePrecision('1234567890.1234567890', 5, 5);
 
 ```php
 // 完整模式显示所有单位
-echo Number::formatToChineseUnits('12345678901234567890');
+echo NumberWan::formatToChineseUnits('12345678901234567890');
 // 输出: 1234京5678兆9012亿3456万7890
 
-echo Number::formatToChineseUnits('123456789012345678901234');
+echo NumberWan::formatToChineseUnits('123456789012345678901234');
 // 输出: 1234垓5678京9012兆3456亿7890万1234
 
 // 简化模式只显示最大单位
-echo Number::formatToChineseUnits('12345678901234567890', 20, true);
+echo NumberWan::formatToChineseUnits('12345678901234567890', 20, true);
 // 输出: 1234京5678901234567890
 
 // 带小数的转换
-echo Number::formatToChineseUnits('12345678901234567890.123456789');
+echo NumberWan::formatToChineseUnits('12345678901234567890.123456789');
 // 输出: 1234京5678兆9012亿3456万7890.123456789
 ```
 
@@ -191,13 +118,13 @@ echo Number::formatToChineseUnits('12345678901234567890.123456789');
 自动选择合适的中文单位显示：
 
 ```php
-echo Number::formatToSmartChineseUnits('123456789');
+echo NumberWan::formatToSmartChineseUnits('123456789');
 // 输出: 1亿23456789
 
-echo Number::formatToSmartChineseUnits('12345678901234567');
+echo NumberWan::formatToSmartChineseUnits('12345678901234567');
 // 输出: 1京2345678901234567
 
-echo Number::formatToSmartChineseUnits('9999');
+echo NumberWan::formatToSmartChineseUnits('9999');
 // 输出: 9999 (小于万直接显示)
 ```
 
@@ -206,16 +133,16 @@ echo Number::formatToSmartChineseUnits('9999');
 将中文数位单位表示转换回数字：
 
 ```php
-echo Number::parseFromChineseUnits('1万2345');
+echo NumberWan::parseFromChineseUnits('1万2345');
 // 输出: 12345
 
-echo Number::parseFromChineseUnits('12亿3456万7890');
+echo NumberWan::parseFromChineseUnits('12亿3456万7890');
 // 输出: 1234567890
 
-echo Number::parseFromChineseUnits('1234京5678兆9012亿3456万7890');
+echo NumberWan::parseFromChineseUnits('1234京5678兆9012亿3456万7890');
 // 输出: 12345678901234567890
 
-echo Number::parseFromChineseUnits('1万.123456789');
+echo NumberWan::parseFromChineseUnits('1万.123456789');
 // 输出: 10000.123456789
 ```