A Kanji Numeral Converter With 小字, 大字, and 壱弐参 Legal Forms

Japanese has three number systems: everyday kanji (一二三), legal kanji (壱弐参 — used on contracts to prevent forgery), and fullwidth digits (１２３). Converting between Arabic numerals and any of these requires handling place values up to 京 (10^16), grouping by 4 digits instead of 3, and knowing when to omit or include the leading 一.

1234 in English is "one thousand two hundred thirty-four". In Japanese it's 千二百三十四 — the 一 before 千 is omitted. But on a legal contract it's 壱阡弐佰参拾肆 — the 壱 is required, and even the unit characters change to their formal equivalents.

🔗 Live demo: https://sen.ltd/portfolio/kansuji-converter/

📦 GitHub: https://github.com/sen-ltd/kansuji-converter

Features:

• 3 systems: 小字 (everyday), 大字 (legal), fullwidth (全角)


• Range: 0 to 10^16 (京)


• Both directions (num → kan, kan → num)


• Legal yen formatting for contracts


• Examples for common amounts


• BigInt-backed math (no float loss)


• Japanese / English UI


• Zero dependencies, 74 tests

Groups of 4, not 3

English groups thousands: 1,234,567,890. Japanese groups ten thousands: 12億3456万7890. Every 4 digits gets a new large unit:

So conversion splits the number into 4-digit groups from the right, formats each group independently, and joins them with large units:

export function toKansuji(num, system = 'shouji') {

  let n = BigInt(num);

  if (n === 0n) return '〇';



  const groups = [];

  while (n > 0n) {

    groups.push(n % 10000n);

    n = n / 10000n;

  }

  // groups[0] is 一-千, groups[1] is 万, groups[2] is 億, groups[3] is 兆, groups[4] is 京



  const parts = [];

  for (let i = groups.length - 1; i >= 0; i--) {

    if (groups[i] === 0n) continue;

    parts.push(formatGroup(groups[i], system) + LARGE_UNITS[i]);

  }

  return parts.join('');

}

Empty groups (0000) are skipped to avoid 一万〇〇〇〇三 garbage output.

BigInt for precision

At 10^16, regular JavaScript numbers start losing precision. 10^16 is Number.MAX_SAFE_INTEGER ≈ 9 × 10^15. BigInt has no such limit:

let n = typeof num === 'bigint' ? num : BigInt(num);

// All arithmetic in BigInt

while (n > 0n) {

  groups.push(n % 10000n);

  n = n / 10000n;

}

The n variable is a bigint, not a number. Operations use 0n, 10000n (BigInt literals) to avoid mixing types. The result is exact even at 9,999,999,999,999,999 (which is within the 京 range).

Implicit 一 omission

In 小字 (everyday) notation, a leading 1 before 十/百/千 is usually omitted:

• 11 = 十一 (not 一十一)


• 100 = 百 (not 一百)


• 1000 = 千 (not 一千)


• 10000 = 一万 (NOT 一十千 — the 一 before 万 IS required)
  

function formatGroup(n, system) {

  const digits = [Number(n) / 1000 | 0, (Number(n) / 100 | 0) % 10, ...];

  let result = '';

  const units = ['千', '百', '十', ''];

  for (let i = 0; i < 4; i++) {

    if (digits[i] === 0) continue;

    // Omit leading 一 before 千/百/十 (but not before standalone 一)

    if (digits[i] === 1 && units[i] !== '' && system === 'shouji') {

      result += units[i];

    } else {

      result += DIGIT_CHARS[digits[i]] + units[i];

    }

  }

  return result;

}

In 大字 (legal) notation, the 壱 is NEVER omitted. This is intentional — legal documents use 大字 precisely to prevent someone from adding a stroke to a 一 and turning 一万円 into 十万円. The 壱 is visually too different to forge.

大字: 壱弐参 for contracts

The legal kanji system uses visually distinct characters:

Real legal use: Japanese checks, contracts, and official documents legally require 大字 for monetary amounts. The purpose is forgery prevention — 一 can be turned into 二, 十, 千 with added strokes, but 壱 cannot be turned into 弐 without obvious tampering.

Series

This is entry #86 in my 100+ public portfolio series.

• 📦 Repo: https://github.com/sen-ltd/kansuji-converter
  


• 🌐 Live: https://sen.ltd/portfolio/kansuji-converter/
  


• 🏢 Company: https://sen.ltd/