Julia Language
स्ट्रिंग मैक्रोज़

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

• मैक्रो "स्ट्रिंग" # शॉर्ट, स्ट्रिंग मैक्रो फॉर्म
• @ macro_str "स्ट्रिंग" # लंबी, नियमित मैक्रो फॉर्म
• macro`command`

टिप्पणियों

julia> "$("x")"
"x"

julia> doc"$("x")"
ERROR: KeyError: key :x not found

julia> doc"""$("x")"""
"x"

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

स्ट्रिंग मैक्रोज़ कुछ मैक्रो इनवोकेशन के लिए सिंटैक्टिक शुगर हैं। पार्सर जैसे सिंटैक्स का विस्तार करता है

mymacro"my string"

में

@mymacro_str "my string"

जो तब किसी भी अन्य मैक्रो कॉल की तरह, @mymacro_str मैक्रो रिटर्न जो भी अभिव्यक्ति के साथ प्रतिस्थापित किया जाता है। बेस जूलिया कई स्ट्रिंग मैक्रोज़ के साथ आता है, जैसे:

@b_str

इस स्ट्रिंग मैक्रो निर्माणों बाइट सरणियों के बजाय तार । स्ट्रिंग की सामग्री, यूटीएफ -8 के रूप में एन्कोडेड, बाइट्स के सरणी के रूप में उपयोग की जाएगी। यह निम्न-स्तरीय एपीआई के साथ इंटरफेस करने के लिए उपयोगी हो सकता है, जिनमें से कई स्ट्रिंग्स के बजाय बाइट सरणियों के साथ काम करते हैं।

julia> b"Hello World!"
12-element Array{UInt8,1}:
 0x48
 0x65
 0x6c
 0x6c
 0x6f
 0x20
 0x57
 0x6f
 0x72
 0x6c
 0x64
 0x21

@big_str

इस मैक्रो एक वापस आ जाएगी BigInt या एक BigFloat स्ट्रिंग यह दिया है से पार्स।

julia> big"1"
1

julia> big"1.0"
1.000000000000000000000000000000000000000000000000000000000000000000000000000000

यह मैक्रो मौजूद है क्योंकि big(0.1) व्यवहार नहीं करता है क्योंकि कोई शुरू में उम्मीद कर सकता है: 0.1 सच 0.1 ( 1//10 ) का एक Float64 सन्निकटन है, और BigFloat को बढ़ावा देने से BigFloat की सन्निकटन त्रुटि Float64 । मैक्रो का उपयोग करना BigFloat को सीधे 0.1 पार्स करेगा, सन्निकटन त्रुटि को कम करेगा।

julia> big(0.1)
1.000000000000000055511151231257827021181583404541015625000000000000000000000000e-01

julia> big"0.1"
1.000000000000000000000000000000000000000000000000000000000000000000000000000002e-01

@doc_str

यह स्ट्रिंग मैक्रो Base.Markdown.MD ऑब्जेक्ट का निर्माण Base.Markdown.MD है, जो किसी भी वातावरण के लिए रिच-टेक्स्ट प्रलेखन प्रदान करने के लिए आंतरिक प्रलेखन प्रणाली में उपयोग किया जाता है। ये एमडी ऑब्जेक्ट एक टर्मिनल में अच्छी तरह से प्रस्तुत करते हैं:

और एक ब्राउज़र में भी:

@html_str

यह स्ट्रिंग मैक्रो HTML स्ट्रिंग शाब्दिक का निर्माण करता है, जो एक ब्राउज़र में अच्छी तरह से प्रस्तुत करता है:

@ip_str

यह स्ट्रिंग मैक्रो IP एड्रेस शाब्दिक निर्माण करता है। यह IPv4 और IPv6 दोनों के साथ काम करता है:

julia> ip"127.0.0.1"
ip"127.0.0.1"

julia> ip"::"
ip"::"

@r_str

यह स्ट्रिंग मैक्रो Regex शाब्दिक का निर्माण करता है ।

@s_str

यह स्ट्रिंग मैक्रो SubstitutionString शाब्दिक का निर्माण करता है, जो Regex शाब्दिक के साथ मिलकर काम करता है ताकि अधिक उन्नत टेक्स्टुअल प्रतिस्थापन की अनुमति मिल सके।

@text_str

यह स्ट्रिंग मैक्रो @doc_str और @html_str भावना के समान है, लेकिन इसमें कोई फैंसी स्वरूपण विशेषताएं नहीं हैं:

@v_str

यह स्ट्रिंग मैक्रो VersionNumber लिटरल्स का निर्माण करता है। वे क्या हैं और उनका उपयोग कैसे करें, इसके विवरण के लिए संस्करण संख्या देखें।

@MIME_str

यह स्ट्रिंग मैक्रो सिंगलटन प्रकार के MIME प्रकारों का निर्माण करता है। उदाहरण के लिए, MIME"text/plain" MIME("text/plain") का प्रकार है MIME("text/plain") ।

वे प्रतीक जो कानूनी पहचानकर्ता नहीं हैं

जूलिया प्रतीक शाब्दिक कानूनी पहचानकर्ता होना चाहिए। यह काम:

julia> :cat
:cat

लेकिन यह नहीं है:

julia> :2cat
ERROR: MethodError: no method matching *(::Int64, ::Base.#cat)
Closest candidates are:
  *(::Any, ::Any, ::Any, ::Any...) at operators.jl:288
  *{T<:Union{Int128,Int16,Int32,Int64,Int8,UInt128,UInt16,UInt32,UInt64,UInt8}}(::T<:Union{Int128,Int16,Int32,Int64,Int8,UInt128,UInt16,UInt32,UInt64,UInt8}, ::T<:Union{Int128,Int16,Int32,Int64,Int8,UInt128,UInt16,UInt32,UInt64,UInt8}) at int.jl:33
  *(::Real, ::Complex{Bool}) at complex.jl:180
  ...

यहाँ एक प्रतीक शाब्दिक जैसा दिखता है, वास्तव में :2 (जो कि सिर्फ 2 ) और फ़ंक्शन cat अंतर्निहित गुणन के रूप में देखा जा रहा है, जो स्पष्ट रूप से काम नहीं करता है।

हम प्रयोग कर सकते हैं

julia> Symbol("2cat")
Symbol("2cat")

मुद्दे के आसपास काम करने के लिए।

एक स्ट्रिंग मैक्रो इस अधिक विशिष्ट बनाने में मदद कर सकता है। अगर हम @sym_str मैक्रो को परिभाषित करते हैं:

macro sym_str(str)
    Meta.quot(Symbol(str))
end

तो हम बस कर सकते हैं

julia> sym"2cat"
Symbol("2cat")

ऐसे प्रतीक बनाना जो वैध जूलिया पहचानकर्ता न हों।

बेशक, इन तकनीकों भी मान्य जूलिया पहचानकर्ता हैं प्रतीकों बना सकते हैं। उदाहरण के लिए,

julia> sym"test"
:test

एक स्ट्रिंग मैक्रो में प्रक्षेप को लागू करना

स्ट्रिंग मैक्रोज़ अंतर्निर्मित प्रक्षेप सुविधाओं के साथ नहीं आते हैं। हालांकि, इस कार्यक्षमता को मैन्युअल रूप से लागू करना संभव है। ध्यान दें कि स्ट्रिंग स्ट्रिंग से बचने के बिना एम्बेड करना संभव नहीं है जो आसपास के स्ट्रिंग मैक्रो के समान सीमांकक है; वह है, हालांकि """ $("x") """ संभव है, " $("x") " नहीं है। इसके बजाय, इसे " $(\"x\") " रूप में बच जाना चाहिए। इस सीमा के बारे में अधिक जानकारी के लिए टिप्पणी अनुभाग देखें।

मैन्युअल रूप से प्रक्षेप को लागू करने के लिए दो दृष्टिकोण हैं: मैन्युअल रूप से पार्सिंग लागू करें, या जूलिया को पार्स करने के लिए प्राप्त करें। पहला दृष्टिकोण अधिक लचीला है, लेकिन दूसरा दृष्टिकोण आसान है।

मैनुअल पार्सिंग

macro interp_str(s)
    components = []
    buf = IOBuffer(s)
    while !eof(buf)
        push!(components, rstrip(readuntil(buf, '$'), '$'))
        if !eof(buf)
            push!(components, parse(buf; greedy=false))
        end
    end
    quote
        string($(map(esc, components)...))
    end
end

जूलिया पार्स कर रही है

macro e_str(s)
    esc(parse("\"$(escape_string(s))\""))
end

यह विधि स्ट्रिंग से बच जाती है (लेकिन ध्यान दें कि escape_string $ संकेतों से बच नहीं जाता है) और इसे जूलिया के पार्सर को पार्स करने के लिए वापस भेज देता है। स्ट्रिंग को बचाना यह सुनिश्चित करने के लिए आवश्यक है कि " और \ _ स्ट्रिंग की पार्सिंग को प्रभावित न करें। परिणामी अभिव्यक्ति एक :string अभिव्यक्ति है, जिसे मैक्रो उद्देश्यों के लिए जांच और विघटित किया जा सकता है।

कमान मैक्रों

mymacro`xyz`

@mymacro_cmd "xyz"

macro julia_cmd(s)
    esc(Meta.quot(parse(s)))
end

julia> julia`1+1`
:(1 + 1)

julia> julia`hypot2(x,y)=x^2+y^2`
:(hypot2(x,y) = begin  # none, line 1:
            x ^ 2 + y ^ 2
        end)

julia> julia```
       function hello()
           println("Hello, World!")
       end
       ```
:(function hello() # none, line 2:
        println("Hello, World!")
    end)

julia> x = 2
2

julia> julia`1 + $x`
:(1 + 2)

julia> julia```
       x = 2
       y = 3
       ```
ERROR: ParseError("extra token after end of expression")