Erlang 21

unicode




erlang

unicode

मॉड्यूल

यूनिकोड

मॉड्यूल सारांश

यूनिकोड वर्णों को परिवर्तित करने के लिए कार्य।

विवरण

इस मॉड्यूल में विभिन्न चरित्र अभ्यावेदन के बीच परिवर्तित करने के लिए कार्य शामिल हैं। यह आईएसओ लैटिन -1 वर्णों और यूनिकोड वर्णों के बीच परिवर्तित होता है, लेकिन यह विभिन्न यूनिकोड एनकोडिंग (जैसे UTF-8, UTF-16 और UTF-32) के बीच भी परिवर्तित हो सकता है।

Erlang में डिफ़ॉल्ट यूनिकोड एन्कोडिंग बायनेरिज़ UTF-8 में है, जो कि प्रारूप भी है जिसमें OTP में अंतर्निहित फ़ंक्शन और लाइब्रेरीज़ बाइनरी यूनिकोड डेटा को खोजने की उम्मीद करते हैं। सूचियों में, यूनिकोड डेटा को पूर्णांकों के रूप में एन्कोड किया गया है, प्रत्येक पूर्णांक एक वर्ण का प्रतिनिधित्व करता है और केवल चरित्र के लिए यूनिकोड कोड बिंदु के रूप में एन्कोड किया गया है।

द्विवार्षिक में कोड पॉइंट या UTF-8 का प्रतिनिधित्व करने वाले पूर्णांक की तुलना में अन्य यूनिकोड एनकोडिंग को "बाहरी एनकोडिंग" कहा जाता है। आईएसओ लैटिन -1 एन्कोडिंग बायनेरिज़ में है और सूची को लैटिन 1-एन्कोडिंग के रूप में जाना जाता है।

केवल बाहरी संस्थाओं के साथ संचार के लिए बाहरी एन्कोडिंग का उपयोग करने की सिफारिश की जाती है जहां यह आवश्यक है। Erlang / OTP पर्यावरण के अंदर काम करते समय, यूनिकोड वर्णों का प्रतिनिधित्व करते समय, UTF-8 में बायनेरिज़ को रखने की सिफारिश की जाती है। आईएसओ लैटिन -1 एन्कोडिंग पिछड़े संगतता के लिए और यूनिकोड वर्ण सेट का समर्थन नहीं करने वाली बाहरी संस्थाओं के साथ संचार के लिए समर्थित है।

कार्यक्रमों को हमेशा एक सामान्यीकृत रूप में संचालित करना चाहिए और विहित-समरूप यूनिकोड वर्णों की तुलना करना चाहिए। सिस्टम सीमाओं पर एक बार सभी वर्णों को एक रूप में सामान्य किया जाना चाहिए। निम्न कार्यों में से एक वर्णों को उनके सामान्यीकृत रूपों में परिवर्तित कर सकते हैं अक्षर_to_nfc_list characters_to_nfc_list/1 , characters_to_nfc_binary/1 , characters_to_nfd_list/1 या characters_to_nfd_binary/1 । सामान्य पाठ characters_to_nfc_list/1 लिए_ characters_to_nfc_list/1 या characters_to_nfc_binary/1 को प्राथमिकता दी जाती है, और पहचानकर्ताओं के लिए संगतता सामान्यीकरण कार्यों में से एक, जैसे कि characters_to_nfkc_list/1 को सुरक्षा कारणों से पसंद किया जाता है। सामान्यीकरण फ़ंक्शंस जहाँ ओटीपी 20 में पेश किया गया है। सामान्यीकरण पर अतिरिक्त जानकारी Unicode FAQ में पाई जा सकती है।

जानकारी का प्रकार

encoding() =
latin1 |
unicode |
utf8 |
utf16 |
{utf16, endian() } |
utf32 |
{utf32, endian() }

endian() = big | little
unicode_binary() = binary()

UTF-8 कोडिंग मानक में एन्कोडेड वर्णों के साथ एक binary()

charlist() =
maybe_improper_list(char() | unicode_binary() | charlist() ,
unicode_binary() | [])

external_unicode_binary() = binary()

यूटीएफ -8 (यानी, यूटीएफ -16 या यूटीएफ -32) के अलावा एक उपयोगकर्ता-निर्दिष्ट यूनिकोड एन्कोडिंग में कोडित binary() )।

external_charlist() =
maybe_improper_list(char() |
external_unicode_binary() |
external_charlist() ,
external_unicode_binary() | [])

latin1_binary() = binary()

आईएसओ लैटिन -1 में कोडित वर्णों के साथ एक binary()

latin1_char() = byte()

एक integer() एक वैध आईएसओ लैटिन -1 चरित्र (0-255) का प्रतिनिधित्व करता है।

iodata()

latin1_charlist() =
maybe_improper_list( latin1_char() |
latin1_binary() |
latin1_charlist() ,
latin1_binary() | [])

iolist() रूप में iolist()

निर्यात

बम_तो_कोडिंग (बिन) -> {एन्कोडिंग, लंबाई}

प्रकार

एक binary() ऐसा जो byte_size(Bin) >= 4

बाइनरी की शुरुआत में एक यूटीएफ बाइट ऑर्डर मार्क (बीओएम) के लिए चेक। यदि आपूर्ति की गई बाइनरी Bin UTF-8, UTF-16, या UTF-32 के लिए मान्य BOM से शुरू होती है, तो फ़ंक्शन बाइट में BOM लंबाई के साथ पहचाने गए एन्कोडिंग को वापस कर देता है।

यदि कोई BOM नहीं पाया जाता है, तो फ़ंक्शन {latin1,0} वापस {latin1,0}

characters_to_binary (डेटा) -> परिणाम

प्रकार

Character_to_binary characters_to_binary(Data, unicode, unicode)

characters_to_binary (डेटा, InEncoding) -> परिणाम

प्रकार

characters_to_binary(Data, InEncoding, unicode)

character_to_binary (डेटा, InEncoding, OutEncoding) -> परिणाम

प्रकार

अक्षर_to_list characters_to_list/2 रूप में व्यवहार करता है, लेकिन एक यूनिकोड सूची के बजाय एक बाइनरी पैदा करता है।

यदि बायनेरिज़ Data में मौजूद हैं, तो InEncoding परिभाषित करता है कि इनपुट की व्याख्या कैसे की जाए

OutEncoding परिभाषित करता है कि किस प्रारूप में आउटपुट उत्पन्न किया जाना है।

विकल्प:

unicode

utf8 लिए एक उपनाम, क्योंकि यह बायनेरिज़ में यूनिकोड वर्णों के लिए पसंदीदा एन्कोडिंग है।

utf16

{utf16,big} लिए एक उपनाम।

utf32

{utf32,big} लिए एक उपनाम।

परमाणु big और little बड़े-या छोटे-अंत वाले एन्कोडिंग को दर्शाते हैं।

त्रुटियों और अपवादों के रूप में होते हैं characters_to_list/2 , लेकिन टपल error या incomplete में दूसरा तत्व एक binary() और एक list()

characters_to_list (डेटा) -> परिणाम

प्रकार

Characters_to_list characters_to_list(Data, unicode)

character_to_list (डेटा, Incncoding) -> परिणाम

प्रकार

यूनिकोड वर्णों का प्रतिनिधित्व करने वाले पूर्णांकों की सूची में पूर्णांकों और बायनेरिज़ की संभवतः एक गहरी सूची को रूपांतरित करता है। इनपुट में बायनेरिज़ में निम्न में से एक के रूप में एन्कोड किए गए वर्ण हो सकते हैं:

  • आईएसओ लैटिन -1 (0-255, बाइट प्रति एक वर्ण)। यहां, केस पैरामीटर InEncoding को InEncoding रूप में निर्दिष्ट किया जाना है।

  • UTF- एन्कोडिंग में से एक, जो कि InEncoding पैरामीटर के रूप में निर्दिष्ट है।

ध्यान दें कि सूची में पूर्णांक हमेशा कोड बिंदुओं का प्रतिनिधित्व करते हैं, भले ही InEncoding पारित हो। यदि InEncoding latin1 पारित हो जाता है, तो केवल कोड बिंदु <256 की अनुमति है; अन्यथा, सभी मान्य यूनिकोड कोड बिंदुओं की अनुमति है।

यदि InEncoding है, तो पैरामीटर Data InEncoding iodata() प्रकार से मेल खाता है, लेकिन unicode , पैरामीटर Data में पूर्णांक> 255 (आईएसओ लैटिन -1 रेंज से परे यूनिकोड वर्ण) हो सकता है, जो इसे iodata() रूप में अमान्य बनाता है।

फ़ंक्शन का उद्देश्य मुख्य रूप से यूनिकोड वर्णों के संयोजन को आगे की प्रक्रिया के लिए सूची प्रतिनिधित्व में एक शुद्ध यूनिकोड स्ट्रिंग में परिवर्तित करना है। किसी बाहरी इकाई को डेटा लिखने के लिए, रिवर्स फंक्शन characters_to_binary/3 काम आता है।

विकल्प unicode utf8 लिए एक उपनाम है, क्योंकि यह बायनेरिज़ में यूनिकोड वर्णों के लिए पसंदीदा एन्कोडिंग है। utf16 {utf16,big} लिए एक उपनाम है और utf32 {utf32,big} लिए एक उपनाम है। परमाणु big और little बड़े-या छोटे-अंत वाले एन्कोडिंग को दर्शाते हैं।

यदि डेटा परिवर्तित नहीं किया जा सकता है, या तो सूची में अवैध यूनिकोड / आईएसओ लैटिन -1 वर्णों के कारण, या किसी भी बायनेरिज़ में अमान्य यूटीएफ एन्कोडिंग के कारण, एक त्रुटि ट्यूपल वापस आ जाता है। त्रुटि टपल में टैग error , वर्णों का प्रतिनिधित्व करने वाली एक सूची है जो त्रुटि होने से पहले परिवर्तित की जा सकती है और आक्रामक पूर्णांक / बाइट्स सहित और उसके बाद पात्रों का प्रतिनिधित्व करती है। अंतिम भाग ज्यादातर डिबगिंग के लिए है, क्योंकि यह अभी भी संभवतः गहरी या मिश्रित सूची का गठन करता है, या दोनों, मूल डेटा के समान गहराई की आवश्यकता नहीं है। त्रुटि तब होती है जब सूची को ट्रेस करना और जो कुछ भी डीकोड करना बाकी है उसे "जैसा है" वापस कर दिया जाता है।

हालाँकि, यदि इनपुट Data एक शुद्ध बाइनरी है, तो त्रुटि ट्यूपल का तीसरा भाग बाइनरी होने की गारंटी है।

निम्नलिखित कारणों से त्रुटियां होती हैं:

  • रेंजरों से बाहर।

    यदि InEncoding latin1 , तो एक त्रुटि तब होती है जब कोई पूर्णांक> 255 सूचियों में पाया जाता है।

    यदि InEncoding एक यूनिकोड प्रकार का है, तो जब भी निम्न में से कोई एक त्रुटि मिलती है:

    • एक पूर्णांक> 16 # 10FFFF (अधिकतम यूनिकोड वर्ण)

    • 16 # D800 से 16 # DFFF रेंज में एक पूर्णांक (UTF-16 सरोगेट जोड़े के लिए आरक्षित अमान्य श्रेणी)

  • गलत UTF एन्कोडिंग।

    यदि InEncoding UTF प्रकारों में से एक है, तो किसी भी बायनेरिज़ में बाइट्स उस एन्कोडिंग में मान्य होना चाहिए।

    निम्न सहित विभिन्न कारणों से त्रुटियां हो सकती हैं:

    • "शुद्ध" डिकोडिंग त्रुटियां (जैसे बाइट्स के ऊपरी बिट्स गलत हो रहे हैं)।

    • बाइट्स को बहुत बड़ी संख्या में डिकोड किया जाता है।

    • अमान्य यूनिकोड श्रेणी में बाइट्स को कोड बिंदु पर डिकोड किया जाता है।

    • एन्कोडिंग "अधिक लंबा" है, जिसका अर्थ है कि एक संख्या को कम बाइट्स में एन्कोड किया जाना चाहिए था।

    काटे गए UTF के मामले को विशेष रूप से नियंत्रित किया जाता है, नीचे दिए गए अधूरे बायनेरिज़ के बारे में पैराग्राफ देखें।

    यदि InEncoding है, तो बायनेरिज़ हमेशा तब तक मान्य होते हैं, जब तक वे पूरे बाइट्स नहीं होते हैं, क्योंकि प्रत्येक बाइट मान्य ISO लैटिन -1 श्रेणी में आता है।

एक विशेष प्रकार की त्रुटि तब होती है जब कोई वास्तविक अमान्य पूर्णांक या बाइट्स नहीं मिलते हैं, लेकिन अंतिम चरित्र को डीकोड करने के लिए एक अनुगामी binary() में बहुत कम बाइट्स होते हैं। यह त्रुटि तब हो सकती है यदि बाइट्स को किसी फ़ाइल से चंक्स में पढ़ा जाता है या यदि अन्य तरीकों से बायनेरिज़ को गैर-UTF वर्ण सीमाओं पर विभाजित किया जाता है। तब error ट्यूपल के बजाय एक incomplete टपल लौटाया जाता है। इसमें error ट्यूपल के समान भाग होते हैं, लेकिन टैग error बजाय incomplete और अंतिम तत्व को हमेशा (अब तक) मान्य UTF वर्ण के पहले भाग से मिलकर एक द्विआधारी होने की गारंटी है।

यदि कोई UTF वर्ण Data में दो लगातार बायनेरिज़ पर विभाजित होता है, तो रूपांतरण सफल होता है। इसका मतलब यह है कि एक चरित्र को बायनेरिज़ की श्रेणी से तब तक डिकोड किया जा सकता है जब तक कि पूरी रेंज त्रुटियों के बिना इनपुट के रूप में निर्दिष्ट हो।

उदाहरण:

decode_data(Data) ->
   case unicode:characters_to_list(Data,unicode) of
      {incomplete,Encoded, Rest} ->
            More = get_some_more_data(),
            Encoded ++ decode_data([Rest, More]);
      {error,Encoded,Rest} ->
            handle_error(Encoded,Rest);
      List ->
            List
   end.

हालाँकि, बिट स्ट्रिंग्स जो पूरे बाइट्स की अनुमति नहीं हैं, इसलिए UTF वर्ण को 8-बिट सीमाओं के साथ कभी भी विघटित किया जाना चाहिए।

एक badarg अपवाद निम्न मामलों के लिए फेंका गया है:

  • कोई भी पैरामीटर गलत प्रकार का है।
  • सूची संरचना अमान्य है (पूंछ के रूप में एक संख्या)।
  • बायनेरिज़ में पूरे बाइट्स (बिट स्ट्रिंग्स) नहीं होते हैं।
characters_to_nfc_list (CD :: chardata() ) ->
[चार ()] | {त्रुटि, [चार ()], chardata() }

यूनिकोड मानक के अनुसार विहित समतुल्य समान वर्णों के एक सामान्यीकृत रूप में वर्णों और बायनेरिज़ की संभवतः गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम वर्णों की एक सूची है।

3> unicode:characters_to_nfc_list([<<"abc..a">>,[778],$a,[776],$o,[776]]).
"abc..åäö"
character_to_nfc_binary (CD :: chardata() ) ->
unicode_binary() |
{त्रुटि, unicode_binary() , chardata() }

यूनिकोड मानक के अनुसार विहित समतुल्य समान वर्णों के एक सामान्यीकृत रूप में वर्णों और बायनेरिज़ की संभवतः गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम एक utf8 एन्कोडेड बाइनरी है।

4> unicode:characters_to_nfc_binary([<<"abc..a">>,[778],$a,[776],$o,[776]]).
<<"abc..åäö"/utf8>>
character_to_nfd_list (CD :: chardata() ) ->
[चार ()] | {त्रुटि, [चार ()], chardata() }

यूनिकोड मानक के अनुसार विहित समतुल्य विघटित वर्णों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की संभवतः गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम वर्णों की एक सूची है।

1> unicode:characters_to_nfd_list("abc..åäö").
[97,98,99,46,46,97,778,97,776,111,776]
characters_to_nfd_binary (CD :: chardata() ) ->
unicode_binary() |
{त्रुटि, unicode_binary() , chardata() }

यूनिकोड मानक के अनुसार विहित समतुल्य विघटित वर्णों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की संभवतः गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम एक utf8 एन्कोडेड बाइनरी है।

2> unicode:characters_to_nfd_binary("abc..åäö").
<<97,98,99,46,46,97,204,138,97,204,136,111,204,136>>
characters_to_nfkc_list (CD :: chardata() ) ->
[चार ()] |
{त्रुटि, [चार ()], chardata() }

संभवत: यूनिकोड मानक के अनुसार, समान रूप से समकक्ष संकलित पात्रों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की गहरी सूची को रूपांतरित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम वर्णों की एक सूची है।

3> unicode:characters_to_nfkc_list([<<"abc..a">>,[778],$a,[776],$o,[776],[65299,65298]]).
"abc..åäö32"
character_to_nfkc_binary (CD :: chardata() ) ->
unicode_binary() |
{त्रुटि, unicode_binary() , chardata() }

संभवत: यूनिकोड मानक के अनुसार, समान रूप से समकक्ष संकलित पात्रों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की गहरी सूची को रूपांतरित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम एक utf8 एन्कोडेड बाइनरी है।

4> unicode:characters_to_nfkc_binary([<<"abc..a">>,[778],$a,[776],$o,[776],[65299,65298]]).
<<"abc..åäö32"/utf8>>
characters_to_nfkd_list (CD :: chardata() ) ->
[चार ()] |
{त्रुटि, [चार ()], chardata() }

संभवत: यूनिकोड मानक के अनुसार वर्णनात्मक रूप से समतुल्य विघटित वर्णों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम वर्णों की एक सूची है।

1> unicode:characters_to_nfkd_list(["abc..åäö",[65299,65298]]).
[97,98,99,46,46,97,778,97,776,111,776,51,50]
character_to_nfkd_binary (CD :: chardata() ) ->
unicode_binary() |
{त्रुटि, unicode_binary() , chardata() }

संभवत: यूनिकोड मानक के अनुसार वर्णनात्मक रूप से समतुल्य विघटित वर्णों के एक सामान्यीकृत रूप में पात्रों और बायनेरिज़ की गहरी सूची में परिवर्तित करता है।

इनपुट में किसी भी बायनेरिज़ को utf8 एन्कोडिंग के साथ एन्कोड किया जाना चाहिए।

परिणाम एक utf8 एन्कोडेड बाइनरी है।

2> unicode:characters_to_nfkd_binary(["abc..åäö",[65299,65298]]).
<<97,98,99,46,46,97,204,138,97,204,136,111,204,136,51,50>>
एन्कोडिंग_टो_बॉम (इनकॉन्डिंग) -> बिन

प्रकार

एक binary() ऐसा जो byte_size(Bin) >= 4

आपूर्ति InEncoding गए InEncoding से बाइनरी के रूप में UTF बाइट ऑर्डर मार्क (BOM) InEncoding । BOM है, अगर सभी पर समर्थित है, उम्मीद है कि पहले UTF एन्कोडेड फ़ाइलों या संदेशों में रखा जाएगा।

फ़ंक्शन रिटर्न <<>> लैटिन 1 एन्कोडिंग के लिए, क्योंकि आईएसओ लैटिन -1 के लिए कोई बीओएम नहीं है।

ध्यान दें कि UTF-8 के लिए BOM शायद ही कभी इस्तेमाल किया गया हो, और यह वास्तव में बाइट ऑर्डर मार्क नहीं है। UTF-8 के साथ स्पष्ट रूप से कोई बाइट ऑर्डर के मुद्दे नहीं हैं, इसलिए BOM केवल UTF-8 को अन्य UTF स्वरूपों से अलग करने के लिए है।