def utf8_decode_manual(byte_sequence):
    """UTF-8バイト列を手動でデコードする（教育用実装）"""
    result = []
    i = 0
    while i < len(byte_sequence):
        b = byte_sequence[i]
 
        if b < 0x80:
            # 1バイト文字 (0xxxxxxx)
            codepoint = b
            i += 1
        elif b < 0xC0:
            # 継続バイト (10xxxxxx) が先頭に来るのはエラー
            raise ValueError(f"不正な継続バイト: 0x{b:02X} at position {i}")
        elif b < 0xE0:
            # 2バイト文字 (110xxxxx 10xxxxxx)
            if i + 1 >= len(byte_sequence):
                raise ValueError("不完全な2バイト文字")
            codepoint = ((b & 0x1F) << 6) | (byte_sequence[i+1] & 0x3F)
            # オーバーロング検出: U+0080未満は1バイトで表すべき
            if codepoint < 0x80:
                raise ValueError(f"オーバーロング: U+{codepoint:04X}")
            i += 2
        elif b < 0xF0:
            # 3バイト文字 (1110xxxx 10xxxxxx 10xxxxxx)
            if i + 2 >= len(byte_sequence):
                raise ValueError("不完全な3バイト文字")
            codepoint = ((b & 0x0F) << 12) | \
                       ((byte_sequence[i+1] & 0x3F) << 6) | \
                       (byte_sequence[i+2] & 0x3F)
            if codepoint < 0x800:
                raise ValueError(f"オーバーロング: U+{codepoint:04X}")
            # サロゲートペア範囲は不正
            if 0xD800 <= codepoint <= 0xDFFF:
                raise ValueError(f"サロゲート: U+{codepoint:04X}")
            i += 3
        elif b < 0xF8:
            # 4バイト文字 (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
            if i + 3 >= len(byte_sequence):
                raise ValueError("不完全な4バイト文字")
            codepoint = ((b & 0x07) << 18) | \
                       ((byte_sequence[i+1] & 0x3F) << 12) | \
                       ((byte_sequence[i+2] & 0x3F) << 6) | \
                       (byte_sequence[i+3] & 0x3F)
            if codepoint < 0x10000:
                raise ValueError(f"オーバーロング: U+{codepoint:04X}")
            if codepoint > 0x10FFFF:
                raise ValueError(f"範囲外: U+{codepoint:04X}")
            i += 4
        else:
            raise ValueError(f"不正な先頭バイト: 0x{b:02X}")
 
        result.append(chr(codepoint))
 
    return ''.join(result)
 
 
# テスト
test_bytes = bytes([0xE3, 0x81, 0x82])  # 'あ'
print(utf8_decode_manual(test_bytes))  # あ
 
test_bytes2 = bytes([0xF0, 0x9F, 0x98, 0x80])  # '😀'
print(utf8_decode_manual(test_bytes2))  # 😀
 
 
def utf8_encode_manual(text):
    """文字列をUTF-8バイト列に手動エンコード（教育用実装）"""
    result = bytearray()
    for char in text:
        cp = ord(char)
        if cp < 0x80:
            result.append(cp)
        elif cp < 0x800:
            result.append(0xC0 | (cp >> 6))
            result.append(0x80 | (cp & 0x3F))
        elif cp < 0x10000:
            result.append(0xE0 | (cp >> 12))
            result.append(0x80 | ((cp >> 6) & 0x3F))
            result.append(0x80 | (cp & 0x3F))
        else:
            result.append(0xF0 | (cp >> 18))
            result.append(0x80 | ((cp >> 12) & 0x3F))
            result.append(0x80 | ((cp >> 6) & 0x3F))
            result.append(0x80 | (cp & 0x3F))
    return bytes(result)
 
# テスト
print(utf8_encode_manual("あ").hex())  # e38182
print(utf8_encode_manual("😀").hex())  # f09f9880

# サロゲートペアの計算
 
def codepoint_to_utf16(cp):
    """コードポイントからUTF-16エンコーディングを計算"""
    if cp < 0x10000:
        return [cp]
    else:
        cp -= 0x10000
        high = 0xD800 + (cp >> 10)
        low = 0xDC00 + (cp & 0x3FF)
        return [high, low]
 
def utf16_to_codepoint(units):
    """UTF-16コードユニットからコードポイントを復元"""
    if len(units) == 1:
        return units[0]
    else:
        high, low = units
        return ((high - 0xD800) << 10) + (low - 0xDC00) + 0x10000
 
# テスト
print([hex(u) for u in codepoint_to_utf16(0x1F600)])  # ['0xd83d', '0xde00']
print(hex(utf16_to_codepoint([0xD83D, 0xDE00])))      # 0x1f600

# 文字化けの再現と分析
 
text = "こんにちは"
 
# UTF-8でエンコードしたバイト列
utf8_bytes = text.encode('utf-8')
# b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf'
 
# ❌ パターン1: Latin-1としてデコード → 文字化け（最も多い）
wrong = utf8_bytes.decode('latin-1')
# 'ã\x81\x93ã\x82\x93ã\x81«ã\x81¡ã\x81¯'
# → UTF-8のバイトをLatin-1として解釈した典型パターン
 
# ❌ パターン2: Shift_JISとしてデコード → 別の文字化け
wrong2 = utf8_bytes.decode('shift_jis', errors='replace')
# '縺薙s縺ォ縺。縺ッ' のような意味不明な文字列
 
# ❌ パターン3: 二重エンコード（UTF-8を更にUTF-8としてエンコード）
double_encoded = text.encode('utf-8').decode('latin-1').encode('utf-8')
# 元に戻すには逆操作が必要
recovered = double_encoded.decode('utf-8').encode('latin-1').decode('utf-8')
print(recovered)  # 'こんにちは'
 
# ✅ 正しいエンコーディングでデコード
correct = utf8_bytes.decode('utf-8')
# 'こんにちは'

# 文字化けの自動診断
 
def diagnose_encoding(broken_text, expected_text=None):
    """文字化けテキストのエンコーディングを診断"""
    # よくある文字化けパターンを試す
    patterns = [
        # (encode_as, decode_as, description)
        ('latin-1', 'utf-8', 'UTF-8をLatin-1で開いた'),
        ('cp1252', 'utf-8', 'UTF-8をWindows-1252で開いた'),
        ('shift_jis', 'utf-8', 'UTF-8をShift_JISで開いた'),
        ('utf-8', 'shift_jis', 'Shift_JISをUTF-8で開いた'),
        ('utf-8', 'euc-jp', 'EUC-JPをUTF-8で開いた'),
        ('euc-jp', 'utf-8', 'UTF-8をEUC-JPで開いた'),
    ]
 
    results = []
    for enc, dec, desc in patterns:
        try:
            recovered = broken_text.encode(enc).decode(dec)
            if expected_text and recovered == expected_text:
                results.append((desc, recovered, "✓ MATCH"))
            elif recovered.isprintable() and not any(c == '\ufffd' for c in recovered):
                results.append((desc, recovered, "? 可能性あり"))
        except (UnicodeDecodeError, UnicodeEncodeError):
            pass
 
    return results
 
 
# chardetライブラリによる自動検出
# pip install chardet
import chardet
 
def detect_encoding(byte_data):
    """バイト列のエンコーディングを推定"""
    result = chardet.detect(byte_data)
    return result
    # {'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}
 
# 使用例
with open('unknown_file.txt', 'rb') as f:
    raw_data = f.read()
    detection = chardet.detect(raw_data)
    print(f"推定: {detection['encoding']} (信頼度: {detection['confidence']:.2%})")
    text = raw_data.decode(detection['encoding'])

# === Python ===
 
# ファイル読み書き（常にencodingを明示）
with open('file.txt', 'r', encoding='utf-8') as f:
    text = f.read()
 
with open('file.txt', 'w', encoding='utf-8') as f:
    f.write(text)
 
# Python 3.15+ ではデフォルトがUTF-8に変更予定
# Python 3.7+: UTF-8モード
# PYTHONUTF8=1 環境変数 or python3 -X utf8
 
# CSVファイル（Excel対応でBOM付きUTF-8が必要な場合）
with open('data.csv', 'w', encoding='utf-8-sig') as f:
    # utf-8-sig = BOM (EF BB BF) + UTF-8
    f.write('名前,年齢\n')
 
# バイト列と文字列の変換
text = "日本語"
encoded = text.encode('utf-8')     # str → bytes
decoded = encoded.decode('utf-8')  # bytes → str
 
# エラーハンドリング
text = b'\xff\xfe'.decode('utf-8', errors='replace')   # '??'（置換）
text = b'\xff\xfe'.decode('utf-8', errors='ignore')    # ''（無視）
text = b'\xff\xfe'.decode('utf-8', errors='backslashreplace')  # '\\xff\\xfe'

-- === MySQL ===
 
-- データベース作成時
CREATE DATABASE mydb
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;
 
-- テーブル作成時
CREATE TABLE users (
  id INT PRIMARY KEY,
  name VARCHAR(100) CHARACTER SET utf8mb4
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
-- 接続時
SET NAMES utf8mb4;
-- または接続パラメータで: charset=utf8mb4
 
-- 既存テーブルの変更
ALTER TABLE users CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
-- 確認
SHOW VARIABLES LIKE 'character_set%';
SHOW VARIABLES LIKE 'collation%';
 
-- utf8 vs utf8mb4 の違い:
-- utf8:    最大3バイト（BMP内のみ, 絵文字不可, U+0000-U+FFFF）
-- utf8mb4: 最大4バイト（全Unicode対応, 絵文字OK, U+0000-U+10FFFF）
-- → 常にutf8mb4を使うべき

// === JavaScript / Node.js ===
 
// ファイル読み書き
const fs = require('fs');
const text = fs.readFileSync('file.txt', 'utf-8');
fs.writeFileSync('file.txt', text, 'utf-8');
 
// Buffer操作
const buf = Buffer.from('こんにちは', 'utf-8');
console.log(buf);        // <Buffer e3 81 93 e3 82 93 ...>
console.log(buf.length); // 15 (バイト数)
const str = buf.toString('utf-8');
 
// TextEncoder / TextDecoder (Web API & Node.js)
const encoder = new TextEncoder();  // デフォルトUTF-8
const decoder = new TextDecoder('utf-8');
 
const encoded = encoder.encode('Hello, 世界');
const decoded = decoder.decode(encoded);
 
// Shift_JISのデコード（Node.js: iconv-lite）
// const iconv = require('iconv-lite');
// const text = iconv.decode(buffer, 'Shift_JIS');
 
// fetch APIでの文字コード指定
// Response.text() はデフォルトでUTF-8
// Content-Type ヘッダーの charset を参照

// === Go ===
 
package main
 
import (
    "fmt"
    "strings"
    "unicode/utf8"
 
    "golang.org/x/text/encoding/japanese"
    "golang.org/x/text/transform"
)
 
func main() {
    // Goの文字列はデフォルトでUTF-8
    s := "こんにちは"
    fmt.Println(len(s))                    // 15 (バイト数)
    fmt.Println(utf8.RuneCountInString(s)) // 5 (文字数)
 
    // ルーン（Unicodeコードポイント）でのイテレーション
    for i, r := range s {
        fmt.Printf("byte[%d]: U+%04X '%c'\n", i, r, r)
    }
 
    // UTF-8の妥当性チェック
    fmt.Println(utf8.ValidString(s))  // true
 
    // Shift_JISからUTF-8への変換
    sjisReader := transform.NewReader(
        strings.NewReader(sjisData),
        japanese.ShiftJIS.NewDecoder(),
    )
    // utf8Data, _ := io.ReadAll(sjisReader)
    _ = sjisReader
}

# 「が」の2つの表現方法
 
# 1. 合成済み文字（NFC）: 1文字
ga_nfc = '\u304C'  # 'が' (1コードポイント)
len(ga_nfc)  # 1
 
# 2. 結合文字（NFD）: 基底文字 + 濁点
ga_nfd = '\u304B\u3099'  # 'か' + '゙' (2コードポイント)
len(ga_nfd)  # 2
 
# 見た目は同じ 'が' だが、==で比較するとFalse!
ga_nfc == ga_nfd  # False!
 
# 対策: unicodedata.normalize で正規化
import unicodedata
unicodedata.normalize('NFC', ga_nfd) == ga_nfc  # True

import unicodedata
 
# NFC（Canonical Decomposition, followed by Canonical Composition）
# → 最も一般的。合成済み形式。Webで推奨
nfc = unicodedata.normalize('NFC', text)
 
# NFD（Canonical Decomposition）
# → macOSのファイルシステム（HFS+）が使用
nfd = unicodedata.normalize('NFD', text)
 
# NFKC（Compatibility Decomposition, followed by Canonical Composition）
# → 検索/比較に最適。互換文字を統一
nfkc = unicodedata.normalize('NFKC', text)
 
# NFKD（Compatibility Decomposition）
# → 最も分解された形式
nfkd = unicodedata.normalize('NFKD', text)
 
# NFC vs NFD の例:
text = "が"  # U+304C
nfc = unicodedata.normalize('NFC', text)
nfd = unicodedata.normalize('NFD', text)
print(len(nfc), [hex(ord(c)) for c in nfc])  # 1 ['0x304c']
print(len(nfd), [hex(ord(c)) for c in nfd])  # 2 ['0x304b', '0x3099']
 
# NFKC vs NFC の例:
# 全角英数字 → 半角英数字
text2 = "Ａ１"  # U+FF21, U+FF11（全角）
nfc2 = unicodedata.normalize('NFC', text2)    # "Ａ１"（そのまま）
nfkc2 = unicodedata.normalize('NFKC', text2)  # "A1"（半角に変換）
print(nfkc2)  # A1
 
# 互換分解の例:
# ① → 1  (U+2460 → U+0031)
# ㌔ → キロ (U+3314 → U+30AD U+30ED)
# fi → fi  (U+FB01 → U+0066 U+0069)
# ² → 2   (U+00B2 → U+0032)
 
# 実務での使い分け:
# - 保存/表示: NFC（最も広くサポート）
# - 検索/比較: NFKC（互換文字を統一）
# - macOSファイル名: NFD（OSが自動変換）

# 1つの「見た目の文字」が複数のコードポイントから構成される場合
 
# 例1: 家族絵文字
family = "👨‍👩‍👧‍👦"
print(len(family))  # 11 (コードポイント数!)
# 構成: 👨 U+1F468 + ZWJ + 👩 U+1F469 + ZWJ + 👧 U+1F467 + ZWJ + 👦 U+1F466
# ZWJ = Zero Width Joiner (U+200D)
 
# 例2: 国旗絵文字
flag_jp = "🇯🇵"
print(len(flag_jp))  # 2
# 構成: U+1F1EF (Regional Indicator J) + U+1F1F5 (Regional Indicator P)
 
# 例3: 肌の色修飾子
wave = "👋🏽"
print(len(wave))  # 2
# 構成: U+1F44B (手を振る) + U+1F3FD (肌色修飾子: Medium)
 
# 例4: 結合文字（アクセント付き文字）
e_acute = "é"  # U+0065 + U+0301 (NFD) or U+00E9 (NFC)
 
# 正しく「見た目の文字数」を数えるには:
# Python: regex ライブラリ（標準のreではなく第三者ライブラリ）
import regex  # pip install regex
text = "👨‍👩‍👧‍👦こんにちは"
graphemes = regex.findall(r'\X', text)
print(len(graphemes))  # 6 (家族1 + ひらがな5)
 
# JavaScript:
# Intl.Segmenter API (ES2022+)
# const segmenter = new Intl.Segmenter('ja', { granularity: 'grapheme' });
# const segments = [...segmenter.segment(text)];
# segments.length; // 正しい書記素クラスタ数
 
# Go:
# golang.org/x/text/unicode/norm パッケージ
# rivo/uniseg パッケージ

# 各言語での「文字列の長さ」の意味の違い
 
text = "Hello, 世界! 😀"
 
# Python 3: コードポイント数
print(len(text))                    # 11
print(len(text.encode('utf-8')))    # 18 (バイト数)
 
# Pythonでの正しいスライス
# text[7:9] は 'World' の一部ではなく、コードポイント単位
 
# 各言語の比較:
# ┌─────────────┬──────────────────────┬────────┐
# │ 言語        │ lengthの意味          │ 値     │
# ├─────────────┼──────────────────────┼────────┤
# │ Python 3    │ コードポイント数      │ 11     │
# │ JavaScript  │ UTF-16コードユニット数│ 12*    │
# │ Java        │ UTF-16コードユニット数│ 12*    │
# │ Rust (str)  │ バイト数             │ 18     │
# │ Go          │ バイト数             │ 18     │
# │ C (strlen)  │ バイト数（NULまで）  │ 18     │
# │ Swift       │ 書記素クラスタ数     │ 11**   │
# └─────────────┴──────────────────────┴────────┘
# * 😀が2カウント（サロゲートペア）
# ** Swiftは最も直感的だが、O(n)のコスト

// JavaScript での文字列長の罠
 
const text = "Hello, 世界! 😀";
 
// .length は UTF-16 コードユニット数
console.log(text.length);  // 12 (😀 がサロゲートペアで2カウント)
 
// コードポイント数
console.log([...text].length);  // 11
 
// 正しい文字列操作
// ❌ 危険: text[10] は絵文字の上位サロゲートのみ
console.log(text[10]);  // '\uD83D' (壊れた文字)
 
// ✅ 安全: Array.from() or スプレッド構文
const chars = [...text];
console.log(chars[10]);  // '😀'
 
// ✅ 安全: codePointAt / String.fromCodePoint
for (const cp of text) {
    console.log(cp.codePointAt(0).toString(16));
}
 
// 書記素クラスタでの分割 (ES2022+)
const segmenter = new Intl.Segmenter('ja', { granularity: 'grapheme' });
const segments = [...segmenter.segment(text)];
console.log(segments.length);  // 11

// Rust での文字列操作
 
fn main() {
    let text = "Hello, 世界! 😀";
 
    // .len() はバイト数
    println!("{}", text.len());  // 18
 
    // .chars().count() はコードポイント数
    println!("{}", text.chars().count());  // 11
 
    // バイトでのイテレーション
    for b in text.bytes() {
        print!("{:02X} ", b);
    }
    println!();
 
    // コードポイントでのイテレーション
    for c in text.chars() {
        println!("U+{:04X} '{}'", c as u32, c);
    }
 
    // 文字列スライスはバイト境界でないとパニック
    // let s = &text[0..7]; // OK (ASCII部分)
    // let s = &text[0..8]; // パニック! UTF-8の途中で切断
 
    // 安全なスライス
    if text.is_char_boundary(7) {
        let s = &text[0..7];
        println!("{}", s);  // "Hello, "
    }
 
    // char_indices でバイト位置とcharを取得
    for (i, c) in text.char_indices() {
        println!("byte[{}]: U+{:04X} '{}'", i, c as u32, c);
    }
}

# 見えない文字の検出と除去
 
import unicodedata
 
def detect_invisible_chars(text):
    """見えない文字を検出して報告"""
    invisible = []
    for i, char in enumerate(text):
        cat = unicodedata.category(char)
        if cat.startswith('C') and char not in '\n\r\t':
            # C = Control, Cf = Format, Co = Private Use
            invisible.append((i, hex(ord(char)), unicodedata.name(char, '???'), cat))
    return invisible
 
def remove_invisible_chars(text):
    """見えない文字を除去（改行・タブは保持）"""
    return ''.join(
        c for c in text
        if not unicodedata.category(c).startswith('C')
        or c in '\n\r\t'
    )
 
# ホモグリフ検出
def detect_homoglyphs(text):
    """ラテン文字に見えるが異なるスクリプトの文字を検出"""
    suspicious = []
    for i, char in enumerate(text):
        if char.isalpha():
            script = unicodedata.name(char, '').split()[0] if unicodedata.name(char, '') else ''
            # ラテン文字に見えるがCyrillicやGreekの文字
            if script in ('CYRILLIC', 'GREEK') and char.lower() in 'abcdefghijklmnopqrstuvwxyz':
                suspicious.append((i, char, hex(ord(char)), script))
    return suspicious
 
 
# Unicode カテゴリの概要
categories = """
L  = Letter（文字）
  Lu = Uppercase Letter（大文字）
  Ll = Lowercase Letter（小文字）
  Lt = Titlecase Letter
  Lm = Modifier Letter
  Lo = Other Letter（漢字、ひらがな等）
 
M  = Mark（結合文字）
  Mn = Nonspacing Mark（濁点等）
  Mc = Spacing Combining Mark
  Me = Enclosing Mark
 
N  = Number（数字）
  Nd = Decimal Digit Number（0-9等）
  Nl = Letter Number（ローマ数字等）
  No = Other Number（丸数字等）
 
P  = Punctuation（句読点）
S  = Symbol（記号）
Z  = Separator（空白文字）
  Zs = Space Separator
  Zl = Line Separator
  Zp = Paragraph Separator
 
C  = Other（制御文字等）
  Cc = Control
  Cf = Format（ZWJ, BOM等）
  Co = Private Use
  Cs = Surrogate
"""

<!-- HTML での文字コード指定 -->
<!DOCTYPE html>
<html lang="ja">
<head>
    <!-- 必ず最初の1024バイト以内に -->
    <meta charset="utf-8">
    <!-- Content-Type ヘッダーでも指定 -->
    <!-- Content-Type: text/html; charset=utf-8 -->
    <title>文字コードテスト</title>
</head>
<body>
    <!-- フォームのデフォルトエンコーディング -->
    <form accept-charset="utf-8" method="post">
        <input type="text" name="name" value="">
        <button type="submit">送信</button>
    </form>
</body>
</html>

# Flask での文字コード処理
 
from flask import Flask, request, Response
import json
 
app = Flask(__name__)
 
@app.route('/api/data', methods=['POST'])
def handle_data():
    # リクエストのデコード
    # Flask は Content-Type の charset を自動検出
    text = request.data.decode('utf-8')
 
    # JSON レスポンス（ensure_ascii=False で日本語をそのまま出力）
    data = {"message": "こんにちは", "status": "ok"}
    response = Response(
        json.dumps(data, ensure_ascii=False),
        content_type='application/json; charset=utf-8'
    )
    return response
 
# Django の場合:
# settings.py で DEFAULT_CHARSET = 'utf-8'（デフォルト）
# FILE_CHARSET = 'utf-8'

# MySQL での絵文字対応
 
import mysql.connector
 
# 接続時にutf8mb4を指定
conn = mysql.connector.connect(
    host='localhost',
    user='root',
    password='password',
    database='mydb',
    charset='utf8mb4',
    collation='utf8mb4_unicode_ci'
)
 
cursor = conn.cursor()
 
# 絵文字を含むデータの挿入
cursor.execute(
    "INSERT INTO messages (content) VALUES (%s)",
    ("こんにちは 😀🎉",)
)
conn.commit()
 
# PostgreSQL の場合:
# デフォルトでUTF-8をフルサポート
# CREATE DATABASE mydb ENCODING 'UTF8' LC_COLLATE 'ja_JP.UTF-8';

# CSV ファイルの文字コード処理
 
import csv
 
# UTF-8 CSV の読み込み
with open('data.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
 
# Excel互換のCSV出力（BOM付きUTF-8）
with open('output.csv', 'w', encoding='utf-8-sig', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['名前', '年齢', '住所'])
    writer.writerow(['田中太郎', '30', '東京都'])
 
# Shift_JIS CSVの読み込み（レガシーシステムから）
with open('legacy.csv', 'r', encoding='shift_jis') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
 
# Shift_JIS → UTF-8 の一括変換
def convert_encoding(input_path, output_path, from_enc='shift_jis', to_enc='utf-8'):
    with open(input_path, 'r', encoding=from_enc) as f_in:
        content = f_in.read()
    with open(output_path, 'w', encoding=to_enc) as f_out:
        f_out.write(content)
 
 
# JSON ファイル（常にUTF-8）
import json
 
data = {"名前": "田中", "趣味": ["読書", "😀"]}
 
# ensure_ascii=False が重要!
with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
 
# 結果: {"名前": "田中", "趣味": ["読書", "😀"]}
# ensure_ascii=True だと: {"\u540d\u524d": "\u7530\u4e2d", ...}

# ファイルの文字コード判定
file -i document.txt
# document.txt: text/plain; charset=utf-8
 
# nkf（Network Kanji Filter）で変換
nkf -w input_sjis.txt > output_utf8.txt     # Shift_JIS → UTF-8
nkf -s input_utf8.txt > output_sjis.txt     # UTF-8 → Shift_JIS
nkf --guess input.txt                        # エンコーディング推定
 
# iconv で変換
iconv -f SHIFT_JIS -t UTF-8 input.txt > output.txt
 
# Python ワンライナー
python3 -c "
import sys
sys.stdout.buffer.write(
    sys.stdin.buffer.read().decode('shift_jis').encode('utf-8')
)" < input_sjis.txt > output_utf8.txt
 
# hexdump でバイト列確認
echo -n "あ" | xxd
# 00000000: e381 82                                  ...
# → E3 81 82 = UTF-8の「あ」
 
# ロケール確認
locale
# LANG=ja_JP.UTF-8
 
# 環境変数での文字コード設定
export LANG=ja_JP.UTF-8
export LC_ALL=ja_JP.UTF-8

# 演習1 解答
 
# 'Z' = U+005A
# 2進: 101 1010 (7ビット → 1バイト)
# UTF-8: 0_1011010 = 0x5A
print('Z'.encode('utf-8').hex())  # 5a
 
# '¥' = U+00A5
# 2進: 10 100101 (8ビット → 2バイト)
# 分割: 00010 100101
# UTF-8: 110_00010 10_100101 = 0xC2 0xA5
print('¥'.encode('utf-8').hex())  # c2a5
 
# '漢' = U+6F22
# 2進: 0110 1111 0010 0010 (16ビット → 3バイト)
# 分割: 0110 111100 100010
# UTF-8: 1110_0110 10_111100 10_100010 = 0xE6 0xBC 0xA2
print('漢'.encode('utf-8').hex())  # e6bca2
 
# '𠮷' = U+20BB7
# 2進: 0010 0000 1011 1011 0111 (21ビット → 4バイト)
# 分割: 000 100000 101110 110111
# UTF-8: 11110_000 10_100000 10_101110 10_110111 = 0xF0 0xA0 0xAE 0xB7
print('𠮷'.encode('utf-8').hex())  # f0a0aeb7
 
 
# 演習2 解答
bytes_data = bytes([0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E])
result = bytes_data.decode('utf-8')
print(result)  # '日本語'
 
# 手動デコード:
# E6 97 A5:
#   1110_0110 10_010111 10_100101
#   0110 010111 100101 = 0x65E5 → 不正
#   正しくは: 0110 100111 100101 ... → U+65E5 = '日'
 
 
# 演習3 解答
import unicodedata
 
def visual_equal(s1, s2):
    """2つの文字列が見た目上同じかを判定"""
    # NFC正規化で比較
    nfc1 = unicodedata.normalize('NFC', s1)
    nfc2 = unicodedata.normalize('NFC', s2)
    if nfc1 == nfc2:
        return True
 
    # NFKC正規化でも比較（互換文字の違いも吸収）
    nfkc1 = unicodedata.normalize('NFKC', s1)
    nfkc2 = unicodedata.normalize('NFKC', s2)
    return nfkc1 == nfkc2
 
# テスト
print(visual_equal('\u304C', '\u304B\u3099'))  # True (が = か+゛)
print(visual_equal('Ａ', 'A'))                  # True (全角A = 半角A, NFKC)
print(visual_equal('あ', 'ア'))                  # False

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md