ASCII 编解码

复制import sys

# 字符 → ASCII 码（十进制）
def char_to_ascii(char: str) -> int:
    if len(char) != 1:
        raise ValueError("输入必须为单个字符")
    return ord(char)

# ASCII 码（十进制）→ 字符
def ascii_to_char(code: int) -> str:
    if not (0 <= code <= 127):
        raise ValueError("ASCII 码范围 0-127")
    return chr(code)

# 字符 → 十六进制
def char_to_hex(char: str) -> str:
    return hex(ord(char))[2:].upper()

# 十六进制 → 字符
def hex_to_char(hex_str: str) -> str:
    return chr(int(hex_str, 16))

if __name__ == "__main__":
    # 示例：字符 'A' 的 ASCII 码和十六进制
    c = 'A'
    print(f"'{c}' → ASCII: {char_to_ascii(c)}, Hex: {char_to_hex(c)}")
    # 输出: 'A' → ASCII: 65, Hex: 41

    # 示例：ASCII 码 65 还原为字符
    print(f"65 → '{ascii_to_char(65)}'")
    # 输出: 65 → 'A'

    # 示例：十六进制 '41' 还原为字符
    print(f"0x41 → '{hex_to_char('41')}'")
    # 输出: 0x41 → 'A'

复制package main

import (
	"fmt"
	"strconv"
)

// charToASCII 返回字符的十进制 ASCII 码
func charToASCII(c rune) int {
	return int(c)
}

// asciiToChar 将十进制 ASCII 码转为字符
func asciiToChar(code int) (string, error) {
	if code < 0 || code > 127 {
		return "", fmt.Errorf("ASCII 码超出 0-127 范围: %d", code)
	}
	return string(rune(code)), nil
}

// charToHex 返回字符的十六进制表示（大写）
func charToHex(c rune) string {
	return fmt.Sprintf("%X", int(c))
}

// hexToChar 将十六进制字符串转为字符
func hexToChar(hexStr string) (string, error) {
	code, err := strconv.ParseInt(hexStr, 16, 32)
	if err != nil {
		return "", fmt.Errorf("无效的十六进制: %s", hexStr)
	}
	if code < 0 || code > 127 {
		return "", fmt.Errorf("十六进制值超出 ASCII 范围: %s", hexStr)
	}
	return string(rune(code)), nil
}

func main() {
	// 示例：字符 'A' 的 ASCII 码和十六进制
	c := 'A'
	fmt.Printf("'%c' → ASCII: %d, Hex: %s\n", c, charToASCII(c), charToHex(c))
	// 输出: 'A' → ASCII: 65, Hex: 41

	// 示例：ASCII 码 65 还原为字符
	ch, _ := asciiToChar(65)
	fmt.Printf("65 → '%s'\n", ch)
	// 输出: 65 → 'A'

	// 示例：十六进制 '41' 还原为字符
	ch2, _ := hexToChar("41")
	fmt.Printf("0x41 → '%s'\n", ch2)
	// 输出: 0x41 → 'A'
}

复制// 字符 → ASCII 码（十进制）
function charToASCII(char) {
  if (char.length !== 1) {
    throw new Error('输入必须为单个字符');
  }
  return char.charCodeAt(0);
}

// ASCII 码（十进制）→ 字符
function asciiToChar(code) {
  if (code < 0 || code > 127) {
    throw new Error('ASCII 码范围 0-127');
  }
  return String.fromCharCode(code);
}

// 字符 → 十六进制（大写）
function charToHex(char) {
  return char.charCodeAt(0).toString(16).toUpperCase();
}

// 十六进制 → 字符
function hexToChar(hexStr) {
  const code = parseInt(hexStr, 16);
  if (isNaN(code) || code < 0 || code > 127) {
    throw new Error('无效的十六进制值');
  }
  return String.fromCharCode(code);
}

// 示例
const c = 'A';
console.log(`'${c}' → ASCII: ${charToASCII(c)}, Hex: ${charToHex(c)}`);
// 输出: 'A' → ASCII: 65, Hex: 41

console.log(`65 → '${asciiToChar(65)}'`);
// 输出: 65 → 'A'

console.log(`0x41 → '${hexToChar('41')}'`);
// 输出: 0x41 → 'A'