プログラミング必須！文字列とASCIIコード変換の完全マスターガイド

// 文字 → ASCIIコード
const charToAscii = (char: string): number => {
  return char.charCodeAt(0);
};

// ASCIIコード → 文字
const asciiToChar = (code: number): string => {
  return String.fromCharCode(code);
};

// 文字列 → ASCII配列
const stringToAsciiArray = (str: string): number[] => {
  return Array.from(str).map(char => char.charCodeAt(0));
};

// ASCII配列 → 文字列
const asciiArrayToString = (codes: number[]): string => {
  return String.fromCharCode(...codes);
};

# 文字 → ASCIIコード
def char_to_ascii(char: str) -> int:
    return ord(char)

# ASCIIコード → 文字
def ascii_to_char(code: int) -> str:
    return chr(code)

# 文字列 → ASCII配列
def string_to_ascii_list(text: str) -> list[int]:
    return [ord(char) for char in text]

# ASCII配列 → 文字列
def ascii_list_to_string(codes: list[int]) -> str:
    return ''.join(chr(code) for code in codes)

# 高速化版（大量データ用）
def fast_string_to_ascii(text: str) -> bytes:
    return text.encode('ascii')

// 文字 → ASCIIコード
public static int charToAscii(char ch) {
    return (int) ch;
}

// ASCIIコード → 文字
public static char asciiToChar(int code) {
    return (char) code;
}

// 文字列 → ASCII配列
public static int[] stringToAsciiArray(String str) {
    return str.chars().toArray();
}

// ASCII配列 → 文字列
public static String asciiArrayToString(int[] codes) {
    return new String(codes, 0, codes.length);
}

// 文字 → ASCIIコード
public static int CharToAscii(char ch)
{
    return (int)ch;
}

// ASCIIコード → 文字
public static char AsciiToChar(int code)
{
    return (char)code;
}

// 文字列 → ASCII配列
public static int[] StringToAsciiArray(string str)
{
    return str.Select(c => (int)c).ToArray();
}

// ASCII配列 → 文字列
public static string AsciiArrayToString(int[] codes)
{
    return new string(codes.Select(c => (char)c).ToArray());
}

// JavaScript: ビット操作による高速変換
function fastAsciiConversion(str) {
  const buffer = new ArrayBuffer(str.length);
  const view = new Uint8Array(buffer);
  
  for (let i = 0; i < str.length; i++) {
    view[i] = str.charCodeAt(i) & 0xFF; // ビットマスク
  }
  
  return view;
}

// Node.js: ストリーミングASCII変換
const { Transform } = require('stream');

class AsciiTransform extends Transform {
  constructor(options = {}) {
    super(options);
    this.mode = options.mode || 'encode';
  }

  _transform(chunk, encoding, callback) {
    try {
      if (this.mode === 'encode') {
        const result = Array.from(chunk.toString())
          .map(char => char.charCodeAt(0))
          .join(' ');
        this.push(result);
      } else {
        // デコード処理
        const codes = chunk.toString().split(' ');
        const result = String.fromCharCode(...codes.map(Number));
        this.push(result);
      }
      callback();
    } catch (error) {
      callback(error);
    }
  }
}

// Python: マルチプロセシングによる並列ASCII変換
import multiprocessing as mp
from functools import partial

def chunk_to_ascii(chunk):
    """文字列チャンクをASCII配列に変換"""
    return [ord(char) for char in chunk]

def parallel_ascii_conversion(text, num_processes=4):
    """並列処理でASCII変換を実行"""
    chunk_size = len(text) // num_processes
    chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
    
    with mp.Pool(processes=num_processes) as pool:
        results = pool.map(chunk_to_ascii, chunks)
    
    # 結果をフラット化
    return [item for sublist in results for item in sublist]

// JavaScript: メモリ効率的なASCII変換
class EfficientAsciiConverter {
  constructor(bufferSize = 1024) {
    this.buffer = new ArrayBuffer(bufferSize);
    this.view = new Uint8Array(this.buffer);
    this.position = 0;
  }

  convertString(str) {
    if (str.length > this.view.length) {
      // バッファサイズを動的に拡張
      this.resizeBuffer(str.length);
    }

    for (let i = 0; i < str.length; i++) {
      this.view[i] = str.charCodeAt(i);
    }

    return this.view.slice(0, str.length);
  }

  resizeBuffer(newSize) {
    this.buffer = new ArrayBuffer(newSize * 2); // 余裕を持たせる
    this.view = new Uint8Array(this.buffer);
  }
}

// Python: LRUキャッシュを使った最適化
from functools import lru_cache
import hashlib

class CachedAsciiConverter:
    def __init__(self, cache_size=1000):
        self.cache_size = cache_size
        self._convert_cached = lru_cache(maxsize=cache_size)(self._convert)

    def _convert(self, text_hash, text):
        """実際の変換処理（キャッシュ対象）"""
        return [ord(char) for char in text]

    def convert(self, text):
        """キャッシュ機能付きASCII変換"""
        text_hash = hashlib.md5(text.encode()).hexdigest()
        return self._convert_cached(text_hash, text)

    def get_cache_info(self):
        """キャッシュ統計情報を取得"""
        return self._convert_cached.cache_info()

// JavaScript: シーザー暗号の実装
class CaesarCipher {
  constructor(shift = 3) {
    this.shift = shift;
  }

  encrypt(text) {
    return text.split('').map(char => {
      const ascii = char.charCodeAt(0);
      
      // アルファベットのみ暗号化
      if (ascii >= 65 && ascii <= 90) { // A-Z
        return String.fromCharCode(((ascii - 65 + this.shift) % 26) + 65);
      } else if (ascii >= 97 && ascii <= 122) { // a-z
        return String.fromCharCode(((ascii - 97 + this.shift) % 26) + 97);
      }
      return char; // 非アルファベットはそのまま
    }).join('');
  }

  decrypt(text) {
    const originalShift = this.shift;
    this.shift = 26 - this.shift; // 逆シフト
    const result = this.encrypt(text);
    this.shift = originalShift;
    return result;
  }
}

// Python: ASCII範囲チェック付きバリデーター
class AsciiValidator:
    """ASCII文字列の検証クラス"""

    def __init__(self):
        self.valid_ranges = {
            'printable': (32, 126), # 印刷可能文字
            'alphanumeric': [(48, 57), (65, 90), (97, 122)],
            'control': (0, 31) # 制御文字
        }

    def validate_ascii_range(self, text, range_type='printable'):
        """指定された範囲のASCII文字かチェック"""
        invalid_chars = []
        
        for i, char in enumerate(text):
            ascii_val = ord(char)
            
            if not self._is_in_range(ascii_val, range_type):
                invalid_chars.append({
                    'char': char,
                    'ascii': ascii_val,
                    'position': i
                })
        
        return {
            'is_valid': len(invalid_chars) == 0,
            'invalid_chars': invalid_chars
        }

    def _is_in_range(self, ascii_val, range_type):
        """ASCII値が指定範囲内かチェック"""
        ranges = self.valid_ranges.get(range_type)
        
        if isinstance(ranges, tuple):
            return ranges[0] <= ascii_val <= ranges[1]
        elif isinstance(ranges, list):
            return any(r[0] <= ascii_val <= r[1] for r in ranges)
        
        return False

// Node.js: ASCII ベースの簡単なプロトコル実装
class AsciiProtocol {
  constructor() {
    this.HEADER_SIZE = 4; // ヘッダーサイズ
    this.DELIMITER = 0x1E; // ASCII Record Separator
  }

  encodeMessage(type, data) {
    // メッセージタイプ（1バイト）+ データ長（3バイト）+ データ
    const typeCode = type.charCodeAt(0);
    const dataBytes = Buffer.from(data, 'utf8');
    const length = dataBytes.length;
    
    const header = Buffer.alloc(this.HEADER_SIZE);
    header.writeUInt8(typeCode, 0);
    header.writeUIntBE(length, 1, 3);
    
    return Buffer.concat([header, dataBytes, Buffer.from([this.DELIMITER])]);
  }

  decodeMessage(buffer) {
    if (buffer.length < this.HEADER_SIZE) {
      throw new Error('Invalid message: too short');
    }

    const type = String.fromCharCode(buffer.readUInt8(0));
    const length = buffer.readUIntBE(1, 3);
    const data = buffer.slice(this.HEADER_SIZE, this.HEADER_SIZE + length).toString('utf8');
    
    return { type, data, length };
  }
}

// JavaScript: 堅牢なASCII変換関数
function safeAsciiConvert(input, options = {}) {
  const { strict = true, fallback = '?' } = options;
  
  // 入力検証
  if (input === null || input === undefined) {
    throw new Error('Input cannot be null or undefined');
  }

  if (typeof input !== 'string') {
    input = String(input);
  }

  const result = [];
  const errors = [];

  for (let i = 0; i < input.length; i++) {
    const char = input[i];
    const code = char.charCodeAt(0);

    if (code > 127) {
      if (strict) {
        errors.push({
          position: i,
          character: char,
          code: code,
          message: `Non-ASCII character at position ${i}`
        });
      } else {
        result.push(fallback.charCodeAt(0));
      }
    } else {
      result.push(code);
    }
  }

  if (strict && errors.length > 0) {
    throw new Error(`ASCII conversion failed: ${JSON.stringify(errors)}`);
  }

  return { result, errors };
}

// Python: セキュリティを考慮したASCII変換
import re
from typing import Optional, Dict, Any

class SecureAsciiConverter:
    """セキュリティを考慮したASCII変換クラス"""

    def __init__(self, max_length: int = 10000):
        self.max_length = max_length
        self.dangerous_chars = set(range(0, 32)) - {9, 10, 13} # 危険な制御文字

    def sanitize_input(self, text: str) -> str:
        """入力データのサニタイズ"""
        if len(text) > self.max_length:
            raise ValueError(f"Input too long: {len(text)} > {self.max_length}")

        # 危険な制御文字を除去
        sanitized = ''
        for char in text:
            ascii_val = ord(char)
            if ascii_val not in self.dangerous_chars:
                sanitized += char

        return sanitized

    def secure_convert(self, text: str) -> Dict[str, Any]:
        """セキュアなASCII変換"""
        try:
            sanitized = self.sanitize_input(text)
            ascii_codes = [ord(char) for char in sanitized]
            
            return {
                'success': True,
                'data': ascii_codes,
                'original_length': len(text),
                'sanitized_length': len(sanitized)
            }
        except Exception as e:
            return {
                'success': False,
                'error': str(e)
            }

// Node.js: レート制限付きASCII変換API
const rateLimit = require('express-rate-limit');

const asciiConversionLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 100, // 最大100リクエスト
  message: {
    error: 'Too many ASCII conversion requests',
    retryAfter: '15 minutes'
  },
  standardHeaders: true,
  legacyHeaders: false
});

// セキュアなAPI エンドポイント
app.post('/api/ascii-convert', asciiConversionLimiter, (req, res) => {
  const { text, options = {} } = req.body;

  // 入力検証
  if (!text || typeof text !== 'string') {
    return res.status(400).json({
      error: 'Invalid input: text must be a string'
    });
  }

  if (text.length > 10000) {
    return res.status(400).json({
      error: 'Input too long: maximum 10000 characters'
    });
  }

  try {
    const result = safeAsciiConvert(text, options);
    res.json({ success: true, data: result });
  } catch (error) {
    res.status(500).json({
      error: 'Conversion failed',
      details: error.message
    });
  }
});

// Jest: ASCII変換のテストスイート
describe('ASCII Conversion Tests', () => {
  const converter = new AsciiConverter();

  describe('Basic Conversion', () => {
    test('should convert single character to ASCII', () => {
      expect(converter.charToAscii('A')).toBe(65);
      expect(converter.charToAscii('a')).toBe(97);
      expect(converter.charToAscii('0')).toBe(48);
    });

    test('should convert ASCII to character', () => {
      expect(converter.asciiToChar(65)).toBe('A');
      expect(converter.asciiToChar(97)).toBe('a');
      expect(converter.asciiToChar(48)).toBe('0');
    });
  });

  describe('Edge Cases', () => {
    test('should handle empty string', () => {
      expect(converter.stringToAscii('')).toEqual([]);
    });

    test('should handle special characters', () => {
      expect(converter.charToAscii(' ')).toBe(32);
      expect(converter.charToAscii('\n')).toBe(10);
      expect(converter.charToAscii('\t')).toBe(9);
    });
  });

  describe('Error Handling', () => {
    test('should throw error for invalid ASCII codes', () => {
      expect(() => converter.asciiToChar(-1)).toThrow();
      expect(() => converter.asciiToChar(128)).toThrow();
    });

    test('should handle null/undefined input', () => {
      expect(() => converter.stringToAscii(null)).toThrow();
      expect(() => converter.stringToAscii(undefined)).toThrow();
    });
  });

  describe('Performance Tests', () => {
    test('should handle large strings efficiently', () => {
      const largeString = 'A'.repeat(100000);
      const startTime = performance.now();
      const result = converter.stringToAscii(largeString);
      const endTime = performance.now();

      expect(result.length).toBe(100000);
      expect(endTime - startTime).toBeLessThan(1000); // 1秒以内
    });
  });
});