Erlang 21

string




erlang

string

मॉड्यूल

तार

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

स्ट्रिंग प्रसंस्करण कार्य।

विवरण

यह मॉड्यूल स्ट्रिंग प्रसंस्करण के लिए कार्य प्रदान करता है।

इस मॉड्यूल में एक स्ट्रिंग को unicode:chardata() द्वारा दर्शाया गया unicode:chardata() , unicode:chardata() एक सूची, UTF-8-एन्कोडेड कोडपॉइंट्स ( UTF-8 बायनेरिज़ ) के साथ बायनेरिज़ , या दोनों का मिश्रण।

"abcd"               is a valid string
<<"abcd">>           is a valid string
["abcd"]             is a valid string
<<"abc..åäö"/utf8>>  is a valid string
<<"abc..åäö">>       is NOT a valid string,
                     but a binary with Latin-1-encoded codepoints
[<<"abc">>, "..åäö"] is a valid string
[atom]               is NOT a valid string

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

"Ã¥"  [229] or [97, 778]
"eÌŠ"  [101, 778]

"Ss ↑ e̊" की स्ट्रिंग लंबाई 3 है, भले ही यह [223,8593,101,778] या UTF-8 बाइनरी <<195,159,226,134,145,101,204,138>> का प्रतिनिधित्व करता है।

क्लास prepend और गैर-आधुनिक (या विघटित) हंगुल के कोडपॉइंट्स के लिए ग्रेफेम क्लस्टर को find/3 , replace/3 , split/2 , split/2 और trim/3 प्रदर्शन कारणों से नियंत्रित नहीं किया जाता है।

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

अधिकांश फ़ंक्शंस की उम्मीद है कि सभी इनपुट एक रूप में सामान्य हो जाएंगे, उदाहरण के लिए unicode:characters_to_nfc_list/1 देखें unicode:characters_to_nfc_list/1

किसी भी फ़ंक्शन में भाषा या स्थानीय विशिष्ट इनपुट से निपटने पर विचार नहीं किया जाता है।

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

जब तक अन्यथा निर्दिष्ट रिटर्न मान प्रकार इनपुट प्रकार के समान नहीं है। अर्थात्, बाइनरी इनपुट बाइनरी आउटपुट देता है, सूची इनपुट एक सूची आउटपुट देता है, और मिश्रित इनपुट एक मिश्रित आउटपुट वापस कर सकता है।

1> string:trim("  sarah  ").
"sarah"
2> string:trim(<<"  sarah  ">>).
<<"sarah">>
3> string:lexemes("foo bar", " ").
["foo","bar"]
4> string:lexemes(<<"foo bar">>, " ").
[<<"foo">>,<<"bar">>]

इस मॉड्यूल को unicode:chardata() / OTP 20 में unicode:chardata() को संभालने के लिए फिर से बनाया गया है unicode:chardata() और unicode:chardata() समूहों पर काम करते हैं। old functions जो इनपुट के रूप में केवल लैटिन -1 सूचियों पर काम करते हैं, वे अभी भी उपलब्ध हैं, लेकिन उनका उपयोग नहीं किया जाना चाहिए, उन्हें भविष्य के रिलीज में हटा दिया जाएगा।

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

direction() = leading | trailing
grapheme_cluster() = char() | [char()]

एक या एक से अधिक कोडपॉइंट्स से मिलकर एक उपयोगकर्ता-कथित वर्ण।

निर्यात

casefold (स्ट्रिंग :: unicode:chardata() ) -> unicode:chardata()

String को एक केस-अज्ञेय तुलनीय स्ट्रिंग में परिवर्तित करता है। फंक्शन casefold/1 को lowercase/1 से अधिक पसंद किया जाता है जब समानता के लिए दो स्ट्रिंग्स की तुलना की जाती है। equal/4 भी देखें।

उदाहरण:

1> string:casefold("Ω and ẞ SHARP S").
"ω and ss sharp s"
chomp (स्ट्रिंग :: unicode:chardata() ) -> unicode:chardata()

एक स्ट्रिंग लौटाता है जहां किसी भी अनुगामी \n या \r\n को String से हटा दिया गया है।

उदाहरण:

182> string:chomp(<<"\nHello\n\n">>).
<<"\nHello">>
183> string:chomp("\nHello\r\r\n").
"\nHello\r"
बराबर (ए, बी) -> बूलियन ()
बराबर (ए, बी, इग्नोरकेस) -> बूलियन ()
बराबर (ए, बी, इग्नोरकेस, नॉर्म) -> बूलियन ()

प्रकार

अगर A और B बराबर हैं, तो false

अगर IgnoreCase true कि फ़ंक्शन समानता परीक्षण से पहले मक्खी पर casefold ing करता है।

यदि Norm none तो फंक्शन समानता परीक्षण से पहले फ्लाई पर सामान्यीकरण लागू करता है। चार सामान्य उपलब्ध रूप हैं: unicode:characters_to_nfc_list/1 , nfd , nfkc , और nfkd

डिफ़ॉल्ट रूप से, IgnoreCase false और Norm none

उदाहरण:

1> string:equal("åäö", <<"åäö"/utf8>>).
true
2> string:equal("åäö", unicode:characters_to_nfd_binary("åäö")).
false
3> string:equal("åäö", unicode:characters_to_nfd_binary("ÅÄÖ"), true, nfc).
true
ढूंढें (स्ट्रिंग, सर्चपैटर्न) -> unicode:chardata() | कोई मुकाबला नहीं
ढूंढें (स्ट्रिंग, सर्चपैटर्न, डिर) -> unicode:chardata() | कोई मुकाबला नहीं

प्रकार

String में SearchPattern से पहले कुछ भी SearchPattern देता है और String के शेष को वापस कर देता है या nomatch नहीं SearchPattern पर SearchPattern है। Dir , जो leading या trailing हो सकता है, यह इंगित करता है कि किस दिशा के पात्रों को खोजना है।

डिफ़ॉल्ट रूप से, Dir leading

उदाहरण:

1> string:find("ab..cd..ef", ".").
"..cd..ef"
2> string:find(<<"ab..cd..ef">>, "..", trailing).
<<"..ef">>
3> string:find(<<"ab..cd..ef">>, "x", leading).
nomatch
4> string:find("ab..cd..ef", "x", trailing).
nomatch
is_empty (स्ट्रिंग :: unicode:chardata() ) -> बूलियन ()

true अगर String खाली स्ट्रिंग है, अन्यथा false

उदाहरण:

1> string:is_empty("foo").
false
2> string:is_empty(["",<<>>]).
true
लंबाई (स्ट्रिंग :: unicode:chardata() ) -> पूर्णांक ()> = ०

String में ग्रेपैम समूहों की संख्या लौटाता है।

उदाहरण:

1> string:length("ß↑e̊").
3
2> string:length(<<195,159,226,134,145,101,204,138>>).
3
lexemes (स्ट्रिंग :: unicode:chardata() ,
विभाजक सूची :: [ grapheme_cluster() ]) ->
[ unicode:chardata() ]

स्ट्रीपिंग में लेक्फेम्स की सूची लौटाता है, जिसे सेपरेटरलिस्ट में ग्रैफेम क्लस्टर्स द्वारा अलग किया जाता है।

ध्यान दें कि, जैसा कि इस उदाहरण में दिखाया गया है, String में दो या अधिक आसन्न विभाजक अंगूरों के समूहों को एक माना जाता है। यही है, lexemes की परिणामी सूची में कोई खाली स्ट्रिंग नहीं हैं। split/3 भी देखें जो खाली तार देता है।

ध्यान दें कि [$\r,$\n] एक अंगूर का समूह है।

उदाहरण:

1> string:lexemes("abc deÌŠfxxghix jkl\r\nfoo", "x e" ++ [[$\r,$\n]]).
["abc","deÌŠf","ghi","jkl","foo"]
2> string:lexemes(<<"abc deÌŠfxxghix jkl\r\nfoo"/utf8>>, "x e" ++ [$\r,$\n]).
[<<"abc">>,<<"deÌŠf"/utf8>>,<<"ghi">>,<<"jkl\r\nfoo">>]
लोअरकेस (स्ट्रिंग :: unicode:chardata() ) -> unicode:chardata()

String को लोअरकेस में परिवर्तित करता है।

ध्यान दें कि फंक्शन casefold/1 का उपयोग तब किया जाना चाहिए जब एक स्ट्रिंग को समानता के लिए परीक्षण किया जाए।

उदाहरण:

2> string:lowercase(string:uppercase("Michał")).
"michał"
next_codepoint (स्ट्रिंग :: unicode:chardata() ) ->
हो सकता है_इम्प्रोपर_लिस्ट (चार), unicode:chardata() ) |
{त्रुटि, unicode:chardata() }

String में पहला कोडपॉइंट और पूंछ में बाकी String । यदि String खाली है या एक {error, String} टपल है तो एक खाली सूची लौटाता है यदि अगला बाइट अमान्य है।

उदाहरण:

1> string:next_codepoint(unicode:characters_to_binary("eÌŠfg")).
[101|<<"ÌŠfg"/utf8>>]
next_grapheme (स्ट्रिंग :: unicode:chardata() ) ->
हो सकता है_प्रकार_सूची ( grapheme_cluster() ,
unicode:chardata() ) |
{त्रुटि, unicode:chardata() }

String में पहला ग्रेपैम क्लस्टर और पूंछ में बाकी String लौटाता है। यदि String खाली है या एक {error, String} टपल है तो एक खाली सूची लौटाता है यदि अगला बाइट अमान्य है।

उदाहरण:

1> string:next_grapheme(unicode:characters_to_binary("eÌŠfg")).
["eÌŠ"|<<"fg">>]
nth_lexeme (स्ट्रिंग, एन, सेपरेटरलिस्ट) -> unicode:chardata()

प्रकार

String में lexeme नंबर N को लौटाता है, जहां सेपरेटलिस्ट में ग्रैफेमी क्लस्टर्स द्वारा लेक्सेम को अलग किया जाता है।

उदाहरण:

1> string:nth_lexeme("abc.deÌŠf.ghiejkl", 3, ".e").
"ghi"
पैड (स्ट्रिंग, लंबाई) -> unicode:charlist()
पैड (स्ट्रिंग, लंबाई, unicode:charlist() ) -> unicode:charlist()
पैड (स्ट्रिंग, लंबाई, दिर, चार) -> unicode:charlist()

प्रकार

पैड String की Length साथ String Char Dir , जो leading , trailing या both , इंगित करता है कि पैडिंग को कहां जोड़ा जाना चाहिए।

डिफ़ॉल्ट रूप से, Char $\s और Dir trailing

उदाहरण:

1> string:pad(<<"He̊llö"/utf8>>, 8).
[<<72,101,204,138,108,108,195,182>>,32,32,32]
2> io:format("'~ts'~n",[string:pad("He̊llö", 8, leading)]).
'   He̊llö'
3> io:format("'~ts'~n",[string:pad("He̊llö", 8, both)]).
' He̊llö  '
उपसर्ग (स्ट्रिंग :: unicode:chardata() , प्रीफ़िक्स :: unicode:chardata() ) ->
नाममात्र | unicode:chardata()

यदि Prefix String का उपसर्ग है, तो इसे हटाता है और String के शेष को वापस करता है, अन्यथा nomatch वापस nomatch

उदाहरण:

1> string:prefix(<<"prefix of string">>, "pre").
<<"fix of string">>
2> string:prefix("pre", "prefix").
nomatch
बदलें (स्ट्रिंग, SearchPattern, प्रतिस्थापन) ->
[ unicode:chardata() ]
बदलें (स्ट्रिंग, सर्चपैटर्न, रिप्लेसमेंट, कहां) ->
[ unicode:chardata() ]

प्रकार

Replacement साथ String में SearchPattern जगह। Where , डिफ़ॉल्ट leading , इंगित करता है कि leading , trailing या SearchPattern all मुठभेड़ों को प्रतिस्थापित किया जाना है।

के रूप में लागू किया जा सकता है:

lists:join(Replacement, split(String, SearchPattern, Where)).

उदाहरण:

1> string:replace(<<"ab..cd..ef">>, "..", "*").
[<<"ab">>,"*",<<"cd..ef">>]
2> string:replace(<<"ab..cd..ef">>, "..", "*", all).
[<<"ab">>,"*",<<"cd">>,"*",<<"ef">>]
उल्टा (स्ट्रिंग :: unicode:chardata() ) -> [ grapheme_cluster() ]

String में अंगूर के समूहों की रिवर्स सूची देता है।

उदाहरण:

1> Reverse = string:reverse(unicode:characters_to_nfd_binary("ÅÄÖ")).
[[79,776],[65,776],[65,778]]
2> io:format("~ts~n",[Reverse]).
ÖÄÅ
टुकड़ा (स्ट्रिंग, प्रारंभ) -> टुकड़ा
टुकड़ा (स्ट्रिंग, प्रारंभ, लंबाई) -> टुकड़ा

प्रकार

स्थिति Start , सबसे अधिक Length अंगूर समूहों के String का एक विकल्प देता है।

डिफ़ॉल्ट रूप से, Length infinity

उदाहरण:

1> string:slice(<<"He̊llö Wörld"/utf8>>, 4).
<<"ö Wörld"/utf8>>
2> string:slice(["He̊llö ", <<"Wörld"/utf8>>], 4,4).
"ö Wö"
3> string:slice(["He̊llö ", <<"Wörld"/utf8>>], 4,50).
"ö Wörld"
विभाजन (स्ट्रिंग, सर्चपैटर्न) -> [ unicode:chardata() ]
विभाजन (स्ट्रिंग, सर्चपार्टनर, कहां) -> [ unicode:chardata() ]

प्रकार

स्प्लिट्स String जहां SearchPattern का सामना करना पड़ा है और शेष भागों को वापस करें। Where , डिफ़ॉल्ट leading , इंगित करता है कि क्या leading , SearchPattern या SearchPattern all मुठभेड़ String को विभाजित करेंगे।

उदाहरण:

0> string:split("ab..bc..cd", "..").
["ab","bc..cd"]
1> string:split(<<"ab..bc..cd">>, "..", trailing).
[<<"ab..bc">>,<<"cd">>]
2> string:split(<<"ab..bc....cd">>, "..", all).
[<<"ab">>,<<"bc">>,<<>>,<<"cd">>]
ले (स्ट्रिंग, वर्ण) -> {अग्रणी, अनुगामी}
ले (स्ट्रिंग, वर्ण, पूरक) -> {अग्रणी, अनुगामी}
ले (स्ट्रिंग, वर्ण, पूरक, डर) -> {अग्रणी, अनुगामी}

प्रकार

जब तक अक्षर सेट Characters सदस्य या सेट Characters के पूरक हैं, तब तक String से वर्ण लेता है। Dir , जो leading या trailing हो सकता है, इंगित करता है कि किस दिशा के पात्रों को लिया जाना है।

उदाहरण:

5> string:take("abc0z123", lists:seq($a,$z)).
{"abc","0z123"}
6> string:take(<<"abc0z123">>, lists:seq($0,$9), true, leading).
{<<"abc">>,<<"0z123">>}
7> string:take("abc0z123", lists:seq($0,$9), false, trailing).
{"abc0z","123"}
8> string:take(<<"abc0z123">>, lists:seq($a,$z), true, trailing).
{<<"abc0z">>,<<"123">>}
शीर्षक (स्ट्रिंग :: unicode:chardata() ) -> unicode:chardata()

String टू टाइटलकेस।

उदाहरण:

1> string:titlecase("ß is a SHARP s").
"Ss is a SHARP s"
to_float (स्ट्रिंग) -> {फ्लोट, आराम} | {त्रुटि, कारण}

प्रकार

तर्क String के एक मान्य पाठ के साथ शुरू होने की उम्मीद है जो फ्लोट का प्रतिनिधित्व करता है (अंक ASCII मान हैं)। Rest में फ्लोट वापस आने के बाद स्ट्रिंग में शेष वर्ण।

उदाहरण:

> {F1,Fs} = string:to_float("1.0-1.0e-1"),
> {F2,[]} = string:to_float(Fs),
> F1+F2.
0.9
> string:to_float("3/2=1.5").
{error,no_float}
> string:to_float("-1.5eX").
{-1.5,"eX"}
to_integer (स्ट्रिंग) -> {इंट, रेस्ट} | {त्रुटि, कारण}

प्रकार

तर्क String को एक मान्य पाठ प्रतिनिधित्व पूर्णांक (अंक ASCII मान हैं) के साथ शुरू होने की उम्मीद है। Rest में पूर्णांक वापस आने के बाद स्ट्रिंग में शेष वर्ण।

उदाहरण:

> {I1,Is} = string:to_integer("33+22"),
> {I2,[]} = string:to_integer(Is),
> I1-I2.
11
> string:to_integer("0.5").
{0,".5"}
> string:to_integer("x=2").
{error,no_integer}
to_graphemes (स्ट्रिंग :: unicode:chardata() ) -> [ grapheme_cluster() unicode:chardata() ] []

String को अंगूर के समूहों की सूची में परिवर्तित करता है।

उदाहरण:

1> string:to_graphemes("ß↑e̊").
[223,8593,[101,778]]
2> string:to_graphemes(<<"ß↑e̊"/utf8>>).
[223,8593,[101,778]]
ट्रिम (स्ट्रिंग) -> unicode:chardata()
ट्रिम (स्ट्रिंग, डिर) -> unicode:chardata()
ट्रिम (स्ट्रिंग, डिर, वर्ण) -> unicode:chardata()

प्रकार

एक स्ट्रिंग लौटाता है, जहां अग्रणी या अनुगामी, या दोनों, Characters हटा दिए गए हैं। Dir जो leading , trailing या both , यह इंगित करता है कि किस दिशा के पात्रों को हटाया जाना है।

डिफॉल्ट Characters नॉनब्रेकेबल व्हाट्सएप कोडपॉइंट्स का सेट है, जिसे Unicode Standard Annex #31 में Pattern_White_Space के रूप में परिभाषित किया गया है। By default, Dir both

ध्यान दें कि [$\r,$\n] यूनिकोड मानक के अनुसार एक अंगूर समूह है।

उदाहरण:

1> string:trim("\t Hello \n").
"Hello"
2> string:trim(<<"\t Hello \n">>, leading).
<<"Hello  \n">>
3> string:trim(<<".Hello.\n">>, trailing, "\n.").
<<".Hello">>
अपरकेस (स्ट्रिंग :: unicode:chardata() ) -> unicode:chardata()

String को अपरकेस में परिवर्तित करता है।

titlecase/1 भी देखें।

उदाहरण:

1> string:uppercase("Michał").
"MICHAŁ"

अप्रचलित एपीआई कार्य

यहां पुराने एपीआई के कार्य का अनुसरण किया गया है। ये कार्य केवल लैटिन -1 वर्णों की सूची पर काम करते हैं।

ध्यान दें

कार्यों को पिछड़े संगतता के लिए रखा जाता है, लेकिन अनुशंसित नहीं हैं। उन्हें भविष्य के रिलीज में पदावनत किया जाएगा।

string में किसी भी अवांछित कार्य का उपयोग नहीं किया जाना है।

निर्यात

केंद्र (स्ट्रिंग, संख्या) -> केंद्रित
केंद्र (स्ट्रिंग, संख्या, चरित्र) -> केंद्रित

प्रकार

एक स्ट्रिंग लौटाता है, जहां String में केंद्रित है और रिक्त स्थान या Character घिरा हुआ है। परिणामी स्ट्रिंग की लंबाई Number

यह फ़ंक्शन obsolete pad/3 उपयोग करें।

chars (चरित्र, संख्या) -> स्ट्रिंग
वर्ण (वर्ण, संख्या, पूंछ) -> स्ट्रिंग

प्रकार

Number वर्णों से मिलकर एक स्ट्रिंग लौटाता है। वैकल्पिक रूप से, स्ट्रिंग स्ट्रिंग Tail साथ समाप्त हो सकती है।

यह फ़ंक्शन obsolete lists:duplicate/2 उपयोग करें lists:duplicate/2

chr (स्ट्रिंग, चरित्र) -> सूचकांक

प्रकार

String में Character की पहली घटना का सूचकांक लौटाता है। Character नहीं होने पर 0 देता है।

यह फ़ंक्शन obsolete । उपयोग find/2

concat (स्ट्रिंग 1, स्ट्रिंग 2) -> स्ट्रिंग 3

प्रकार

String1 और String2 को एक नया स्ट्रिंग String3 , जो वापस आ गया है।

यह फ़ंक्शन obsolete Data तर्क के रूप में [String1, String2] उपयोग करें और unicode:characters_to_list/2 कॉल करें unicode:characters_to_list/2 या unicode:characters_to_binary/2 आउटपुट को समतल करने के लिए।

प्रतियां (स्ट्रिंग, संख्या) -> प्रतियां

प्रकार

एक स्ट्रिंग देता है जिसमें String बार-बार Number है।

यह फ़ंक्शन obsolete lists:duplicate/2 उपयोग करें lists:duplicate/2

cspan (स्ट्रिंग, चार्ट) -> लंबाई

प्रकार

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

यह फ़ंक्शन obsolete । का उपयोग करें take/3

उदाहरण:

> string:cspan("\t    abcdef", " \t").
0
join (StringList, विभाजक) -> स्ट्रिंग

प्रकार

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

यह फ़ंक्शन obsolete lists:join/2 उपयोग करें lists:join/2

उदाहरण:

> join(["one", "two", "three"], ", ").
"one, two, three"
बाएँ (स्ट्रिंग, संख्या) -> बाएँ
बाएँ (स्ट्रिंग, संख्या, वर्ण) -> बाएँ

प्रकार

Number अनुसार समायोजित की गई लंबाई के साथ रिटर्न। बायां मार्जिन तय हो गया है। यदि length(String) < Number , तो String को खाली या Character साथ गद्देदार किया जाता है।

यह फ़ंक्शन obsolete pad/2 या pad/3 उपयोग करें।

उदाहरण:

> string:left("Hello",10,$.).
"Hello....."
len (स्ट्रिंग) -> लंबाई

प्रकार

String में वर्णों की संख्या लौटाता है।

यह फ़ंक्शन obsolete length/1 प्रयोग करें।

rchr (स्ट्रिंग, चरित्र) -> सूचकांक

प्रकार

String में Character की अंतिम घटना के सूचकांक को लौटाता है। Character नहीं होने पर 0 देता है।

यह फ़ंक्शन obsolete । उपयोग find/3

सही (स्ट्रिंग, संख्या) -> सही
सही (स्ट्रिंग, संख्या, चरित्र) -> सही

प्रकार

Number अनुसार समायोजित की गई लंबाई के साथ रिटर्न। सही मार्जिन तय हो गया है। यदि (String) Number < Number , तो String को खाली या Character साथ गद्देदार किया जाता है।

यह फ़ंक्शन obsolete pad/3 उपयोग करें।

उदाहरण:

> string:right("Hello", 10, $.).
".....Hello"
रैस्ट (स्ट्रिंग, सबस्ट्रिंग) -> सूचकांक

प्रकार

उस स्थिति में वापस SubString जहां String में SubString की अंतिम घटना शुरू होती है। 0 रिटर्न अगर SubString String में मौजूद नहीं है।

यह फ़ंक्शन obsolete । उपयोग find/3

उदाहरण:

> string:rstr(" Hello Hello World World ", "Hello World").
8
स्पैन (स्ट्रिंग, चार्ट) -> लंबाई

प्रकार

String के अधिकतम प्रारंभिक खंड की लंबाई लौटाता है, जिसमें पूरी तरह से वर्ण से वर्ण होते हैं।

यह फ़ंक्शन obsolete । उपयोग take/2

उदाहरण:

> string:span("\t    abcdef", " \t").
5
str (स्ट्रिंग, सबस्ट्रिंग) -> सूचकांक

प्रकार

उस स्थिति को लौटाता है जहां String में SubString की पहली घटना शुरू होती है। 0 रिटर्न अगर SubString String में मौजूद नहीं है।

यह फ़ंक्शन obsolete । उपयोग find/2

उदाहरण:

> string:str(" Hello Hello World World ", "Hello World").
8
पट्टी (स्ट्रिंग :: स्ट्रिंग) () -> स्ट्रिंग ()
स्ट्रिप (स्ट्रिंग, दिशा) -> स्ट्रिप्ड
पट्टी (स्ट्रिंग, दिशा, चरित्र) -> स्ट्रिप्ड

प्रकार

एक स्ट्रिंग लौटाता है, जहां अग्रणी या अनुगामी, या दोनों, रिक्त या कई Character हटा दिए गए हैं। Direction , जिसे left , right या both को दिखाया जा सकता है, यह दर्शाता है कि किस दिशा से रिक्त स्थान को हटाया जाना है। strip/1 strip(String, both) बराबर है।

यह फ़ंक्शन obsolete trim/3 उपयोग करें।

उदाहरण:

> string:strip("...Hello.....", both, $.).
"Hello"
सब_स्ट्रिंग (स्ट्रिंग, प्रारंभ) -> सबस्ट्रिंग
सब_स्ट्रिंग (स्ट्रिंग, स्टार्ट, स्टॉप) -> सबस्ट्रिंग

प्रकार

स्ट्रिंग का एक विकल्प देता है, स्थिति पर शुरू String के अंत में, या करने के लिए स्थिति Stop और शामिल है।

यह फ़ंक्शन obsolete slice/3 उपयोग करें।

उदाहरण:

sub_string("Hello World", 4, 8).
"lo Wo"
पदार्थ (स्ट्रिंग, प्रारंभ) -> सबस्ट्रिंग
पदार्थ (स्ट्रिंग, प्रारंभ, लंबाई) -> सबस्ट्रिंग

प्रकार

स्ट्रिंग का एक विकल्प देता है, स्थिति पर Start , और स्ट्रिंग के अंत में या लंबाई Length पर समाप्त होता है।

यह फ़ंक्शन obsolete slice/3 उपयोग करें।

उदाहरण:

> substr("Hello World", 4, 5).
"lo Wo"
उप_शब्द (स्ट्रिंग, संख्या) -> शब्द
उप_शब्द (स्ट्रिंग, संख्या, वर्ण) -> शब्द

प्रकार

शब्द को स्थिति में वापस String है String Number । शब्द रिक्त या Character s द्वारा अलग किए गए हैं।

यह फ़ंक्शन obsolete nth_lexeme/3 उपयोग करें।

उदाहरण:

> string:sub_word(" Hello old boy !",3,$o).
"ld b"
to_lower (स्ट्रिंग) -> परिणाम
to_lower (चार) -> CharResult
to_upper (स्ट्रिंग) -> परिणाम
to_upper (चार) -> CharResult

प्रकार

निर्दिष्ट स्ट्रिंग या वर्ण केस-रूपांतरित है। ध्यान दें कि समर्थित वर्ण सेट ISO / IEC 8859-1 है (जिसे लैटिन 1 भी कहा जाता है); इस सेट के बाहर सभी मान अपरिवर्तित हैं

यह फ़ंक्शन obsolete उपयोग lowercase/1 , uppercase/1 , titlecase/1 या casefold/1

टोकन (स्ट्रिंग, सेपरेटरलिस्ट) -> टोकन

प्रकार

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

उदाहरण:

> tokens("abc defxxghix jkl", "x ").
["abc", "def", "ghi", "jkl"]

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

यह फ़ंक्शन obsolete split/2 प्रयोग करें।

शब्द (स्ट्रिंग) -> गणना
शब्द (स्ट्रिंग, चरित्र) -> गणना

प्रकार

String या Character द्वारा अलग किए गए String में शब्दों की संख्या लौटाता है।

यह फ़ंक्शन obsolete split/2 प्रयोग करें।

उदाहरण:

> words(" Hello old boy!", $o).
4

टिप्पणियाँ

कुछ सामान्य स्ट्रिंग फ़ंक्शन एक दूसरे को ओवरलैप करने के लिए लग सकते हैं। कारण यह है कि यह स्ट्रिंग पैकेज दो पुराने पैकेजों का संयोजन है और दोनों पैकेजों के सभी कार्यों को बरकरार रखा गया है।