Julia Language
स्ट्रिंग्स

वाक्य - विन्यास

• "[स्ट्रिंग]"
• '[यूनिकोड स्केलर मूल्य]'
• graphemes ([स्ट्रिंग])

पैरामीटर

नमस्ते दुनिया!

जूलिया में तार " प्रतीक: " का उपयोग करके सीमांकित किए जाते हैं

julia> mystring = "Hello, World!"
"Hello, World!"

ध्यान दें कि कुछ अन्य भाषाओं के विपरीत, ' प्रतीक का उपयोग इसके बजाय नहीं किया जा सकता है। ' एक चरित्र शाब्दिक परिभाषित करता है; यह एक Char डेटा प्रकार है और केवल एक यूनिकोड स्केलर मान संग्रहीत करेगा:

julia> 'c'
'c'

julia> 'character'
ERROR: syntax: invalid character literal

एक एक के साथ इस पर पुनरावृत्ति द्वारा एक स्ट्रिंग से यूनिकोड अदिश मूल्यों निकाल सकते हैं for पाश :

julia> for c in "Hello, World!"
           println(c)
       end
H
e
l
l
o
,
 
W
o
r
l
d
!

Graphemes

जूलिया के Char प्रकार एक यूनिकोड स्केलर मूल्य का प्रतिनिधित्व करते हैं, जो केवल कुछ मामलों में मनुष्यों को "चरित्र" के रूप में समझते हैं। उदाहरण के लिए, चरित्र का एक प्रतिनिधित्व, जैसा कि रिज्यूमे में है, वास्तव में दो यूनिकोड स्केलर मूल्यों का एक संयोजन है:

julia> collect("é")
2-element Array{Char,1}:
 'e'
 '́'

इन कोडपॉइंट्स के लिए यूनिकोड विवरण "LATIN SMALL LETTER E" और "COMBINING ACUTE ACCENT" हैं। साथ में, वे एक एकल "मानव" चरित्र को परिभाषित करते हैं, जिसे यूनिकोड की शर्तों को एक अंगूर कहा जाता है। विशेष रूप से, यूनिकोड एनेक्स # 29 एक अंगूर समूह की परिभाषा को प्रेरित करता है क्योंकि:

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

जूलिया एक स्ट्रिंग में अंगूर के समूहों पर पुनरावृति करने के लिए graphemes का graphemes प्रदान करता है:

julia> for c in graphemes("résumé")
           println(c)
       end
r
é
s
u
m
é

ध्यान दें कि परिणाम, प्रत्येक वर्ण को अपनी रेखा पर मुद्रित करना, इससे बेहतर है कि हमने यूनिकोड स्केलर मानों पर पुनरावृत्ति की है:

julia> for c in "résumé"
           println(c)
       end
r
e

s
u
m
e

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

julia> wordlength(word) = length(word)
wordlength (generic function with 1 method)

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

julia> wordlength("résumé")
8

जब हम अधिक सही परिभाषा का उपयोग करते हैं, तो graphemes फलन का उपयोग करके, हमें अपेक्षित परिणाम मिलता है:

julia> wordlength(word) = length(graphemes(word))
wordlength (generic function with 1 method)

julia> wordlength("résumé")
6

संख्यात्मक प्रकारों को स्ट्रिंग्स में कनवर्ट करें

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

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

string() फ़ंक्शन भी अधिक तर्क ले सकता है:

julia> string(a, "b")
"123b"

आप $ का उपयोग करके तार में (उर्फ इंटरपोलेट) पूर्णांक (और कुछ अन्य प्रकार) भी सम्मिलित कर सकते हैं:

julia> MyString = "my integer is $a"
"my integer is 123"

प्रदर्शन युक्ति: उपर्युक्त विधियाँ कई बार काफी सुविधाजनक हो सकती हैं। लेकिन, यदि आप कई, कई ऐसे ऑपरेशन कर रहे हैं और आप अपने कोड की निष्पादन गति के बारे में चिंतित हैं, तो जूलिया प्रदर्शन गाइड इसके खिलाफ सिफारिश करता है, और इसके बजाय नीचे दिए गए तरीकों के पक्ष में है:

आप print() करने के लिए कई तर्क दे सकते हैं print() और println() जो उन पर ठीक उसी तरह काम करेंगे जैसे string() कई तर्कों पर काम करता है:

julia> println(a, "b")
123b

या, फ़ाइल में लिखते समय, आप इसी तरह उपयोग कर सकते हैं, जैसे

open("/path/to/MyFile.txt", "w") do file
    println(file, a, "b", 13)
end

या

file = open("/path/to/MyFile.txt", "a")
println(file, a, "b", 13)
close(file)

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

क्रेडिट: एसओ प्रश्न के आधार पर उत्तर । जूलिया में इंट को स्ट्रिंग में बदलने का सबसे अच्छा तरीका क्या है? फेंगयांग वांग से माइकल ओह्ल्रोगे और इनपुट द्वारा उत्तर के साथ

स्ट्रिंग प्रक्षेप (स्ट्रिंग में चर द्वारा परिभाषित मूल्य डालें)

जूलिया में, कई अन्य भाषाओं की तरह, चर द्वारा परिभाषित मूल्यों को तार में सम्मिलित करके प्रक्षेपित करना संभव है। एक साधारण उदाहरण के लिए:

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

हम संख्यात्मक के अलावा अन्य प्रकारों का उपयोग कर सकते हैं, जैसे

Result = false
julia> println("test results is $Result")
test results is false

आपके पास दिए गए स्ट्रिंग के भीतर कई प्रक्षेप हो सकते हैं:

MySubStr = "a32"
MyNum = 123.31
println("$MySubStr  ,   $MyNum")

प्रदर्शन टिप इंटरपोलेशन काफी सुविधाजनक है। लेकिन, यदि आप इसे बहुत तेजी से कई बार करने जा रहे हैं, तो यह सबसे अधिक कुशल नहीं है। इसके बजाय, जब प्रदर्शन एक समस्या हो तो सुझावों के लिए संख्यात्मक प्रकारों को रूपांतरित करें देखें।

स्प्रिंट का उपयोग करके IO फ़ंक्शंस के साथ स्ट्रिंग्स बनाएं

sprint फ़ंक्शन का उपयोग करके IO ऑब्जेक्ट्स के साथ काम करने वाले फ़ंक्शन से स्ट्रिंग्स बनाया जा सकता है। उदाहरण के लिए, code_llvm फ़ंक्शन एक IO ऑब्जेक्ट को पहले तर्क के रूप में स्वीकार करता है। आमतौर पर, इसका उपयोग किया जाता है

julia> code_llvm(STDOUT, *, (Int, Int))

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

मान लीजिए कि हम उस आउटपुट को एक स्ट्रिंग के बजाय चाहते हैं। तब हम बस कर सकते हैं

julia> sprint(code_llvm, *, (Int, Int))
"\ndefine i64 @\"jlsys_*_46115\"(i64, i64) #0 {\ntop:\n  %2 = mul i64 %1, %0\n  ret i64 %2\n}\n"

julia> println(ans)

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

"इंटरएक्टिव" फ़ंक्शन के परिणामों को code_llvm में code_llvm में code_llvm करना स्वचालित विश्लेषण के लिए उपयोगी हो सकता है, जैसे कि यह परीक्षण करना कि क्या उत्पन्न कोड फिर से हो सकता है।

sprint फ़ंक्शन एक उच्च-क्रम फ़ंक्शन है जो IO ऑब्जेक्ट्स पर फ़ंक्शन को इसके पहले तर्क के रूप में संचालित करता है। दृश्यों के पीछे, यह रैम में एक IOBuffer बनाता है, दिए गए फ़ंक्शन को कॉल करता है, और बफर से डेटा को String ऑब्जेक्ट में ले जाता है।