繁簡轉換,支援簡繁雙向轉換、智慧分詞、自訂詞庫、文字偵測及多種輸出格式,零依賴。 Lightweight Chinese converter library for conversion between Simplified and Traditional Chinese. 轻量级简繁体中文智能转换库,支持简繁双向转换、智能分词、自定义词库、文本检测及多种输出格式,零依赖。
npm install switch-chinesebash
npm install switch-chinese
`
使用 yarn 安装:
`bash
yarn add switch-chinese
`
$3
#### 基础用法
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized, detect } = stcasc();
// 简体转繁体
const tc = traditionalized('简繁转换 繁简切换 香烟 香烟袅袅');
console.log(tc);
// 输出: 簡繁轉換 繁簡切換 香菸 香煙裊裊
// 繁体转简体
const sc = simplized('繁體中文');
console.log(sc);
// 输出: 繁体中文
`
#### 检测中文类型
`javascript
import stcasc, { ChineseType } from 'switch-chinese';
const { detect } = stcasc();
const type1 = detect('简体中文');
if (type1 === ChineseType.SIMPLIFIED) {
console.log('检测到简体中文');
}
const type2 = detect('繁體中文');
if (type2 === ChineseType.TRADITIONAL) {
console.log('检测到繁体中文');
}
const type3 = detect('English');
if (type3 === ChineseType.UNKNOWN) {
console.log('未检测到中文');
}
`
ChineseType 枚举值:
- ChineseType.SIMPLIFIED (0): 简体中文
- ChineseType.TRADITIONAL (1): 繁体中文
- ChineseType.UNKNOWN (2): 未知类型
#### 转换数组和对象
库支持转换数组和对象中的所有字符串,非字符串值保持原样:
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized } = stcasc();
// 转换数组
const arr = ['简体中文', '软件', '网络', 123, true, null];
const arrTc = traditionalized(arr);
console.log(arrTc);
// 输出: ['簡體中文', '軟體', '網路', 123, true, null]
// 转换对象
const obj = {
title: '简体中文标题',
description: '这是一个简体中文描述',
count: 100,
active: true,
tags: ['软件', '网络', '服务器']
};
const objTc = traditionalized(obj);
console.log(objTc);
// 输出: {
// title: '簡體中文標題',
// description: '這是一個簡體中文描述',
// count: 100,
// active: true,
// tags: ['軟體', '網路', '伺服器']
// }
// 转换嵌套结构
const nested = {
user: {
name: '简体名称',
profile: {
bio: '这是简体中文简介',
skills: ['软件开发', '网络管理']
}
},
count: 42
};
const nestedTc = traditionalized(nested);
// 所有字符串属性值都会被转换,数字等其他类型保持不变
`
$3
#### 使用缓存优化性能
在多次调用时,建议使用缓存机制避免重复生成字典,提升性能:
`javascript
import stcasc from 'switch-chinese';
// 第一次调用,生成字典
let converter = stcasc();
const cache = converter.cache;
// 保存缓存到持久化存储(如 localStorage、文件等)
localStorage.setItem('stcasc-cache', JSON.stringify(cache));
// 后续调用,直接使用缓存
const cachedData = JSON.parse(localStorage.getItem('stcasc-cache'));
converter = stcasc(cachedData);
// 现在可以直接使用,无需重新生成字典
const result = converter.traditionalized('简体中文');
`
#### 自定义简繁转换词库
可以根据业务需求自定义简繁转换规则:
`javascript
import stcasc from 'switch-chinese';
const customDict = {
'身份': '身分',
'转义': '跳脫',
'转换': '轉檔',
'软件': '軟體',
'硬件': '硬體',
'网络': '網路',
'服务器': '伺服器'
};
const { traditionalized, simplized } = stcasc({}, customDict);
console.log(traditionalized('软件转换'));
// 输出: 軟體轉檔(使用自定义词库)
`
#### 禁用术语转换
默认情况下,库会转换一些特定术语(如「知识产权」→「智慧財產權」)。如需禁用此功能:
`javascript
import stcasc from 'switch-chinese';
// 第三个参数设置为 true 以禁用术语转换
const { traditionalized } = stcasc({}, {}, true);
console.log(traditionalized('知识产权'));
// 输出: 知識産權(仅做字符转换,不转换术语)
`
#### 输出格式选项
库支持多种输出格式:
`javascript
import stcasc, { OutputFormat } from 'switch-chinese';
const { traditionalized } = stcasc();
// 普通格式(默认)
const normal = traditionalized('简体中文');
// 输出: 簡體中文
// 括号格式:同时显示原文和转换后的文本
const bracket = traditionalized('简体中文', { format: OutputFormat.BRACKET });
// 输出: 簡(简)體(体)中文
// Ruby 注音格式:适用于 HTML 显示
const ruby = traditionalized('简体中文', { format: OutputFormat.RUBY });
// 输出: 簡體中文
`
OutputFormat 枚举值:
- OutputFormat.NORMAL (0): 只输出转换后的结果(默认)
- OutputFormat.BRACKET (1): 输出「转换(原文)」格式
- OutputFormat.RUBY (2): 输出 HTML 标签格式
$3
#### stcasc(cache?, custom?, disableTerms?)
主函数,用于创建转换器实例。
参数:
- cache (Object, 可选): 缓存对象,用于避免重复生成字典
- custom (Object, 可选): 自定义简繁转换词库
- disableTerms (Boolean, 可选): 是否禁用术语转换,默认 false
返回值:
返回包含以下方法的对象:
- traditionalized(input, options?): 将简体中文转换为繁体中文
- input: 可以是字符串、数组或对象
- 字符串:直接转换返回新字符串
- 数组:转换所有字符串元素,其他类型保持不变
- 对象:递归转换所有字符串属性值,其他类型保持不变
- simplized(input, options?): 将繁体中文转换为简体中文
- input: 可以是字符串、数组或对象
- 支持的数据类型同 traditionalized
- detect(text): 检测文本的中文类型,返回 ChineseType 枚举值
- cache: 字典缓存对象
Options 参数:
- format (Number, 可选): 输出格式,使用 OutputFormat 常量
#### ChineseType
导出的常量对象,用于表示中文类型检测结果:
`javascript
export const ChineseType = {
SIMPLIFIED: 0, // 简体中文
TRADITIONAL: 1, // 繁体中文
UNKNOWN: 2 // 未知类型
};
`
#### OutputFormat
导出的常量对象,用于表示输出格式选项:
`javascript
export const OutputFormat = {
NORMAL: 0, // 只输出转换后的结果
BRACKET: 1, // 输出「转换(原文)」格式
RUBY: 2 // 输出 HTML 标签格式
};
`
$3
#### 智能词组转换
该库支持基于上下文的智能词组转换,能够正确处理「一简多繁」的情况:
`javascript
const { traditionalized } = stcasc();
// 智能识别词组边界
console.log(traditionalized('香烟袅袅'));
// 输出: 香煙裊裊
console.log(traditionalized('里长面子'));
// 输出: 里長面子(「里长」是职务名称)
console.log(traditionalized('吃干面'));
// 输出: 吃乾麵(「干面」是食物)
console.log(traditionalized('把考卷发回来'));
// 输出: 把考卷發回來(「发」是动词)
console.log(traditionalized('卷发'));
// 输出: 捲髮(「卷发」是发型)
`
#### 术语转换
内置常用的大陆简体与台湾正体术语转换:
`javascript
const { traditionalized } = stcasc();
console.log(traditionalized('知识产权'));
// 输出: 智慧財產權
console.log(traditionalized('计算机软件'));
// 输出: 計算機軟體
console.log(traditionalized('网络服务器'));
// 输出: 網路伺服器
`
$3
#### 高性能
- 使用字典树(Trie)优化词组匹配
- 支持缓存机制,避免重复初始化
- 纯 JavaScript 实现,执行效率高
#### 准确转换
- 内置大量简繁对照字符
- 支持「一简多繁」智能识别
- 基于词组的上下文分析
#### 易于集成
- ES Module 标准导出
- TypeScript 类型支持(通过常量枚举)
- 零依赖,兼容性好
$3
支持所有现代浏览器及 Node.js 环境:
- Chrome
- Firefox
- Safari
- Edge
- Node.js 12+
$3
MIT License
$3
- GitHub 仓库
- NPM 包地址
- 问题反馈
$3
简繁转换, 繁简转换, 简体中文, 繁体中文, 正体中文, 中文转换, 一简多繁, 简繁切换, 繁简切换, 中文检测, 智能分词, 自定义词库, 零依赖, 轻量级
---
English
Lightweight Chinese converter library for bidirectional conversion between Simplified and Traditional Chinese with intelligent word segmentation and one-to-many character mapping support.
 
$3
- Lightweight: Zero dependencies, small footprint, excellent performance
- Intelligent Conversion: Context-aware word segmentation and accurate one-to-many character mapping
- Multiple Data Types: Supports string, array, and object conversion with automatic recursive processing
- Custom Dictionary: User-defined conversion rules support
- Caching Mechanism: Dictionary caching to avoid repeated initialization
- Text Detection: Automatic detection of Simplified Chinese, Traditional Chinese, or unknown text
- Term Conversion: Built-in mainland China and Taiwan terminology mapping
- Zero Dependencies: Pure JavaScript implementation, no third-party dependencies required
$3
Install via npm:
`bash
npm install switch-chinese
`
Install via yarn:
`bash
yarn add switch-chinese
`
$3
#### Basic Usage
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized, detect } = stcasc();
// Simplified to Traditional
const tc = traditionalized('简繁转换 繁简切换 香烟 香烟袅袅');
console.log(tc);
// Output: 簡繁轉換 繁簡切換 香菸 香煙裊裊
// Traditional to Simplified
const sc = simplized('繁體中文');
console.log(sc);
// Output: 繁体中文
`
#### Text Detection
`javascript
import stcasc, { ChineseType } from 'switch-chinese';
const { detect } = stcasc();
const type1 = detect('简体中文');
if (type1 === ChineseType.SIMPLIFIED) {
console.log('Detected Simplified Chinese');
}
const type2 = detect('繁體中文');
if (type2 === ChineseType.TRADITIONAL) {
console.log('Detected Traditional Chinese');
}
const type3 = detect('English');
if (type3 === ChineseType.UNKNOWN) {
console.log('No Chinese text detected');
}
`
ChineseType enumeration values:
- ChineseType.SIMPLIFIED (0): Simplified Chinese
- ChineseType.TRADITIONAL (1): Traditional Chinese
- ChineseType.UNKNOWN (2): Unknown type
#### Converting Arrays and Objects
The library supports converting all strings in arrays and objects, while preserving non-string values:
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized } = stcasc();
// Convert array
const arr = ['简体中文', '软件', '网络', 123, true, null];
const arrTc = traditionalized(arr);
console.log(arrTc);
// Output: ['簡體中文', '軟體', '網路', 123, true, null]
// Convert object
const obj = {
title: '简体中文标题',
description: '这是一个简体中文描述',
count: 100,
active: true,
tags: ['软件', '网络', '服务器']
};
const objTc = traditionalized(obj);
console.log(objTc);
// Output: {
// title: '簡體中文標題',
// description: '這是一個簡體中文描述',
// count: 100,
// active: true,
// tags: ['軟體', '網路', '伺服器']
// }
// Convert nested structures
const nested = {
user: {
name: '简体名称',
profile: {
bio: '这是简体中文简介',
skills: ['软件开发', '网络管理']
}
},
count: 42
};
const nestedTc = traditionalized(nested);
// All string property values will be converted, other types remain unchanged
`
$3
#### Performance Optimization with Caching
For multiple conversions, use caching mechanism to improve performance:
`javascript
import stcasc from 'switch-chinese';
// First call, generate dictionary
let converter = stcasc();
const cache = converter.cache;
// Save cache to persistent storage (e.g., localStorage, file system)
localStorage.setItem('stcasc-cache', JSON.stringify(cache));
// Subsequent calls, use cached data
const cachedData = JSON.parse(localStorage.getItem('stcasc-cache'));
converter = stcasc(cachedData);
// Now you can use it directly without regenerating dictionary
const result = converter.traditionalized('简体中文');
`
#### Custom Conversion Dictionary
Customize conversion rules according to your needs:
`javascript
import stcasc from 'switch-chinese';
const customDict = {
'身份': '身分',
'转义': '跳脫',
'转换': '轉檔',
'软件': '軟體',
'硬件': '硬體',
'网络': '網路',
'服务器': '伺服器'
};
const { traditionalized, simplized } = stcasc({}, customDict);
console.log(traditionalized('软件转换'));
// Output: 軟體轉檔 (using custom dictionary)
`
#### Disable Term Conversion
By default, the library converts specific terms (e.g., "知识产权" → "智慧財產權"). To disable this feature:
`javascript
import stcasc from 'switch-chinese';
// Set the third parameter to true to disable term conversion
const { traditionalized } = stcasc({}, {}, true);
console.log(traditionalized('知识产权'));
// Output: 知識産權 (character conversion only, no term conversion)
`
#### Output Formats
The library supports multiple output formats:
`javascript
import stcasc, { OutputFormat } from 'switch-chinese';
const { traditionalized } = stcasc();
// Normal format (default)
const normal = traditionalized('简体中文');
// Output: 簡體中文
// Bracket format: shows both original and converted text
const bracket = traditionalized('简体中文', { format: OutputFormat.BRACKET });
// Output: 簡(简)體(体)中文
// Ruby annotation format: for HTML display
const ruby = traditionalized('简体中文', { format: OutputFormat.RUBY });
// Output: 簡體中文
`
OutputFormat enumeration values:
- OutputFormat.NORMAL (0): Output converted result only (default)
- OutputFormat.BRACKET (1): Output in "converted(original)" format
- OutputFormat.RUBY (2): Output in HTML tag format
$3
#### stcasc(cache?, custom?, disableTerms?)
Main function to create a converter instance.
Parameters:
- cache (Object, optional): Cache object to avoid regenerating dictionary
- custom (Object, optional): Custom Simplified-Traditional conversion dictionary
- disableTerms (Boolean, optional): Whether to disable term conversion, default false
Returns:
An object containing the following methods:
- traditionalized(input, options?): Convert Simplified Chinese to Traditional Chinese
- input: Can be a string, array, or object
- String: Directly converts and returns a new string
- Array: Converts all string elements, other types remain unchanged
- Object: Recursively converts all string property values, other types remain unchanged
- simplized(input, options?): Convert Traditional Chinese to Simplified Chinese
- input: Can be a string, array, or object
- Supports the same data types as traditionalized
- detect(text): Detect Chinese text type, returns ChineseType enumeration value
- cache: Dictionary cache object
Options parameter:
- format (Number, optional): Output format, use OutputFormat constants
#### ChineseType
Exported constant object representing text detection results:
`javascript
export const ChineseType = {
SIMPLIFIED: 0, // Simplified Chinese
TRADITIONAL: 1, // Traditional Chinese
UNKNOWN: 2 // Unknown type
};
`
#### OutputFormat
Exported constant object representing output format options:
`javascript
export const OutputFormat = {
NORMAL: 0, // Output converted result only
BRACKET: 1, // Output "converted(original)" format
RUBY: 2 // Output HTML tag format
};
`
$3
#### Intelligent Word Segmentation
The library supports context-aware intelligent word segmentation, accurately handling one-to-many character mappings:
`javascript
const { traditionalized } = stcasc();
// Intelligent phrase boundary recognition
console.log(traditionalized('香烟袅袅'));
// Output: 香煙裊裊
console.log(traditionalized('里长面子'));
// Output: 里長面子 ("里长" is a position title)
console.log(traditionalized('吃干面'));
// Output: 吃乾麵 ("干面" is a food)
console.log(traditionalized('把考卷发回来'));
// Output: 把考卷發回來 ("发" is a verb in this context)
console.log(traditionalized('卷发'));
// Output: 捲髮 ("卷发" is a hairstyle)
`
#### Term Conversion
Built-in conversion for common mainland China and Taiwan terminology:
`javascript
const { traditionalized } = stcasc();
console.log(traditionalized('知识产权'));
// Output: 智慧財產權
console.log(traditionalized('计算机软件'));
// Output: 計算機軟體
console.log(traditionalized('网络服务器'));
// Output: 網路伺服器
`
$3
#### High Performance
- Dictionary tree (Trie) optimization for phrase matching
- Caching mechanism support to avoid repeated initialization
- Pure JavaScript implementation for high execution efficiency
#### Accurate Conversion
- Extensive built-in Simplified-Traditional character mappings
- Intelligent recognition for one-to-many character conversions
- Context-based phrase analysis
#### Easy Integration
- ES Module standard export
- TypeScript support through constant enumerations
- Zero dependencies, excellent compatibility
$3
Supports all modern browsers and Node.js environments:
- Chrome
- Firefox
- Safari
- Edge
- Node.js 12+
$3
MIT License
$3
- GitHub Repository
- NPM Package
- Issue Tracker
$3
Chinese Converter, Simplified Chinese, Traditional Chinese, Chinese Translation, Character Detection, Text Converter, Language Converter, i18n, Localization, Ruby Annotation, One-to-Many Mapping, Intelligent Word Segmentation, Custom Dictionary, Zero Dependencies, Lightweight
---
繁體中文
簡繁體中文智能轉換庫 - 支援簡體中文與正體中文雙向轉換,基於詞組的智能分詞處理「一簡多繁」問題
 
$3
- 輕量級:零依賴,體積小,效能優異
- 智能轉換:支援基於詞組的智能分詞和「一簡多繁」精準轉換
- 多種資料類型:支援字串、陣列、物件的轉換,自動遞迴處理巢狀結構
- 自訂詞庫:允許使用者自訂簡繁轉換詞彙
- 快取機制:支援字典快取,避免重複初始化
- 簡繁檢測:自動檢測文字是簡體中文、繁體中文還是未知類型
- 術語轉換:內建大陸簡體與台灣正體的常用術語轉換
- 無依賴:純 JavaScript 實現,無需任何第三方依賴
$3
使用 npm 安裝:
`bash
npm install switch-chinese
`
使用 yarn 安裝:
`bash
yarn add switch-chinese
`
$3
#### 基礎用法
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized, detect } = stcasc();
// 簡體轉繁體
const tc = traditionalized('简繁转换 繁简切换 香烟 香烟袅袅');
console.log(tc);
// 輸出: 簡繁轉換 繁簡切換 香菸 香煙裊裊
// 繁體轉簡體
const sc = simplized('繁體中文');
console.log(sc);
// 輸出: 繁体中文
`
#### 檢測中文類型
`javascript
import stcasc, { ChineseType } from 'switch-chinese';
const { detect } = stcasc();
const type1 = detect('简体中文');
if (type1 === ChineseType.SIMPLIFIED) {
console.log('檢測到簡體中文');
}
const type2 = detect('繁體中文');
if (type2 === ChineseType.TRADITIONAL) {
console.log('檢測到繁體中文');
}
const type3 = detect('English');
if (type3 === ChineseType.UNKNOWN) {
console.log('未檢測到中文');
}
`
ChineseType 列舉值:
- ChineseType.SIMPLIFIED (0): 簡體中文
- ChineseType.TRADITIONAL (1): 繁體中文
- ChineseType.UNKNOWN (2): 未知類型
#### 轉換陣列和物件
函式庫支援轉換陣列和物件中的所有字串,非字串值保持原樣:
`javascript
import stcasc from 'switch-chinese';
const { traditionalized, simplized } = stcasc();
// 轉換陣列
const arr = ['简体中文', '软件', '网络', 123, true, null];
const arrTc = traditionalized(arr);
console.log(arrTc);
// 輸出: ['簡體中文', '軟體', '網路', 123, true, null]
// 轉換物件
const obj = {
title: '简体中文标题',
description: '这是一个简体中文描述',
count: 100,
active: true,
tags: ['软件', '网络', '服务器']
};
const objTc = traditionalized(obj);
console.log(objTc);
// 輸出: {
// title: '簡體中文標題',
// description: '這是一個簡體中文描述',
// count: 100,
// active: true,
// tags: ['軟體', '網路', '伺服器']
// }
// 轉換巢狀結構
const nested = {
user: {
name: '简体名称',
profile: {
bio: '这是简体中文简介',
skills: ['软件开发', '网络管理']
}
},
count: 42
};
const nestedTc = traditionalized(nested);
// 所有字串屬性值都會被轉換,數字等其他類型保持不變
`
$3
#### 使用快取最佳化效能
在多次呼叫時,建議使用快取機制避免重複生成字典,提升效能:
`javascript
import stcasc from 'switch-chinese';
// 第一次呼叫,生成字典
let converter = stcasc();
const cache = converter.cache;
// 將快取儲存至持久化儲存(如 localStorage、檔案等)
localStorage.setItem('stcasc-cache', JSON.stringify(cache));
// 後續呼叫,直接使用快取
const cachedData = JSON.parse(localStorage.getItem('stcasc-cache'));
converter = stcasc(cachedData);
// 現在可以直接使用,無需重新生成字典
const result = converter.traditionalized('简体中文');
`
#### 自訂簡繁轉換詞庫
可以根據業務需求自訂簡繁轉換規則:
`javascript
import stcasc from 'switch-chinese';
const customDict = {
'身份': '身分',
'转义': '跳脫',
'转换': '轉檔',
'软件': '軟體',
'硬件': '硬體',
'网络': '網路',
'服务器': '伺服器'
};
const { traditionalized, simplized } = stcasc({}, customDict);
console.log(traditionalized('软件转换'));
// 輸出: 軟體轉檔(使用自訂詞庫)
`
#### 停用術語轉換
預設情況下,函式庫會轉換一些特定術語(如「知识产权」→「智慧財產權」)。如需停用此功能:
`javascript
import stcasc from 'switch-chinese';
// 第三個參數設定為 true 以停用術語轉換
const { traditionalized } = stcasc({}, {}, true);
console.log(traditionalized('知识产权'));
// 輸出: 知識産權(僅做字元轉換,不轉換術語)
`
#### 輸出格式選項
函式庫支援多種輸出格式:
`javascript
import stcasc, { OutputFormat } from 'switch-chinese';
const { traditionalized } = stcasc();
// 普通格式(預設)
const normal = traditionalized('简体中文');
// 輸出: 簡體中文
// 括號格式:同時顯示原文和轉換後的文字
const bracket = traditionalized('简体中文', { format: OutputFormat.BRACKET });
// 輸出: 簡(简)體(体)中文
// Ruby 注音格式:適用於 HTML 顯示
const ruby = traditionalized('简体中文', { format: OutputFormat.RUBY });
// 輸出: 簡體中文
`
OutputFormat 列舉值:
- OutputFormat.NORMAL (0): 只輸出轉換後的結果(預設)
- OutputFormat.BRACKET (1): 輸出「轉換(原文)」格式
- OutputFormat.RUBY (2): 輸出 HTML 標籤格式
$3
#### stcasc(cache?, custom?, disableTerms?)
主函式,用於建立轉換器實例。
參數:
- cache (Object, 可選): 快取物件,用於避免重複生成字典
- custom (Object, 可選): 自訂簡繁轉換詞庫
- disableTerms (Boolean, 可選): 是否停用術語轉換,預設 false
回傳值:
回傳包含以下方法的物件:
- traditionalized(input, options?): 將簡體中文轉換為繁體中文
- input: 可以是字串、陣列或物件
- 字串:直接轉換並回傳新字串
- 陣列:轉換所有字串元素,其他類型保持不變
- 物件:遞迴轉換所有字串屬性值,其他類型保持不變
- simplized(input, options?): 將繁體中文轉換為簡體中文
- input: 可以是字串、陣列或物件
- 支援的資料類型同 traditionalized
- detect(text): 檢測文字的中文類型,回傳 ChineseType 列舉值
- cache: 字典快取物件
Options 參數:
- format (Number, 可選): 輸出格式,使用 OutputFormat 常數
#### ChineseType
匯出的常數物件,用於表示中文類型檢測結果:
`javascript
export const ChineseType = {
SIMPLIFIED: 0, // 簡體中文
TRADITIONAL: 1, // 繁體中文
UNKNOWN: 2 // 未知類型
};
`
#### OutputFormat
匯出的常數物件,用於表示輸出格式選項:
`javascript
export const OutputFormat = {
NORMAL: 0, // 只輸出轉換後的結果
BRACKET: 1, // 輸出「轉換(原文)」格式
RUBY: 2 // 輸出 HTML 標籤格式
};
`
$3
#### 智能詞組轉換
本函式庫支援基於上下文的智能詞組轉換,能夠正確處理「一簡多繁」的情況:
`javascript
const { traditionalized } = stcasc();
// 智能識別詞組邊界
console.log(traditionalized('香烟袅袅'));
// 輸出: 香煙裊裊
console.log(traditionalized('里长面子'));
// 輸出: 里長面子(「里長」是職務名稱)
console.log(traditionalized('吃干面'));
// 輸出: 吃乾麵(「乾麵」是食物)
console.log(traditionalized('把考卷发回来'));
// 輸出: 把考卷發回來(「發」是動詞)
console.log(traditionalized('卷发'));
// 輸出: 捲髮(「捲髮」是髮型)
`
#### 術語轉換
內建常用的大陸簡體與台灣正體術語轉換:
`javascript
const { traditionalized } = stcasc();
console.log(traditionalized('知识产权'));
// 輸出: 智慧財產權
console.log(traditionalized('计算机软件'));
// 輸出: 計算機軟體
console.log(traditionalized('网络服务器'));
// 輸出: 網路伺服器
``