Elixir 1.7

String




elixir

String

अमृत ​​में एक स्ट्रिंग UTF-8 एन्कोडेड बाइनरी है।

कोडपॉइंट्स और ग्रैफेम क्लस्टर

इस मॉड्यूल में कार्य यूनिकोड मानक के अनुसार कार्य करते हैं, संस्करण 11.0.0।

मानक के अनुसार, एक कोडपॉइंट एक एकल यूनिकोड चरित्र है, जिसे एक या अधिक बाइट्स द्वारा दर्शाया जा सकता है।

उदाहरण के लिए, कोडपॉइंट "é" दो बाइट्स हैं:

iex> byte_size("é")
2

हालाँकि, यह मॉड्यूल उचित लंबाई लौटाता है:

iex> String.length("é")
1

इसके अलावा, यह मॉड्यूल ग्रैफेम क्लस्टर (अब से ग्रैफेम्स के रूप में संदर्भित) की अवधारणा भी प्रस्तुत करता है। ग्रैपहेम में कई कोडपॉइंट्स शामिल हो सकते हैं जिन्हें पाठकों द्वारा एकल वर्ण के रूप में माना जा सकता है। उदाहरण के लिए, "é" को या तो एक "ई के साथ तीव्र" कोडपॉइंट के रूप में या पत्र "ई" के रूप में "तीव्र उच्चारण के संयोजन" (दो कोडपॉइंट्स) के रूप में दर्शाया जा सकता है:

iex> string = "\u0065\u0301"
iex> byte_size(string)
3
iex> String.length(string)
1
iex> String.codepoints(string)
["e", "́"]
iex> String.graphemes(string)
["é"]

यद्यपि ऊपर दिया गया उदाहरण दो वर्णों से बना है, यह उपयोगकर्ताओं द्वारा एक के रूप में माना जाता है।

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

सामान्य तौर पर, इस मॉड्यूल में कार्य यूनिकोड मानक पर निर्भर करते हैं, लेकिन इनमें कोई स्थानीय विशिष्ट व्यवहार नहीं होता है।

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

बाइनरी को एक अलग एन्कोडिंग में परिवर्तित करने और यूनिकोड के सामान्यीकरण तंत्र के लिए, एरलांग के :unicode मॉड्यूल देखें।

स्ट्रिंग और बाइनरी ऑपरेशन

यूनिकोड मानक के अनुसार कार्य करने के लिए, इस मॉड्यूल में कई कार्य रैखिक समय में चलते हैं, क्योंकि उन्हें उचित यूनिकोड कोडपॉइंट्स पर विचार करते हुए पूरे स्ट्रिंग को पीछे करने की आवश्यकता होती है।

उदाहरण के लिए, String.length/1 इनपुट बढ़ने पर अधिक समय लेगी। दूसरी ओर, Kernel.byte_size/1 हमेशा स्थिर समय में चलता है (यानी इनपुट आकार की परवाह किए बिना)।

इसका मतलब है कि अक्सर इस मॉड्यूल में फ़ंक्शन का उपयोग करने में प्रदर्शन लागत होती है, जो कि निम्न स्तर के संचालन की तुलना में होती है, जो सीधे बायनेरिज़ के साथ काम करते हैं:

कई परिस्थितियां हैं जहां String मॉड्यूल का उपयोग करके बाइनरी फ़ंक्शन या पैटर्न मिलान के पक्ष में टाला जा सकता है। उदाहरण के लिए, कल्पना करें कि आपके पास एक स्ट्रिंग prefix और आप इस उपसर्ग को full नाम की किसी अन्य स्ट्रिंग से निकालना चाहते हैं।

एक लिखने के लिए परीक्षा हो सकती है:

iex> take_prefix = fn full, prefix ->
...>   base = String.length(prefix)
...>   String.slice(full, base, String.length(full) - base)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"

यद्यपि उपरोक्त कार्य कार्य करता है, लेकिन यह खराब प्रदर्शन करता है। स्ट्रिंग की लंबाई की गणना करने के लिए, हमें इसे पूरी तरह से पार करने की आवश्यकता है, इसलिए हम prefix और full तार दोनों को पीछे prefix हैं, फिर full काटते हैं, इसे फिर से पार करते हैं।

इसे बेहतर बनाने का पहला प्रयास रेंज के साथ हो सकता है:

iex> take_prefix = fn full, prefix ->
...>   base = String.length(prefix)
...>   String.slice(full, base..-1)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"

हालांकि यह बहुत बेहतर है (हम दो बार full नहीं करते हैं), फिर भी इसमें सुधार किया जा सकता है। इस स्थिति में, चूंकि हम स्ट्रिंग से एक विकल्प निकालना चाहते हैं, इसलिए हम Kernel.byte_size/1 उपयोग कर सकते हैं।

iex> take_prefix = fn full, prefix ->
...>   base = byte_size(prefix)
...>   binary_part(full, base, byte_size(full) - base)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"

या बस पैटर्न मिलान का उपयोग करें:

iex> take_prefix = fn full, prefix ->
...>   base = byte_size(prefix)
...>   <<_::binary-size(base), rest::binary>> = full
...>   rest
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"

दूसरी ओर, यदि आप एक पूर्णांक मान के आधार पर एक स्ट्रिंग को गतिशील रूप से स्लाइस करना चाहते हैं, तो String.slice/3 का उपयोग करना सबसे अच्छा विकल्प है क्योंकि यह गारंटी देता है कि हम गलत कोड को कई बाइट्स में गलत तरीके से विभाजित नहीं करेंगे।

पूर्णांक कोडप्वाइंट

हालाँकि कोडपॉइंट्स को पूर्णांकों के रूप में दर्शाया जा सकता है, यह मॉड्यूल स्ट्रिंग्स के रूप में सभी कोडपॉइंट्स का प्रतिनिधित्व करता है। उदाहरण के लिए:

iex> String.codepoints("olá")
["o", "l", "á"]

एक वर्ण पूर्णांक कोडपॉइंट को पुनः प्राप्त करने के कुछ तरीके हैं। एक का उपयोग कर सकते हैं ? निर्माण:

iex> ?o
111

iex> ?á
225

या पैटर्न मिलान के माध्यम से भी:

iex> <<aacute::utf8>> = "á"
iex> aacute
225

जैसा कि हमने ऊपर देखा है, कोडपॉइंट्स को उनके हेक्साडेसिमल कोड द्वारा एक स्ट्रिंग में डाला जा सकता है:

"ol\u0061\u0301" #=>
"olá"

स्व तुल्यकालन

UTF-8 एन्कोडिंग स्व-सिंक्रनाइज़िंग है। इसका मतलब यह है कि यदि विकृत डेटा (यानी, एन्कोडिंग की परिभाषा के अनुसार डेटा संभव नहीं है) का सामना करना पड़ता है, तो केवल एक कोडपॉइंट को अस्वीकार करने की आवश्यकता है।

यह मॉड्यूल इस तरह के अमान्य वर्णों को अनदेखा करने के लिए इस व्यवहार पर निर्भर करता है। उदाहरण के लिए, length/1 एक सही परिणाम लौटाएगा भले ही उसमें एक अवैध कोडपॉइंट खिलाया गया हो।

दूसरे शब्दों में, इस मॉड्यूल को उम्मीद है कि बाहरी स्रोत से डेटा प्राप्त करते समय, आमतौर पर अमान्य डेटा का पता लगाया जा सकता है। उदाहरण के लिए, एक चालक जो डेटाबेस से तार पढ़ता है, एन्कोडिंग की वैधता की जांच करने के लिए जिम्मेदार होगा। String.chunk/2 का उपयोग किसी स्ट्रिंग को वैध और अमान्य भागों में तोड़ने के लिए किया जा सकता है।

पैटर्न्स

इस मॉड्यूल में कई कार्य पैटर्न के साथ काम करते हैं। उदाहरण के लिए, String.split/2 एक स्ट्रिंग को कई पैटर्न में विभाजित करके एक पैटर्न दिया जा सकता है। यह पैटर्न एक स्ट्रिंग, तार की एक सूची या एक संकलित पैटर्न हो सकता है:

iex> String.split("foo bar", " ")
["foo", "bar"]

iex> String.split("foo bar!", [" ", "!"])
["foo", "bar", ""]

iex> pattern = :binary.compile_pattern([" ", "!"])
iex> String.split("foo bar!", pattern)
["foo", "bar", ""]

संकलित पैटर्न तब उपयोगी होता है जब एक ही मैच बार-बार किया जाएगा। ध्यान दें कि संकलित पैटर्न को मॉड्यूल विशेषता में संग्रहीत नहीं किया जा सकता है क्योंकि पैटर्न रनटाइम पर उत्पन्न होता है और संकलित अवधि तक जीवित नहीं रहता है।

सारांश

प्रकार

codepoint()

एक UTF-8 कोडपॉइंट। यह एक या एक से अधिक बाइट्स हो सकता है

grapheme()

एकाधिक कोडपॉइंट्स जिन्हें पाठकों द्वारा एकल वर्ण के रूप में माना जा सकता है

pattern()

replace/3 और split/2 जैसे कार्यों में प्रयुक्त पैटर्न

t()

एक UTF-8 एन्कोडेड बाइनरी

कार्य

पर (स्ट्रिंग, स्थिति)

दिए गए UTF-8 string की position में ग्रेपैम लौटाता है। यदि position string लंबाई से अधिक है, तो यह nil देता है

पूंजी करें (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

दिए गए स्ट्रिंग में पहले वर्ण को अपरकेस और शेष को mode अनुसार नीचे करने के लिए परिवर्तित करता mode

चंक (स्ट्रिंग, विशेषता)

एक सामान्य विशेषता साझा करने वाले वर्णों की श्रृंखला में स्ट्रिंग को विभाजित करता है

codepoints(string)

स्ट्रिंग में सभी कोडपॉइंट देता है

शामिल हैं। (स्ट्रिंग, सामग्री)

जाँच करता है कि string में दी गई कोई contents

डाउनकेस (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

दिए गए स्ट्रिंग में सभी वर्णों को mode अनुसार कम करने के लिए परिवर्तित करता mode

डुप्लिकेट (विषय, एन)

एक स्ट्रिंग subject n बार दोहराया जाता है

End_with; (स्ट्रिंग, प्रत्यय)

अगर string दी गई किसी भी प्रत्यय के साथ समाप्त हो जाती true तो true

समकक्ष? (string1, string2)

अगर string1 'स्ट्रिंग 2' के बराबर है तो यह true है।

first(string)

UTF-8 स्ट्रिंग से पहला ग्रेपैम लौटाता है, यदि स्ट्रिंग खाली है तो nil

graphemes(string)

विस्तारित Grapheme क्लस्टर एल्गोरिथ्म के अनुसार स्ट्रिंग में यूनिकोड अंगूर को लौटाता है

jaro_distance (string1, string2)

0 और string2 बीच Jaro दूरी का प्रतिनिधित्व करते हुए 0 (कोई समानता नहीं है) और 1 (एक सटीक मिलान) के बीच एक फ्लोट मान लौटाता है

last(string)

UTF-8 स्ट्रिंग से अंतिम ग्रेपैम लौटाता है, यदि स्ट्रिंग खाली है तो nil

length/1

यूटीएफ -8 स्ट्रिंग में यूनिकोड अंगूर की संख्या लौटाता है

मैच। (स्ट्रिंग, regex)

जाँच करता है कि string दी गई नियमित अभिव्यक्ति से मेल खाती है या नहीं

myers_difference (string1, string2)

एक कीवर्ड सूची देता है जो एक संपादित स्क्रिप्ट का प्रतिनिधित्व करता है

next_codepoint(string)

एक स्ट्रिंग में अगला कोडपॉइंट देता है

next_grapheme(binary)

अगले अंगूर को एक स्ट्रिंग में लौटाता है

next_grapheme_size(string)

अगले अंगूर का आकार देता है

सामान्य करना (स्ट्रिंग, रूप)

सभी वर्णों को string में यूनिकोड के सामान्यीकरण रूप से पहचाना जाता form

pad_leading (स्ट्रिंग, गिनती, गद्दी \\ [""])

एक प्रमुख भराव के साथ गद्देदार एक नया स्ट्रिंग देता है जो padding से तत्वों से बना होता है

pad_trailing (स्ट्रिंग, गिनती, गद्दी \\ [""])

एक नए स्ट्रिंग को एक अनुगामी भराव के साथ गद्देदार लौटाता है जो padding से तत्वों से बना है

मुद्रण योग्य; (स्ट्रिंग, character_limit \\: अनंत)

जाँचता है कि क्या किसी स्ट्रिंग में केवल character_limit तक के मुद्रण योग्य character_limit

बदलें (विषय, पैटर्न, प्रतिस्थापन, विकल्प \\ [])

replacement साथ subject में pattern की घटनाओं को प्रतिस्थापित करके बनाया गया एक नया स्ट्रिंग देता है

प्रतिस्थापन_ भ्रामक (स्ट्रिंग, मैच, प्रतिस्थापन)

string में match replacement द्वारा match सभी प्रमुख घटनाओं को replacement string

प्रतिस्थापन_ उपसर्ग (स्ट्रिंग, मैच, प्रतिस्थापन)

यदि यह मेल match तो replacement द्वारा string में उपसर्ग बदल देता है

प्रतिस्थापन_सुफी (स्ट्रिंग, मैच, प्रतिस्थापन)

यदि यह मेल match तो replacement द्वारा string में replacement होता है

प्रतिस्थापन_ स्ट्रिंग (स्ट्रिंग, मैच, प्रतिस्थापन)

string में replacement द्वारा match की सभी अनुगामी घटनाओं को replacement string

reverse(string)

दिए गए स्ट्रिंग में अंगूर को उलट देता है

टुकड़ा (स्ट्रिंग, रेंज)

रेंज के प्रारंभ द्वारा दिए गए ऑफसेट से रेंज के अंत तक दिए गए ऑफसेट का एक विकल्प देता है

टुकड़ा (स्ट्रिंग, शुरू, लेन)

ऑफसेट start और लंबाई len पर एक विकल्प start

split(binary)

प्रमुख और अनुगामी व्हाट्सएप की अनदेखी के साथ प्रत्येक यूनिकोड व्हाट्सएप घटना पर सबस्ट्रिंग में एक स्ट्रिंग को विभाजित करता है। व्हाट्सएप के समूहों को एक ही घटना के रूप में माना जाता है। विभाजन गैर-ब्रेकिंग व्हाट्सएप पर नहीं होता है

विभाजन (स्ट्रिंग, पैटर्न, विकल्प \\ [])

एक पैटर्न के आधार पर सबस्ट्रिंग में एक स्ट्रिंग को विभाजित करता है

विभाजित_त (स्ट्रिंग, स्थिति)

निर्दिष्ट ऑफसेट पर एक स्ट्रिंग को दो में विभाजित करता है। जब दी गई ऑफसेट नकारात्मक होती है, तो स्ट्रिंग के अंत से स्थान गिना जाता है

फाड़नेवाला (स्ट्रिंग, पैटर्न, विकल्प \\ [])

एक enumerable देता है जो मांग पर एक स्ट्रिंग को विभाजित करता है

start_with; (स्ट्रिंग, उपसर्ग)

अगर string दिए गए किसी भी उपसर्ग के साथ शुरू होती true तो true

to_atom(string)

एक स्ट्रिंग को एक परमाणु में परिवर्तित करता है

to_charlist(string)

एक स्ट्रिंग को चारलिस्ट में परिवर्तित करता है

to_existing_atom(string)

एक स्ट्रिंग को एक मौजूदा परमाणु में परिवर्तित करता है

to_float(string)

एक फ्लोट देता है जिसका पाठ प्रतिनिधित्व string

to_integer(string)

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व string

to_integer (स्ट्रिंग, आधार)

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व आधार में string है

trim(string)

एक स्ट्रिंग लौटाता है जहाँ सभी अग्रणी और अनुगामी यूनिकोड व्हाट्सएप को हटा दिया गया है

ट्रिम करें (स्ट्रिंग, to_trim)

एक स्ट्रिंग लौटाता है जहाँ सभी अग्रणी और अनुगामी to_trim s को हटा दिया गया है

trim_leading(string)

एक स्ट्रिंग लौटाता है जहाँ सभी प्रमुख यूनिकोड व्हाट्सएप हटा दिए गए हैं

trim_leading (स्ट्रिंग, to_trim)

एक स्ट्रिंग देता है जहाँ सभी अग्रणी to_trim s को हटा दिया गया है

trim_trailing(string)

एक स्ट्रिंग लौटाता है जहां सभी अनुगामी यूनिकोड व्हाट्सएप को हटा दिया गया है

trim_trailing (स्ट्रिंग, to_trim)

एक स्ट्रिंग लौटाता है, जहाँ सभी ट्रेलिंग_ट्रीम एस हटा दिए गए हैं

चढ़ाई (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

दिए गए स्ट्रिंग के सभी वर्णों को mode अनुसार अपरकेस में परिवर्तित करता mode

valid?(string)

जाँचता है कि क्या string में केवल मान्य वर्ण हैं

प्रकार

कोडपॉइंट ()

codepoint() :: t()

एक UTF-8 कोडपॉइंट। यह एक या एक से अधिक बाइट्स हो सकता है।

ग्रफीम ()

grapheme() :: t()

एकाधिक कोडपॉइंट्स जिन्हें पाठकों द्वारा एकल वर्ण के रूप में माना जा सकता है

पैटर्न ()

pattern() :: t() | [t()] | :binary.cp()

replace/3 और split/2 जैसे कार्यों में प्रयुक्त पैटर्न

टी ()

t() :: binary()

एक UTF-8 एन्कोडेड बाइनरी।

नोट String.t() और binary() विश्लेषण उपकरण के बराबर हैं। हालाँकि, दस्तावेज़ पढ़ने वालों के लिए, String.t() का अर्थ है कि यह UTF-8 एन्कोडेड बाइनरी है।

कार्य

पर (स्ट्रिंग, स्थिति)

at(t(), integer()) :: grapheme() | nil

दिए गए UTF-8 string की position में ग्रेपैम लौटाता है। यदि position string लंबाई से अधिक है, तो यह nil देता है।

उदाहरण

iex> String.at("elixir", 0)
"e"

iex> String.at("elixir", 1)
"l"

iex> String.at("elixir", 10)
nil

iex> String.at("elixir", -1)
"r"

iex> String.at("elixir", -10)
nil

पूंजी करें (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

capitalize(t(), :default | :ascii | :greek) :: t()

दिए गए स्ट्रिंग में पहले वर्ण को अपरकेस और शेष को mode अनुसार नीचे करने के लिए परिवर्तित करता mode

mode हो सकता है :default :ascii या :greek :default मोड यूनिकोड मानक में उल्लिखित सभी गैर-सशर्त परिवर्तनों पर विचार करता है। :ascii एससीआई केवल ए से जेड तक के अक्षरों को कम करता है :greek ग्रीक में ग्रीक में पाए जाने वाले संदर्भ संवेदनशील मैपिंग शामिल हैं।

उदाहरण

iex> String.capitalize("abcd")
"Abcd"

iex> String.capitalize("fin")
"Fin"

iex> String.capitalize("olá")
"Olá"

चंक (स्ट्रिंग, विशेषता)

chunk(t(), :valid | :printable) :: [t()]

एक सामान्य विशेषता साझा करने वाले वर्णों की श्रृंखला में स्ट्रिंग को विभाजित करता है।

लक्षण दो विकल्पों में से एक हो सकता है:

  • :valid - स्ट्रिंग वैध और अमान्य वर्ण अनुक्रमों के विखंडन में विभाजित है

  • :printable - स्ट्रिंग को मुद्रण योग्य और गैर-मुद्रण योग्य वर्ण अनुक्रमों के विखंडन में विभाजित किया जाता है

प्रत्येक की एक ही प्रकार के वर्णों की सूची देता है।

यदि दी गई स्ट्रिंग खाली है, तो एक खाली सूची वापस आ जाती है।

उदाहरण

iex> String.chunk(<<?a, ?b, ?c, 0>>, :valid)
["abc\0"]

iex> String.chunk(<<?a, ?b, ?c, 0, 0xFFFF::utf16>>, :valid)
["abc\0", <<0xFFFF::utf16>>]

iex> String.chunk(<<?a, ?b, ?c, 0, 0x0FFFF::utf8>>, :printable)
["abc", <<0, 0x0FFFF::utf8>>]

कोड पॉइंट्स (स्ट्रिंग)

codepoints(t()) :: [codepoint()]

स्ट्रिंग में सभी कोडपॉइंट देता है।

कोडपॉइंट और अंगूर के बारे में जानकारी के लिए, String मॉड्यूल प्रलेखन देखें।

उदाहरण

iex> String.codepoints("olá")
["o", "l", "á"]

iex> String.codepoints("оптими зации")
["о", "п", "т", "и", "м", "и", " ", "з", "а", "ц", "и", "и"]

iex> String.codepoints("ἅἪῼ")
["ἅ", "Ἢ", "ῼ"]

iex> String.codepoints("é")
["é"]

iex> String.codepoints("é")
["e", "́"]

शामिल हैं। (स्ट्रिंग, सामग्री)

contains?(t(), pattern()) :: boolean()

जाँच करता है कि string में दी गई कोई contents

contents या तो एक स्ट्रिंग, तार की एक सूची या एक संकलित पैटर्न हो सकती है।

उदाहरण

iex> String.contains?("elixir of life", "of")
true
iex> String.contains?("elixir of life", ["life", "death"])
true
iex> String.contains?("elixir of life", ["death", "mercury"])
false

तर्क एक संकलित पैटर्न भी हो सकता है:

iex> pattern = :binary.compile_pattern(["life", "death"])
iex> String.contains?("elixir of life", pattern)
true

एक खाली स्ट्रिंग हमेशा मेल करेगी:

iex> String.contains?("elixir of life", "")
true
iex> String.contains?("elixir of life", ["", "other"])
true

ध्यान दें कि यह फ़ंक्शन अंगूर की सीमाओं के भीतर या उससे मेल खा सकता है। उदाहरण के लिए, अंगूर "ए" को लें जो वर्ण "ई" और तीव्र उच्चारण से बना है। निम्नलिखित रिटर्न true :

iex> String.contains?(String.normalize("é", :nfd), "e")
true

हालांकि, यदि "é" एकल चरित्र "ई के साथ तीव्र" उच्चारण द्वारा दर्शाया जाता है, तो यह false होगा:

iex> String.contains?(String.normalize("é", :nfc), "e")
false

डाउनकेस (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

downcase(t(), :default | :ascii | :greek) :: t()

दिए गए स्ट्रिंग में सभी वर्णों को mode अनुसार कम करने के लिए परिवर्तित करता mode

mode हो सकता है :default :ascii या :greek :default मोड यूनिकोड मानक में उल्लिखित सभी गैर-सशर्त परिवर्तनों पर विचार करता है। :ascii एससीआई केवल ए से जेड तक के अक्षरों को कम करता है :greek ग्रीक में ग्रीक में पाए जाने वाले संदर्भ संवेदनशील मैपिंग शामिल हैं।

उदाहरण

iex> String.downcase("ABCD")
"abcd"

iex> String.downcase("AB 123 XPTO")
"ab 123 xpto"

iex> String.downcase("OLÁ")
"olá"

:ascii एएससीआई मोड यूनिकोड वर्णों को अनदेखा करता है और अधिक प्रभावी कार्यान्वयन प्रदान करता है जब आपको पता है कि स्ट्रिंग में केवल ASCII वर्ण हैं:

iex> String.downcase("OLÁ", :ascii)
"olÁ"

और :greek ग्रीक ग्रीक में संदर्भ संवेदनशील सिग्मा को ठीक से संभालता है:

iex> String.downcase("ΣΣ")
"σσ"

iex> String.downcase("ΣΣ", :greek)
"σς"

डुप्लिकेट (विषय, एन)

duplicate(t(), non_neg_integer()) :: t()

एक स्ट्रिंग subject n बार दोहराया जाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> String.duplicate("abc", 0)
""

iex> String.duplicate("abc", 1)
"abc"

iex> String.duplicate("abc", 2)
"abcabc"

End_with; (स्ट्रिंग, प्रत्यय)

ends_with?(t(), t() | [t()]) :: boolean()

अगर string दी गई किसी भी प्रत्यय के साथ समाप्त हो जाती true तो true

suffixes या तो एक प्रत्यय या प्रत्यय की सूची हो सकती है।

उदाहरण

iex> String.ends_with?("language", "age")
true
iex> String.ends_with?("language", ["youth", "age"])
true
iex> String.ends_with?("language", ["youth", "elixir"])
false

एक खाली प्रत्यय हमेशा मैच करेगा:

iex> String.ends_with?("language", "")
true
iex> String.ends_with?("language", ["", "other"])
true

समकक्ष? (string1, string2)

equivalent?(t(), t()) :: boolean()

यह true कि अगर string1 कैनोनिक रूप से 'string2' के बराबर है।

यह उनकी तुलना करने से पहले स्ट्रिंग्स पर सामान्यीकरण प्रपत्र कैननिकल अपघटन (NFD) करता है। यह फ़ंक्शन इसके बराबर है:

String.normalize(string1, :nfd) == String.normalize(string2, :nfd)

इसलिए, यदि आप एक पंक्ति में कई बार, कई बार तार की तुलना करने की योजना बनाते हैं, तो आप उन्हें उल्टा सामान्य कर सकते हैं और कई सामान्यीकरण पास से बचने के लिए सीधे तुलना कर सकते हैं।

उदाहरण

iex> String.equivalent?("abc", "abc")
true

iex> String.equivalent?("man\u0303ana", "mañana")
true

iex> String.equivalent?("abc", "ABC")
false

iex> String.equivalent?("nø", "nó")
false

पहले (स्ट्रिंग)

first(t()) :: grapheme() | nil

UTF-8 स्ट्रिंग से पहला ग्रेपैम लौटाता है, यदि स्ट्रिंग खाली है तो nil

उदाहरण

iex> String.first("elixir")
"e"

iex> String.first("Õ¥Õ¸Õ£Õ¬Õ«")
"Õ¥"

graphemes (स्ट्रिंग)

graphemes(t()) :: [grapheme()]

विस्तारित Grapheme क्लस्टर एल्गोरिथ्म के अनुसार स्ट्रिंग में यूनिकोड अंगूर को लौटाता है।

एल्गोरिथ्म को यूनिकोड मानक अनुलग्नक # 29, यूनिकोड पाठ विभाजन में उल्लिखित किया गया है।

कोडपॉइंट और अंगूर के बारे में जानकारी के लिए, String मॉड्यूल प्रलेखन देखें।

उदाहरण

iex> String.graphemes("Ńaïve")
["Ń", "a", "ï", "v", "e"]

iex> String.graphemes("é")
["é"]

iex> String.graphemes("é")
["é"]

jaro_distance (string1, string2)

jaro_distance(t(), t()) :: float()

0 और string2 बीच Jaro दूरी का प्रतिनिधित्व करते हुए 0 (1 के बराबर नहीं) और 1 (एक सटीक मिलान) के बीच एक फ्लोट मान लौटाता है।

यारो दूरी मीट्रिक को डिज़ाइन किया गया है और व्यक्ति के नाम जैसे छोटे तारों के लिए सबसे उपयुक्त है।

उदाहरण

iex> String.jaro_distance("dwayne", "duane")
0.8222222222222223
iex> String.jaro_distance("even", "odd")
0.0
iex> String.jaro_distance("same", "same")
1.0

पिछले (स्ट्रिंग)

last(t()) :: grapheme() | nil

UTF-8 स्ट्रिंग से अंतिम ग्रेपैम लौटाता है, यदि स्ट्रिंग खाली है तो nil

उदाहरण

iex> String.last("elixir")
"r"

iex> String.last("Õ¥Õ¸Õ£Õ¬Õ«")
"Õ«"

लंबाई (स्ट्रिंग)

length(t()) :: non_neg_integer()

यूटीएफ -8 स्ट्रिंग में यूनिकोड अंगूर की संख्या लौटाता है।

उदाहरण

iex> String.length("elixir")
6

iex> String.length("Õ¥Õ¸Õ£Õ¬Õ«")
5

मैच। (स्ट्रिंग, regex)

match?(t(), Regex.t()) :: boolean()

जाँच करता है कि string दी गई नियमित अभिव्यक्ति से मेल खाती है या नहीं।

उदाहरण

iex> String.match?("foo", ~r/foo/)
true

iex> String.match?("bar", ~r/foo/)
false

myers_difference (string1, string2)

myers_difference(t(), t()) :: [{:eq | :ins | :del, t()}]

एक कीवर्ड सूची देता है जो एक संपादित स्क्रिप्ट का प्रतिनिधित्व करता है।

अधिक जानकारी के लिए List.myers_difference/2 जाँच करें।

उदाहरण

iex> string1 = "fox hops over the dog"
iex> string2 = "fox jumps over the lazy cat"
iex> String.myers_difference(string1, string2)
[eq: "fox ", del: "ho", ins: "jum", eq: "ps over the ", del: "dog", ins: "lazy cat"]

next_codepoint (स्ट्रिंग)

next_codepoint(t()) :: {codepoint(), t()} | nil

एक स्ट्रिंग में अगला कोडपॉइंट देता है।

परिणाम कोडपॉइंट के साथ एक टपल होता है और स्ट्रिंग के अंत में पहुंचने पर स्ट्रिंग या nil का शेष भाग।

स्ट्रिंग मॉड्यूल में अन्य कार्यों की तरह, यह फ़ंक्शन कोडपॉइंट की वैधता की जांच नहीं करता है। उस ने कहा, यदि कोई अमान्य कोडपॉइंट पाया जाता है, तो उसे इस फ़ंक्शन द्वारा वापस कर दिया जाएगा।

उदाहरण

iex> String.next_codepoint("olá")
{"o", "lá"}

next_grapheme (बाइनरी)

next_grapheme(t()) :: {grapheme(), t()} | nil

अगले अंगूर को एक स्ट्रिंग में लौटाता है।

इसका परिणाम अंगूर के साथ एक तुक है और स्ट्रिंग या nil के शेष रहने की स्थिति में स्ट्रिंग अपने अंत तक पहुंच गई।

उदाहरण

iex> String.next_grapheme("olá")
{"o", "lá"}

next_grapheme_size (स्ट्रिंग)

next_grapheme_size(t()) :: {pos_integer(), t()} | nil

अगले अंगूर का आकार देता है।

परिणाम अगले अंगूर के आकार के साथ एक टपल है और स्ट्रिंग के अंत में शेष स्ट्रिंग या nil के शेष तक पहुंच गया है।

उदाहरण

iex> String.next_grapheme_size("olá")
{1, "lá"}

सामान्य करना (स्ट्रिंग, रूप)

normalize(t(), atom()) :: t()

सभी वर्णों को string में यूनिकोड के सामान्यीकरण रूप से पहचाना जाता form

फार्म

समर्थित रूप हैं:

  • :nfd - सामान्यीकरण फॉर्म Canonical Decomposition। वर्णों को विहित सामंजस्य द्वारा विघटित किया जाता है, और कई संयोजन वर्णों को एक विशिष्ट क्रम में व्यवस्थित किया जाता है।

  • :nfc - सामान्यीकरण फॉर्म Canonical रचना। वर्ण विघटित हो जाते हैं और फिर विहित सामंजस्य द्वारा पुन: स्थापित होते हैं।

उदाहरण

iex> String.normalize("yêṩ", :nfd)
"yêṩ"

iex> String.normalize("leña", :nfc)
"leña"

pad_leading (स्ट्रिंग, गिनती, गद्दी \\ [""])

pad_leading(t(), non_neg_integer(), t() | [t()]) :: t()

एक प्रमुख भराव के साथ गद्देदार एक नया स्ट्रिंग देता है जो padding से तत्वों से बना होता है।

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

जब count string की लंबाई से कम या उसके बराबर होती है, तो दी गई string वापस आ जाती है।

यदि दिए गए padding में गैर-स्ट्रिंग तत्व है, तो ArgumentError उठाता है।

उदाहरण

iex> String.pad_leading("abc", 5)
"  abc"

iex> String.pad_leading("abc", 4, "12")
"1abc"

iex> String.pad_leading("abc", 6, "12")
"121abc"

iex> String.pad_leading("abc", 5, ["1", "23"])
"123abc"

pad_trailing (स्ट्रिंग, गिनती, गद्दी \\ [""])

pad_trailing(t(), non_neg_integer(), t() | [t()]) :: t()

एक नए स्ट्रिंग को एक अनुगामी भराव के साथ गद्देदार लौटाता है जो padding से तत्वों से बना है।

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

जब count string की लंबाई से कम या उसके बराबर होती है, तो दी गई string वापस आ जाती है।

यदि दिए गए padding में गैर-स्ट्रिंग तत्व है, तो ArgumentError उठाता है।

उदाहरण

iex> String.pad_trailing("abc", 5)
"abc  "

iex> String.pad_trailing("abc", 4, "12")
"abc1"

iex> String.pad_trailing("abc", 6, "12")
"abc121"

iex> String.pad_trailing("abc", 5, ["1", "23"])
"abc123"

मुद्रण योग्य; (स्ट्रिंग, character_limit \\: अनंत)

printable?(t(), pos_integer() | :infinity) :: boolean()
printable?(t(), 0) :: true

जाँचता है कि क्या किसी स्ट्रिंग में केवल character_limit तक के मुद्रण योग्य character_limit

दूसरे तर्क के रूप में एक वैकल्पिक character_limit लेता है। यदि character_limit 0 , तो यह फ़ंक्शन true लौटेगा।

उदाहरण

iex> String.printable?("abc")
true

iex> String.printable?("abc" <> <<0>>)
false

iex> String.printable?("abc" <> <<0>>, 2)
true

iex> String.printable?("abc" <> <<0>>, 0)
true

बदलें (विषय, पैटर्न, प्रतिस्थापन, विकल्प \\ [])

replace(t(), pattern() | Regex.t(), t(), keyword()) :: t()

replacement साथ subject में pattern की घटनाओं को प्रतिस्थापित करके बनाया गया एक नया स्ट्रिंग देता है।

pattern एक स्ट्रिंग, एक नियमित अभिव्यक्ति या एक संकलित पैटर्न हो सकता है।

डिफ़ॉल्ट रूप से यह सभी घटनाओं को बदल देता है लेकिन इस व्यवहार को इसके माध्यम से नियंत्रित किया जा सकता है :global विकल्प; नीचे "विकल्प" अनुभाग देखें।

विकल्प

  • :global - (बूलियन) यदि true , तो pattern की सभी घटनाओं को प्रतिस्थापन के साथ बदल दिया जाता है, अन्यथा केवल पहली घटना को बदल दिया जाता है। true अवहेलना

  • :insert_replaced - (पूर्णांक या पूर्णांक की सूची) उस स्थिति को निर्दिष्ट करता है जहां replacement अंदर प्रतिस्थापित भाग को सम्मिलित करना है। यदि इसमें दी गई कोई भी स्थिति :insert_replaced विकल्प प्रतिस्थापन स्ट्रिंग से बड़ा है, या नकारात्मक है, तो एक ArgumentError उठाया जाता है। नीचे दिए गए उदाहरण देखें

उदाहरण

iex> String.replace("a,b,c", ",", "-")
"a-b-c"

iex> String.replace("a,b,c", ",", "-", global: false)
"a-b,c"

जब पैटर्न एक नियमित अभिव्यक्ति है, तो कोई नियमित स्ट्रिंग में विशिष्ट कैप्चर का उपयोग करने के लिए replacement स्ट्रिंग में \N या \g{N} दे सकता है:

iex> String.replace("a,b,c", ~r/,(.)/, ",\\1\\g{1}")
"a,bb,cc"

ध्यान दें कि हमें बैकस्लैश एस्केप कैरेक्टर से बचना था (यानी, हमने बैकस्लैश से बचने के लिए just \N बजाय \\N इस्तेमाल किया; वही \\g{N} )। \0 देकर, कोई प्रतिस्थापन स्ट्रिंग में पूरे मिलान पैटर्न को इंजेक्ट कर सकता है।

जब पैटर्न एक स्ट्रिंग है, तो एक डेवलपर replacement अंदर बदले हुए भाग का उपयोग कर सकता है :insert_replaced विकल्प और replacement अंदर स्थिति (एस) निर्दिष्ट करने के लिए जहां स्ट्रिंग पैटर्न डाला जाएगा:

iex> String.replace("a,b,c", "b", "[]", insert_replaced: 1)
"a,[b],c"

iex> String.replace("a,b,c", ",", "[]", insert_replaced: 2)
"a[],b[],c"

iex> String.replace("a,b,c", ",", "[]", insert_replaced: [1, 1])
"a[,,]b[,,]c"

एक संकलित पैटर्न भी दिया जा सकता है:

iex> pattern = :binary.compile_pattern(",")
iex> String.replace("a,b,c", pattern, "[]", insert_replaced: 2)
"a[],b[],c"

जब एक रिक्त स्ट्रिंग को एक pattern रूप में प्रदान किया जाता है, तो फ़ंक्शन इसे प्रत्येक अंगूर के बीच एक अंतर्निहित खाली स्ट्रिंग के रूप में व्यवहार करेगा और स्ट्रिंग को इंटरसेप्ट किया जाएगा। यदि रिक्त स्ट्रिंग को replacement के रूप में प्रदान किया जाता है, तो subject वापस कर दिया जाएगा:

iex> String.replace("ELIXIR", "", ".")
".E.L.I.X.I.R."

iex> String.replace("ELIXIR", "", "")
"ELIXIR"

प्रतिस्थापन_ भ्रामक (स्ट्रिंग, मैच, प्रतिस्थापन)

replace_leading(t(), t(), t()) :: t() | no_return()

string में match replacement द्वारा match सभी प्रमुख घटनाओं को replacement string

यदि कोई घटना न हो तो स्ट्रिंग को अछूता लौटाता है।

यदि match "" , तो यह फ़ंक्शन एक ArgumentError अपवाद उठाता है: ऐसा इसलिए होता है क्योंकि यह फ़ंक्शन string की शुरुआत में match की सभी घटनाओं को बदल देता है, और "" की "कई" घटनाओं को प्रतिस्थापित करना असंभव है।

उदाहरण

iex> String.replace_leading("hello world", "hello ", "")
"world"
iex> String.replace_leading("hello hello world", "hello ", "")
"world"

iex> String.replace_leading("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_leading("hello hello world", "hello ", "ola ")
"ola ola world"

प्रतिस्थापन_ उपसर्ग (स्ट्रिंग, मैच, प्रतिस्थापन)

replace_prefix(t(), t(), t()) :: t()

यदि यह मेल match तो replacement द्वारा string में उपसर्ग बदल देता है।

मैच न होने पर स्ट्रिंग को अछूता लौटाता है। यदि match एक रिक्त स्ट्रिंग ( "" ) है, तो replacement string लिए पूर्व निर्धारित है।

उदाहरण

iex> String.replace_prefix("world", "hello ", "")
"world"
iex> String.replace_prefix("hello world", "hello ", "")
"world"
iex> String.replace_prefix("hello hello world", "hello ", "")
"hello world"

iex> String.replace_prefix("world", "hello ", "ola ")
"world"
iex> String.replace_prefix("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_prefix("hello hello world", "hello ", "ola ")
"ola hello world"

iex> String.replace_prefix("world", "", "hello ")
"hello world"

प्रतिस्थापन_सुफी (स्ट्रिंग, मैच, प्रतिस्थापन)

replace_suffix(t(), t(), t()) :: t()

यदि यह मेल match तो replacement द्वारा string में replacement होता है।

मैच न होने पर स्ट्रिंग को अछूता लौटाता है। यदि match एक खाली स्ट्रिंग ( "" ) है, तो replacement को केवल string जोड़ा जाता string

उदाहरण

iex> String.replace_suffix("hello", " world", "")
"hello"
iex> String.replace_suffix("hello world", " world", "")
"hello"
iex> String.replace_suffix("hello world world", " world", "")
"hello world"

iex> String.replace_suffix("hello", " world", " mundo")
"hello"
iex> String.replace_suffix("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_suffix("hello world world", " world", " mundo")
"hello world mundo"

iex> String.replace_suffix("hello", "", " world")
"hello world"

प्रतिस्थापन_ स्ट्रिंग (स्ट्रिंग, मैच, प्रतिस्थापन)

replace_trailing(t(), t(), t()) :: t() | no_return()

string में replacement द्वारा match की सभी अनुगामी घटनाओं को replacement string

यदि कोई घटना न हो तो स्ट्रिंग को अछूता लौटाता है।

यदि match "" , तो यह फ़ंक्शन एक ArgumentError अपवाद उठाता है: ऐसा इसलिए होता है क्योंकि यह फ़ंक्शन string के अंत में match की सभी घटनाओं को बदल देता है, और "" की "कई" घटनाओं को बदलना असंभव है।

उदाहरण

iex> String.replace_trailing("hello world", " world", "")
"hello"
iex> String.replace_trailing("hello world world", " world", "")
"hello"

iex> String.replace_trailing("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_trailing("hello world world", " world", " mundo")
"hello mundo mundo"

रिवर्स (स्ट्रिंग)

reverse(t()) :: t()

दिए गए स्ट्रिंग में अंगूर को उलट देता है।

उदाहरण

iex> String.reverse("abcd")
"dcba"

iex> String.reverse("hello world")
"dlrow olleh"

iex> String.reverse("hello ∂og")
"go∂ olleh"

ध्यान रखें एक ही स्ट्रिंग को दो बार उल्टा करने से मूल स्ट्रिंग नहीं निकलती है:

iex> "Ì€e"
"Ì€e"
iex> String.reverse("Ì€e")
"è"
iex> String.reverse(String.reverse("Ì€e"))
"è"

पहले उदाहरण में उच्चारण स्वर से पहले है, इसलिए इसे दो अंगूर माना जाता है। हालांकि, जब आप इसे एक बार उलट देते हैं, तो आपके पास उच्चारण के बाद स्वर होता है, जो कि एक ग्रेफेम बन जाता है। इसे फिर से उलटाने से यह एक सिंगल ग्रेपमे के रूप में रह जाएगा।

टुकड़ा (स्ट्रिंग, रेंज)

slice(t(), Range.t()) :: t()

रेंज के प्रारंभ द्वारा दिए गए ऑफसेट से रेंज के अंत तक दिए गए ऑफसेट का एक विकल्प देता है।

यदि रेंज की शुरुआत दिए गए स्ट्रिंग के लिए एक वैध ऑफसेट नहीं है या यदि रेंज रिवर्स ऑर्डर में है, तो रिटर्न ""

यदि रेंज का प्रारंभ या अंत नकारात्मक है, तो नकारात्मक सूचकांकों को सकारात्मक में बदलने के लिए पूरे स्ट्रिंग को पहले ट्रैवर्स किया जाता है।

याद रखें कि यह फ़ंक्शन यूनिकोड ग्रेफेम के साथ काम करता है और स्लाइस को ग्रेपमे ऑफ़सेट का प्रतिनिधित्व करता है। यदि आप कच्ची बाइट पर विभाजित करना चाहते हैं, तो इसके बजाय Kernel.binary_part/3 जांचें।

उदाहरण

iex> String.slice("elixir", 1..3)
"lix"

iex> String.slice("elixir", 1..10)
"lixir"

iex> String.slice("elixir", 10..3)
""

iex> String.slice("elixir", -4..-1)
"ixir"

iex> String.slice("elixir", 2..-1)
"ixir"

iex> String.slice("elixir", -4..6)
"ixir"

iex> String.slice("elixir", -1..-4)
""

iex> String.slice("elixir", -10..-7)
""

iex> String.slice("a", 0..1500)
"a"

iex> String.slice("a", 1..1500)
""

टुकड़ा (स्ट्रिंग, शुरू, लेन)

slice(t(), integer(), non_neg_integer()) :: grapheme()

ऑफसेट start और लंबाई len पर एक विकल्प start

यदि ऑफसेट स्ट्रिंग की लंबाई से अधिक है, तो यह "" लौटाता है।

याद रखें कि यह फ़ंक्शन यूनिकोड ग्रेफेम के साथ काम करता है और स्लाइस को ग्रेपमे ऑफ़सेट का प्रतिनिधित्व करता है। यदि आप कच्ची बाइट पर विभाजित करना चाहते हैं, तो इसके बजाय Kernel.binary_part/3 जांचें।

उदाहरण

iex> String.slice("elixir", 1, 3)
"lix"

iex> String.slice("elixir", 1, 10)
"lixir"

iex> String.slice("elixir", 10, 3)
""

iex> String.slice("elixir", -4, 4)
"ixir"

iex> String.slice("elixir", -10, 3)
""

iex> String.slice("a", 0, 1500)
"a"

iex> String.slice("a", 1, 1500)
""

iex> String.slice("a", 2, 1500)
""

विभाजन (बाइनरी)

split(t()) :: [t()]

प्रमुख और अनुगामी व्हाट्सएप की अनदेखी के साथ प्रत्येक यूनिकोड व्हाट्सएप घटना पर सबस्ट्रिंग में एक स्ट्रिंग विभाजित करता है। व्हाट्सएप के समूहों को एक ही घटना के रूप में माना जाता है। विभाजन गैर-ब्रेकिंग व्हाट्सएप पर नहीं होता है।

उदाहरण

iex> String.split("foo bar")
["foo", "bar"]

iex> String.split("foo" <> <<194, 133>> <> "bar")
["foo", "bar"]

iex> String.split(" foo   bar ")
["foo", "bar"]

iex> String.split("no\u00a0break")
["no\u00a0break"]

विभाजन (स्ट्रिंग, पैटर्न, विकल्प \\ [])

split(t(), pattern() | Regex.t(), keyword()) :: [t()]

एक पैटर्न के आधार पर सबस्ट्रिंग में एक स्ट्रिंग को विभाजित करता है।

इन सबस्ट्रिंग्स की सूची देता है। पैटर्न एक स्ट्रिंग, तार की एक सूची, एक नियमित अभिव्यक्ति या एक संकलित पैटर्न हो सकता है।

स्ट्रिंग को डिफ़ॉल्ट रूप से यथासंभव कई भागों में विभाजित किया जाता है, लेकिन इसे :parts विकल्प के माध्यम से नियंत्रित किया जा सकता है।

यदि :trim विकल्प सेट किया जाता है तो रिक्त स्ट्रिंग्स केवल परिणाम से हटा दिए जाते हैं true

जब इस्तेमाल किया जाने वाला पैटर्न एक नियमित अभिव्यक्ति है, तो स्ट्रिंग का उपयोग करके विभाजित किया जाता है Regex.split/3

विकल्प

  • :parts (धनात्मक पूर्णांक या :infinity ) - इस विकल्प के निर्दिष्ट होते ही स्ट्रिंग को कई भागों में विभाजित किया जाता है। यदि :infinity , स्ट्रिंग को सभी संभावित भागों में विभाजित किया जाएगा। अपभ्रंश :infinity

  • :trim (बूलियन) - यदि true , परिणामी सूची से खाली तार हटा दिए जाते हैं।

यह समारोह भी सभी विकल्प द्वारा स्वीकार कर लिया स्वीकार करता Regex.split/3 है, तो pattern एक नियमित अभिव्यक्ति है।

उदाहरण

एक स्ट्रिंग पैटर्न के साथ विभाजन:

iex> String.split("a,b,c", ",")
["a", "b", "c"]

iex> String.split("a,b,c", ",", parts: 2)
["a", "b,c"]

iex> String.split(" a b c ", " ", trim: true)
["a", "b", "c"]

पैटर्न की एक सूची:

iex> String.split("1,2 3,4", [" ", ","])
["1", "2", "3", "4"]

एक नियमित अभिव्यक्ति:

iex> String.split("a,b,c", ~r{,})
["a", "b", "c"]

iex> String.split("a,b,c", ~r{,}, parts: 2)
["a", "b,c"]

iex> String.split(" a b c ", ~r{\s}, trim: true)
["a", "b", "c"]

iex> String.split("abc", ~r{b}, include_captures: true)
["a", "b", "c"]

एक संकलित पैटर्न:

iex> pattern = :binary.compile_pattern([" ", ","])
iex> String.split("1,2 3,4", pattern)
["1", "2", "3", "4"]

खाली स्ट्रिंग रिटर्न पर बंटवारा अंगूर:

iex> String.split("abc", "")
["", "a", "b", "c", ""]

iex> String.split("abc", "", trim: true)
["a", "b", "c"]

iex> String.split("abc", "", parts: 1)
["abc"]

iex> String.split("abc", "", parts: 3)
["", "a", "bc"]

ध्यान दें कि यह फ़ंक्शन अंगूर की सीमाओं के भीतर या उससे अलग हो सकता है। उदाहरण के लिए, अंगूर "ए" को लें जो वर्ण "ई" और तीव्र उच्चारण से बना है। निम्नलिखित रिटर्न true :

iex> String.split(String.normalize("é", :nfd), "e")
["", "́"]

हालांकि, यदि "é" एकल चरित्र "ई के साथ तीव्र" उच्चारण द्वारा दर्शाया गया है, तो यह वापस आ जाएगा false :

iex> String.split(String.normalize("é", :nfc), "e")
["é"]

विभाजित_त (स्ट्रिंग, स्थिति)

split_at(t(), integer()) :: {t(), t()}

निर्दिष्ट ऑफसेट पर एक स्ट्रिंग को दो में विभाजित करता है। जब दी गई ऑफसेट नकारात्मक होती है, तो स्ट्रिंग के अंत से स्थान गिना जाता है।

ऑफसेट स्ट्रिंग की लंबाई के लिए छाया हुआ है। दो तत्वों के साथ एक ट्यूपल लौटाता है।

नोट: ध्यान रखें कि यह फ़ंक्शन अंगूर पर विभाजित होता है और इसके लिए इसे स्ट्रिंग को रैखिक रूप से पार करना पड़ता है। यदि आप बाइट्स की संख्या के आधार पर एक स्ट्रिंग या एक बाइनरी को विभाजित करना चाहते हैं, तो Kernel.binary_part/3 इसके बजाय का उपयोग करें ।

उदाहरण

iex> String.split_at("sweetelixir", 5)
{"sweet", "elixir"}

iex> String.split_at("sweetelixir", -6)
{"sweet", "elixir"}

iex> String.split_at("abc", 0)
{"", "abc"}

iex> String.split_at("abc", 1000)
{"abc", ""}

iex> String.split_at("abc", -1000)
{"", "abc"}

फाड़नेवाला (स्ट्रिंग, पैटर्न, विकल्प \\ [])

splitter(t(), pattern(), keyword()) :: Enumerable.t()

एक enumerable देता है जो मांग पर एक स्ट्रिंग को विभाजित करता है।

यह इसके विपरीत है split/3 जो पूरे स्ट्रिंग अपफ्रंट को विभाजित करता है।

नोट फाड़नेवाला नियमित अभिव्यक्तियों का समर्थन नहीं करता है (जैसा कि कई बार पास होने की तुलना में एक बार में नियमित रूप से भावों को स्ट्रिंग में पीछे करना अधिक कुशल होता है)।

विकल्प

  • : ट्रिम - जब true , खाली पैटर्न का उत्सर्जन नहीं करता है

उदाहरण

iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", [" ", ","]) |> Enum.take(4)
["1", "2", "3", "4"]

iex> String.splitter("abcd", "") |> Enum.take(10)
["", "a", "b", "c", "d", ""]

iex> String.splitter("abcd", "", trim: true) |> Enum.take(10)
["a", "b", "c", "d"]

एक संकलित पैटर्न भी दिया जा सकता है:

iex> pattern = :binary.compile_pattern([" ", ","])
iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", pattern) |> Enum.take(4)
["1", "2", "3", "4"]

start_with; (स्ट्रिंग, उपसर्ग)

starts_with?(t(), pattern()) :: boolean()

true यदि string दिए गए उपसर्गों में से किसी के साथ शुरू होता है, तो लौटाता है ।

prefix या तो एक स्ट्रिंग, तार की एक सूची या एक संकलित पैटर्न हो सकता है।

उदाहरण

iex> String.starts_with?("elixir", "eli")
true
iex> String.starts_with?("elixir", ["erlang", "elixir"])
true
iex> String.starts_with?("elixir", ["erlang", "ruby"])
false

एक संकलित पैटर्न भी दिया जा सकता है:

iex> pattern = :binary.compile_pattern(["erlang", "elixir"])
iex> String.starts_with?("elixir", pattern)
true

एक खाली स्ट्रिंग हमेशा मेल करेगी:

iex> String.starts_with?("elixir", "")
true
iex> String.starts_with?("elixir", ["", "other"])
true

to_atom (स्ट्रिंग)

to_atom(String.t()) :: atom()

एक स्ट्रिंग को एक परमाणु में परिवर्तित करता है।

चेतावनी: यह फ़ंक्शन परमाणुओं को गतिशील रूप से बनाता है और परमाणु कचरा-एकत्र नहीं होते हैं। इसलिए, string एक अविश्वसनीय मान नहीं होना चाहिए, जैसे कि सॉकेट से प्राप्त इनपुट या वेब अनुरोध के दौरान। to_existing_atom(string) इसके बजाय उपयोग करने पर विचार करें ।

डिफ़ॉल्ट रूप से, परमाणुओं की अधिकतम संख्या है 1_048_576 । VM विकल्प का उपयोग करके इस सीमा को बढ़ाया या कम किया जा सकता है +t

अधिकतम परमाणु आकार 255 वर्णों का होता है। Erlang / OTP 20 से पहले, केवल लैटिन 1 वर्णों की अनुमति है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> String.to_atom("my_atom")
:my_atom

to_charlist (स्ट्रिंग)

to_charlist(t()) :: charlist()

एक स्ट्रिंग को चारलिस्ट में परिवर्तित करता है।

विशेष रूप से, यह फ़ंक्शन UTF-8 एन्कोडेड बाइनरी लेता है और इसके पूर्णांक कोडपॉइंट्स की सूची देता है। यह codepoints(string) सिवाय इसके के समान है कि बाद वाले तार के रूप में कोडपॉइंट्स की एक सूची देता है।

मामले में आपको बाइट्स के साथ काम करने की आवश्यकता होती है, :binary मॉड्यूल पर एक नज़र डालें ।

उदाहरण

iex> String.to_charlist("æß")
'æß'

to_existing_atom (स्ट्रिंग)

to_existing_atom(String.t()) :: atom()

एक स्ट्रिंग को एक मौजूदा परमाणु में परिवर्तित करता है।

अधिकतम परमाणु आकार 255 वर्णों का होता है। Erlang / OTP 20 से पहले, केवल लैटिन 1 वर्णों की अनुमति है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> _ = :my_atom
iex> String.to_existing_atom("my_atom")
:my_atom

iex> String.to_existing_atom("this_atom_will_never_exist")
** (ArgumentError) argument error

to_float (स्ट्रिंग)

to_float(String.t()) :: float()

एक फ्लोट देता है जिसका पाठ प्रतिनिधित्व है string

string दशमलव बिंदु सहित फ्लोट का स्ट्रिंग प्रतिनिधित्व होना चाहिए। दशमलव के बिना एक स्ट्रिंग को एक फ्लोट के रूप में पार्स करने के लिए तब Float.parse/1 उपयोग किया जाना चाहिए। अन्यथा, एक ArgumentError उठाया जाएगा।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> String.to_float("2.2017764e+0")
2.2017764

iex> String.to_float("3.0")
3.0

String.to_float("3")
#=> ** (ArgumentError) argument error

to_integer (स्ट्रिंग)

to_integer(String.t()) :: integer()

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व है string

संकलक द्वारा झुका हुआ।

उदाहरण

iex> String.to_integer("123")
123

to_integer (स्ट्रिंग, आधार)

to_integer(String.t(), 2..36) :: integer()

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व string आधार में है base

संकलक द्वारा झुका हुआ।

उदाहरण

iex> String.to_integer("3FF", 16)
1023

ट्रिम (स्ट्रिंग)

trim(t()) :: t()

एक स्ट्रिंग लौटाता है जहाँ सभी अग्रणी और अनुगामी यूनिकोड व्हाट्सएप को हटा दिया गया है।

उदाहरण

iex> String.trim("\n  abc\n  ")
"abc"

ट्रिम करें (स्ट्रिंग, to_trim)

trim(t(), t()) :: t()

एक स्ट्रिंग लौटाता है जहां सभी अग्रणी और अनुगामी to_trim s को हटा दिया गया है।

उदाहरण

iex> String.trim("a  abc  a", "a")
"  abc  "

trim_leading (स्ट्रिंग)

trim_leading(t()) :: t()

एक स्ट्रिंग लौटाता है जहाँ सभी प्रमुख यूनिकोड व्हाट्सएप हटा दिए गए हैं।

उदाहरण

iex> String.trim_leading("\n  abc   ")
"abc   "

trim_leading (स्ट्रिंग, to_trim)

trim_leading(t(), t()) :: t()

एक स्ट्रिंग लौटाता है, जहां सभी प्रमुख to_trim एस हटा दिए गए हैं।

उदाहरण

iex> String.trim_leading("__ abc _", "_")
" abc _"

iex> String.trim_leading("1 abc", "11")
"1 abc"

trim_trailing (स्ट्रिंग)

trim_trailing(t()) :: t()

एक स्ट्रिंग लौटाता है जहां सभी अनुगामी यूनिकोड व्हाट्सएप को हटा दिया गया है।

उदाहरण

iex> String.trim_trailing("   abc\n  ")
"   abc"

trim_trailing (स्ट्रिंग, to_trim)

trim_trailing(t(), t()) :: t()

एक स्ट्रिंग लौटाता है जहाँ सभी अनुगामी to_trim s को हटा दिया गया है।

उदाहरण

iex> String.trim_trailing("_ abc __", "_")
"_ abc "

iex> String.trim_trailing("abc 1", "11")
"abc 1"

चढ़ाई (स्ट्रिंग, मोड \\: डिफ़ॉल्ट)

upcase(t(), :default | :ascii | :greek) :: t()

दिए गए स्ट्रिंग में सभी वर्णों को अपरकेस के अनुसार परिवर्तित करता है mode

mode हो सकता है :default , :ascii या :greek :default मोड सभी बिना शर्त वाले यूनीकोड मानक में उल्लिखित परिवर्तनों पर विचार करता है। :ascii अपरकेस केवल अक्षर a to z :greek ग्रीक में पाए जाने वाले संदर्भ संवेदनशील मैपिंग शामिल हैं।

उदाहरण

iex> String.upcase("abcd")
"ABCD"

iex> String.upcase("ab 123 xpto")
"AB 123 XPTO"

iex> String.upcase("olá")
"OLÁ"

:ascii मोड यूनिकोड वर्ण ध्यान नहीं देता और जब आप जानते हैं स्ट्रिंग केवल ASCII वर्ण हैं एक अधिक performant कार्यान्वयन प्रदान करता है:

iex> String.upcase("olá", :ascii)
"OLá"

वैध? (स्ट्रिंग)

valid?(t()) :: boolean()

जाँचता है कि क्या string केवल मान्य वर्ण हैं।

उदाहरण

iex> String.valid?("a")
true

iex> String.valid?("ø")
true

iex> String.valid?(<<0xFFFF::16>>)
false

iex> String.valid?(<<0xEF, 0xB7, 0x90>>)
true

iex> String.valid?("asd" <> <<0xFFFF::16>>)
false

Original text