Whiz Tools

数字进制转换器

数字进制转换器：理解和转换不同的数字系统

简介

数字进制（或基数）是一个数学表示系统，它使用特定数量的独特符号来表示数量。基数决定了在该系统中用于表示数字的不同数字的数量。我们的数字进制转换器工具允许您在不同的数字基数之间进行转换，范围从二进制（基数 2）到基数 36，包括所有数字（0-9）和字母（A-Z）。

在我们的日常生活中，我们主要使用十进制系统（基数 10），它使用十个数字（0-9）。然而，在计算机和各种专业领域中，其他数字基数也经常使用：

  • 二进制（基数 2）：仅使用 0 和 1，直接表示电子电路中的开/关状态
  • 八进制（基数 8）：使用数字 0-7
  • 十进制（基数 10）：使用数字 0-9
  • 十六进制（基数 16）：使用数字 0-9 和字母 A-F
  • 基数 36：使用数字 0-9 和字母 A-Z（使用字母数字字符的最大基数）

我们的转换器处理从 2 到 36 的所有基数，使其成为程序员、学生和在不同数字系统中工作的专业人士的多功能工具。

如何使用此转换器

  1. 在“要转换的数字”字段中输入您想要转换的数字
  2. 使用“源基数”字段选择源基数（您输入的数字的基数）
  3. 使用“目标基数”字段选择目标基数（您想要转换到的基数）
  4. 单击“转换”按钮以查看结果
  5. 使用“复制”按钮将结果复制到剪贴板

转换器验证您的输入，以确保它仅包含所选源基数的有效字符。例如，如果您选择二进制（基数 2）作为源基数，则您的输入应仅包含 0 和 1。

公式和计算方法

将数字从一个基数转换到另一个基数涉及两个主要步骤：

  1. 将源数字转换为十进制（基数 10）
  2. 将十进制数字转换为目标基数

第一步：从任意基数转换为十进制

要将数字从基数 bb 转换为十进制，我们使用每个数字的位置值。对于具有数字 dn,dn−1,...,d1,d0d_n, d_{n-1}, ..., d_1, d_0 的数字，十进制值计算为：

十进制值=dn×bn+dn−1×bn−1+...+d1×b1+d0×b0\text{十进制值} = d_n \times b^n + d_{n-1} \times b^{n-1} + ... + d_1 \times b^1 + d_0 \times b^0

例如，要将二进制数字“1010”转换为十进制： 1×23+0×22+1×21+0×20=8+0+2+0=101 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 0 \times 2^0 = 8 + 0 + 2 + 0 = 10

对于高于 10 的基数，字母表示超过 9 的值：

  • A = 10, B = 11, ..., Z = 35

例如，要将十六进制数字“1A”转换为十进制： 1×161+10×160=16+10=261 \times 16^1 + 10 \times 16^0 = 16 + 10 = 26

第二步：从十进制转换为任意基数

要将十进制数字转换为基数 bb，我们重复将数字除以 bb 并收集余数，顺序相反：

  1. 将十进制数字除以目标基数
  2. 记录余数（这是结果的最右侧数字）
  3. 用步骤 1 中的商替换十进制数字
  4. 重复步骤 1-3，直到商变为 0
  5. 从下到上读取余数以获得结果

例如，要将十进制数字“10”转换为二进制：

10 ÷ 2 = 5 余数 0
5 ÷ 2 = 2 余数 1
2 ÷ 2 = 1 余数 0
1 ÷ 2 = 0 余数 1

从下到上读取余数：1010

对于高于 10 的基数，余数大于 9 的用字母表示：

  • 10 = A, 11 = B, ..., 35 = Z

边缘情况和特殊考虑

前导零

前导零不会改变任何基数中数字的值，但在某些上下文中，例如固定宽度的二进制表示中，它们可能是重要的。我们的转换器默认删除前导零。

大小写敏感性

对于使用字母（A-Z）的基数高于 10，我们的转换器接受大写和小写字母作为输入，并标准化输出。

大数字

非常大的数字可能会在某些编程语言中导致精度问题。我们的转换器通过使用适当的数据类型和算法来保持精度来处理此问题。

分数数字

虽然我们当前的转换器专注于整数转换，但值得注意的是，不同基数中的分数数字与整数的工作原理相似，但需要额外的步骤来处理分数部分。

负数

我们的转换器主要处理正数。在不同基数中，负数通常使用与正数相同的表示，但带有负号前缀。

用例

数字基数转换在各个领域有许多实际应用：

  1. 计算机编程：程序员经常使用二进制、八进制和十六进制表示。十六进制通常用于表示内存地址、颜色代码和以更紧凑的形式表示的二进制数据。

  2. 数字电子学：工程师使用二进制和十六进制来表示和分析数字电路和内存内容。

  3. 计算机科学教育：理解不同的数字基数是计算机科学教育的基础，帮助学生掌握计算机如何存储和处理数据。

  4. 密码学：各种密码算法涉及不同基数中的运算。

  5. 数据压缩：某些压缩算法使用不同的数字基数进行高效编码。

  6. 网络管理：IPv6 地址通常以十六进制表示。

  7. 网页开发：CSS 和 HTML 中的颜色代码使用十六进制表示法（例如，#FF5733）。

替代方案

虽然直接的基数转换如我们工具中所实现的最为常见，但对于特定用例还有替代方法：

  1. 查找表：对于小的固定值集，预计算的查找表可以比算法转换更快。

  2. 位运算：对于二进制与 2 的幂（如八进制和十六进制）之间的转换，位运算可能更有效。

  3. 专用库：对于非常大的数字或高精度要求，专用数学库可能更合适。

  4. 硬件加速：某些处理器具有用于特定基数转换的内置指令。

数字系统的历史

不同数字系统的发展有着悠久的历史，跨越了数千年：

  1. 记号（单一系统）：最早的计数系统，使用简单的标记来表示数量，可以追溯到史前时代。

  2. 巴比伦系统：最早的一个位置数字系统，使用基数 60（六十进制），大约在公元前 3000 年发展。这个系统的遗留物仍然存在于我们的时间测量中（60 秒，60 分钟）和角度（360 度）中。

  3. 埃及系统：使用基数 10 的系统，具有用于 10 的幂的象形符号，约在公元前 3000 年发展。

  4. 罗马数字：一种非位置系统，使用字母（I、V、X、L、C、D、M），约在公元前 500 年发展，并在整个罗马帝国中使用。

  5. 印度-阿拉伯系统：我们现代的十进制（基数 10）系统起源于公元 5 世纪的印度，后来被阿拉伯数学家采用。它引入了零作为占位符和位置记数法的概念。

  6. 二进制系统：在 17 世纪由戈特弗里德·威廉·莱布尼茨正式发展，尽管早期在各种文化中就存在这一概念。

  7. 现代计算机数字系统：随着 20 世纪数字计算机的出现，二进制成为计算的基础。八进制和十六进制作为更易于人类阅读的二进制数据表示法被引入。

  8. 基数 36 及更高：使用字母数字字符的扩展数字系统在计算中变得有用，例如用于哈希函数和唯一标识符的紧凑表示。

数字系统的演变反映了人类对更有效表示和操作数量的日益需要，尤其是在数学和技术进步的背景下。

代码示例

以下是各种编程语言中基数转换的实现：

' Excel VBA 函数进行基数转换
Function ConvertBase(ByVal number As String, ByVal fromBase As Integer, ByVal toBase As Integer) As String
    ' 首先转换为十进制
    Dim decimal As Double
    decimal = 0
    Dim i As Integer
    Dim digit As Integer
    
    For i = 1 To Len(number)
        Dim char As String
        char = UCase(Mid(number, i, 1))
        
        If char >= "0" And char <= "9" Then
            digit = Asc(char) - Asc("0")
        ElseIf char >= "A" And char <= "Z" Then
            digit = Asc(char) - Asc("A") + 10
        End If
        
        decimal = decimal * fromBase + digit
    Next i
    
    ' 然后从十进制转换到目标基数
    If decimal = 0 Then
        ConvertBase = "0"
        Exit Function
    End If
    
    Dim result As String
    result = ""
    
    While decimal > 0
        Dim remainder As Integer
        remainder = decimal Mod toBase
        decimal = Int(decimal / toBase)
        
        If remainder < 10 Then
            result = Chr(remainder + Asc("0")) & result
        Else
            result = Chr(remainder - 10 + Asc("A")) & result
        End If
    Wend
    
    ConvertBase = result
End Function

def convert_base(number, from_base, to_base):
    """
    将数字从一个基数转换为另一个基数
    
    参数：
        number (str): 要转换的数字
        from_base (int): 输入数字的基数（2-36）
        to_base (int): 要转换到的基数（2-36）
        
    返回：
        str: 转换后的数字
    """
    # 验证基数
    if not (2 <= from_base <= 36 and 2 <= to_base <= 36):
        raise ValueError("基数必须在 2 到 36 之间")
    
    # 转换为大写以保持一致性
    number = number.upper()
    
    # 首先转换为十进制（基数 10）
    decimal = 0
    for digit in number:
        if '0' <= digit <= '9':
            value = ord(digit) - ord('0')
        else:
            value = ord(digit) - ord('A') + 10
            
        if value >= from_base:
            raise ValueError(f"基数 {from_base} 的无效数字 '{digit}'")
            
        decimal = decimal * from_base + value
    
    # 然后从十进制转换到目标基数
    if decimal == 0:
        return "0"
    
    result = ""
    while decimal > 0:
        remainder = decimal % to_base
        decimal //= to_base
        
        if remainder < 10:
            result = str(remainder) + result
        else:
            result = chr(remainder - 10 + ord('A')) + result
    
    return result

# 示例用法
binary = "1010"
decimal = convert_base(binary, 2, 10)
print(f"二进制 {binary} 转换为十进制: {decimal}")  # 输出: 二进制 1010 转换为十进制: 10

hex_num = "1A"
decimal = convert_base(hex_num, 16, 10)
print(f"十六进制 {hex_num} 转换为十进制: {decimal}")  # 输出: 十六进制 1A 转换为十进制: 26

decimal = "42"
binary = convert_base(decimal, 10, 2)
print(f"十进制 {decimal} 转换为二进制: {binary}")  # 输出: 十进制 42 转换为二进制: 101010

/**
 * 将数字从一个基数转换为另一个基数
 * @param {string} number - 要转换的数字
 * @param {number} fromBase - 输入数字的基数（2-36）
 * @param {number} toBase - 要转换到的基数（2-36）
 * @returns {string} 转换后的数字
 */
function convertBase(number, fromBase, toBase) {
  // 验证基数
  if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {
    throw new Error("基数必须在 2 到 36 之间");
  }
  
  // 转换为大写以保持一致性
  number = number.toUpperCase();
  
  // 首先转换为十进制
  let decimal = 0;
  for (let i = 0; i < number.length; i++) {
    const char = number[i];
    let digit;
    
    if (char >= '0' && char <= '9') {
      digit = char.charCodeAt(0) - '0'.charCodeAt(0);
    } else {
      digit = char.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
    }
    
    if (digit >= fromBase) {
      throw new Error(`基数 ${fromBase} 的无效数字 '${char}'`);
    }
    
    decimal = decimal * fromBase + digit;
  }
  
  // 然后从十进制转换到目标基数
  if (decimal === 0) {
    return "0";
  }
  
  let result = "";
  while (decimal > 0) {
    const remainder = decimal % toBase;
    decimal = Math.floor(decimal / toBase);
    
    if (remainder < 10) {
      result = remainder + result;
    } else {
      result = String.fromCharCode('A'.charCodeAt(0) + remainder - 10) + result;
    }
  }
  
  return result;
}

// 示例用法
console.log(convertBase("1010", 2, 10));  // 输出: "10"
console.log(convertBase("10", 10, 2));    // 输出: "1010"
console.log(convertBase("1A", 16, 10));   // 输出: "26"
console.log(convertBase("26", 10, 16));   // 输出: "1A"
console.log(convertBase("XYZ", 36, 10));  // 输出: "44027"

public class BaseConverter {
    /**
     * 将数字从一个基数转换为另一个基数
     * 
     * @param number   作为字符串的要转换的数字
     * @param fromBase 输入数字的基数（2-36）
     * @param toBase   要转换到的基数（2-36）
     * @return 转换后的数字作为字符串
     */
    public static String convertBase(String number, int fromBase, int toBase) {
        // 验证基数
        if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {
            throw new IllegalArgumentException("基数必须在 2 到 36 之间");
        }
        
        // 转换为大写以保持一致性
        number = number.toUpperCase();
        
        // 首先转换为十进制
        int decimal = 0;
        for (int i = 0; i < number.length(); i++) {
            char c = number.charAt(i);
            int digit;
            
            if (c >= '0' && c <= '9') {
                digit = c - '0';
            } else {
                digit = c - 'A' + 10;
            }
            
            if (digit >= fromBase) {
                throw new IllegalArgumentException("基数 " + fromBase + " 的无效数字");
            }
            
            decimal = decimal * fromBase + digit;
        }
        
        // 然后从十进制转换到目标基数
        if (decimal == 0) {
            return "0";
        }
        
        StringBuilder result = new StringBuilder();
        while (decimal > 0) {
            int remainder = decimal % toBase;
            decimal = decimal / toBase;
            
            if (remainder < 10) {
                result.insert(0, (char)('0' + remainder));
            } else {
                result.insert(0, (char)('A' + remainder - 10));
            }
        }
        
        return result.toString();
    }
    
    public static void main(String[] args) {
        // 示例用法
        System.out.println("二进制 1010 转换为十进制: " + convertBase("1010", 2, 10));  // 输出: 10
        System.out.println("十进制 10 转换为二进制: " + convertBase("10", 10, 2));      // 输出: 1010
        System.out.println("十六进制 1A 转换为十进制: " + convertBase("1A", 16, 10));  // 输出: 26
        System.out.println("十进制 26 转换为十六进制: " + convertBase("26", 10, 16));  // 输出: 1A
    }
}

#include <iostream>
#include <string>
#include <stdexcept>
#include <cmath>

/**
 * 将数字从一个基数转换为另一个基数
 * 
 * @param number 要转换的数字作为字符串
 * @param fromBase 输入数字的基数（2-36）
 * @param toBase 要转换到的基数（2-36）
 * @return 转换后的数字作为字符串
 */
std::string convertBase(const std::string& number, int fromBase, int toBase) {
    // 验证基数
    if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {
        throw std::invalid_argument("基数必须在 2 到 36 之间");
    }
    
    // 转换为大写以保持一致性
    std::string upperNumber = number;
    for (char& c : upperNumber) {
        c = toupper(c);
    }
    
    // 首先转换为十进制
    int decimal = 0;
    for (char c : upperNumber) {
        int digit;
        
        if (c >= '0' && c <= '9') {
            digit = c - '0';
        } else {
            digit = c - 'A' + 10;
        }
        
        if (digit >= fromBase) {
            throw std::invalid_argument("基数 " + std::to_string(fromBase) + " 的无效数字");
        }
        
        decimal = decimal * fromBase + digit;
    }
    
    // 然后从十进制转换到目标基数
    if (decimal == 0) {
        return "0";
    }
    
    std::string result = "";
    while (decimal > 0) {
        int remainder = decimal % toBase;
        decimal = decimal / toBase;
        
        if (remainder < 10) {
            result = std::string(1, '0' + remainder) + result;
        } else {
            result = std::string(1, 'A' + remainder - 10) + result;
        }
    }
    
    return result;
}

int main() {
    // 示例用法
    std::cout << "二进制 1010 转换为十进制: " << convertBase("1010", 2, 10) << std::endl;  // 输出: 10
    std::cout << "十进制 10 转换为二进制: " << convertBase("10", 10, 2) << std::endl;      // 输出: 1010
    std::cout << "十六进制 1A 转换为十进制: " << convertBase("1A", 16, 10) << std::endl;  // 输出: 26
    std::cout << "十进制 26 转换为十六进制: " << convertBase("26", 10, 16) << std::endl;  // 输出: 1A
    
    return 0;
}

# 将数字从一个基数转换为另一个基数
# @param number [String] 要转换的数字
# @param from_base [Integer] 输入数字的基数（2-36）
# @param to_base [Integer] 要转换到的基数（2-36）
# @return [String] 转换后的数字
def convert_base(number, from_base, to_base)
  # 验证基数
  if from_base < 2 || from_base > 36 || to_base < 2 || to_base > 36
    raise ArgumentError, "基数必须在 2 到 36 之间"
  end
  
  # 转换为大写以保持一致性
  number = number.upcase
  
  # 首先转换为十进制
  decimal = 0
  number.each_char do |char|
    digit = if char >= '0' && char <= '9'
              char.ord - '0'.ord
            else
              char.ord - 'A'.ord + 10
            end
    
    if digit >= from_base
      raise ArgumentError, "基数 #{from_base} 的无效数字 '#{char}'"
    end
    
    decimal = decimal * from_base + digit
  end
  
  # 然后从十进制转换到目标基数
  return "0" if decimal == 0
  
  result = ""
  while decimal > 0
    remainder = decimal % to_base
    decimal = decimal / to_base
    
    if remainder < 10
      result = remainder.to_s + result
    else
      result = (remainder - 10 + 'A'.ord).chr + result
    end
  end
  
  result
end

# 示例用法
puts "二进制 1010 转换为十进制: #{convert_base('1010', 2, 10)}"  # 输出: 10
puts "十进制 10 转换为二进制: #{convert_base('10', 10, 2)}"      # 输出: 1010
puts "十六进制 1A 转换为十进制: #{convert_base('1A', 16, 10)}"  # 输出: 26
puts "十进制 26 转换为十六进制: #{convert_base('26', 10, 16)}"  # 输出: 1A

<?php
/**
 * 将数字从一个基数转换为另一个基数
 * 
 * @param string $number 要转换的数字
 * @param int $fromBase 输入数字的基数（2-36）
 * @param int $toBase 要转换到的基数（2-36）
 * @return string 转换后的数字
 */
function convertBase($number, $fromBase, $toBase) {
    // 验证基数
    if ($fromBase < 2 || $fromBase > 36 || $toBase < 2 || $toBase > 36) {
        throw new InvalidArgumentException("基数必须在 2 到 36 之间");
    }
    
    // 转换为大写以保持一致性
    $number = strtoupper($number);
    
    // 首先转换为十进制
    $decimal = 0;
    $length = strlen($number);
    
    for ($i = 0; $i < $length; $i++) {
        $char = $number[$i];
        
        if ($char >= '0' && $char <= '9') {
            $digit = ord($char) - ord('0');
        } else {
            $digit = ord($char) - ord('A') + 10;
        }
        
        if ($digit >= $fromBase) {
            throw new InvalidArgumentException("基数 $fromBase 的无效数字 '$char'");
        }
        
        $decimal = $decimal * $fromBase + $digit;
    }
    
    // 然后从十进制转换到目标基数
    if ($decimal === 0) {
        return "0";
    }
    
    $result = "";
    while ($decimal > 0) {
        $remainder = $decimal % $toBase;
        $decimal = intdiv($decimal, $toBase);
        
        if ($remainder < 10) {
            $result = $remainder . $result;
        } else {
            $result = chr(ord('A') + $remainder - 10) . $result;
        }
    }
    
    return $result;
}

// 示例用法
echo "二进制 1010 转换为十进制: " . convertBase("1010", 2, 10) . PHP_EOL;  // 输出: 10
echo "十进制 10 转换为二进制: " . convertBase("10", 10, 2) . PHP_EOL;      // 输出: 1010
echo "十六进制 1A 转换为十进制: " . convertBase("1A", 16, 10) . PHP_EOL;  // 输出: 26
echo "十进制 26 转换为十六进制: " . convertBase("26", 10, 16) . PHP_EOL;  // 输出: 1A
?>

数字示例

以下是一些常见的转换示例：

  1. 二进制转十进制：

    • 二进制：1010
    • 十进制：10
    • 计算： (1 × 2³) + (0 × 2²) + (1 × 2¹) + (0 × 2⁰) = 8 + 0 + 2 + 0 = 10

  2. 十进制转二进制：

    • 十进制：25
    • 二进制：11001
    • 计算：
      • 25 ÷ 2 = 12 余数 1
      • 12 ÷ 2 = 6 余数 0
      • 6 ÷ 2 = 3 余数 0
      • 3 ÷ 2 = 1 余数 1
      • 1 ÷ 2 = 0 余数 1
      • 从下到上读取余数：11001

  3. 十六进制转十进制：

    • 十六进制：1A
    • 十进制：26
    • 计算： (1 × 16¹) + (10 × 16⁰) = 16 + 10 = 26

  4. 十进制转十六进制：

    • 十进制：255
    • 十六进制：FF
    • 计算：
      • 255 ÷ 16 = 15 余数 15 (F)
      • 15 ÷ 16 = 0 余数 15 (F)
      • 从下到上读取余数：FF

  5. 二进制转十六进制：

    • 二进制：11111111
    • 十六进制：FF
    • 计算：将二进制数字按 4 位分组，从右到左：
      • 1111 = F
      • 1111 = F
      • 结果：FF

  6. 基数 36 示例：

    • 基数 36：XYZ
    • 十进制：44027
    • 计算： (33 × 36²) + (34 × 36¹) + (35 × 36⁰) = 42768 + 1224 + 35 = 44027

参考文献

  1. "数字系统转换。"可汗学院，https://www.khanacademy.org/math/algebra/x2f8bb11595b61c86:foundation-algebra/x2f8bb11595b61c86:alternate-number-bases/a/conversion-between-decimal-and-binary。访问日期：2024 年 8 月 2 日。

  2. "位置记数法。"维基百科，维基媒体基金会，https://en.wikipedia.org/wiki/Positional_notation。访问日期：2024 年 8 月 2 日。

  3. "十六进制。"维基百科，维基媒体基金会，https://en.wikipedia.org/wiki/Hexadecimal。访问日期：2024 年 8 月 2 日。

  4. Knuth, Donald E. "计算机程序设计的艺术，第二卷：半数字算法。" Addison-Wesley，1997 年。

  5. "二进制数字。"维基百科，维基媒体基金会，https://en.wikipedia.org/wiki/Binary_number。访问日期：2024 年 8 月 2 日。

  6. "基数 36。"维基百科，维基媒体基金会，https://en.wikipedia.org/wiki/Base36。访问日期：2024 年 8 月 2 日。

现在尝试我们的数字进制转换器，快速准确地在不同的数字系统之间进行转换。无论您是学习数字系统的学生、在不同基数中工作的程序员，还是对数字表示方式感到好奇，我们的工具都提供了简单高效的解决方案。

相关工具

时间单位转换器：年、天、小时、分钟、秒
Base64 编码器和解码器：将文本转换为/从 Base64
JSON 格式化器与美化器：使用缩进美化 JSON
鞋码转换器：美国、英国、欧盟和日本尺码系统
位和字节长度计算器 - 计算多种编码的数据长度
文本反转工具：反转任意字符串中的字符顺序
随机API密钥生成器：创建安全的32字符字符串
用于测试的有效随机CPF生成器工具
使用tiktoken库计算字符串中的令牌数量
Unix时间戳到日期转换器：支持12/24小时格式
Feedback