Lua
पैटर्न मिलान

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

• string.find (str, pattern [, init [, plain]]) - रिटर्न स्टार्ट और एंड का इंडेक्स ऑफ मैच

• string.match (str, pattern [, index]) - एक बार एक पैटर्न से मेल खाता है (index पर शुरू)

• string.gmatch (str, pattern) - एक ऐसा फंक्शन देता है जो str के सभी मैचों से होता है

• string.gsub (str, pattern, repl [, n]) - प्रतिस्थापित पदार्थ (अधिकतम n तक)

• . सभी पात्रों का प्रतिनिधित्व करता है

• %a सभी पत्रों का प्रतिनिधित्व करता है

• %l सभी लोअरकेस अक्षरों का प्रतिनिधित्व करता है

• %u सभी अपरकेस अक्षरों का प्रतिनिधित्व करता है

• %d सभी अंकों का प्रतिनिधित्व करता है

• %x सभी हेक्साडेसिमल अंकों का प्रतिनिधित्व करता है

• %s सभी व्हाट्सएप पात्रों का प्रतिनिधित्व करता है

• %p सभी विराम चिह्नों का प्रतिनिधित्व करता है

• %g अंतरिक्ष को छोड़कर सभी मुद्रण योग्य वर्णों का प्रतिनिधित्व करता है

• %c सभी नियंत्रण वर्णों का प्रतिनिधित्व करता है

• [set] उस वर्ग का प्रतिनिधित्व करता है जो सेट में सभी वर्णों का मिलन है।

• [^set] के पूरक का प्रतिनिधित्व करता है

• * लालची मैच 0 या पिछले चरित्र वर्ग की अधिक घटनाएँ

• + लालची मैच पिछले चरित्र वर्ग की 1 या अधिक घटनाओं

• - आलसी मैच 0 या पिछले चरित्र वर्ग की अधिक घटनाएं

• ? मैच पिछले चरित्र वर्ग की 0 या 1 घटना

टिप्पणियों

लुआ पैटर्न मिलान

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

जैसा कि ऊपर उल्लेख किया गया है, उन वर्गों का कोई भी ऊपरी-मामला संस्करण वर्ग के पूरक का प्रतिनिधित्व करता है। उदाहरण के लिए, %D किसी भी गैर-अंक वर्ण क्रम से मेल खाएगा:

string.match("f123", "%D")          --> f

चरित्र वर्गों के अलावा, कुछ पात्रों में पैटर्न के रूप में विशेष कार्य होते हैं:

( ) % . + - * [ ? ^ $

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

एक वर्ण सेट, जो वर्ग कोष्ठक ( [] ) के अंदर दर्शाया गया है, आपको एक विशेष वर्ण वर्ग बनाने की अनुमति देता है, विभिन्न वर्गों और एकल वर्णों को मिलाकर:

local foo = "bar123bar2341"
print(foo:match "[arb]")            --> b

आप वर्ण के पूरक को ^ से शुरू करके निर्धारित कर सकते हैं:

local foo = "bar123bar2341"
print(string.match(foo, "[^bar]"))  --> 1

इस उदाहरण में, string.match को पहली घटना मिलेगी जो b , a या r नहीं है ।

पुनरावृत्ति / वैकल्पिक संशोधक की मदद से पैटर्न अधिक उपयोगी हो सकते हैं, लुआ में पैटर्न ये चार वर्ण प्रदान करते हैं:

चरित्र + अनुक्रम में एक या अधिक मिलान किए गए वर्णों का प्रतिनिधित्व करता है और यह हमेशा सबसे लंबे मिलान वाले अनुक्रम को लौटाएगा:

local foo = "12345678bar123"
print(foo:match "%d+")  --> 12345678

जैसा कि आप देख सकते हैं, * यह + समान है, लेकिन यह वर्णों की शून्य घटनाओं को स्वीकार करता है और आमतौर पर विभिन्न पैटर्न के बीच वैकल्पिक स्थानों से मेल खाने के लिए उपयोग किया जाता है।

चरित्र - भी * समान है, लेकिन सबसे लंबे समय तक मिलान क्रम को वापस करने के बजाय, यह सबसे छोटे से मेल खाता है।

संशोधक ? एक वैकल्पिक चरित्र से मेल खाता है, जिससे आप मिलान कर सकते हैं, उदाहरण के लिए, एक नकारात्मक अंक:

local foo = "-20"
print(foo:match "[+-]?%d+")

लुआ पैटर्न मिलान इंजन कुछ अतिरिक्त पैटर्न मिलान आइटम प्रदान करता है:

string.find (परिचय)

find समारोह

आइए सबसे पहले string.find पर एक नज़र string.find हैं। सामान्य रूप से कार्य करते हैं:

फ़ंक्शन string.find (s, substr [, init [, plain]]) एक सबस्ट्रिंग का प्रारंभ और अंत सूचकांक लौटाता है यदि मिला, और nil अन्यथा, सूचकांक init पर शुरू होता है यदि यह प्रदान किया जाता है (डिफ़ॉल्ट 1)।

("Hello, I am a string"):find "am" --> returns 10 11
-- equivalent to string.find("Hello, I am a string", "am") -- see remarks

पेश है पैटर्न

("hello world"):find ".- " -- will match characters until it finds a space
    --> so it will return 1, 6

निम्नलिखित वर्णों को छोड़कर सभी स्वयं का प्रतिनिधित्व करते हैं ^$()%.[]*+-?) । इन वर्णों में से किसी का भी चरित्र के बाद % द्वारा प्रतिनिधित्व किया जा सकता है।

("137'5 m47ch s0m3 d1g175"):find "m%d%d" -- will match an m followed by 2 digit
    --> this will match m47 and return 7, 9

("stack overflow"):find "[abc]" -- will match an 'a', a 'b' or a 'c'
    --> this will return 3 (the A in stAck)

("stack overflow"):find "[^stack ]"
    -- will match all EXCEPT the letters s, t, a, c and k and the space character
    --> this will match the o in overflow

("hello"):find "o%d?" --> matches o, returns 5, 5
("hello20"):find "o%d?" --> matches o2, returns 5, 6
    -- the ? means the character is optional

("helllllo"):find "el+" --> will match elllll
("heo"):find "el+" --> won't match anything

("helllllo"):find "el*" --> will match elllll
("heo"):find "el*" --> will match e

("helelo"):find "h.+l" -- + will match as much as it gets
    --> this matches "helel"
("helelo"):find "h.-l" -- - will match as few as it can
    --> this wil only match "hel"

("hello"):match "o%d*"
    --> like ?, this matches the "o", because %d is optional
("hello20"):match "o%d*"
    --> unlike ?, it maches as many %d as it gets, "o20"
("hello"):match "o%d"
    --> wouldn't find anything, because + looks for 1 or more characters

`Gmatch` फ़ंक्शन

यह काम किस प्रकार करता है

string.gmatch फ़ंक्शन एक इनपुट स्ट्रिंग और एक पैटर्न लेगा। यह पैटर्न वास्तव में वापस लाने के बारे में बताता है। यह फ़ंक्शन एक फ़ंक्शन लौटाएगा जो वास्तव में एक पुनरावृत्त है। इस पुनरावृत्ति का परिणाम पैटर्न से मेल खाएगा।

type(("abc"):gmatch ".") --> returns "function"

for char in ("abc"):gmatch "." do
    print char -- this prints:
    --> a
    --> b
    --> c
end

for match in ("#afdde6"):gmatch "%x%x" do
    print("#" .. match) -- prints:
    --> #af
    --> #dd
    --> #e6
end

पेश है कैप्चर:

यह नियमित कार्य के लिए बहुत ही अनुकूल है, हालांकि यह पूर्ण मैच के बजाय केवल कैप्चर लौटाएगा।

for key, value in ("foo = bar, bar=foo"):gmatch "(%w+)%s*=%s*(%w+)" do
    print("key: " .. key .. ", value: " .. value)
    --> key: foo, value: bar
    --> key: bar, value: foo
end

Gsub फ़ंक्शन

string.sub फ़ंक्शन के साथ भ्रमित न हों, जो एक विकल्प देता है!

यह काम किस प्रकार करता है

स्ट्रिंग तर्क

("hello world"):gsub("o", "0")
    --> returns "hell0 w0rld", 2
    -- the 2 means that 2 substrings have been replaced (the 2 Os)

("hello world, how are you?"):gsub("[^%s]+", "word")
    --> returns "word word, word word word?", 5

("hello world"):gsub("([^%s])([^%s]*)", "%2%1")
    --> returns "elloh orldw", 2

कार्य तर्क

local word = "[^%s]+"

function func(str)
    if str:sub(1,1):lower()=="h" then
        return str
    else
        return "no_h"
    end
end
("hello world"):gsub(word, func)
    --> returns "hello no_h", 2

तालिका तर्क

local word = "[^%s]+"

sub = {}
sub["hello"] = "g'day"
sub["world"] = "m8"

("hello world"):gsub(word, sub)
    --> returns "g'day m8"

("hello world, how are you?"):gsub(word, sub)
    --> returns "g'day m8, how are you?"
    -- words that are not in the table are simply ignored