目录

1. 概述
2. 工具功能
3. 核心实现
4. Kotlin 源代码
5. JavaScript 编译代码
6. ArkTS 调用代码
7. 实战案例
8. 最佳实践

---

概述

本文档介绍如何在 Kotlin Multiplatform (KMP) 鸿蒙跨端开发中实现一个功能完整的进制转换工具系统。进制转换是计算机科学中的基础概念，广泛应用于编程、网络协议、硬件开发、数据编码等领域。这个工具提供了对多种进制的全面转换支持，包括十进制、二进制、八进制、十六进制等，以及进制转换的各种操作和分析。

在实际应用中，进制转换工具广泛应用于以下场景：编程开发工具、网络协议分析、硬件调试、数据编码、颜色值处理、内存地址转换等。通过 KMP 框架的跨端能力，我们可以在不同平台上使用相同的进制转换逻辑，确保转换结果的准确性和一致性。

工具的特点

• 完整的进制支持：支持二进制、八进制、十进制、十六进制的相互转换
• 灵活的转换：支持任意两种进制之间的转换
• 格式化显示：支持多种格式的进制表示
• 批量转换：支持多个数值的批量转换
• 进制分析：提供进制转换的详细分析
• 跨端兼容：一份 Kotlin 代码可同时服务多个平台

---

工具功能

1. 十进制转换

十进制是日常生活中最常用的进制。十进制转换是将十进制数转换为其他进制。十进制转换需要支持正数、负数和浮点数。

• 十进制到二进制：将十进制数转换为二进制表示
• 十进制到八进制：将十进制数转换为八进制表示
• 十进制到十六进制：将十进制数转换为十六进制表示
• 负数处理：正确处理负数的进制转换

2. 二进制转换

二进制是计算机内部使用的进制。二进制转换对于理解计算机工作原理很重要。二进制转换需要处理位操作和补码表示。

• 二进制到十进制：将二进制数转换为十进制
• 二进制到八进制：通过十进制中间转换
• 二进制到十六进制：通过十进制中间转换
• 位数显示：支持固定位数的二进制表示

3. 八进制转换

八进制在某些编程语言和系统中使用。八进制转换提供了另一种进制表示方式。八进制转换通常用于 Unix 文件权限等场景。

• 八进制到十进制：将八进制数转换为十进制
• 八进制到二进制：通过十进制中间转换
• 八进制到十六进制：通过十进制中间转换
• 有效性检查：检查八进制数是否有效

4. 十六进制转换

十六进制在编程和网络中广泛使用。十六进制转换对于处理颜色值、内存地址等很重要。十六进制转换需要支持大小写字母。

• 十六进制到十进制：将十六进制数转换为十进制
• 十六进制到二进制：通过十进制中间转换
• 十六进制到八进制：通过十进制中间转换
• 大小写处理：支持大小写字母的十六进制表示

5. 进制识别和验证

进制识别是根据数值格式自动识别其进制。进制验证是检查数值是否符合指定进制的规则。进制识别和验证对于输入处理很重要。

• 自动进制识别：根据前缀识别进制（如 0x 表示十六进制）
• 进制验证：检查数值是否符合指定进制
• 格式检查：检查数值格式是否正确
• 错误报告：提供详细的错误信息

6. 进制运算

进制运算是在不同进制下进行数学运算。进制运算对于某些特殊应用很有用。

• 进制加法：在指定进制下进行加法运算
• 进制减法：在指定进制下进行减法运算
• 进制乘法：在指定进制下进行乘法运算
• 进制除法：在指定进制下进行除法运算

7. 进制分析和统计

进制分析是对进制数据进行分析和统计。进制分析对于数据处理和编码很有用。

• 位数统计：统计进制数的位数
• 数字分布：分析进制数中各数字的分布
• 进制特性：分析进制数的特性
• 转换统计：统计转换过程中的信息

---

核心实现

1. 十进制转其他进制

fun decimalToBase(decimal: Long, base: Int): String {
    if (decimal == 0L) return "0"
    
    val digits = "0123456789ABCDEF"
    val result = StringBuilder()
    var num = kotlin.math.abs(decimal)
    
    while (num > 0) {
        result.insert(0, digits[(num % base).toInt()])
        num /= base
    }
    
    if (decimal < 0) result.insert(0, "-")
    return result.toString()
}

fun decimalToBinary(decimal: Long): String = decimalToBase(decimal, 2)
fun decimalToOctal(decimal: Long): String = decimalToBase(decimal, 8)
fun decimalToHex(decimal: Long): String = decimalToBase(decimal, 16)

代码说明： 十进制转其他进制使用除法和取余操作。通过循环除以目标进制，逐步提取各位数字。使用字符串存储数字符号，支持十六进制的字母表示。

2. 其他进制转十进制

fun baseToDecimal(value: String, base: Int): Long {
    return try {
        value.toLong(base)
    } catch (e: Exception) {
        0L
    }
}

fun binaryToDecimal(binary: String): Long = baseToDecimal(binary, 2)
fun octalToDecimal(octal: String): Long = baseToDecimal(octal, 8)
fun hexToDecimal(hex: String): Long = baseToDecimal(hex, 16)

代码说明： 其他进制转十进制使用 Kotlin 内置的 toLong 函数，指定目标进制。这种方法简洁高效，并且自动处理大小写和错误情况。

3. 进制间接转换

fun convertBetweenBases(value: String, fromBase: Int, toBase: Int): String {
    return try {
        val decimal = value.toLong(fromBase)
        if (toBase == 10) {
            decimal.toString()
        } else {
            decimalToBase(decimal, toBase)
        }
    } catch (e: Exception) {
        "转换失败"
    }
}

fun binaryToHex(binary: String): String = convertBetweenBases(binary, 2, 16)
fun hexToBinary(hex: String): String = convertBetweenBases(hex, 16, 2)
fun octalToHex(octal: String): String = convertBetweenBases(octal, 8, 16)

代码说明： 进制间接转换通过十进制作为中间进制。先将源进制转换为十进制，再转换为目标进制。这种方法通用且易于实现。

4. 进制验证

fun validateBase(value: String, base: Int): Pair<Boolean, String> {
    if (value.isEmpty()) return Pair(false, "数值不能为空")
    
    val validDigits = when (base) {
        2 -> "01"
        8 -> "01234567"
        10 -> "0123456789"
        16 -> "0123456789ABCDEFabcdef"
        else -> return Pair(false, "不支持的进制")
    }
    
    val checkValue = if (value.startsWith("-")) value.substring(1) else value
    
    for (char in checkValue) {
        if (char !in validDigits) {
            return Pair(false, "数值 '$char' 在 $base 进制中无效")
        }
    }
    
    return Pair(true, "数值有效")
}

代码说明： 进制验证检查数值中的每个字符是否符合指定进制的规则。通过定义每个进制的有效数字集合，进行逐字符检查。

5. 进制分析

fun analyzeBase(value: String, base: Int): Map<String, Any> {
    val stats = mutableMapOf<String, Any>()
    
    val validation = validateBase(value, base)
    stats["valid"] = validation.first
    
    if (validation.first) {
        val checkValue = if (value.startsWith("-")) value.substring(1) else value
        stats["length"] = checkValue.length
        stats["decimal"] = baseToDecimal(value, base)
        
        val digitCounts = mutableMapOf<Char, Int>()
        for (char in checkValue) {
            digitCounts[char] = (digitCounts[char] ?: 0) + 1
        }
        stats["digitDistribution"] = digitCounts
        
        stats["isNegative"] = value.startsWith("-")
    }
    
    return stats
}

代码说明： 进制分析提供关于进制数的详细信息，包括有效性、长度、十进制值、数字分布等。这对于理解进制数的特性很有用。

6. 进制运算

fun addInBase(num1: String, num2: String, base: Int): String {
    return try {
        val decimal1 = num1.toLong(base)
        val decimal2 = num2.toLong(base)
        val result = decimal1 + decimal2
        decimalToBase(result, base)
    } catch (e: Exception) {
        "运算失败"
    }
}

fun subtractInBase(num1: String, num2: String, base: Int): String {
    return try {
        val decimal1 = num1.toLong(base)
        val decimal2 = num2.toLong(base)
        val result = decimal1 - decimal2
        decimalToBase(result, base)
    } catch (e: Exception) {
        "运算失败"
    }
}

fun multiplyInBase(num1: String, num2: String, base: Int): String {
    return try {
        val decimal1 = num1.toLong(base)
        val decimal2 = num2.toLong(base)
        val result = decimal1 * decimal2
        decimalToBase(result, base)
    } catch (e: Exception) {
        "运算失败"
    }
}

代码说明： 进制运算通过转换为十进制进行计算，然后将结果转换回目标进制。这种方法简洁且易于实现。

---

Kotlin 源代码

// BaseConverter.kt
import kotlin.math.abs

class BaseConverter {
    
    fun decimalToBase(decimal: Long, base: Int): String {
        if (decimal == 0L) return "0"
        
        val digits = "0123456789ABCDEF"
        val result = StringBuilder()
        var num = abs(decimal)
        
        while (num > 0) {
            result.insert(0, digits[(num % base).toInt()])
            num /= base
        }
        
        if (decimal < 0) result.insert(0, "-")
        return result.toString()
    }
    
    fun decimalToBinary(decimal: Long): String = decimalToBase(decimal, 2)
    fun decimalToOctal(decimal: Long): String = decimalToBase(decimal, 8)
    fun decimalToHex(decimal: Long): String = decimalToBase(decimal, 16)
    
    fun baseToDecimal(value: String, base: Int): Long {
        return try {
            value.toLong(base)
        } catch (e: Exception) {
            0L
        }
    }
    
    fun binaryToDecimal(binary: String): Long = baseToDecimal(binary, 2)
    fun octalToDecimal(octal: String): Long = baseToDecimal(octal, 8)
    fun hexToDecimal(hex: String): Long = baseToDecimal(hex, 16)
    
    fun convertBetweenBases(value: String, fromBase: Int, toBase: Int): String {
        return try {
            val decimal = value.toLong(fromBase)
            if (toBase == 10) {
                decimal.toString()
            } else {
                decimalToBase(decimal, toBase)
            }
        } catch (e: Exception) {
            "转换失败"
        }
    }
    
    fun binaryToHex(binary: String): String = convertBetweenBases(binary, 2, 16)
    fun hexToBinary(hex: String): String = convertBetweenBases(hex, 16, 2)
    fun octalToHex(octal: String): String = convertBetweenBases(octal, 8, 16)
    fun hexToOctal(hex: String): String = convertBetweenBases(hex, 16, 8)
    
    fun validateBase(value: String, base: Int): Pair<Boolean, String> {
        if (value.isEmpty()) return Pair(false, "数值不能为空")
        
        val validDigits = when (base) {
            2 -> "01"
            8 -> "01234567"
            10 -> "0123456789"
            16 -> "0123456789ABCDEFabcdef"
            else -> return Pair(false, "不支持的进制")
        }
        
        val checkValue = if (value.startsWith("-")) value.substring(1) else value
        
        for (char in checkValue) {
            if (char !in validDigits) {
                return Pair(false, "数值 '$char' 在 $base 进制中无效")
            }
        }
        
        return Pair(true, "数值有效")
    }
    
    fun analyzeBase(value: String, base: Int): Map<String, Any> {
        val stats = mutableMapOf<String, Any>()
        
        val validation = validateBase(value, base)
        stats["valid"] = validation.first
        
        if (validation.first) {
            val checkValue = if (value.startsWith("-")) value.substring(1) else value
            stats["length"] = checkValue.length
            stats["decimal"] = baseToDecimal(value, base)
            
            val digitCounts = mutableMapOf<Char, Int>()
            for (char in checkValue) {
                digitCounts[char] = (digitCounts[char] ?: 0) + 1
            }
            stats["digitDistribution"] = digitCounts
            stats["isNegative"] = value.startsWith("-")
        }
        
        return stats
    }
    
    fun addInBase(num1: String, num2: String, base: Int): String {
        return try {
            val decimal1 = num1.toLong(base)
            val decimal2 = num2.toLong(base)
            val result = decimal1 + decimal2
            decimalToBase(result, base)
        } catch (e: Exception) {
            "运算失败"
        }
    }
    
    fun subtractInBase(num1: String, num2: String, base: Int): String {
        return try {
            val decimal1 = num1.toLong(base)
            val decimal2 = num2.toLong(base)
            val result = decimal1 - decimal2
            decimalToBase(result, base)
        } catch (e: Exception) {
            "运算失败"
        }
    }
    
    fun multiplyInBase(num1: String, num2: String, base: Int): String {
        return try {
            val decimal1 = num1.toLong(base)
            val decimal2 = num2.toLong(base)
            val result = decimal1 * decimal2
            decimalToBase(result, base)
        } catch (e: Exception) {
            "运算失败"
        }
    }
    
    fun getBaseInfo(base: Int): Map<String, Any> {
        return mapOf(
            "base" to base,
            "name" to when (base) {
                2 -> "二进制"
                8 -> "八进制"
                10 -> "十进制"
                16 -> "十六进制"
                else -> "未知进制"
            },
            "digits" to when (base) {
                2 -> "0-1"
                8 -> "0-7"
                10 -> "0-9"
                16 -> "0-9, A-F"
                else -> "未知"
            }
        )
    }
}

fun main() {
    val converter = BaseConverter()
    
    println("=== 进制转换工具演示 ===\n")
    
    // 十进制转其他进制
    val decimal = 255L
    println("十进制 $decimal 转换:")
    println("  二进制: ${converter.decimalToBinary(decimal)}")
    println("  八进制: ${converter.decimalToOctal(decimal)}")
    println("  十六进制: ${converter.decimalToHex(decimal)}\n")
    
    // 其他进制转十进制
    println("二进制 11111111 转十进制: ${converter.binaryToDecimal("11111111")}")
    println("十六进制 FF 转十进制: ${converter.hexToDecimal("FF")}\n")
    
    // 进制间转换
    println("二进制 11111111 转十六进制: ${converter.binaryToHex("11111111")}\n")
    
    // 进制验证
    val validation = converter.validateBase("FF", 16)
    println("验证 FF 是否为有效十六进制: ${validation.first}\n")
    
    // 进制分析
    val analysis = converter.analyzeBase("FF", 16)
    println("十六进制 FF 的分析: $analysis\n")
    
    // 进制运算
    println("十六进制 FF + 1 = ${converter.addInBase("FF", "1", 16)}")
}

Kotlin 代码说明： 这个实现提供了完整的进制转换功能。BaseConverter 类包含了进制转换、验证、分析、运算等多个方法。通过使用 Kotlin 内置的进制转换函数，实现了高效的转换。

---

JavaScript 编译代码

// BaseConverter.js
class BaseConverter {
    decimalToBase(decimal, base) {
        if (decimal === 0) return "0";
        
        const digits = "0123456789ABCDEF";
        let result = "";
        let num = Math.abs(decimal);
        
        while (num > 0) {
            result = digits[num % base] + result;
            num = Math.floor(num / base);
        }
        
        if (decimal < 0) result = "-" + result;
        return result;
    }
    
    decimalToBinary(decimal) { return this.decimalToBase(decimal, 2); }
    decimalToOctal(decimal) { return this.decimalToBase(decimal, 8); }
    decimalToHex(decimal) { return this.decimalToBase(decimal, 16); }
    
    baseToDecimal(value, base) {
        try {
            return parseInt(value, base);
        } catch (e) {
            return 0;
        }
    }
    
    binaryToDecimal(binary) { return this.baseToDecimal(binary, 2); }
    octalToDecimal(octal) { return this.baseToDecimal(octal, 8); }
    hexToDecimal(hex) { return this.baseToDecimal(hex, 16); }
    
    convertBetweenBases(value, fromBase, toBase) {
        try {
            const decimal = parseInt(value, fromBase);
            if (toBase === 10) {
                return decimal.toString();
            } else {
                return this.decimalToBase(decimal, toBase);
            }
        } catch (e) {
            return "转换失败";
        }
    }
    
    binaryToHex(binary) { return this.convertBetweenBases(binary, 2, 16); }
    hexToBinary(hex) { return this.convertBetweenBases(hex, 16, 2); }
    octalToHex(octal) { return this.convertBetweenBases(octal, 8, 16); }
    hexToOctal(hex) { return this.convertBetweenBases(hex, 16, 8); }
    
    validateBase(value, base) {
        if (!value) return { valid: false, message: "数值不能为空" };
        
        const validDigits = {
            2: "01",
            8: "01234567",
            10: "0123456789",
            16: "0123456789ABCDEFabcdef"
        };
        
        if (!validDigits[base]) return { valid: false, message: "不支持的进制" };
        
        const checkValue = value.startsWith("-") ? value.substring(1) : value;
        
        for (let char of checkValue) {
            if (!validDigits[base].includes(char.toUpperCase())) {
                return { valid: false, message: `数值 '${char}' 在 ${base} 进制中无效` };
            }
        }
        
        return { valid: true, message: "数值有效" };
    }
    
    analyzeBase(value, base) {
        const stats = {};
        const validation = this.validateBase(value, base);
        stats.valid = validation.valid;
        
        if (validation.valid) {
            const checkValue = value.startsWith("-") ? value.substring(1) : value;
            stats.length = checkValue.length;
            stats.decimal = this.baseToDecimal(value, base);
            
            const digitCounts = {};
            for (let char of checkValue) {
                const upper = char.toUpperCase();
                digitCounts[upper] = (digitCounts[upper] || 0) + 1;
            }
            stats.digitDistribution = digitCounts;
            stats.isNegative = value.startsWith("-");
        }
        
        return stats;
    }
    
    addInBase(num1, num2, base) {
        try {
            const decimal1 = parseInt(num1, base);
            const decimal2 = parseInt(num2, base);
            const result = decimal1 + decimal2;
            return this.decimalToBase(result, base);
        } catch (e) {
            return "运算失败";
        }
    }
    
    subtractInBase(num1, num2, base) {
        try {
            const decimal1 = parseInt(num1, base);
            const decimal2 = parseInt(num2, base);
            const result = decimal1 - decimal2;
            return this.decimalToBase(result, base);
        } catch (e) {
            return "运算失败";
        }
    }
    
    multiplyInBase(num1, num2, base) {
        try {
            const decimal1 = parseInt(num1, base);
            const decimal2 = parseInt(num2, base);
            const result = decimal1 * decimal2;
            return this.decimalToBase(result, base);
        } catch (e) {
            return "运算失败";
        }
    }
    
    getBaseInfo(base) {
        const names = { 2: "二进制", 8: "八进制", 10: "十进制", 16: "十六进制" };
        const digits = { 2: "0-1", 8: "0-7", 10: "0-9", 16: "0-9, A-F" };
        
        return {
            base: base,
            name: names[base] || "未知进制",
            digits: digits[base] || "未知"
        };
    }
}

// 使用示例
const converter = new BaseConverter();

console.log("=== 进制转换工具演示 ===\n");

const decimal = 255;
console.log(`十进制 ${decimal} 转换:`);
console.log("  二进制:", converter.decimalToBinary(decimal));
console.log("  八进制:", converter.decimalToOctal(decimal));
console.log("  十六进制:", converter.decimalToHex(decimal));

console.log("\n二进制 11111111 转十进制:", converter.binaryToDecimal("11111111"));
console.log("十六进制 FF 转十进制:", converter.hexToDecimal("FF"));

console.log("\n二进制 11111111 转十六进制:", converter.binaryToHex("11111111"));

const validation = converter.validateBase("FF", 16);
console.log("\n验证 FF 是否为有效十六进制:", validation.valid);

const analysis = converter.analyzeBase("FF", 16);
console.log("\n十六进制 FF 的分析:", analysis);

console.log("\n十六进制 FF + 1 =", converter.addInBase("FF", "1", 16));

JavaScript 代码说明： JavaScript 版本是 Kotlin 代码的直接转译。由于 JavaScript 和 Kotlin 在进制转换上有差异，我们使用 parseInt 函数进行进制转换。整体逻辑和算法与 Kotlin 版本保持一致。

---

ArkTS 调用代码

// BaseConverterPage.ets
import { BaseConverter } from './BaseConverter';

@Entry
@Component
struct BaseConverterPage {
    @State inputValue: string = '255';
    @State fromBase: string = '10';
    @State toBase: string = '16';
    @State result: string = '';
    @State showResult: boolean = false;
    @State isLoading: boolean = false;
    @State operationType: string = 'convert';
    
    private converter: BaseConverter = new BaseConverter();
    
    private baseOptions = [
        { label: '二进制 (2)', value: '2' },
        { label: '八进制 (8)', value: '8' },
        { label: '十进制 (10)', value: '10' },
        { label: '十六进制 (16)', value: '16' }
    ];
    
    private operationOptions = [
        { label: '进制转换', value: 'convert' },
        { label: '进制验证', value: 'validate' },
        { label: '进制分析', value: 'analyze' },
        { label: '进制加法', value: 'add' },
        { label: '进制减法', value: 'subtract' },
        { label: '进制乘法', value: 'multiply' }
    ];
    
    performOperation() {
        this.isLoading = true;
        try {
            let resultText = '';
            const fromBaseNum = parseInt(this.fromBase);
            const toBaseNum = parseInt(this.toBase);
            
            switch (this.operationType) {
                case 'convert':
                    resultText = this.converter.convertBetweenBases(this.inputValue, fromBaseNum, toBaseNum);
                    break;
                case 'validate':
                    const validation = this.converter.validateBase(this.inputValue, fromBaseNum);
                    resultText = validation.valid ? '✓ ' + validation.message : '✗ ' + validation.message;
                    break;
                case 'analyze':
                    const analysis = this.converter.analyzeBase(this.inputValue, fromBaseNum);
                    resultText = `📊 进制分析\n`;
                    resultText += `━━━━━━━━━━━━━━━━━━━━━\n`;
                    resultText += `有效性: ${analysis.valid ? '有效' : '无效'}\n`;
                    if (analysis.valid) {
                        resultText += `位数: ${analysis.length}\n`;
                        resultText += `十进制值: ${analysis.decimal}\n`;
                        resultText += `是否为负数: ${analysis.isNegative ? '是' : '否'}\n`;
                        resultText += `数字分布: ${JSON.stringify(analysis.digitDistribution)}`;
                    }
                    break;
                case 'add':
                    resultText = this.converter.addInBase(this.inputValue, '1', fromBaseNum);
                    break;
                case 'subtract':
                    resultText = this.converter.subtractInBase(this.inputValue, '1', fromBaseNum);
                    break;
                case 'multiply':
                    resultText = this.converter.multiplyInBase(this.inputValue, '2', fromBaseNum);
                    break;
                default:
                    resultText = '未知操作';
            }
            
            this.result = resultText;
            this.showResult = true;
        } catch (error) {
            this.result = '操作失败: ' + (error instanceof Error ? error.message : String(error));
            this.showResult = true;
        } finally {
            this.isLoading = false;
        }
    }
    
    build() {
        Column() {
            // 标题
            Text('进制转换工具')
                .fontSize(28)
                .fontWeight(FontWeight.Bold)
                .margin({ top: 20, bottom: 20 })
                .textAlign(TextAlign.Center)
                .width('100%')
            
            // 操作类型选择
            Column() {
                Text('操作类型')
                    .fontSize(14)
                    .fontColor('#666666')
                    .margin({ bottom: 10 })
                
                Select(this.operationOptions)
                    .value(this.operationType)
                    .onSelect((index: number, value?: string) => {
                        this.operationType = value || 'convert';
                    })
                    .width('100%')
                    .height(40)
            }
            .width('100%')
            .padding(15)
            .backgroundColor('#ffffff')
            .borderRadius(10)
            .border({ width: 1, color: '#eeeeee' })
            .margin({ bottom: 20 })
            
            // 进制选择
            Row() {
                Column() {
                    Text('源进制')
                        .fontSize(12)
                        .fontColor('#666666')
                        .margin({ bottom: 8 })
                    
                    Select(this.baseOptions)
                        .value(this.fromBase)
                        .onSelect((index: number, value?: string) => {
                            this.fromBase = value || '10';
                        })
                        .width('100%')
                        .height(40)
                }
                .width('48%')
                
                Text('→')
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('4%')
                    .textAlign(TextAlign.Center)
                
                Column() {
                    Text('目标进制')
                        .fontSize(12)
                        .fontColor('#666666')
                        .margin({ bottom: 8 })
                    
                    Select(this.baseOptions)
                        .value(this.toBase)
                        .onSelect((index: number, value?: string) => {
                            this.toBase = value || '16';
                        })
                        .width('100%')
                        .height(40)
                }
                .width('48%')
            }
            .width('100%')
            .padding(15)
            .backgroundColor('#ffffff')
            .borderRadius(10)
            .border({ width: 1, color: '#eeeeee' })
            .margin({ bottom: 20 })
            
            // 输入框
            Column() {
                Text('输入值')
                    .fontSize(14)
                    .fontColor('#666666')
                    .margin({ bottom: 10 })
                
                TextInput({ placeholder: '输入数值' })
                    .value(this.inputValue)
                    .onChange((value: string) => {
                        this.inputValue = value;
                    })
                    .width('100%')
                    .height(45)
                    .padding({ left: 10, right: 10 })
                    .border({ width: 1, color: '#cccccc', radius: 8 })
                    .fontSize(14)
            }
            .width('100%')
            .padding(15)
            .backgroundColor('#ffffff')
            .borderRadius(10)
            .border({ width: 1, color: '#eeeeee' })
            .margin({ bottom: 20 })
            
            // 操作按钮
            Button('执行操作')
                .width('100%')
                .height(45)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .backgroundColor('#1B7837')
                .fontColor('#ffffff')
                .onClick(() => {
                    this.performOperation();
                })
                .margin({ bottom: 20 })
            
            // 结果显示
            if (this.showResult) {
                Column() {
                    Text('结果')
                        .fontSize(16)
                        .fontWeight(FontWeight.Bold)
                        .fontColor('#FFFFFF')
                        .width('100%')
                        .padding(12)
                        .backgroundColor('#1B7837')
                        .borderRadius(8)
                        .margin({ bottom: 12 })
                    
                    Scroll() {
                        Text(this.result)
                            .fontSize(13)
                            .fontColor('#333333')
                            .width('100%')
                            .padding(12)
                            .backgroundColor('#f9f9f9')
                            .borderRadius(6)
                            .textAlign(TextAlign.Start)
                            .fontFamily('monospace')
                            .selectable(true)
                    }
                    .width('100%')
                    .height(150)
                }
                .width('100%')
                .padding(15)
                .backgroundColor('#ffffff')
                .borderRadius(10)
                .border({ width: 1, color: '#eeeeee' })
            }
            
            Blank()
        }
        .width('100%')
        .height('100%')
        .padding(15)
        .backgroundColor('#f5f5f5')
        .scrollable(ScrollDirection.Vertical)
    }
}

ArkTS 代码说明： ArkTS 调用代码展示了如何在 OpenHarmony 应用中使用进制转换工具。页面包含操作类型选择、源进制和目标进制选择、输入框、操作按钮和结果显示等功能。通过 @State 装饰器管理状态，实现了完整的用户交互流程。用户可以选择操作类型和进制，输入数值，然后点击执行按钮获得结果。

---

实战案例

案例1：网络协议分析

在网络协议分析中，需要将十六进制的网络数据转换为十进制进行分析。

fun analyzeNetworkPacket(hexData: String): Map<String, Any> {
    val converter = BaseConverter()
    
    val validation = converter.validateBase(hexData, 16)
    if (!validation.first) {
        return mapOf("error" to validation.second)
    }
    
    val decimal = converter.hexToDecimal(hexData)
    val binary = converter.hexToBinary(hexData)
    
    return mapOf(
        "hexValue" to hexData,
        "decimalValue" to decimal,
        "binaryValue" to binary,
        "byteCount" to (hexData.length / 2)
    )
}

案例2：颜色值处理

在图形应用中，需要将十六进制的颜色值转换为 RGB 值。

fun parseColorValue(hexColor: String): Map<String, Int> {
    val converter = BaseConverter()
    
    val cleanHex = hexColor.removePrefix("#")
    val r = converter.hexToDecimal(cleanHex.substring(0, 2)).toInt()
    val g = converter.hexToDecimal(cleanHex.substring(2, 4)).toInt()
    val b = converter.hexToDecimal(cleanHex.substring(4, 6)).toInt()
    
    return mapOf("r" to r, "g" to g, "b" to b)
}

案例3：文件权限转换

在 Unix 系统中，文件权限使用八进制表示。

fun parseFilePermission(octalPermission: String): Map<String, String> {
    val converter = BaseConverter()
    
    val binary = converter.octalToBinary(octalPermission)
    val decimal = converter.octalToDecimal(octalPermission)
    
    return mapOf(
        "octal" to octalPermission,
        "binary" to binary,
        "decimal" to decimal.toString(),
        "readable" to if (binary.length > 0 && binary[0] == '1') "是" else "否",
        "writable" to if (binary.length > 1 && binary[1] == '1') "是" else "否",
        "executable" to if (binary.length > 2 && binary[2] == '1') "是" else "否"
    )
}

---

最佳实践

1. 输入验证

始终验证输入数值是否符合指定进制的规则。

2. 错误处理

提供清晰的错误消息，帮助用户理解转换失败的原因。

3. 进制识别

支持自动识别进制，如 0x 前缀表示十六进制。

4. 大小写处理

对于十六进制，支持大小写字母的混合使用。

5. 性能优化

缓存常用的转换结果，避免重复计算。

6. 用户体验

提供实时反馈，显示转换过程和结果。

---

总结

进制转换工具是计算机科学中的基础工具。通过 KMP 框架，我们可以创建一个跨端的进制转换系统，在 Kotlin、JavaScript 和 ArkTS 中使用相同的转换逻辑。这不仅提高了代码的可维护性，还确保了不同平台上转换结果的一致性。

在实际应用中，合理使用进制转换工具可以提高开发效率和代码质量。无论是网络协议分析、颜色值处理还是文件权限转换，进制转换工具都能发挥重要作用。通过提供完整的进制转换功能和灵活的操作选项，我们可以帮助开发者更好地处理和理解不同进制的数据。
欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net