perluniintro - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

perluniintro - पर्ल यूनिकोड परिचय

वर्णन

यह दस्तावेज़ यूनिकोड का एक सामान्य विचार देता है और पर्ल में यूनिकोड का उपयोग कैसे करें। देखना
यूनिकोड के अधिक गहन उपचारों के संदर्भ के लिए "आगे के संसाधन"।

यूनिकोड
यूनिकोड एक वर्ण सेट मानक है जो सभी लेखन प्रणालियों को संहिताबद्ध करने की योजना बनाता है
दुनिया, साथ ही कई अन्य प्रतीक।

यूनिकोड और आईएसओ/आईईसी 10646 समन्वित मानक हैं जो लगभग सभी अन्य आधुनिक को एकीकृत करते हैं
चरित्र निर्धारण मानक, जिसमें 80 से अधिक लेखन प्रणालियाँ और सैकड़ों भाषाएँ शामिल हैं,
इसमें सभी व्यावसायिक रूप से महत्वपूर्ण आधुनिक भाषाएँ शामिल हैं। सभी पात्र सबसे बड़े
चीनी, जापानी और कोरियाई शब्दकोश भी एन्कोडेड हैं। मानक अंततः होंगे
250 से अधिक लेखन प्रणालियों और हजारों भाषाओं में लगभग सभी पात्रों को कवर करें।
यूनिकोड 1.0 अक्टूबर 1991 में और 6.0 अक्टूबर 2010 में जारी किया गया था।

एक यूनिकोड चरित्र एक अमूर्त इकाई है. यह किसी विशेष पूर्णांक से बंधा नहीं है
चौड़ाई, विशेष रूप से सी भाषा "चार" के लिए नहीं। यूनिकोड भाषा-तटस्थ है और प्रदर्शन-
तटस्थ: यह पाठ की भाषा को एन्कोड नहीं करता है, और यह आम तौर पर परिभाषित नहीं करता है
फ़ॉन्ट या अन्य ग्राफिकल लेआउट विवरण। यूनिकोड वर्णों और निर्मित पाठ पर काम करता है
उन किरदारों से.

यूनिकोड "लैटिन कैपिटल लेटर ए" या "ग्रीक स्मॉल लेटर अल्फा" जैसे अक्षरों को परिभाषित करता है और
वर्णों के लिए अद्वितीय संख्याएँ, इस मामले में क्रमशः 0x0041 और 0x03B1। इन
यूनिक नंबर कहलाते हैं कोड अंक. एक कोड बिंदु अनिवार्य रूप से की स्थिति है
सभी संभावित यूनिकोड वर्णों के सेट के भीतर वर्ण, और इस प्रकार पर्ल में, शब्द
क्रमवाचक अक्सर इसके साथ पर्यायवाची रूप से प्रयोग किया जाता है।

यूनिकोड मानक कोड बिंदुओं के लिए हेक्साडेसिमल नोटेशन का उपयोग करना पसंद करता है। यदि संख्याएँ
जैसे 0x0041 आपके लिए अपरिचित हैं, बाद के अनुभाग, "हेक्साडेसिमल नोटेशन" पर एक नज़र डालें।
यूनिकोड मानक देने के लिए "U+0041 लैटिन कैपिटल लेटर ए" नोटेशन का उपयोग करता है
हेक्साडेसिमल कोड बिंदु और चरित्र का मानक नाम।

यूनिकोड भी विभिन्न को परिभाषित करता है गुण वर्णों के लिए, जैसे "अपरकेस" या
"लोअरकेस", "दशमलव अंक", या "विराम चिह्न"; ये गुण इससे स्वतंत्र हैं
पात्रों के नाम. इसके अलावा, पात्रों पर विभिन्न ऑपरेशन जैसे
अपरकेसिंग, लोअरकेसिंग और कोलेटिंग (सॉर्टिंग) को परिभाषित किया गया है।

एक यूनिकोड तार्किक "चरित्र" वास्तव में एक से अधिक आंतरिक तत्वों से मिलकर बना हो सकता है वास्तविक
"वर्ण" या कोड बिंदु. पश्चिमी भाषाओं के लिए, इसे पर्याप्त रूप से एक द्वारा प्रतिरूपित किया गया है आधार
चरित्र (जैसे "लैटिन कैपिटल लेटर ए") के बाद एक या अधिक संशोधक (पसंद
"तीव्र उच्चारण का संयोजन")। आधार वर्ण और संशोधक के इस अनुक्रम को a कहा जाता है
संयोजन चरित्र अनुक्रम. कुछ गैर-पश्चिमी भाषाओं को अधिक जटिल मॉडल की आवश्यकता होती है,
इसलिए यूनिकोड ने बनाया ग्रफीम समूह अवधारणा, जिसे बाद में और अधिक परिष्कृत किया गया
विस्तृत ग्रफीम समूह. उदाहरण के लिए, एक कोरियाई हंगुल शब्दांश को एकल माना जाता है
तार्किक चरित्र, लेकिन अक्सर इसमें तीन वास्तविक यूनिकोड वर्ण होते हैं: एक अग्रणी
व्यंजन के बाद आंतरिक स्वर और उसके बाद पिछला व्यंजन आता है।

इन विस्तारित ग्रेफेम समूहों को "अक्षर" कहना है या नहीं, यह आपके दृष्टिकोण पर निर्भर करता है
देखना। यदि आप एक प्रोग्रामर हैं, तो संभवतः आप प्रत्येक तत्व को देखने की ओर प्रवृत्त होंगे
एक इकाई, या "वर्ण" के रूप में अनुक्रम। हालाँकि, उपयोगकर्ता के दृष्टिकोण से, संपूर्ण
अनुक्रम को एक "वर्ण" के रूप में देखा जा सकता है क्योंकि संभवतः यह वैसा ही दिखता है
उपयोगकर्ता की भाषा का संदर्भ. इस दस्तावेज़ में, हम प्रोग्रामर का दृष्टिकोण लेते हैं:
एक "वर्ण" एक यूनिकोड कोड बिंदु है।

आधार चरित्र और संशोधक के कुछ संयोजनों के लिए, वहाँ हैं पूर्वनिर्मित अक्षर.
उदाहरण के लिए, अनुक्रम "लैटिन कैपिटल" के लिए एक एकल वर्ण समतुल्य है
अक्षर ए" के बाद "तीव्र उच्चारण का संयोजन" आता है। इसे "लैटिन कैपिटल अक्षर ए" कहा जाता है।
तीव्र के साथ"। हालाँकि, ये पूर्वनिर्मित वर्ण केवल कुछ के लिए ही उपलब्ध हैं
संयोजन, और मुख्य रूप से यूनिकोड और के बीच राउंड-ट्रिप रूपांतरणों का समर्थन करने के लिए हैं
विरासत मानक (जैसे आईएसओ 8859)। अनुक्रमों का उपयोग, जैसा कि यूनिकोड करता है, आवश्यकता को पूरा करने की अनुमति देता है
कई अधिक संभावित ग्रेफेम को व्यक्त करने के लिए कम बुनियादी बिल्डिंग ब्लॉक (कोड बिंदु)।
समूह. समतुल्य रूपों के बीच रूपांतरण का समर्थन करने के लिए, विभिन्न सामान्यीकरण रूपों रहे
परिभाषित भी किया गया. इस प्रकार, "लैटिन बड़े अक्षर ए तीव्र के साथ" में है मानकीकरण प्रपत्र
बना, (संक्षिप्त एनएफसी), और अनुक्रम "लैटिन कैपिटल लेटर ए" के बाद
"तीव्र उच्चारण का संयोजन" उसी चरित्र का प्रतिनिधित्व करता है मानकीकरण प्रपत्र विघटित
(एनएफडी)।

लीगेसी एन्कोडिंग के साथ पिछड़ी संगतता के कारण, "प्रत्येक के लिए एक अद्वितीय संख्या
चरित्र" का विचार थोड़ा टूट जाता है: इसके बजाय, "प्रत्येक के लिए कम से कम एक संख्या होती है
चरित्र"। एक ही चरित्र को कई विरासतों में अलग-अलग तरीके से दर्शाया जा सकता है
एन्कोडिंग। इसका विपरीत सत्य नहीं है: कुछ कोड बिंदुओं में कोई निर्दिष्ट वर्ण नहीं होता है।
सबसे पहले, अन्यथा उपयोग किए गए ब्लॉक के भीतर असंबद्ध कोड बिंदु हैं। दूसरी बात, वहाँ
विशेष यूनिकोड नियंत्रण वर्ण हैं जो वास्तविक वर्णों का प्रतिनिधित्व नहीं करते हैं।

जब पहली बार यूनिकोड की कल्पना की गई थी, तो यह सोचा गया था कि इसमें दुनिया के सभी अक्षर हो सकते हैं
16-बिट शब्द का उपयोग करके दर्शाया गया; यानी अधिकतम 0x10000 (या 65,536) वर्ण होंगे
0x0000 से 0xFFFF तक की आवश्यकता होगी। यह जल्द ही गलत साबित हुआ, और यूनिकोड 2.0 के बाद से
(जुलाई 1996), यूनिकोड को 21 बिट्स (0x10FFFF) तक परिभाषित किया गया है, और यूनिकोड
3.1 (मार्च 2001) ने 0xFFFF से ऊपर के पहले वर्णों को परिभाषित किया। पहले 0x10000 अक्षर
को कहा जाता है विमान 0या, बुनियादी बहुभाषी विमान (बीएमपी)। यूनिकोड 3.1, 17 के साथ (हाँ,
कुल मिलाकर सत्रह) तलों को परिभाषित किया गया था--लेकिन वे कहीं भी परिभाषित से पूर्ण नहीं हैं
पात्र, फिर भी।

जब एक नई भाषा को एन्कोड किया जा रहा है, तो यूनिकोड आम तौर पर "ब्लॉक" का चयन करेगा
इसके वर्णों के लिए लगातार असंबद्ध कोड बिंदु। अब तक, कोड बिंदुओं की संख्या
इन ब्लॉकों में हमेशा 16 से समान रूप से विभाज्य होता है। एक ब्लॉक में अतिरिक्त, वर्तमान में नहीं
भविष्य के विकास के लिए आवश्यक, आवंटित नहीं किया गया है। लेकिन ऐसे मौके भी आए हैं जब ए
बाद में रिलीज़ के लिए उपलब्ध अतिरिक्त की तुलना में अधिक कोड बिंदुओं की आवश्यकता थी, और एक नए ब्लॉक की आवश्यकता थी
अतिप्रवाह को संभालने के लिए, कहीं और आवंटित किया गया है, प्रारंभिक के निकट नहीं।
इस प्रकार, यह पहले ही स्पष्ट हो गया कि "ब्लॉक" एक पर्याप्त आयोजन प्रिंसिपल नहीं था,
और इस प्रकार "स्क्रिप्ट" संपत्ति बनाई गई। (बाद में एक बेहतर स्क्रिप्ट प्रॉपर्टी जोड़ी गई
ठीक है, "Script_Extensions" संपत्ति।) वे कोड बिंदु जो ओवरफ्लो ब्लॉक में हैं
इसमें अभी भी मूल स्क्रिप्ट जैसी ही स्क्रिप्ट हो सकती है। स्क्रिप्ट अवधारणा अधिक बारीकी से फिट बैठती है
प्राकृतिक भाषा के साथ: "लैटिन" लिपि, "ग्रीक" लिपि, इत्यादि है; और वहाँ है
कई कृत्रिम स्क्रिप्ट, जैसे पात्रों के लिए "सामान्य" जिनका उपयोग एकाधिक में किया जाता है
स्क्रिप्ट, जैसे गणितीय प्रतीक। लिपियाँ आमतौर पर अनेकों भागों में फैली होती हैं
ब्लॉक. स्क्रिप्ट के बारे में अधिक जानकारी के लिए, पर्लुनिकोड में "स्क्रिप्ट" देखें। प्रखंड
ब्लॉक मौजूद हैं, लेकिन यह लगभग पूरी तरह से आकस्मिक है - कैसे की एक कलाकृति
पात्रों का आवंटन किया गया है और अभी भी किया जा रहा है। (ध्यान दें कि इस अनुच्छेद में है
एक परिचय के तौर पर चीजों को अतिसरलीकृत किया गया। यूनिकोड वास्तव में नहीं है
भाषाओं को एन्कोड करें, लेकिन उनके लिए लेखन प्रणालियाँ--उनकी स्क्रिप्ट; और एक स्क्रिप्ट हो सकती है
कई भाषाओं द्वारा उपयोग किया जाता है। यूनिकोड उन चीजों को भी एनकोड करता है जो वास्तव में भाषाओं से संबंधित नहीं हैं,
जैसे कि "बैगेज क्लेम" जैसे प्रतीक।)

यूनिकोड कोड बिंदु केवल अमूर्त संख्याएँ हैं। इन सार को इनपुट और आउटपुट करने के लिए
संख्याएँ, संख्याएँ अवश्य होनी चाहिए इनकोडिंग or धारावाहिक किसी तरह। यूनिकोड कई को परिभाषित करता है
चरित्र एन्कोडिंग रूपों, जिनमें से UTF-8 सबसे लोकप्रिय है. UTF-8 एक परिवर्तनीय लंबाई है
एन्कोडिंग जो यूनिकोड वर्णों को 1 से 4 बाइट्स के रूप में एन्कोड करती है। अन्य एन्कोडिंग में UTF-16 शामिल है
और यूटीएफ-32 और उनके बड़े और छोटे-एंडियन वेरिएंट (यूटीएफ-8 बाइट-ऑर्डर स्वतंत्र है)।
आईएसओ/आईईसी 10646 यूसीएस-2 और यूसीएस-4 एन्कोडिंग फॉर्म को परिभाषित करता है।

एन्कोडिंग के बारे में अधिक जानकारी के लिए--उदाहरण के लिए, क्या जानने के लिए किराए की कोख और बाइट
आदेश निशान (बीओएम) हैं--परलुनिकोड देखें।

पर्ल के यूनिकोड सहायता
पर्ल v5.6.0 से शुरू करके, पर्ल में यूनिकोड को मूल रूप से संभालने की क्षमता है। पर्ल
हालाँकि, v5.8.0, गंभीर यूनिकोड कार्य के लिए पहली अनुशंसित रिलीज़ है।
रखरखाव रिलीज़ 5.6.1 ने प्रारंभिक यूनिकोड की कई समस्याओं को ठीक कर दिया
कार्यान्वयन, लेकिन उदाहरण के लिए रेगुलर एक्सप्रेशन अभी भी यूनिकोड के साथ काम नहीं करते हैं
5.6.1. पर्ल v5.14.0 पहली रिलीज़ है जहां यूनिकोड समर्थन (लगभग) निर्बाध रूप से है
कुछ गेट्चा के बिना एकीकृत (कोटमेटा में कुछ अंतर अपवाद है, और
यह पर्ल 5.16.0 में शुरू होने पर तय हो गया है)। इस निर्बाध समर्थन को सक्षम करने के लिए, आपको "उपयोग करना चाहिए
सुविधा 'यूनिकोड_स्ट्रिंग्स'" (यदि आप "5.012" या उच्चतर का उपयोग करते हैं तो यह स्वचालित रूप से चयनित हो जाती है)।
फ़ीचर देखें. (5.14 यूनिकोड मानक से कई बग और विचलन को भी ठीक करता है।)

पर्ल v5.8.0 से पहले, "यूज़ utf8" का उपयोग उस ऑपरेशन को घोषित करने के लिए किया जाता था
वर्तमान ब्लॉक या फ़ाइल यूनिकोड-जागरूक होगी। यह मॉडल ग़लत पाया गया, या पर
कम से कम अनाड़ी: "यूनिकोडनेस" अब डेटा से जुड़े होने के बजाय, उसके साथ ले जाया जाता है
परिचालन. पर्ल v5.8.0 से शुरू करके, केवल एक ही मामला बचा है जहां स्पष्ट "उपयोग" होता है
utf8" की आवश्यकता है: यदि आपकी पर्ल स्क्रिप्ट स्वयं UTF-8 में एन्कोडेड है, तो आप अपने में UTF-8 का उपयोग कर सकते हैं
पहचानकर्ता नाम, और स्ट्रिंग और नियमित अभिव्यक्ति शाब्दिक में, "utf8 का उपयोग करें" कहकर।
यह डिफ़ॉल्ट नहीं है क्योंकि लीगेसी 8-बिट डेटा वाली स्क्रिप्ट टूट जाएंगी। देखना
यूटीएफ8.

पर्ल के यूनिकोड आदर्श
पर्ल आठ-बिट देशी बाइट्स के प्री-5.6 स्ट्रिंग्स और यूनिकोड के दोनों स्ट्रिंग्स का समर्थन करता है
पात्र। सामान्य सिद्धांत यह है कि पर्ल अपने डेटा को आठ-बिट बाइट्स के रूप में रखने का प्रयास करता है
जब तक संभव हो, लेकिन जैसे ही यूनिकोडनेस को टाला नहीं जा सकता, डेटा है
पारदर्शी रूप से यूनिकोड में अपग्रेड किया गया। पर्ल v5.14.0 से पहले, अपग्रेड पूरी तरह से नहीं था
पारदर्शी (परलुनिकोड में "यूनिकोड बग" देखें), और पश्चगामी संगतता के लिए,
पूर्ण पारदर्शिता तब तक प्राप्त नहीं होती जब तक कि "सुविधा 'यूनिकोड_स्ट्रिंग्स' का उपयोग न करें" (सुविधा देखें) या
"5.012 का उपयोग करें" (या उच्चतर) चुना गया है।

आंतरिक रूप से, पर्ल वर्तमान में या तो मूल आठ-बिट वर्ण सेट का उपयोग करता है
प्लेटफ़ॉर्म (उदाहरण के लिए लैटिन-1), यूनिकोड स्ट्रिंग्स को एनकोड करने के लिए डिफ़ॉल्ट रूप से यूटीएफ-8 है।
विशेष रूप से, यदि स्ट्रिंग में सभी कोड बिंदु 0xFF या उससे कम हैं, तो पर्ल नेटिव का उपयोग करता है
आठ-बिट वर्ण सेट। अन्यथा, यह UTF-8 का उपयोग करता है।

पर्ल के उपयोगकर्ता को आम तौर पर यह जानने की आवश्यकता नहीं होती है और न ही इसकी परवाह होती है कि पर्ल इसे कैसे एन्कोड करता है
आंतरिक स्ट्रिंग्स, लेकिन यूनिकोड स्ट्रिंग्स को स्ट्रीम में आउटपुट करते समय यह प्रासंगिक हो जाता है
PerlIO परत के बिना ("डिफ़ॉल्ट" एन्कोडिंग वाला)। ऐसे में कच्ची बाइट्स
आंतरिक रूप से उपयोग किया जाएगा (मूल वर्ण सेट या यूटीएफ-8, प्रत्येक स्ट्रिंग के लिए उपयुक्त)।
उपयोग किया जाएगा, और यदि उन तारों में एक "व्यापक वर्ण" चेतावनी जारी की जाएगी
0x00FF से परे वर्ण.

उदाहरण के लिए,

perl -e 'प्रिंट "\x{DF}\n", "\x{0100}\x{DF}\n"'

देशी बाइट्स और यूटीएफ-8 का काफी बेकार मिश्रण तैयार करता है, साथ ही एक चेतावनी भी देता है:

प्रिंट में व्यापक चरित्र...

UTF-8 को आउटपुट करने के लिए, ":एन्कोडिंग" या ":utf8" आउटपुट लेयर का उपयोग करें। तैयारी

बिनमोड(STDOUT, ":utf8");

इस नमूना प्रोग्राम के लिए यह सुनिश्चित करता है कि आउटपुट पूरी तरह से UTF-8 है, और हटा देता है
कार्यक्रम की चेतावनी.

आप अपने मानक फ़ाइल हैंडल के स्वचालित यूटीएफ-8-इफिकेशन को सक्षम कर सकते हैं, डिफ़ॉल्ट "ओपन()"
परत, और @ARGV या तो "-C" कमांड लाइन स्विच या "PERL_UNICODE" का उपयोग करके
पर्यावरण चर, "-C" स्विच के दस्तावेज़ के लिए perlrun देखें।

ध्यान दें कि इसका मतलब यह है कि पर्ल अन्य सॉफ़्टवेयर से उसी तरह काम करने की अपेक्षा करता है: यदि पर्ल ने किया है
यह विश्वास दिलाया गया कि एसटीडीआईएन यूटीएफ-8 होना चाहिए, लेकिन फिर एसटीडीआईएन दूसरे से आ रहा है
कमांड UTF-8 नहीं है, पर्ल संभवतः विकृत UTF-8 के बारे में शिकायत करेगा।

यूनिकोड और I/O को संयोजित करने वाली सभी सुविधाओं के लिए भी नई PerlIO सुविधा का उपयोग करना आवश्यक है।
हालाँकि, लगभग सभी पर्ल 5.8 प्लेटफ़ॉर्म पर्लिओ का उपयोग करते हैं: आप देख सकते हैं कि आपका है या नहीं
"perl -V" चला रहे हैं और "useperlio=define" ढूंढ रहे हैं।

यूनिकोड और EBCDIC
पर्ल 5.8.0 ने ईबीसीडीआईसी प्लेटफॉर्म पर यूनिकोड के लिए समर्थन जोड़ा। इस समर्थन की अनुमति दी गई थी
बाद की रिलीज़ों में चूक हो गई, लेकिन 5.22 में इसे पुनर्जीवित कर दिया गया। यूनिकोड समर्थन कुछ अधिक है
इसे लागू करना जटिल है क्योंकि अतिरिक्त रूपांतरणों की आवश्यकता है। अधिक के लिए perlebcdic देखें
जानकारी.

EBCDIC प्लेटफॉर्म पर, आंतरिक यूनिकोड एन्कोडिंग फॉर्म UTF-8 के बजाय UTF-EBCDIC है।
अंतर यह है कि चूंकि UTF-8 "ASCII-सुरक्षित" है, इसलिए ASCII वर्ण UTF-8 में एन्कोड होते हैं
जैसा है, जबकि यूटीएफ-ईबीसीडीआईसी "ईबीसीडीआईसी-सुरक्षित" है, इसमें सभी मूल पात्र (जिसमें शामिल हैं)
वे सभी जिनमें ASCII समकक्ष हैं (जैसे "ए", "0", "%", इत्यादि) दोनों में समान हैं
ईबीसीडीआईसी और यूटीएफ-ईबीसीडीआईसी। अक्सर, दस्तावेज़ीकरण में UTF-EBCDIC के अर्थ में "UTF-8" शब्द का उपयोग किया जाएगा
भी। इस दस्तावेज़ में यही मामला है.

बनाना यूनिकोड
यह अनुभाग v5.22 से शुरू होने वाले पर्ल्स पर पूरी तरह से लागू होता है। पहले के लिए विभिन्न चेतावनियाँ
रिलीज़ नीचे "पूर्व रिलीज़ चेतावनियाँ" उपधारा में हैं।

शाब्दिक रूप से यूनिकोड वर्ण बनाने के लिए, दोहरे उद्धरण चिह्न में "\N{...}" नोटेशन का उपयोग करें
तार:

मेरा $smiley_from_name = "\N{सफ़ेद मुस्कुराता हुआ चेहरा}";
मेरा $smiley_from_code_point = "\N{U+263a}";

इसी तरह, उनका उपयोग नियमित अभिव्यक्ति शाब्दिक में भी किया जा सकता है

$स्माइली =~ /\N{सफ़ेद मुस्कुराता हुआ चेहरा}/;
$स्माइली =~ /\N{U+263a}/;

रन-टाइम पर आप इसका उपयोग कर सकते हैं:

वर्णनामों का उपयोग करें ();
मेरा $hebrew_alef_from_name
= charnames::string_vianame("हिब्रू अक्षर एलेफ़");
मेरा $hebrew_alef_from_code_point = charnames::string_vianame('U+05D0');

स्वाभाविक रूप से, "ord()" इसका उलटा करेगा: यह एक वर्ण को एक कोड बिंदु में बदल देता है।

अन्य रनटाइम विकल्प भी हैं। आप "पैक()" का उपयोग कर सकते हैं:

मेरा $hebrew_alef_from_code_point = पैक("U", 0x05d0);

या आप "chr()" का उपयोग कर सकते हैं, हालांकि सामान्य स्थिति में यह कम सुविधाजनक है:

$hebrew_alef_from_code_point = chr(utf8::यूनिकोड_टू_नेटिव(0x05d0));
utf8::upgrade($hebrew_alef_from_code_point);

यदि तर्क है तो "utf8::unicode_to_native()" और "utf8::upgrade()" की आवश्यकता नहीं है
0xFF से ऊपर, इसलिए उपरोक्त को इस प्रकार लिखा जा सकता था

$hebrew_alef_from_code_point = chr(0x05d0);

चूँकि 0x5d0 255 से ऊपर है।

"\x{}" और "\o{}" का उपयोग संकलन समय पर कोड बिंदुओं को डबल में निर्दिष्ट करने के लिए भी किया जा सकता है-
कोटिश स्ट्रिंग्स, लेकिन, पुराने पर्ल्स के साथ बैकवर्ड संगतता के लिए, वही नियम लागू होते हैं
256 से कम कोड बिंदुओं के लिए "chr()" के साथ।

"utf8::unicode_to_native()" का उपयोग किया जाता है ताकि पर्ल कोड EBCDIC प्लेटफ़ॉर्म पर पोर्टेबल हो।
यदि आप हैं तो आप इसे छोड़ सकते हैं वास्तव में निश्चित रूप से कोई भी कभी भी आपके कोड का उपयोग गैर-उपयोग करना नहीं चाहेगा-
ASCII मंच. पर्ल v5.22 से प्रारंभ करके, ASCII प्लेटफ़ॉर्म पर कॉल को अनुकूलित किया गया है,
इसलिए इसे जोड़ने पर कोई प्रदर्शन दंड नहीं है। या आप बस दूसरे का उपयोग कर सकते हैं
ऐसे निर्माण जिन्हें इसकी आवश्यकता नहीं है।

इन सभी नामों और संख्यात्मक कोडों को कैसे ढूंढें, इसके लिए "आगे के संसाधन" देखें।

पूर्व विज्ञप्ति चेतावनियां

EBCDIC प्लेटफ़ॉर्म पर, v5.22 से पहले, "\N{U+...}" का उपयोग ठीक से काम नहीं करता है।

v5.16 से पहले, एक वर्ण नाम के साथ "\N{...}" का उपयोग करना ("U+..." कोड बिंदु के विपरीत)
"charnames का उपयोग करें: पूर्ण" की आवश्यकता है।

v5.14 से पहले, "\N{...}" में एक अक्षर नाम के साथ कुछ बग थे (जैसा कि इसके विपरीत)
"U+..." कोड बिंदु)।

"charnames::string_vianame()" को v5.14 में पेश किया गया था। उसके पहले,
"charnames::vianame()" को काम करना चाहिए, लेकिन केवल तभी जब तर्क "U+..." फ़ॉर्म का हो। आपका
रनटाइम के लिए वर्ण नाम के अनुसार यूनिकोड के लिए सर्वोत्तम शर्त शायद यह है:

वर्णनामों का उपयोग करें ();
मेरा $hebrew_alef_from_name
= पैक("U", charnames::vianame("हिब्रू अक्षर एलेफ़"));

हैंडलिंग यूनिकोड
यूनिकोड को संभालना अधिकांशतः पारदर्शी है: बस हमेशा की तरह स्ट्रिंग्स का उपयोग करें।
"इंडेक्स()", "लेंथ()", और "सबस्ट्र()" जैसे फ़ंक्शन यूनिकोड वर्णों पर काम करेंगे;
रेगुलर एक्सप्रेशन यूनिकोड वर्णों पर काम करेंगे (देखें perlunicode और perlretut)।

ध्यान दें कि उदाहरण के लिए, पर्ल ग्रैफ़ेम क्लस्टर को अलग वर्ण मानता है

प्रिंट लंबाई ("\N{लैटिन बड़े अक्षर A}\N{तीव्र उच्चारण का संयोजन}"),
"\एन";

2 प्रिंट करेगा, 1 नहीं। एकमात्र अपवाद यह है कि रेगुलर एक्सप्रेशन में "\X" होता है
एक विस्तारित ग्रैफेम क्लस्टर से मेल खाता हुआ। (इस प्रकार नियमित अभिव्यक्ति में "\X" मेल खाएगा
दोनों उदाहरण वर्णों का संपूर्ण अनुक्रम।)

हालाँकि, जब विरासत एन्कोडिंग, I/O, और के साथ काम करते हैं तो जीवन इतना पारदर्शी नहीं होता है
कुछ विशेष मामले:

विरासत एन्कोडिंग
जब आप लीगेसी डेटा और यूनिकोड को जोड़ते हैं, तो लीगेसी डेटा को यूनिकोड में अपग्रेड करने की आवश्यकता होती है।
आम तौर पर विरासत डेटा को आईएसओ 8859-1 (या ईबीसीडीआईसी, यदि लागू हो) माना जाता है।

"एनकोड" मॉड्यूल कई एन्कोडिंग के बारे में जानता है और इसमें रूपांतरण करने के लिए इंटरफेस हैं
उन एन्कोडिंग के बीच:

एनकोड 'डिकोड' का उपयोग करें;
$डेटा = डीकोड('आईएसओ-8859-3', $डेटा); # लीगेसी से यूटीएफ-8 में कनवर्ट करें

यूनिकोड मैं / हे
आम तौर पर, यूनिकोड डेटा लिखना

एफएच प्रिंट करें $some_string_with_unicode, "\n";

कच्चे बाइट्स का उत्पादन करता है जिसका उपयोग पर्ल यूनिकोड स्ट्रिंग को आंतरिक रूप से एन्कोड करने के लिए करता है।
पर्ल की आंतरिक एन्कोडिंग सिस्टम के साथ-साथ इसमें मौजूद वर्णों पर भी निर्भर करती है
उस समय स्ट्रिंग. यदि कोई भी वर्ण कोड बिंदु 0x100 या उससे ऊपर पर है, तो आप
चेतावनी मिलेगी. यह सुनिश्चित करने के लिए कि आउटपुट आपके एन्कोडिंग में स्पष्ट रूप से प्रस्तुत किया गया है
इच्छा--और चेतावनी से बचने के लिए--वांछित एन्कोडिंग के साथ स्ट्रीम खोलें। कुछ
उदाहरण:

FH खोलें, ">:utf8", "फ़ाइल";

FH खोलें, ">:एन्कोडिंग(ucs2)", "फ़ाइल";
FH खोलें, ">:एन्कोडिंग(UTF-8)", "फ़ाइल";
FH खोलें, ">:एन्कोडिंग(shift_jis)", "फ़ाइल";

और पहले से खुली स्ट्रीम पर, "बिनमोड()" का उपयोग करें:

बिनमोड(STDOUT, ":utf8");

बिनमोड(STDOUT, ":एन्कोडिंग(ucs2)");
बिनमोड(STDOUT, ":एन्कोडिंग(UTF-8)");
बिनमोड(STDOUT, ":एन्कोडिंग(shift_jis)");

एन्कोडिंग नामों का मिलान ढीला है: मामला कोई मायने नहीं रखता, और कई एन्कोडिंग में होता है
कई उपनाम. ध्यान दें कि ":utf8" परत को हमेशा ठीक उसी प्रकार निर्दिष्ट किया जाना चाहिए;
यह नहीं एन्कोडिंग नामों के ढीले मिलान के अधीन। यह भी ध्यान रखें कि वर्तमान में
":utf8" इनपुट के लिए असुरक्षित है, क्योंकि यह डेटा को सत्यापित किए बिना स्वीकार करता है कि यह सही है
वास्तव में वैध यूटीएफ-8; आपको इसके बजाय ":encoding(utf-8)" (हाइफ़न के साथ या उसके बिना) का उपयोग करना चाहिए।

":utf8" परत के लिए PerlIO, PerlIO::एन्कोडिंग और Encode::PerlIO देखें।
":एनकोडिंग()" परत, और एनकोड::"एनकोड" द्वारा समर्थित कई एन्कोडिंग के लिए समर्थित
मॉड्यूल।

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

खुला(मेरा $fh,'<:एन्कोडिंग(utf8)', 'कुछ भी');
मेरा $line_of_unicode = <$fh>;

खुला(मेरा $fh,'<:एन्कोडिंग(बिग5)', 'कुछ भी');
मेरा $line_of_unicode = <$fh>;

I/O परतों को "खुले" प्राग्मा के साथ अधिक लचीले ढंग से निर्दिष्ट किया जा सकता है। खुला देखें, या
निम्नलिखित उदाहरण देखें.

खुले ':एन्कोडिंग(utf8)' का उपयोग करें; # इनपुट/आउटपुट डिफ़ॉल्ट एन्कोडिंग होगी
# यूटीएफ-8
X खोलें, ">फ़ाइल";
एक्स प्रिंट करें chr(0x100), "\n";
एक्स बंद करें;
Y खोलें, "
प्रिंटफ "%#x\n", ऑर्ड( ); # इसे 0x100 प्रिंट करना चाहिए
Y बंद करें;

"ओपन" प्राग्मा के साथ आप ":लोकेल" परत का उपयोग कर सकते हैं

आरंभ { $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R' }
# :locale जैसे स्थानीय पर्यावरण चर की जांच करेगा
#एलसी_ऑल
open OUT => ':locale' का उपयोग करें; # रस्की पारुस्की
खुला(O, ">koi8");
ओ प्रिंट करें chr(0x430); # यूनिकोड सिरिलिक लघु अक्षर A = KOI8-R 0xc1
बंद करें हे;
खुला(मैं, "
प्रिंटफ "%#x\n", ord( ), "\n"; # इसे 0xc1 प्रिंट करना चाहिए
बंद करो मैं;

ये विधियाँ I/O स्ट्रीम पर एक पारदर्शी फ़िल्टर स्थापित करती हैं जो डेटा को परिवर्तित करता है
जब इसे स्ट्रीम से पढ़ा जाता है तो निर्दिष्ट एन्कोडिंग। परिणाम हमेशा यूनिकोड होता है.

ओपन प्राग्मा डिफॉल्ट लेयर्स सेट करके प्राग्मा के बाद सभी "ओपन ()" कॉल को प्रभावित करता है।
यदि आप केवल कुछ धाराओं को प्रभावित करना चाहते हैं, तो सीधे "ओपन()" में स्पष्ट परतों का उपयोग करें
पु का र ना।

आप "binmode()" का उपयोग करके पहले से खोले गए स्ट्रीम पर एन्कोडिंग स्विच कर सकते हैं; "बिनमोड" देखें
पर्लफंक में.

":लोकेल" वर्तमान में "ओपन()" और "बिनमोड()" के साथ काम नहीं करता है, केवल "ओपन" के साथ
प्रागमा. ":utf8" और ":encoding(...)" विधियां सभी "ओपन()" के साथ काम करती हैं।
"बिनमोड()", और "ओपन" प्राग्मा।

इसी तरह, आप यूनिकोड को स्वचालित रूप से परिवर्तित करने के लिए आउटपुट स्ट्रीम पर इन I/O परतों का उपयोग कर सकते हैं
जब यह स्ट्रीम पर लिखा जाता है तो निर्दिष्ट एन्कोडिंग के लिए। उदाहरण के लिए, निम्नलिखित
स्निपेट फ़ाइल "text.jis" (ISO-2022-JP, उर्फ ​​JIS के रूप में एन्कोडेड) की सामग्री को कॉपी करता है
फ़ाइल "text.utf8", जिसे UTF-8 के रूप में एन्कोड किया गया है:

खुला(मेरा $nihongo, '<:encoding(iso-2022-jp)', 'text.jis');
खुला(मेरा $यूनिकोड, '>:utf8', 'text.utf8');
जबकि (<$nihongo>) {प्रिंट $यूनिकोड $_ }

एन्कोडिंग का नामकरण, "ओपन()" और "ओपन" प्रैग्मा दोनों द्वारा लचीलेपन की अनुमति देता है
नाम: "koi8-r" और "KOI8R" दोनों समझे जाएंगे।

आईएसओ, एमआईएमई, आईएएनए और विभिन्न अन्य मानकीकरण द्वारा मान्यता प्राप्त सामान्य एन्कोडिंग
संगठन मान्यता प्राप्त हैं; अधिक विस्तृत सूची के लिए एनकोड::समर्थित देखें।

"read()" वर्णों को पढ़ता है और वर्णों की संख्या लौटाता है। "खोज()" और "बताओ()"
बाइट गिनती पर काम करें, जैसा कि "sysread()" और "sysseek()" करते हैं।

ध्यान दें कि इनपुट पर कोई रूपांतरण न करने के डिफ़ॉल्ट व्यवहार के कारण यदि
कोई डिफ़ॉल्ट परत नहीं है, गलती से कोड लिखना आसान है जो विस्तार करता रहता है
डेटा को बार-बार एन्कोड करके फ़ाइल करें:

# ख़राब कोड चेतावनी
एफ खोलें, "फ़ाइल";
स्थानीय $/; ## 8-बिट वर्णों की संपूर्ण फ़ाइल पढ़ें
$t= ;
एफ बंद करें;
खुला एफ, ">:एन्कोडिंग(utf8)", "फ़ाइल";
एफ$टी प्रिंट करें; ## आउटपुट पर UTF-8 में कनवर्ट करें
एफ बंद करें;

यदि आप इस कोड को दो बार चलाते हैं, तो इसकी सामग्री पट्टिका दो बार UTF-8 एन्कोड किया जाएगा। एक "उपयोग
open ':encoding(utf8)'" से बग से बचा जा सकता था, या स्पष्ट रूप से खोलने से भी पट्टिका
UTF-8 के रूप में इनपुट के लिए।

ध्यान दें: ":utf8" और ":encoding" सुविधाएं केवल तभी काम करती हैं जब आपका पर्ल इसके साथ बनाया गया हो
PerlIO, जो अधिकांश सिस्टम पर डिफ़ॉल्ट है।

प्रदर्शित यूनिकोड As टेक्स्ट
कभी-कभी आप यूनिकोड वाले पर्ल स्केलर्स को सरल ASCII (या) के रूप में प्रदर्शित करना चाह सकते हैं
ईबीसीडीआईसी) पाठ। निम्नलिखित सबरूटीन अपने तर्क को इस प्रकार परिवर्तित करता है कि यूनिकोड वर्ण
255 से अधिक कोड बिंदुओं को "\x{...}", नियंत्रण वर्ण (जैसे) के रूप में प्रदर्शित किया जाता है
"\n") को "\x.." के रूप में प्रदर्शित किया जाता है, और शेष वर्णों को स्वयं के रूप में प्रदर्शित किया जाता है:

उप नाइस_स्ट्रिंग {
जोड़ना("",
मानचित्र { $_ > 255 # यदि विस्तृत वर्ण...
? स्प्रिंटफ़("\\x{%04X}", $_) # \x{...}
: chr($_) =~ /[[:cntrl:]]/ # अन्यथा यदि नियंत्रण वर्ण...
? स्प्रिंटफ़("\\x%02X", $_) # \x..
: quotemeta(chr($_)) # अन्यथा उद्धृत या स्वयं के रूप में
} अनपैक("W*", $_[0])); # यूनिकोड वर्णों को अनपैक करें
}

उदाहरण के लिए,

Nice_string("foo\x{100}bar\n")

स्ट्रिंग लौटाता है

'फू\x{0100}बार\x0A'

जो छपने के लिए तैयार है.

("\\N{}" के बजाय यहां "\\x{}" का उपयोग किया गया है, क्योंकि यह सबसे अधिक संभावना है कि आप यह देखना चाहते हैं कि क्या
मूल मूल्य हैं।)

विशिष्ट केसेस
· बिट पूरक ऑपरेटर ~ और वीईसी ()

यदि स्ट्रिंग्स पर उपयोग किया जाए तो बिट पूरक ऑपरेटर "~" आश्चर्यजनक परिणाम दे सकता है
255 से ऊपर क्रमिक मान वाले वर्ण युक्त। ऐसे मामले में, परिणाम हैं
वर्णों की आंतरिक एन्कोडिंग के अनुरूप, लेकिन बहुत कुछ के साथ नहीं। इसलिए
ऐसा मत करो. इसी तरह "vec()" के लिए: आप आंतरिक रूप से एन्कोडेड पर काम करेंगे
यूनिकोड वर्णों के बिट पैटर्न, कोड बिंदु मानों पर नहीं, जो बहुत है
संभवतः वह नहीं जो आप चाहते हैं।

· पर्ल की आंतरिक एन्कोडिंग पर नज़र डालना

पर्ल के सामान्य उपयोगकर्ताओं को कभी भी इस बात की परवाह नहीं करनी चाहिए कि पर्ल किसी विशेष यूनिकोड स्ट्रिंग को कैसे एनकोड करता है
(क्योंकि यूनिकोड के साथ एक स्ट्रिंग की सामग्री प्राप्त करने के सामान्य तरीके - इनपुट के माध्यम से
और आउटपुट--हमेशा स्पष्ट रूप से परिभाषित I/O परतों के माध्यम से होना चाहिए)। लेकिन यदि आपको अवश्य ही,
पर्दे के पीछे देखने के दो तरीके हैं।

यूनिकोड वर्णों की आंतरिक एन्कोडिंग के अंदर झाँकने का एक तरीका उपयोग करना है
जो भी स्ट्रिंग एन्कोडिंग होती है उसके बाइट्स प्राप्त करने के लिए "अनपैक करें ("सी*", ..." या
UTF-0 एन्कोडिंग के बाइट्स प्राप्त करने के लिए "अनपैक करें ("U8..", ...)":

# यह UTF-4 बाइट्स 80xc8 0x4 के लिए c0 80 प्रिंट करता है
प्रिंट जॉइन(" ", अनपैक("U0(H2)*", पैक("U", 0x100))), "\n";

फिर भी दूसरा तरीका डेवेल::पीक मॉड्यूल का उपयोग करना होगा:

पर्ल -एमडेवेल::पीक -ई 'डंप(chr(0x100))'

यह FLAGS में "UTF8" ध्वज और UTF-8 बाइट्स और यूनिकोड वर्ण दोनों दिखाता है
"पीवी"। इस दस्तावेज़ में बाद में "utf8::is_utf8()" के बारे में चर्चा भी देखें
समारोह.

उन्नत विषय
· स्ट्रिंग तुल्यता

यूनिकोड में स्ट्रिंग तुल्यता का प्रश्न कुछ हद तक जटिल हो जाता है: आप क्या करते हैं
"बराबर" से मतलब?

(क्या "तीव्र के साथ लैटिन बड़े अक्षर ए" "लैटिन बड़े अक्षर ए" के बराबर है?)

संक्षिप्त उत्तर यह है कि डिफ़ॉल्ट रूप से पर्ल केवल तुल्यता ("eq", "ne") के आधार पर तुलना करता है
पात्रों के कोड बिंदुओं पर. उपरोक्त मामले में, उत्तर नहीं है (क्योंकि 0x00C1
!= 0x0041). लेकिन कभी-कभी, किसी भी बड़े अक्षर A को बराबर या सम माना जाना चाहिए
किसी भी मामले का ए.

लंबा उत्तर यह है कि आपको चरित्र सामान्यीकरण और आवरण पर विचार करने की आवश्यकता है
मुद्दे: यूनिकोड::सामान्यीकरण, यूनिकोड तकनीकी रिपोर्ट #15, यूनिकोड सामान्यीकरण देखें
फार्मhttp://www.unicode.org/unicode/reports/tr15> और केस मैपिंग पर अनुभाग
यूनिकोड मानकhttp://www.unicode.org>.

पर्ल 5.8.0 के अनुसार, "पूर्ण" केस-फोल्डिंग मामला मैपिंग/विशेष आवरण is
कार्यान्वित किया गया, लेकिन बग उनके साथ "qr//i" में बने रहे, अधिकतर 5.14 द्वारा ठीक कर दिए गए, और
अनिवार्य रूप से पूरी तरह से 5.18 तक।

· स्ट्रिंग संयोजन

लोग अपनी स्ट्रिंग्स को अच्छी तरह से क्रमबद्ध देखना पसंद करते हैं - या जैसा कि यूनिकोड की भाषा में कहा जाता है, उन्हें एकत्रित किया हुआ।
लेकिन फिर, मिलान से आपका क्या मतलब है?

(क्या "तीव्र के साथ लैटिन कैपिटल लेटर ए" "लैटिन कैपिटल लेटर ए" से पहले या बाद में आता है?
कब्र के साथ"?)

संक्षिप्त उत्तर यह है कि डिफ़ॉल्ट रूप से, पर्ल स्ट्रिंग्स की तुलना करता है ("lt", "le", "cmp", "ge",
"gt") केवल वर्णों के कोड बिंदुओं पर आधारित है। उपरोक्त मामले में, उत्तर
0x00C1 > 0x00C0 के बाद से "बाद" है।

लंबा उत्तर यह है कि "यह निर्भर करता है", और इसके बिना एक अच्छा उत्तर नहीं दिया जा सकता
(कम से कम) भाषा के संदर्भ को जानना। यूनिकोड::कोलेट, और देखें यूनिकोड
मिलान कलन विधि <http://www.unicode.org/unicode/reports/tr10/>

कई तरह का
· चरित्र श्रेणियाँ और वर्ग

रेगुलर एक्सप्रेशन ब्रैकेटेड वर्ण वर्गों में वर्ण श्रेणियाँ (उदाहरण के लिए, "/[az]/")
और "tr///" (जिसे "y///" के रूप में भी जाना जाता है) ऑपरेटर जादुई रूप से यूनिकोड-जागरूक नहीं हैं।
इसका मतलब यह है कि "[ए-ज़ा-ज़]" का जादुई अर्थ "सभी वर्णानुक्रमिक" नहीं होगा
अक्षर" (ऐसा नहीं है कि इसका मतलब यह है कि 8-बिट वर्णों के लिए भी; उनके लिए, यदि आप हैं
लोकेशंस (परलोकेल) का उपयोग करते हुए, "/[[:alpha:]]/" का उपयोग करें; और यदि नहीं, तो 8-बिट-अवेयर का उपयोग करें
संपत्ति "\p{अल्फा}").

वे सभी गुण जो "\p" (और इसका उलटा "\P") से शुरू होते हैं, वास्तव में वर्ण हैं
वे कक्षाएँ जो यूनिकोड से अवगत हैं। उनमें से दर्जनों हैं, पेरलुनिप्रॉप्स देखें।

v5.22 से प्रारंभ करके, आप यूनिकोड कोड बिंदुओं को नियमित के अंतिम बिंदुओं के रूप में उपयोग कर सकते हैं
अभिव्यक्ति पैटर्न वर्ण श्रेणियाँ, और श्रेणी में सभी यूनिकोड कोड शामिल होंगे
वे बिंदु जो उन अंतिम बिंदुओं के बीच स्थित हैं, सम्मिलित हैं।

qr/ [\N{U+03]-\N{U+20}] /x

कोड बिंदु "\N{U+03}", "\N{U+04}", ..., "\N{U+20}" शामिल हैं।

(पर्ल v5.24 में इस व्यवहार को "tr///" की सीमा तक विस्तारित करने की योजना बनाई गई है।)

· स्ट्रिंग-टू-नंबर रूपांतरण

यूनिकोड इसके अलावा कई अन्य दशमलव--और संख्यात्मक--वर्णों को परिभाषित करता है
परिचित 0 से 9, जैसे अरबी और इंडिक अंक। पर्ल स्ट्रिंग का समर्थन नहीं करता-
ASCII 0 से 9 के अलावा अन्य अंकों के लिए टू-नंबर रूपांतरण (और ASCII "a" से "f" के लिए
हेक्साडेसिमल)। किसी भी यूनिकोड स्ट्रिंग से सुरक्षित रूपांतरण प्राप्त करने के लिए, "का उपयोग करेंसंख्या()"में
यूनिकोड :: यूसीडी।

प्रशन - जवाब
· क्या मेरी पुरानी स्क्रिप्ट टूट जाएंगी?

बहुत संभवतः नहीं. जब तक आप किसी तरह यूनिकोड वर्ण उत्पन्न नहीं कर रहे हों, पुराना
व्यवहार को संरक्षित किया जाना चाहिए. एकमात्र व्यवहार के बारे में जो बदल गया है और जो
यूनिकोड उत्पन्न करना शुरू कर सकता है यह "chr()" का पुराना व्यवहार है जहां आपूर्ति की जाती है
255 से अधिक तर्क ने एक वर्ण मोडुलो 255 उत्पन्न किया।chr(300)", उदाहरण के लिए, था
के बराबर "chr(45)" या "-" (ASCII में), अब यह ब्रेव के साथ लैटिन कैपिटल लेटर I है।

· मैं अपनी स्क्रिप्ट को यूनिकोड के साथ कैसे काम करूँ?

बहुत कम काम की आवश्यकता होनी चाहिए क्योंकि जब तक आप यूनिकोड उत्पन्न नहीं करते तब तक कुछ भी नहीं बदलता है
डेटा। सबसे महत्वपूर्ण बात यूनिकोड के रूप में इनपुट प्राप्त करना है; उसके लिए, पहले देखें
आई/ओ चर्चा. पूर्ण निर्बाध यूनिकोड समर्थन प्राप्त करने के लिए, "उपयोग सुविधा" जोड़ें
अपनी स्क्रिप्ट में 'unicode_strings'" (या "5.012" या उच्चतर का उपयोग करें)।

· मुझे कैसे पता चलेगा कि मेरी स्ट्रिंग यूनिकोड में है या नहीं?

आपको परवाह नहीं करनी चाहिए. लेकिन यदि आपका पर्ल 5.14.0 से पहले का है या आपने नहीं किया है तो आप ऐसा कर सकते हैं
निर्दिष्ट "सुविधा 'यूनिकोड_स्ट्रिंग्स' का उपयोग करें" या "5.012 का उपयोग करें" (या उच्चतर) क्योंकि अन्यथा
128 से 255 की सीमा में कोड बिंदुओं के नियम अलग-अलग हैं
क्या वे जिस स्ट्रिंग में शामिल हैं वह यूनिकोड में है या नहीं। (देखें "जब यूनिकोड
ऐसा नहीं होता" पर्लुनिकोड में।)

यह निर्धारित करने के लिए कि कोई स्ट्रिंग यूनिकोड में है या नहीं, इसका उपयोग करें:

प्रिंट utf8::is_utf8($string)? 1 : 0, "\n";

लेकिन ध्यान दें कि इसका मतलब यह नहीं है कि स्ट्रिंग में कोई भी अक्षर आवश्यक है
यूटीएफ-8 एन्कोडेड, या किसी भी वर्ण के कोड बिंदु 0xFF (255) से अधिक हैं
या यहां तक ​​कि 0x80 (128), या स्ट्रिंग में कोई भी अक्षर है। सभी "is_utf8()"
$स्ट्रिंग से जुड़े आंतरिक "utf8ness" ध्वज का मान वापस करना है।
यदि ध्वज बंद है, तो स्केलर में बाइट्स को एकल बाइट एन्कोडिंग के रूप में समझा जाता है।
यदि झंडा चालू है, तो अदिश में बाइट्स की व्याख्या (चर-लंबाई,
संभावित रूप से बहु-बाइट) वर्णों के यूटीएफ-8 एन्कोडेड कोड बिंदु। बाइट्स को a में जोड़ा गया
UTF-8 एन्कोडेड स्ट्रिंग स्वचालित रूप से UTF-8 में अपग्रेड हो जाती है। यदि गैर-UTF-8 और मिलाया जाए
UTF-8 स्केलर को मर्ज किया गया है (डबल-कोटेड इंटरपोलेशन, स्पष्ट संयोजन, या
printf/sprintf पैरामीटर प्रतिस्थापन), परिणाम प्रतियों की तरह UTF-8 एन्कोडेड होगा
बाइट स्ट्रिंग्स को UTF-8 में अपग्रेड किया गया: उदाहरण के लिए,

$a = "ab\x80c";
$b = "\x{100}";
प्रिंट करें "$a = $b\n";

आउटपुट स्ट्रिंग UTF-8-एनकोडेड "ab\x80c = \x{100}\n" होगी, लेकिन $a बाइट रहेगा-
एन्कोडेड।

कभी-कभी आपको वास्तव में इसके बजाय स्ट्रिंग की बाइट लंबाई जानने की आवश्यकता हो सकती है
चरित्र की लंबाई. इसके लिए या तो "Encode::encode_utf8()" फ़ंक्शन या का उपयोग करें
"बाइट्स" प्राग्मा और "लंबाई ()" फ़ंक्शन:

मेरा $यूनिकोड= chr(0x100);
प्रिंट लंबाई($यूनिकोड), "\n"; # 1 प्रिंट करेगा
एन्कोड की आवश्यकता है;
प्रिंट लंबाई(Encode::encode_utf8($unicode)),"\n"; #2 प्रिंट करेगा
बाइट्स का उपयोग करें;
प्रिंट लंबाई($यूनिकोड), "\n"; #2 भी छापेंगे
# (UTF-0 का 4xC0 80x8)
कोई बाइट्स नहीं;

· मैं कैसे पता लगा सकता हूं कि फ़ाइल में कौन सी एन्कोडिंग है?

आप Encode::Guess आज़मा सकते हैं, लेकिन इसकी कई सीमाएँ हैं।

· मैं उस डेटा का कैसे पता लगा सकता हूं जो किसी विशेष एन्कोडिंग में मान्य नहीं है?

इसे परिवर्तित करने का प्रयास करने के लिए "एनकोड" पैकेज का उपयोग करें। उदाहरण के लिए,

एनकोड 'decode_utf8' का उपयोग करें;

यदि (eval { decode_utf8($string, Encode::FB_CROAK); 1 }) {
# $string मान्य utf8 है
और} {
# $string मान्य utf8 नहीं है
}

या इसे डिकोड करने का प्रयास करने के लिए "अनपैक" का उपयोग करें:

चेतावनी का उपयोग करें;
@chars = unpack("C0U*", $string_of_bytes_that_I_think_is_utf8);

यदि अमान्य है, तो "विकृत UTF-8 वर्ण" चेतावनी उत्पन्न होती है। "C0" का अर्थ है "प्रक्रिया।"
प्रति वर्ण स्ट्रिंग वर्ण"। इसके बिना, "अनपैक("U*", ...)" काम करेगा
"U0" मोड में (यदि प्रारूप स्ट्रिंग "U" से शुरू होती है तो डिफ़ॉल्ट) और यह वापस आ जाएगा
लक्ष्य स्ट्रिंग की UTF-8 एन्कोडिंग बनाने वाले बाइट्स, कुछ ऐसा करेंगे
हर समय काम।

· मैं बाइनरी डेटा को एक विशेष एन्कोडिंग में कैसे परिवर्तित करूं, या इसके विपरीत?

यह संभवतः उतना उपयोगी नहीं है जितना आप सोच सकते हैं। सामान्यतः, आपको इसकी आवश्यकता नहीं होनी चाहिए।

एक अर्थ में, आप जो पूछ रहे हैं उसका कोई खास मतलब नहीं है: एन्कोडिंग के लिए हैं
वर्ण, और बाइनरी डेटा "अक्षर" नहीं हैं, इसलिए "डेटा" को कुछ में परिवर्तित करना
एन्कोडिंग तब तक सार्थक नहीं है जब तक आप यह नहीं जानते कि कौन सा कैरेक्टर सेट और एन्कोडिंग है
बाइनरी डेटा है, इस मामले में यह सिर्फ बाइनरी डेटा नहीं है, अब क्या ऐसा है?

यदि आपके पास बाइट्स का एक कच्चा अनुक्रम है जिसे आप जानते हैं तो इसकी व्याख्या a के माध्यम से की जानी चाहिए
विशेष एन्कोडिंग, आप "एनकोड" का उपयोग कर सकते हैं:

एनकोड 'from_to' का उपयोग करें;
from_to($डेटा, "आइसो-8859-1", "utf-8"); # लैटिन-1 से यूटीएफ-8 तक

"from_to()" पर कॉल करने से $data में बाइट्स बदल जाते हैं, लेकिन इसके बारे में कुछ भी महत्वपूर्ण नहीं
जहां तक ​​पर्ल का सवाल है, स्ट्रिंग की प्रकृति बदल गई है। पहले भी और बाद में भी
कॉल, स्ट्रिंग $data में केवल 8-बिट बाइट्स का एक समूह होता है। जहां तक ​​पर्ल है
चिंतित, स्ट्रिंग का एन्कोडिंग "सिस्टम-मूल 8-बिट बाइट्स" के रूप में रहता है।

आप इसे एक काल्पनिक 'अनुवाद' मॉड्यूल से जोड़ सकते हैं:

अनुवाद का उपयोग;
मेरा $वाक्यांश = "हाँ";
अनुवाद::from_to($phrase, 'english', 'deutsch');
## वाक्यांश में अब "जा" शामिल है

स्ट्रिंग की सामग्री बदलती है, लेकिन स्ट्रिंग की प्रकृति नहीं। पर्ल नहीं करता
पहले की तुलना में कॉल के बाद और अधिक जानें कि स्ट्रिंग की सामग्री इंगित करती है
सकारात्मक।

डेटा परिवर्तित करने के लिए वापस। यदि आपके सिस्टम के मूल 8-बिट में डेटा है (या चाहते हैं)।
एन्कोडिंग (उदाहरण के लिए लैटिन-1, ईबीसीडीआईसी, आदि), आप कनवर्ट करने के लिए पैक/अनपैक का उपयोग कर सकते हैं
यूनिकोड।

$native_string = पैक("W*", अनपैक("U*", $Unicode_string));
$यूनिकोड_स्ट्रिंग = पैक('यू*', अनपैक('डब्ल्यू*', $नेटिव_स्ट्रिंग));

यदि आपके पास बाइट्स का क्रम है तो आप जानना वैध UTF-8 है, लेकिन पर्ल को अभी तक इसकी जानकारी नहीं है,
आप पर्ल को भी आस्तिक बना सकते हैं:

एनकोड 'decode_utf8' का उपयोग करें;
$यूनिकोड = डिकोड_यूटीएफ8($बाइट्स);

या:

$यूनिकोड = पैक('U0a*', $बाइट्स);

आप वे बाइट्स पा सकते हैं जो UTF-8 अनुक्रम बनाते हैं

@बाइट्स = अनपैक('सी*', $यूनिकोड_स्ट्रिंग)

और आप इसके साथ सुगठित यूनिकोड बना सकते हैं

$यूनिकोड_स्ट्रिंग = पैक('यू*', 0xff, ...)

· मैं यूनिकोड कैसे प्रदर्शित करूं? मैं यूनिकोड कैसे इनपुट करूं?

देखोhttp://www.alanwood.net/unicode/> और
<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· यूनिकोड पारंपरिक स्थानों के साथ कैसे काम करता है?

यदि आपका लोकेल UTF-8 लोकेल है, तो पर्ल v5.20 से शुरू होकर, पर्ल सभी के लिए अच्छा काम करता है
छँटाई से संबंधित "LC_COLLATE" और "cmp" ऑपरेटर को छोड़कर श्रेणियाँ।

अन्य स्थानों के लिए, पर्ल 5.16 से शुरू करके, आप निर्दिष्ट कर सकते हैं

लोकेल का उपयोग करें ':not_characters';

ताकि पर्ल उनके साथ अच्छा काम कर सके। समस्या यह है कि आपको से अनुवाद करना होगा
स्थानीय वर्ण स्वयं यूनिकोड पर/से सेट करें। कैसे करें इसके लिए ऊपर "यूनिकोड I/O" देखें

खुले ':locale' का उपयोग करें;

इसे पूरा करने के लिए, लेकिन पूर्ण विवरण पेरलोकेल में "यूनिकोड और यूटीएफ-8" में हैं,
यदि आप ":not_characters" निर्दिष्ट नहीं करते हैं तो होने वाले गोचाचा भी शामिल हैं।

षोडश आधारी नोटेशन
यूनिकोड मानक हेक्साडेसिमल नोटेशन का उपयोग करना पसंद करता है क्योंकि यह अधिक स्पष्ट रूप से दिखता है
यूनिकोड को 256 अक्षरों के ब्लॉक में विभाजित करना। हेक्साडेसिमल भी बस छोटा है
दशमलव से अधिक. आप दशमलव संकेतन का भी उपयोग कर सकते हैं, लेकिन केवल हेक्साडेसिमल का उपयोग करना सीखें
यूनिकोड मानक के साथ जीवन को आसान बनाता है। "U+HHHH" नोटेशन हेक्साडेसिमल का उपयोग करता है
उदाहरण।

"0x" उपसर्ग का अर्थ हेक्साडेसिमल संख्या है, अंक 0-9 हैं और एएफ (या एएफ, मामला
कोई फर्क नहीं पड़ता)। प्रत्येक हेक्साडेसिमल अंक चार बिट्स या आधा बाइट का प्रतिनिधित्व करता है। "प्रिंट करें
0x..., "\n"" दशमलव में एक हेक्साडेसिमल संख्या दिखाएगा, और "printf "%x\n", $decimal" दिखाएगा
हेक्साडेसिमल में दशमलव संख्या दिखाएँ. यदि आपके पास हेक्साडेसिमल के केवल "हेक्स अंक" हैं
संख्या, आप "हेक्स()" फ़ंक्शन का उपयोग कर सकते हैं।

प्रिंट 0x0009, "\n"; #9
प्रिंट 0x000a, "\n"; #10
प्रिंट 0x000f, "\n"; #15
प्रिंट 0x0010, "\n"; #16
प्रिंट 0x0011, "\n"; #17
प्रिंट 0x0100, "\n"; #256

प्रिंट 0x0041, "\n"; #65

प्रिंटफ "%x\n", 65; #41
प्रिंटफ "%#x\n", 65; # 0x41

प्रिंट हेक्स ("41"), "\n"; #65

आगे संसाधन
· यूनिकोड कंसोर्टियम

<http://www.unicode.org/>

· यूनिकोड अक्सर पूछे जाने वाले प्रश्न

<http://www.unicode.org/unicode/faq/>

· यूनिकोड शब्दावली

<http://www.unicode.org/glossary/>

· यूनिकोड अनुशंसित पठन सूची

यूनिकोड कंसोर्टियम के पास लेखों और पुस्तकों की एक सूची है, जिनमें से कुछ बहुत कुछ देते हैं
यूनिकोड का अधिक गहन उपचार:http://unicode.org/resources/readinglist.html>

· यूनिकोड उपयोगी संसाधन

<http://www.unicode.org/unicode/onlinedat/resources.html>

· HTML, फ़ॉन्ट्स, वेब ब्राउज़र और अन्य अनुप्रयोगों में यूनिकोड और बहुभाषी समर्थन

<http://www.alanwood.net/unicode/>

· यूनिक्स/लिनक्स के लिए यूटीएफ-8 और यूनिकोड अक्सर पूछे जाने वाले प्रश्न

<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· विरासत चरित्र सेट

<http://www.czyborra.com/>http://www.eki.ee/letter/>

· आप इसका उपयोग करके यूनिकोड डेटा फ़ाइलों से विभिन्न जानकारी का पता लगा सकते हैं
"यूनिकोड::यूसीडी" मॉड्यूल।

यूनिकोड IN पुराने पर्ल्स

यदि आप अपने पर्ल को 5.8.0 या उसके बाद अपग्रेड नहीं कर सकते, तो भी आप कुछ यूनिकोड कर सकते हैं
मॉड्यूल "यूनिकोड::स्ट्रिंग", "यूनिकोड::मैप8", और "यूनिकोड::मैप" का उपयोग करके प्रसंस्करण।
सीपीएएन से उपलब्ध है। यदि आपके पास जीएनयू रिकोड स्थापित है, तो आप पर्ल का भी उपयोग कर सकते हैं
चरित्र रूपांतरण के लिए फ्रंट-एंड "कन्वर्ट::रीकोड"।

निम्नलिखित आईएसओ 8859-1 (लैटिन-1) बाइट्स से यूटीएफ-8 बाइट्स में तेजी से रूपांतरण हैं और
पीछे, कोड पुराने पर्ल 5 संस्करणों के साथ भी काम करता है।

# ISO 8859-1 से UTF-8
s/([\x80-\xFF])/chr(0xC0|ord($1)>>6).chr(0x80|ord($1)&0x3F)/eg;

# UTF-8 से ISO 8859-1
s/([\xC2\xC3])([\x80-\xBF])/chr(ord($1)<<6&0xC0|ord($2)&0x3F)/eg;

onworks.net सेवाओं का उपयोग करके ऑनलाइन perluniintro का उपयोग करें