Text processing method for quickly converting Chinese characters into Chinese pinyin

Abstract

The invention discloses a text processing method for quickly converting Chinese characters into Chinese pinyin, and belongs to the field of natural language and text processing. Firstly, Chinese characters of UCS-2 coding standards are collected, and pinyin array indexes are obtained through mapping; then, inputting a Chinese character text by a user, and converting the Chinese character text into a UTF-8 format; performing the following processing line by line: removing BOM identifiers of the first three bytes of each line of character string, performing character boundary division to obtain a UTF-8 coded variable-length byte sequence, and further converting the UTF-8 coded variable-length byte sequence into a 16-bit UCS-2 serial number; when the UCS-2 serial number is the supported Chinese character, accessing the corresponding pinyin through the array index; otherwise, marking the characters as unknown characters; returning to an empty pinyin list if judging that the character is empty; the characters containing the spaces are polyphones, and are segmented into pinyin vectors according to the spaces; if the character does not contain the space character, directly returning the character as a single-tone character; the character strings of all the lines are recognized, and a final Chinese character is obtained and converted into a Chinese pinyin text. The method is simple in deployment, low in resource occupation, high in searching efficiency and capable of supporting surname unusual reading.

Description

Technical Field

[0001] This invention belongs to the field of natural language and text processing, specifically a text processing method for quickly converting Chinese characters into Pinyin. Background Technology

[0002] With the continuous development of embedded technology, the functions and hardware conditions of embedded devices are constantly improving; the functions of VoIP products developed based on embedded systems are also constantly being enriched, evolving from simple voice calls to audio and video calls and video conferencing, continuously meeting the needs of users.

[0003] With the development of information technology, Chinese character pinyin conversion plays an important role in many application scenarios:

[0004] In the field of cybersecurity, testers need to convert employee names into pinyin to generate account and password dictionaries; in the field of communications, smartphones need to support pinyin search for contacts; in the field of input methods, pinyin needs to be converted into Chinese character candidates in real time; and in the field of education, pinyin needs to be automatically annotated for Chinese text.

[0005] Currently, the main methods for converting Chinese characters to pinyin are as follows:

[0006] 1. Hash table-based mapping method: For example, Java's pinyin4j library uses a HashMap to store the mapping relationship between Chinese characters and their pinyin, retrieving the pinyin through hash lookup. While this method is highly efficient, it requires calculating hash values, incurring hash collision handling overhead, and necessitates loading data files at runtime, resulting in complex deployment.

[0007] 2. Database-based query method: Store the mapping relationship between Chinese characters and pinyin in SQLite or other databases, and retrieve the pinyin through SQL queries; this method is flexible and easy to update, but has high I / O overhead and high query latency, making it unsuitable for real-time applications and embedded devices.

[0008] 3. Trie-based retrieval method: such as Python's pypinyin library, which uses a Trie tree to store the mapping of Chinese characters to their pinyin. The search efficiency is O(m), where m is the length of the Chinese character encoding. Although prefix matching is supported, the tree structure consumes a lot of memory, and pointer jumps affect caching efficiency.

[0009] 4. Machine learning-based prediction methods: These use deep learning models to predict the pronunciation of polyphonic characters based on context, such as pre-trained models like BERT. While they offer high accuracy, they are large (hundreds of MB), have long inference times (tens of milliseconds), consume significant resources, and are difficult to deploy on embedded devices.

[0010] The above methods share the following common problems:

[0011] 1) Complex deployment: Requires external data files or databases, increasing deployment and maintenance costs.

[0012] 2) High resource consumption: High memory occupancy, not suitable for resource-constrained embedded devices.

[0013] 3) Low search efficiency: There are overheads such as hash calculation, I / O access, and pointer jumps, resulting in poor real-time performance.

[0014] 4) Weak ability to handle heterophonous surnames: Difficult to recognize the heterophonous readings of polysyllabic characters in surname scenarios, affecting the accuracy of name processing.

[0015] 5) Limited encoding support: Most solutions only support specific encoding formats, with poor cross-platform compatibility.

[0016] In the scenario of generating an account dictionary for password attacks, it is crucial to correctly handle heterophonous surnames. For example, the surname "仇" in "仇某" should be pronounced as "Qiu" instead of "Chou", and the surname "朴" in "朴某" of the Korean ethnic group should be pronounced as "Piao" instead of "Pu". Existing solutions are difficult to automatically identify surname scenarios, resulting in insufficient accuracy of the generated account dictionary.

[0017] Therefore, a Chinese character pinyin conversion method with simple deployment, low resource occupancy, high search efficiency, and support for heterophonous surnames is needed. Summary of the Invention

[0018] The present invention provides a text processing method for quickly converting Chinese characters into Chinese pinyin, aiming to solve the problems of complex deployment, high resource consumption, low search efficiency, and weak ability to handle heterophonous surnames in the prior art for Chinese character pinyin conversion. It is applicable to resource-constrained embedded devices, application scenarios with high real-time requirements, and business systems that need to correctly process names, and can achieve efficient and accurate Chinese character pinyin conversion functions with minimal system resource consumption.

[0019] The text processing method for quickly converting Chinese characters into Chinese pinyin is specifically as follows:

[0020] Step 1: Collect Chinese characters in the range of the UCS-2 encoding standard [0x4E00, 0x9FA5], obtain their authoritative pinyin, and linearly map the Unicode sequence numbers in this range to array indices of [0, 20901] through mapping;

[0021] The serial number index mapping formula is: index = unicode - 0x4E00;

[0022] Where unicode is the UCS-2 serial number of the Chinese character, and index is the pinyin array subscript.

[0023] Pinyin is stored in a static string array. The array elements are arranged in Unicode sequence. Multiple pinyin for polyphonic characters are separated by spaces and stored in the same string.

[0024] Step 2: The user inputs a new Chinese text file named txt. The file content is read and scanned byte by byte to verify whether it conforms to the UTF-8 encoding standard. Files that are not in UTF-8 encoding format are converted to UTF-8 format using a conversion tool.

[0025] UTF-8 encoding rule verification uses a bitmask judgment method:

[0026] The first byte of a single-byte character has a pattern of 0xxxxxxx and a value range of 0x00 to 0x7F.

[0027] The first byte of a double-byte character has a pattern of 110xxxxx with a value range of 0xC0 to 0xDF, and the second byte has a pattern of 10xxxxxx with a value range of 0x80 to 0xBF.

[0028] The first byte of a three-byte character is 1110xxxx with a value range of 0xE0 to 0xEF, and the second and third bytes are both 10xxxxxx.

[0029] The first byte of a four-byte character follows the pattern 11110xxx with a value range of 0xF0 to 0xF7. The second, third, and fourth bytes follow the pattern 10xxxxxx.

[0030] The bitmask verification formula is as follows: For byte B, the single byte is judged as (B & 0x80) == 0x00, the first byte of the double byte is judged as (B & 0xE0) == 0xC0, the first byte of the three byte is judged as (B & 0xF0) == 0xE0, the first byte of the four byte is judged as (B & 0xF8) == 0xF0, and subsequent bytes are judged as (B & 0xC0) == 0x80.

[0031] If the file contains illegal byte sequences, including isolated subsequent bytes 10xxxxxx, excessively long byte sequences, truncated multi-byte characters, etc., the verification will fail and an error message will be reported to the user indicating that the file encoding is not UTF-8. The user can use encoding conversion tools such as iconv to convert the file from other encoding formats such as GBK to UTF-8 format.

[0032] Step 3: Read the contents of the UTF-8 formatted file line by line and check if the first 3 bytes of the current line string are the UTF-8 BOM identifier (0xEF 0xBB 0xBF). If so, automatically remove the BOM identifier and proceed to Step 4; otherwise, proceed directly to Step 4.

[0033] The current line is initially the first line of text.

[0034] Step 4: Divide the current line text string after removing the BOM marker into character boundaries to obtain a UTF-8 encoded variable-length byte sequence.

[0035] The characteristics of UTF-8 encoded text variable-length byte sequences are as follows: ASCII characters occupy 1 byte, Chinese characters occupy 3 bytes, symbols occupy 2 bytes, and emoticons occupy 4 bytes.

[0036] Read the first byte of the string, determine the character length (1-4 bytes) through bitmask operation, save the start and end positions of the current character, repeatedly perform boundary recognition and position advance operation, and traverse and process all characters of the entire string in the current line.

[0037] Step 5: Convert the UTF-8 encoded variable-length byte sequence of the current line into a 16-bit UCS-2 sequence number;

[0038] The valid bits are extracted from the UTF-8 variable-length byte sequence and concatenated into a 16-bit UCS-2 sequence number, supporting encoding conversion of single-byte, double-byte, and triple-byte characters.

[0039] Single-byte character conversion formula: U = B1 & 0x7F, where B1 is the first byte, and the lower 7 bits are taken as the Unicode code point, with a code point range of 0x0000 to 0x007F, corresponding to the ASCII character set.

[0040] Double-byte character conversion formula: U = ((B1 & 0x1F) << 6) | (B2 & 0x3F), where B1 is the contribution of the first byte, shifting the lower 5 bits left by 6 bits, and B2 is the contribution of the second byte, shifting the lower 6 bits left. The code point range is 0x0080 to 0x07FF, corresponding to characters such as extended Latin letters and Greek letters.

[0041] The three-byte character conversion formula is: U = ((B1 & 0x0F) << 12) | ((B2 & 0x3F) << 6) | (B3 & 0x3F), where B1 is the first byte contributing the lower 4 bits shifted left by 12 bits, B2 is the second byte contributing the lower 6 bits shifted left by 6 bits, and B3 is the third byte contributing the lower 6 bits. The code point range is from 0x0800 to 0xFFFF, and most Chinese characters use this encoding method.

[0042] The conversion result is a 16-bit unsigned integer type, with a value range of 0x0000 to 0xFFFF;

[0043] Step 6: Determine if the UCS-2 serial number is a supported Chinese character. If it is, access the corresponding pinyin through array index; otherwise, mark it as an unknown character.

[0044] First, determine if the converted UCS-2 sequence number is within the range [0x4E00, 0x9FA5]:

[0045] If so, calculate its index position in the pinyin array using the subtraction operation (index = unicode - 0x4E00); then directly access the pinyin array using the calculated index (pinyin_string = pinyin_list_with_tone_[index]);

[0046] Where pinyin_list_with_tone_ represents the stored list of 20902 pinyin characters, and a pointer to the pinyin string is obtained.

[0047] Otherwise, return a vector containing the transition state (bool) and a list of pinyin. <string>The data structure marks conversion failures and stores the original UTF-8 byte sequence.

[0048] Step 7: For the pinyin string or unknown character accessed by array index, determine whether it is an empty character. If it is, return an empty pinyin list; otherwise, continue to determine whether it contains a space character. If it does, the result is a polyphonic character, which is split into a pinyin vector by spaces; otherwise, the result is a monophonic character and is returned directly.

[0049] Step 8: Output the results of empty pinyin lists, polyphonic characters, or monophonic characters according to the method specified by the user; return to Step 3 to recognize the next line of the user input text until all lines of the user input text have been recognized, and finally obtain the text that quickly converts Chinese characters into Chinese pinyin.

[0050] The specific output method is as follows:

[0051] Tone Removal: The output format of the pinyin is determined by the user-specified --tone option. If tones are present, the original pinyin is returned for speech synthesis and Chinese teaching. Otherwise, the position of the first numeric character is located and the preceding part is truncated for search indexing and account dictionary generation.

[0052] Unknown character handling: For characters marked as unknown (whitespace, English letters, numbers, punctuation, unsupported rare characters), preserve them as is or replace them with the specified string, while maintaining the original row and column format.

[0053] When the user does not specify the --replace-unknown option, the default preservative strategy is used. When the user specifies the --replace-unknown option, the character replacement strategy is enabled, and all unknown characters are replaced with the string specified by the --replace-unknown-with parameter.

[0054] Output of polyphonic characters: Based on the user-specified polyphonic character processing mode and format options, select the appropriate pinyin pronunciation and define three polyphonic character processing modes:

[0055] The user-specified `--polyphone all` mode returns all pronunciations, `--polyphone name` mode prioritizes the pronunciation of the last name (first letter in the spelling list), and `--polyphone noname` mode prioritizes the pronunciation of non-last names (second letter in the spelling list). The default mode is `noname`. Camel case formatting is performed; the `--camel` option determines whether to perform camel case formatting, converting the first letter to uppercase (ASCII code minus 32). All characters in each line are converted, selected, and formatted, and output to the standard output stream.

[0056] The advantages of this invention are:

[0057] 1. This invention uses direct array index access to achieve O(1) time complexity, which is significantly faster than hash table and database methods;

[0058] 2. This invention uses Pinyin data to embed executable files during compilation, resulting in minimal memory usage and full utilization of CPU cache, making it suitable for embedded devices.

[0059] 3. This invention enables single-file deployment, requiring no external database or configuration file, and has good cross-platform compatibility, greatly reducing deployment and maintenance costs;

[0060] 4. This invention has built-in rules for the variant pronunciation of common surnames and supports switching between surname / non-surname pronunciation modes, significantly improving the accuracy of name processing;

[0061] 5. This invention replaces dynamic containers with static arrays, significantly shortening compilation time and reducing executable file size;

[0062] 6. This invention supports multiple pinyin formats, output styles, and polyphonic character processing strategies, offering rich and flexible functionality;

[0063] 7. This invention is written in standard C++ and provides a cross-platform build solution; it is easy to integrate and embed, and is suitable for resource-constrained environments; it adopts an open-source license, and the code is clear and easy to extend. Attached Figure Description

[0064] Figure 1 This is a flowchart of a text processing method for quickly converting Chinese characters into Pinyin according to the present invention;

[0065] Figure 2 This is a flowchart of the Pinyin data compilation process of this invention;

[0066] Figure 3 This is a flowchart of the UTF-8 encoding process of this invention;

[0067] Figure 4 This is a flowchart of the Pinyin search process of this invention;

[0068] Figure 5 This is a flowchart of the unknown character processing of the present invention;

[0069] Figure 6 This is a flowchart of the polyphonic character selection and formatted output process of this invention; Detailed Implementation

[0070] To facilitate understanding and implementation of the present invention by those skilled in the art, the present invention will be further described in detail and in depth below with reference to the accompanying drawings.

[0071] This invention proposes a text processing method for quickly converting Chinese characters into Pinyin, applicable to fields such as password dictionary generation, contact search, input method candidate generation, and Pinyin annotation. It can be applied to scenarios such as embedded devices, terminal applications, and search systems. Based on the principle of direct mapping of Unicode serial numbers, this method achieves efficient, low-resource-consumption, and externally independent Chinese character Pinyin conversion through compile-time data embedding and array indexing.

[0072] The text processing method described above for quickly converting Chinese characters into Pinyin, such as... Figure 1 As shown, the specific steps are as follows:

[0073] Step 1: Collect Chinese characters within the UCS-2 encoding standard range [0x4E00, 0x9FA5], obtain their authoritative pinyin, and linearly map the Unicode sequence number of this range to an array index of [0, 20901];

[0074] This step is completed during the program compilation phase, laying the foundation for efficient runtime lookup. First, the conceptual hierarchy of the Unicode encoding system is clarified: Unicode is a text standard encoding, UCS-2 is a 16-bit ordinal table, and UTF-16 is a 16-bit encoding set. While numerically equal, they are conceptually different. This invention uses UCS-2 as its internal ordinal table, selecting the range [0x4E00, 0x9FA5] as the processing range. The pinyin information of 20,902 Chinese characters is collected and organized, handling polyphonic characters and variant pronunciations of surnames. The pinyin data is embedded into the executable file as a static array during compilation, establishing a direct index mapping relationship based on Unicode ordinal numbers.

[0075] The formula for mapping serial number index is: index = unicode - 0x4E00;

[0076] Where unicode is the UCS-2 index of the Chinese character, and index is the subscript of the pinyin array.

[0077] Specifically, it includes the following:

[0078] 1) Determine the Unicode range for Chinese characters;

[0079] Select the range [0x4E00, 0x9FA5] in the UCS-2 encoding standard as the processing range. This range covers 6,763 simplified Chinese characters in the GB2312 standard, 13,053 traditional Chinese characters in the BIG5 standard, and some extended Chinese characters. The Chinese characters in this range are arranged continuously in the Unicode standard without holes or jumps, covering more than 99% of the Chinese character requirements in daily applications. It includes 3,500 common characters, 3,000 less common characters, and a large number of special characters. Establish a linear mapping relationship between Unicode serial numbers and array indices, laying the foundation for subsequent direct array index lookups with O(1) complexity and avoiding the overhead of hash calculations and tree traversals.

[0080] As Figure 2 shown, the specific implementation is as follows: For any Chinese character H, its Unicode serial number U(H) belongs to the range [0x4E00, 0x9FA5]. The index I(H) in the pinyin array A is equal to U(H) minus 0x4E00, and the corresponding pinyin P(H) is equal to A[I(H)]. The entire lookup process only requires one subtraction operation and one array access operation, with a time complexity of O(1).

[0081] The system defines two constant boundary values. The starting boundary is equal to the Chinese character "一" corresponding to 0x4E00, and the ending boundary is equal to the Chinese character "龥" corresponding to 0x9FA5. The Chinese character range check is implemented by judging whether the Unicode serial number is greater than or equal to the starting boundary and less than or equal to the ending boundary at the same time.

[0082] 2) Collection and collation of pinyin data;

[0083] Obtain the pinyin information of 20,902 Chinese characters from authoritative pinyin data sources and handle the case of polyphonic characters. Especially handle the different pronunciations of surnames, putting the surname pronunciation in the first place and the non-surname pronunciation in the second place. This order design enables subsequent fast switching between surname and non-surname pronunciations through simple index selection, meeting the requirements of both the scenario of handling personal names and general text processing.

[0084] Obtain the basic pinyin data from the Uni2Pinyin data table of the Institute of Humanities and Social Sciences of Kyoto University. This data table contains the standard correspondence between Unicode serial numbers and pinyin. And supplement and collate more than 100 different pronunciations of surnames, mainly referring to authoritative sources such as "Hundred Family Surnames", discussions on professional forums of surname pronunciations, and summary materials of different pronunciations of surnames.

[0085] Typical cases of different pronunciations of surnames include: The surname "仇" is pronounced as "qiu2" instead of "chou2", the surname "朴" is pronounced as "piao2" instead of "pu3", the surname "区" is pronounced as "ou1" instead of "qu1", the surname "单" is pronounced as "shan4" instead of "dan1", etc. For the pinyin sorting order of polyphones, the pronunciation of the surname is placed in the first position, and other pronunciations are sorted in descending order of usage frequency in subsequent positions. The pinyin format uniformly adopts the annotation method of lowercase letters plus digital tones, where the numbers 1 to 4 represent the four tones of flat tone, rising tone, falling-rising tone, and falling tone respectively.

[0086] Typical pinyin data examples are arranged in ascending order of Unicode numbers: The first Unicode number is 0x4E00, corresponding to the Chinese character "一" with the pinyin "yi1", which is a monosyllabic word; the Unicode number 0x4E01 corresponds to the Chinese character "丁" with the pinyin "ding1", which is a monosyllabic word; the Unicode number 0x4E0A corresponds to the Chinese character "上" with the pinyin "shang4 shang3", and the main pronunciation of the polyphone is in the front; the Unicode number 0x4EC7 corresponds to the Chinese character "仇" with the pinyin "qiu2 chou2", which is a case of different pronunciations of a surname, and the surname pronunciation "qiu2" is in the first place; the Unicode number 0x6734 corresponds to the Chinese character "朴" with the pinyin "piao2 pu3 po4 pu2 po1", which is a case of different pronunciations of a surname, and the surname pronunciation "piao2" is in the first place; the Unicode number 0x884C corresponds to the Chinese character "行" with the pinyin "xing2 hang2", which is a polyphone and needs to be selected according to the context.

[0087] 3). Optimized design of data structure;

[0088] The initial design plan uses a nested dynamic container to store pinyin data. The outer container is indexed by Chinese characters, and the inner container stores multiple pinyins. However, this structure causes the compilation time to exceed 30 minutes and the executable file size to reach 16 MB. The reason for the performance bottleneck is that the compiler needs to construct a large number of dynamic container objects during compilation and fill them with string literal constants, generating a large amount of initialization code.

[0089] The optimized plan uses a static string array to store pinyin data. The element type of the array is a pointer to a string literal, and multiple pinyins are separated by space characters in the same string. The specific implementation is to define a static constant pointer array containing 20,902 elements. The array elements are arranged in ascending order of Unicode numbers, and the i-th element corresponds to the pinyin of the Chinese character with the Unicode number 0x4E00 (the first one) plus i.

[0090] The pinyin data structure is defined as: const char* pinyin_list_with_tone_

[20902] . Multiple pinyin of polyphonic characters are separated by spaces and stored in the same string. The pronunciation of the surname is placed first. A static string array is used instead of a dynamic container, which reduces the compilation time from more than 30 minutes to less than 5 seconds and the file size to 2MB. At the same time, the memory layout is maintained to continuously improve the cache hit rate.

[0091] 4) Compile-time data embedding;

[0092] Define the pinyin array as a static constant member of the class, with a data type of an array of pointers to constant characters. The compiler embeds the data into the data segment of the executable file during compilation. No external files need to be loaded at runtime; the program can directly access the pinyin data upon startup, achieving true single-file deployment, eliminating external dependencies, reducing deployment and maintenance costs, and improving performance by avoiding file I / O overhead.

[0093] During the compilation phase, the compiler directly embeds 20,902 string literals into the read-only data segment of the object file and places the pointer array into the data segment. During the linking phase, the linker merges the read-only data segment and the data segment of the object file into the final executable file, making the Pinyin data a component of the executable file.

[0094] When the program runs, the operating system loads the executable file into the process address space through a memory mapping mechanism. The Pinyin data is loaded into memory along with the executable file, without the need for additional file read operations or data loading processes. The read-only data segment is protected by the operating system's memory protection mechanism; any modification operation will trigger a segmentation fault exception, ensuring data integrity and immutability.

[0095] Step 2: When the user inputs a new Chinese text file (txt), scan it byte by byte to verify whether it conforms to the UTF-8 encoding standard. Convert non-UTF-8 encoded files to UTF-8 format using a conversion tool.

[0096] Open the user-specified input file, read its contents, and scan byte by byte to verify whether the encoding format of single-byte, double-byte, triple-byte, and quadruple-byte characters conforms to the UTF-8 encoding standard. This verification ensures that the data being processed subsequently is correctly encoded, avoiding character parsing failures or garbled text due to encoding errors. If the verification fails, prompt the user to use tools such as iconv to convert the encoding and try again.

[0097] UTF-8 encoding rule verification uses a bitmask judgment method:

[0098] The first byte of a single-byte character has a pattern of 0xxxxxxx and a value range of 0x00 to 0x7F.

[0099] The first byte of a double-byte character has a pattern of 110xxxxx with a value range of 0xC0 to 0xDF, and the second byte has a pattern of 10xxxxxx with a value range of 0x80 to 0xBF.

[0100] The first byte of a three-byte character is 1110xxxx with a value range of 0xE0 to 0xEF, and the second and third bytes are both 10xxxxxx.

[0101] The first byte of a four-byte character follows the pattern 11110xxx with a value range of 0xF0 to 0xF7. The second, third, and fourth bytes follow the pattern 10xxxxxx.

[0102] The bitmask verification formula is as follows: For byte B, the single byte is judged as (B & 0x80) == 0x00, the first byte of the double byte is judged as (B & 0xE0) == 0xC0, the first byte of the three byte is judged as (B & 0xF0) == 0xE0, the first byte of the four byte is judged as (B & 0xF8) == 0xF0, and subsequent bytes are judged as (B & 0xC0) == 0x80.

[0103] If the file contains illegal byte sequences, including isolated subsequent bytes 10xxxxxx, excessively long byte sequences, truncated multi-byte characters, etc., the verification will fail and an error message will be reported to the user indicating that the file encoding is not UTF-8. The user can use encoding conversion tools such as iconv to convert the file from other encoding formats such as GBK to UTF-8 format.

[0104] Step 3: Read the contents of the UTF-8 formatted file line by line and check if the first 3 bytes of the current line string are UTF-8 BOM identifiers. If so, automatically remove the BOM identifier and proceed to Step 4; otherwise, proceed directly to Step 4.

[0105] The current line is initially the first line of text. The BOM identifier is defined as three consecutive bytes 0xEF, 0xBB, and 0xBF, corresponding to the Unicode code point U+FEFF, which represents a zero-width non-breaking space.

[0106] The formula for BOM detection is: hasBOM = (byte 1 == 0xEF) && (byte 2 == 0xBB) && (byte 3 == 0xBF).

[0107] If a BOM (Bill of Materials) identifier is detected, a removal operation is performed, extracting bytes from the fourth byte to the end of the string to form a new string. This process prevents the BOM from being treated as a regular character, which could lead to output errors. BOM handling ensures consistency of text files across Windows and Linux operating systems because Windows text editors typically add a BOM identifier at the beginning of UTF-8 files, while Linux systems usually do not.

[0108] Step 4: Divide the current line text string after removing the BOM marker into character boundaries to obtain a UTF-8 encoded variable-length byte sequence.

[0109] The system receives UTF-8 encoded input files or strings, verifies the encoding validity through bitmasking, processes byte order markers, parses the variable-length encoding structure character by character, and finally converts it into an internally used 16-bit UCS-2 sequence number. The specific method is as follows: Figure 3 As shown.

[0110] Read the first byte of the string and determine the byte length of the character (1-4 bytes) through bitmask operations.

[0111] The character length determination formula is as follows: if (first byte & 0x80) == 0x00, the character length is 1 byte; if (first byte & 0xE0) == 0xC0, the character length is 2 bytes; if (first byte & 0xF0) == 0xE0, the character length is 3 bytes; and if (first byte & 0xF8) == 0xF0, the character length is 4 bytes.

[0112] Correctly identifying character boundaries prevents the middle byte of a multi-byte character from being mistaken for the start byte of the next character, ensuring the correctness of subsequent encoding conversions and the preservation of unknown characters as is.

[0113] The characteristics of UTF-8 variable-length encoding are: ASCII characters occupy 1 byte, most Chinese characters occupy 3 bytes, some symbols occupy 2 bytes, and Emoji characters occupy 4 bytes. The start and end positions of the current character are stored for subsequent extraction of the original UTF-8 byte sequence. Boundary detection and position advance operations are repeatedly performed from the beginning of the string, traversing and processing all characters in the entire string.

[0114] Step 5: Convert the UTF-8 encoded variable-length byte sequence of the current line into a 16-bit UCS-2 sequence number;

[0115] The system extracts valid bits from the identified boundary UTF-8 variable-length byte sequence and concatenates them into a 16-bit UCS-2 sequence number according to UTF-8 encoding rules, supporting encoding conversion of single-byte, double-byte, and triple-byte characters. This conversion unifies the variable-length UTF-8 encoding into a fixed-length UCS-2 sequence number, facilitating subsequent array index calculation via simple subtraction, while preserving the original UTF-8 byte sequence for outputting unknown characters as is.

[0116] The encoding conversion formula is as follows:

[0117] Single-byte character conversion formula: U = B1 & 0x7F, where B1 is the first byte, and the lower 7 bits are taken as the Unicode code point, with a code point range of 0x0000 to 0x007F, corresponding to the ASCII character set.

[0118] Double-byte character conversion formula: U = ((B1 & 0x1F) << 6) | (B2 & 0x3F), where B1 is the contribution of the first byte, shifting the lower 5 bits left by 6 bits, and B2 is the contribution of the second byte, shifting the lower 6 bits left. The code point range is 0x0080 to 0x07FF, corresponding to characters such as extended Latin letters and Greek letters.

[0119] The three-byte character conversion formula is: U = ((B1 & 0x0F) << 12) | ((B2 & 0x3F) << 6) | (B3 & 0x3F), where B1 is the first byte contributing the lower 4 bits shifted left by 12 bits, B2 is the second byte contributing the lower 6 bits shifted left by 6 bits, and B3 is the third byte contributing the lower 6 bits. The code point range is from 0x0800 to 0xFFFF, and most Chinese characters use this encoding method.

[0120] The conversion result is a 16-bit unsigned integer type, with a value range of 0x0000 to 0xFFFF; sufficient to represent all 65536 characters of the UCS-2 encoding standard. Simultaneously, the original UTF-8 byte sequence is preserved by recording the start and end positions, ensuring that unknown characters are output as is.

[0121] Encoding conversion example: The input UTF-8 string "张三峰" corresponds to the byte sequence E5 BC A0 E4 B8 89 E5 B3 B0. The UTF-8 byte of the character "张" is E5 BC A0, and the bit pattern is 1110 0101, 10 111100, 10 100000. The valid bits are extracted as 0101, 111100, 100000, and the concatenated result is 0101 111100 100000 which is equal to 0x5F20. The UTF-8 byte of the character "三" is E4 B8 89, and the converted UCS-2 serial number is 0x4E09. The UTF-8 byte of the character "峰" is E5 B3 B0, and the converted UCS-2 serial number is 0x5CF0.

[0122] Step 6: Determine whether the UCS-2 serial number is a supported Chinese character. If it is, access the corresponding pinyin through array indexing; otherwise, mark it as an unknown character.

[0123] The system performs a range check on the converted UCS-2 serial number, calculates the array index, directly accesses the pinyin array to obtain the pinyin, and processes cases such as single characters, polyphones, tones, etc., to achieve an efficient search with an O(1) time complexity; the specific process is as Figure 4 shown.

[0124] 1). Chinese character range check;

[0125] Specifically, it includes: determining whether the converted UCS-2 serial number is within the range of [0x4E00, 0x9FA5]; this check quickly identifies supported Chinese characters and unknown characters (English, numbers, punctuation marks, rare characters, etc.), avoiding invalid pinyin search operations on unknown characters. If the check passes, continue to search for the pinyin; if the check fails, mark it as an unknown character and enter the subsequent unknown character processing process.

[0126] If unicode < 0x4E00, it is a non-Chinese character (possibly an ASCII character, Latin letter, number, punctuation mark, etc.); if unicode > 0x9FA5, it is an unsupported character (possibly a rare Chinese character, other language characters, emoji, etc.). For characters outside the range, mark them as unknown characters and process them according to the unknown character processing strategy in the subsequent steps.

[0127] 2). Direct array index access;

[0128] When the UCS-2 index is within the range [0x4E00, 0x9FA5], the array index is calculated as: index = unicode - starting boundary, i.e., index = unicode - 0x4E00. This calculation is a simple integer subtraction, which can be completed by a single CPU instruction, taking approximately 1 nanosecond. To directly access the index position in the pinyin array, the calculated index is used to directly access the pinyin array.

[0129] pinyin_string = pinyin_list_with_tone_[index]

[0130] Where pinyin_list_with_tone_ represents storing a list of 20902 pinyin characters, and array access is direct memory addressing;

[0131] This linear mapping leverages the continuity of Chinese character Unicode encoding to directly map the Unicode indices of 20,902 Chinese characters to array indices from 0 to 20,901, achieving O(1) complexity index calculation. This is independent of data size and requires no hash functions, binary search, or tree traversal. The operation requires only one memory lookup, with a time complexity of O(1), approximately 3 nanoseconds, which is 50% faster than hash tables and 100 times faster than databases, fully utilizing CPU cache to improve performance.

[0132] Otherwise, return a vector containing the transition state (bool) and a list of pinyin. <string>The data structure marks the conversion failure and stores the original UTF-8 byte sequence. This marker enables subsequent steps to distinguish between successfully converted Chinese characters and unknown characters, and to apply different processing strategies (preserve as is or replace) to unknown characters.

[0133] Step 7: For the pinyin string or unknown character accessed by array index, determine whether it is an empty character. If it is, return an empty pinyin list; otherwise, continue to determine whether it contains a space character. If it does, the result is a polyphonic character, which is split into a pinyin vector by spaces; otherwise, the result is a monophonic character and is returned directly.

[0134] Specifically, this includes: obtaining a pinyin_string in C style, which may be a single pinyin (e.g., "li3") or multiple pinyin separated by spaces (e.g., "qiu2 chou2"); determining if it is an empty string: if pinyin_string[0] == '\0', it means that the Unicode sequence number has no corresponding Chinese pinyin (a gap in the database), and returning an empty pinyin list; determining if it is a monosyllabic character: traversing the string to find a space character, if no space exists, it is a monosyllabic character, and the pinyin is returned directly; a polysyllabic character segmentation algorithm: using pointers to traverse the string, if a space character is encountered, the part before it is taken as a pinyin, and the remaining part is processed; finally, a pinyin vector is obtained, such as vector <string>{"qiu2", "chou2"}、vector <string>{"xing2","hang2"}.

[0135] Step 8: Output the results of empty pinyin lists, polyphonic characters, or monophonic characters according to the method specified by the user; return to Step 3 to recognize the next line of the user input text until all lines of the user input text have been recognized, and finally obtain the text that quickly converts Chinese characters into Chinese pinyin.

[0136] Based on the user-specified polyphonic character processing mode (all / name / noname) and formatting options (with / without tone, camelCase / lowercase), select the appropriate Pinyin pronunciation, perform formatting, and batch output to the standard output stream. The specific output method is as follows:

[0137] 1. Tone Removal: Based on the user-specified --tone option, determine the pinyin output format and whether tones are required. If so, return to the original pinyin (e.g., zhang1) for speech synthesis and Chinese teaching; otherwise, find the position of the first numeric character and extract the preceding part (e.g., zhang) for search indexing and account dictionary generation.

[0138] Specifically, the output format is determined by the user-specified `with_tone` parameter. If `with_tone` is true (specified with `--tone` on the command line), the pinyin with tones is returned directly, such as "li3" or "si4". If `with_tone` is false (not specified with `--tone` on the command line), the tone numbers need to be removed. This function meets the needs of different application scenarios: with tones, it is suitable for speech synthesis and Chinese teaching; without tones, it is suitable for search indexes and account dictionary generation.

[0139] Tone Removal Algorithm: Traverse the pinyin string, find the position of the first numeric character (0-9), and extract the part before that position as the pinyin without tone; for example, the first numeric position of "li3" is 2, so extract [0, 2) to get "li"; process the tone for each pinyin of a polyphonic character separately; pinyin tone numbers mean: 1=high level tone, 2=rising tone, 3=falling tone, 4=falling tone, 5=neutral tone (usually not marked or represented by 5).

[0140] 2. Unknown Character Handling: For characters marked as unknown (whitespace, English letters, numbers, punctuation, unsupported rare characters), a flexible handling strategy is provided: preserve them as is or replace them with a specified string, while maintaining the original text's row and column formatting. Specifically, for example... Figure 5 As shown.

[0141] Specifically, if a character's Unicode index is not within the range of [0x4E00, 0x9FA5], it is marked as an unknown character; if it is within the range but the corresponding pinyin is an empty string, it is also marked as an unknown character.

[0142] Unknown character types: ASCII characters (0x00-0x7F), such as English letters, numbers, and basic punctuation; Latin-1 extended characters (0x80-0xFF), such as European characters with phonetic symbols; CJK symbols and punctuation (0x3000-0x303F), such as Chinese punctuation and full-width spaces; other language characters, such as Japanese kana and Korean letters; Emoji characters (0x1F600-0x1F64F, etc.); Returns a data structure containing the conversion status and the processed string: pair <bool, vector <string>>, if first is false, it indicates that the conversion fails, and second stores the original UTF-8 byte sequence. This classification provides a basis for subsequent differential processing, enabling the system to flexibly handle complex scenarios such as mixed Chinese and English texts, multilingual texts, texts containing special symbols, etc.

[0143] When the user does not specify the --replace-unknown option, the default strategy of retaining the original form is adopted, retaining the original UTF-8 byte sequence; when the user specifies the --replace-unknown option, the character replacement strategy is enabled, and the string specified by the --replace-unknown-with parameter is used to replace all unknown characters; the file is processed line by line, keeping the original line numbers and paragraph formats unchanged.

[0144] For unknown characters, save their original UTF-8 byte sequences; directly output the original characters without any modification when outputting; this strategy maintains the consistency between input and output, and is applicable to scenarios such as mixed Chinese and English texts, texts containing punctuation marks, etc. that require retaining the complete original information, ensuring that non-Chinese content is not lost. For example: "张三峰(ง •̀_•́)ง" is output as "zhang1san1feng1(ง •̀_•́)ง", with English and emojis retained as they are.

[0145] The character replacement strategy specifically includes: when the user specifies the --replace-unknown option, the character replacement strategy is enabled; the string specified by the --replace-unknown-with parameter is used to replace all unknown characters, supporting various replacement rules such as deletion (empty string), single character replacement, and token replacement. This strategy meets different application requirements: deleting unknown characters is used for extracting pure pinyin, unified marking is used for data cleaning, and single character replacement is used for format alignment.

[0146] If replace_unknown_with is an empty string (--replace-unknown-with ''), the unknown characters are deleted; if replace_unknown_with is a single character (such as --replace-unknown-with '*'), it is replaced with that character; if replace_unknown_with is a string (such as --replace-unknown-with '[UNK]'), it is replaced with that token; this strategy is applicable to scenarios that require filtering non-Chinese characters, such as pure pinyin output and data cleaning.

[0147] Format preservation specifically includes: reading the input file line by line, processing each line independently, and outputting a newline character after each line is processed, keeping the original line count unchanged; treating whitespace characters (space 0x20, tab 0x09, full-width space 0x3000) as unknown characters; if the "preserve as is" strategy is used, the output retains the original indentation and alignment; if the "remove" strategy is used, all whitespace is removed from the output; paragraph structure and number of blank lines are completely consistent with the original text; this feature ensures that the number of lines, paragraph structure, and indentation format of the output pinyin text completely correspond to the visual layout of the input file, facilitating manual proofreading and maintaining the pinyin output function without destroying the original text's layout structure.

[0148] 3. Output of polyphonic characters: Based on the user-specified polyphonic character processing mode and format options, select the appropriate pinyin pronunciation, define three polyphonic character processing modes, perform camelCase formatting, and batch output to the standard output stream. The specific process is as follows: Figure 6 As shown;

[0149] The user-specified `--polyphone all` mode returns all pronunciations in the format `<pronunciation1, pronunciation2, ...>`, suitable for full indexing scenarios; the `--polyphone name` mode prioritizes the pronunciation of the surname (first in the pinyin list), suitable for name processing scenarios; the `--polyphone noname` mode prioritizes the pronunciation of non-surname characters (second in the pinyin list), suitable for general text scenarios; the default mode is `noname`. This design is based on a data structure that prioritizes the surname pronunciation, and mode switching can be achieved through simple index selection, meeting the differentiated needs of different application scenarios for selecting the pronunciation of polyphonic characters.

[0150] Extract a unique element from the list of pinyin characters. If the user specifies the --camel option, perform camelCase formatting to convert the first letter to uppercase (ASCII code minus 32). Perform conversion, selection, and formatting on all characters in each line and output to the standard output stream. Directly output the formatted pinyin without separators.

[0151] Monosyllabic characters are output directly without ambiguity, and camelCase formatting enhances visual readability and makes it easier to distinguish the pinyin boundaries of different Chinese characters.

[0152] The processing of single-character pronunciations specifically includes: extracting the only element from the pinyin list: pinyin = pinyin_list[0]; if the user specifies the --camel option, perform camel case formatting: pinyin[0] = toupper(pinyin[0]); the formula for converting to uppercase: toupper(c) = c - 32 (if 'a' ≤ c ≤ 'z'), using the characteristic that the difference between uppercase and lowercase letters in the ASCII code table is 32; directly output the formatted pinyin without separators; output example: for the single-character "张", in --camel mode, it outputs "Zhang", and without --camel, it outputs "zhang".

[0153] The priority processing of different pronunciations of surnames (name mode) specifically includes: when the user specifies --polyphone name, select the first element pinyin_list[0] of the pinyin list as the output; since the pronunciation of the surname has been placed at the front, the first pinyin is the pronunciation of the surname; typical cases: "仇" outputs "qiu" (surname) instead of "chou", "朴" outputs "piao" instead of "pu"; this mode correctly processes "仇小兵" as "QiuXiaoBing" instead of "ChouXiaoBing", and is applicable to scenarios such as generating account dictionaries for penetration testing, processing employee lists in HR systems, and pinyin indexing of address books for people's names, significantly improving the accuracy of processing people's names.

[0154] Supported different pronunciations of surnames include: 仇 (qiu / chou), 朴 (piao / pu), 区 (ou / qu), 单 (shan / dan), 缪 (miao / miu), 曾 (zeng / ceng), etc., more than 100 in total.

[0155] The priority processing of non-surname pronunciations (noname mode) specifically includes: when the user does not specify --polyphone or specifies --polyphone noname (default), select the second element pinyin_list[1] of the pinyin list as the output; if the list has only one element, take pinyin_list[0]; this pinyin is the mainstream pronunciation in daily text; typical cases: "行" outputs "hang" in "银行", "还" outputs "huan" in "还书"; it is applicable to non-people's name scenarios such as general text processing, pinyin annotation of articles, and speech synthesis, covering more than 90% of text processing requirements.

[0156] Full - volume pronunciation output (all mode) specifically includes: when the user specifies --polyphone all, all pronunciations are output; the output format is multiple pronunciations separated by commas wrapped in angle brackets (e.g., <xing2, hang2>): <pronunciation 1, pronunciation 2,...>; single - character words are directly output without angle brackets; typical case: "行" is output as "<xing2, hang2>"; this mode constructs a full - volume pinyin index to ensure that the user can retrieve the target regardless of which pronunciation is input, and is applicable to scenarios such as building a full - volume index for a search engine, generating an input method vocabulary, and candidates for a pinyin input method.

[0157] Camel formatting and batch output specifically include: determining whether to perform camel formatting according to the --camel option; formatting formula: pinyin[0] = toupper(pinyin[0]), that is, pinyin[0] = pinyin[0] - 32 (when 'a' ≤ pinyin[0] ≤ 'z'), converting the first letter to uppercase, and supporting the output in the camel style such as ZhangSanFeng.

[0158] Conversion principle: subtracting 32 from the ASCII code of a lowercase letter gives the corresponding uppercase letter, e.g., 'a'(97) - 32 = 'A'(65); reading the file line by line, performing conversion, selection, and formatting on all characters in each line, and outputting to the standard output stream; there is no separator between characters, and the pinyin is closely connected; a line feed character is output after each line is processed; shell redirection and pipe operations are supported. This batch - processing mechanism achieves high - throughput text conversion while maintaining the simplicity and composability of the Unix philosophy.

[0159] The performance indicators of this invention are as follows: search time complexity: O( )1); single - character conversion time: < 2 microseconds; size of the executable file: < 2MB; no external data files are required, enabling single - file deployment.< / string> < / string> < / string> < / string> < / string>

Claims

1. A text processing method for rapidly converting Chinese characters into Pinyin, characterized in that, Includes the following steps: Step 1: Collect UCS-2 encoded standard Chinese characters, obtain their authoritative pinyin, and linearly map the Unicode sequence number of this range to the pinyin array index through mapping; Pinyin is stored in a static string array, with array elements arranged in Unicode sequence. Multiple pinyin for polyphonic characters are separated by spaces and stored in the same string. Step 2: When the user inputs a new Chinese text file (txt), scan it byte by byte to verify whether it conforms to the UTF-8 encoding standard. Convert non-UTF-8 encoded files to UTF-8 format using a conversion tool. UTF-8 encoding rule verification uses a bitmask judgment method: The first byte of a single-byte character has a pattern of 0xxxxxxx and a value range of 0x00 to 0x7F. The first byte of a double-byte character has a pattern of 110xxxxx with a value range of 0xC0 to 0xDF, and the second byte has a pattern of 10xxxxxx with a value range of 0x80 to 0xBF. The first byte of a three-byte character is 1110xxxx with a value range of 0xE0 to 0xEF, and the second and third bytes are both 10xxxxxx. The first byte of a four-byte character has a pattern of 11110xxx with a value range of 0xF0 to 0xF7, and the subsequent second, third, and fourth bytes all have a pattern of 10xxxxxx. The bitmask verification formula is as follows: For byte B, a single byte is judged as (B & 0x80) == 0x00, the first byte of a two-byte is judged as (B & 0xE0) == 0xC0, the first byte of a three-byte is judged as (B & 0xF0) == 0xE0, the first byte of a four-byte is judged as (B & 0xF8) == 0xF0, and subsequent bytes are judged as (B & 0xC0) == 0x80; If an illegal byte sequence exists in the file, including isolated subsequent bytes 10xxxxxx, excessively long byte sequences, or truncated multi-byte characters, the bitmask verification will fail and an error message will be reported to the user indicating that the file encoding is not in UTF-8 format. Step 3: Read the contents of the UTF-8 formatted file line by line, and check if the first 3 bytes of the current line string are UTF-8 BOM identifiers. If they are, automatically remove the BOM identifiers and proceed to Step 4; otherwise, proceed directly to Step 4. The current line is initially the first line of text; Step 4: Divide the current line of text string after removing the BOM marker into character boundaries to obtain a UTF-8 encoded variable-length byte sequence of text; Read the first byte of the string, determine the character length through bitmask operation, save the start and end positions of the current character, repeatedly perform boundary recognition and position advance operation, and traverse and process all characters of the entire string in the current line; Step 5: Convert the UTF-8 encoded variable-length byte sequence of the current line into a 16-bit UCS-2 sequence number; Extract the valid bits from the UTF-8 variable-length byte sequence and concatenate them into a 16-bit UCS-2 sequence number, supporting encoding conversion of single-byte, double-byte, and three-byte characters; Step 6: Determine if the UCS-2 serial number is a supported Chinese character. If it is, access the corresponding pinyin through array index; otherwise, mark it as an unknown character. Step 7: For the pinyin string or unknown character accessed by array index, determine whether it is an empty character. If it is, return an empty pinyin list; otherwise, continue to determine whether it contains a space character. If it does, the result is a polyphonic character, which is split into a pinyin vector by spaces; otherwise, the result is a monophonic character and is returned directly. Step 8: Output the results of empty pinyin lists, polyphonic characters, or monophonic characters according to the method specified by the user; Return to step three to recognize the next line of the user-input text until all lines of the user-input text have been recognized, resulting in the final text that quickly converts Chinese characters into Pinyin.

2. The text processing method as described in claim 1, characterized in that, In step one, the sequence number index mapping formula is: index = unicode - 0x4E00; Where unicode is the UCS-2 index of the Chinese character, and index is the subscript of the pinyin array.

3. The text processing method as described in claim 1, characterized in that, In step four, the characteristics of the variable-length byte sequence of UTF-8 encoded text are as follows: ASCII characters occupy 1 byte, Chinese characters occupy 3 bytes, symbols occupy 2 bytes, and emoticons occupy 4 bytes.

4. The text processing method as described in claim 1, characterized in that, Step five specifically involves: Single-byte character conversion formula: U = B1 & 0x7F, where B1 is the first byte, and the lower 7 bits are taken as the Unicode code point, with a code point range of 0x0000 to 0x007F, corresponding to the ASCII character set; Double-byte character conversion formula: U = ((B1 & 0x1F) << 6) | (B2 & 0x3F), where B1 is the contribution of the first byte, shifting the lower 5 bits left by 6 bits, and B2 is the contribution of the second byte, shifting the lower 6 bits left. The code point range is 0x0080 to 0x07FF, corresponding to Latin letter extensions and Greek letter characters. The three-byte character conversion formula is: U = ((B1 & 0x0F) << 12) | ((B2 & 0x3F) << 6) | (B3 & 0x3F), where B1 is the lower 4 bits contributed by the first byte, shifted left by 12 bits; B2 is the lower 6 bits contributed by the second byte, shifted left by 6 bits; and B3 is the lower 6 bits contributed by the third byte. The code point range is from 0x0800 to 0xFFFF. Chinese characters use this encoding method. The conversion result is a 16-bit unsigned integer type with a value range of 0x0000 to 0xFFFF.

5. The text processing method as described in claim 1, characterized in that, In step six: First, determine whether the converted UCS-2 sequence number is within the range [0x4E00, 0x9FA5]. If so, calculate its index position in the pinyin array using the subtraction operation (index = unicode - 0x4E00); then directly access the pinyin array using the calculated index (pinyin_string = pinyin_list_with_tone_[index]); Where pinyin_list_with_tone_ represents the stored list of 20902 pinyin characters, and a pointer to the pinyin string is obtained; Otherwise, return a vector containing the transition state (bool) and a list of pinyin. <string>The data structure marks conversion failures and stores the original UTF-8 byte sequence.< / string> 6. The text processing method as described in claim 1, characterized in that, The user-specified output method in step eight is as follows: Tone Removal: The output format of the pinyin is determined by the user-specified --tone option. If tones are present, the original pinyin is returned for speech synthesis and Chinese teaching. Otherwise, locate the position of the first numeric character and extract the preceding part to perform search indexing and account dictionary generation; Unknown character handling: For characters marked as unknown: whitespace, English letters, numbers, punctuation, and unsupported rare characters, preserve them as is or replace them with the specified string, while maintaining the original row and column formatting; When the user does not specify the --replace-unknown option, the default original preservation strategy is used. When the user specifies the --replace-unknown option, the character replacement strategy is enabled, and all unknown characters are replaced with the string specified by the --replace-unknown-with parameter. Output of polyphonic characters: Based on the user-specified polyphonic character processing mode and format options, select the appropriate pinyin pronunciation and define three polyphonic character processing modes: The user specifies --polyphone all mode to return all pronunciations, --polyphone name mode to return the last name pronunciation first, and --polyphone noname mode to return the non-last name pronunciation first. The default mode is noname. Performs camelCase formatting, with the --camel option determining whether to perform camelCase formatting. Converts the first letter to uppercase, performs conversion, selection, and formatting on all characters in each line, and outputs to the standard output stream.

Images