Elixir 1.7

Regex




elixir

Regex

अमृत ​​के लिए नियमित अभिव्यक्ति प्रदान करता है।

रेगेक्स पीसीआरई (पर्ल कम्पेटिबल रेगुलर एक्सप्रेशंस) पर आधारित है और एरलांग के :re मॉड्यूल के शीर्ष पर बनाया गया है। अधिक जानकारी में पाया जा सकता है :re मॉड्यूल प्रलेखन

एलिक्जिर में रेग्युलर एक्सप्रेशंस को सिगिल्स ~r या ~R का उपयोग करके बनाया जा सकता है

# A simple regular expression that matches foo anywhere in the string
~r/foo/

# A regular expression with case insensitive and Unicode options
~r/foo/iu

सिगिल के माध्यम से बनाए गए नियमित भाव पूर्व-संकलित और .beam फ़ाइल में संग्रहीत .beam हैं। ध्यान दें कि यह एक समस्या हो सकती है यदि आप अमृत की पूर्ति कर रहे हैं, तो अधिक जानकारी के लिए "Precompilation" अनुभाग देखें।

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

~r/(?<foo>.)(?<bar>.)/ == ~r/(?<foo>.)(?<bar>.)/

आपकी मशीन, धीरज, उपलब्ध अनुकूलन और अन्य के आधार पर true या false वापसी हो सकती है। हालाँकि, आप source फ़ील्ड पर पहुँचकर संकलित नियमित अभिव्यक्ति के स्रोत को पुनः प्राप्त कर सकते हैं, और फिर सीधे उन लोगों की तुलना कर सकते हैं:

~r/(?<foo>.)(?<bar>.)/.source == ~r/(?<foo>.)(?<bar>.)/.source

Precompilation

.beam साथ निर्मित नियमित अभिव्यक्तियाँ .beam फ़ाइलों में .beam और संग्रहीत होती हैं। यह एक समस्या हो सकती है यदि आप अलग-अलग ओटीपी रिलीज में चलाने के लिए अमृत को प्राथमिकता दे रहे हैं, क्योंकि ओटीपी रिलीज किसी भी समय अंतर्निहित नियमित अभिव्यक्ति इंजन को अपडेट कर सकता है।

इस तरह के कारणों के लिए, हम हमेशा उत्पादन में चलाने के लिए Erlang / OTP संस्करण का उपयोग करके अमृत परियोजनाओं को तैयार करने की सलाह देते हैं। यदि क्रॉस-संकलन वास्तव में आवश्यक है, तो आप मैन्युअल रूप से Regex.recompile/1 या Regex Regex.recompile!/1 को रनटाइम संस्करण की जाँच करने के लिए और आवश्यक होने पर regex को पुनः कनेक्ट कर सकते हैं।

संशोधक

Regex बनाते समय उपलब्ध संशोधक हैं:

  • unicode (यू) - यूनिकोड विशिष्ट प्रतिमानों को सक्षम करता है जैसे \p और यू unicode पर मिलान करने के लिए \w , \W , \s और मित्रों जैसे संशोधक भी बदलते हैं। यह अपेक्षा करता है कि वैध यूनिकोड के तार मैच पर दिए जाएंगे

  • caseless (i) - केस असंवेदनशीलता जोड़ता है

  • dotall (एस) - डॉट का कारण बनता है नई लाइनों से मेल खाता है और यह भी किसी भी तट पर newline सेट; नई लाइन सेटिंग को फिर से प्रलेखन के अनुसार सेटिंग (*CR) या (*LF) या (*CRLF) या (*ANY) ओवरराइड किया जा सकता है

  • multiline (एम) - कारण ^ और $ प्रत्येक पंक्ति की शुरुआत और अंत को चिह्नित करने के लिए; स्ट्रिंग के अंत या शुरुआत से मेल खाने के लिए \A और \z का उपयोग करें

  • extended (x) - व्हाट्सएप वर्णों को नजरअंदाज किया जाता है जब वे बच जाते हैं और टिप्पणियों को # रद्द करने की अनुमति देते हैं

  • फ़र्स्टलाइन (f) - अनचाहे हुए पैटर्न को पहले या पहले न्यूलाइन पर मैच करने के लिए मजबूर करता है, हालाँकि मैच किए गए टेक्स्ट को न्यूलाइन पर जारी रखा जा सकता है

  • ungreedy (U) - regexp के "लालच" का विरोध करता है (पिछले r विकल्प को U पक्ष में हटा दिया गया है)

उपलब्ध विकल्प नहीं हैं:

  • anchored - उपलब्ध नहीं है, इसके बजाय ^ या \A उपयोग करें
  • dollar_endonly - उपलब्ध नहीं, इसके बजाय \z उपयोग करें
  • no_auto_capture - उपलब्ध नहीं, उपयोग ?: बजाय
  • newline - उपलब्ध नहीं है, re प्रलेखन के अनुसार regexp की शुरुआत में उपयोग करें (*CR) या (*LF) या (*CRLF) या (*ANYCRLF) या (*ANY) (*ANYCRLF)

कैप्चर

इस मॉड्यूल में कई फ़ंक्शन हैंडल :capture विकल्प के माध्यम से रेगेक्स मैच में क्या कैप्चर करते हैं। समर्थित मूल्य हैं:

  • :all - पूरी तरह से मिलान स्ट्रिंग सहित सभी कैप्चर किए गए सबपैटर्न (यह डिफ़ॉल्ट है)

  • :first - केवल पहला कैप्चर किया हुआ सबपैटर्न, जो हमेशा स्ट्रिंग का पूर्ण मिलान वाला भाग होता है; सभी स्पष्ट रूप से कैप्चर किए गए सबपैटर्न को छोड़ दिया गया है

  • :all_but_first - सभी लेकिन पहला मैचिंग सबपैटर्न, अर्थात सभी स्पष्ट रूप से कैप्चर किए गए सबपैटर्न, लेकिन स्ट्रिंग का पूरा मिलान वाला हिस्सा नहीं

  • :none - सबपैटर्न से मेल खाता नहीं है

  • :all_names - Regex में सभी नामों को कैप्चर करता है

  • list(binary) - कब्जा करने के लिए नामित कैप्चर की एक सूची

सारांश

प्रकार

t()

कार्य

संकलित करें (स्रोत, विकल्प \\ "")

नियमित अभिव्यक्ति Regex.CompileError है और त्रुटियों के मामले में Regex.CompileError को उठाता है

संकलन (स्रोत, विकल्प \\ "")

नियमित अभिव्यक्ति संकलित करता है

escape(string)

एक स्ट्रिंग का शाब्दिक रूप से एक रेक्स में मिलान किया जाता है

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

एक बूलियन को इंगित करता है कि एक मैच था या नहीं

name_captures (regex, string, options \\ [])

दिए गए कैप्चर को एक नक्शे या nil रूप में लौटाता है यदि कोई कैप्चर नहीं मिला है

names(regex)

रेगेक्स में नामों की सूची लौटाता है

opts(regex)

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

re_pattern(regex)

नियमित अभिव्यक्ति में अंतर्निहित re_pattern लौटाता है

recompile!(regex)

मौजूदा रेगुलर एक्सप्रेशन को Regex.CompileError कंपाइल करता है और त्रुटियों के मामले में Regex.CompileError को बढ़ाता है

recompile(regex)

यदि आवश्यक हो तो मौजूदा नियमित अभिव्यक्ति को फिर से एकत्र करता है

regex?(term)

यदि दिया गया term रेगीक्स true तो true है। अन्यथा false लौट आता false

बदलें (regex, string, प्रतिस्थापन, विकल्प \\ [])

एक रेगेक्स, एक बाइनरी और एक प्रतिस्थापन प्राप्त करता है, एक नया बाइनरी देता है जहां सभी मैचों को प्रतिस्थापन द्वारा प्रतिस्थापित किया जाता है

चलाएँ (regex, string, options \\ [])

पहले मैच तक दिए गए स्ट्रिंग के खिलाफ नियमित अभिव्यक्ति चलाता है। यदि कोई मैच नहीं हुआ, तो यह सभी कैप्चर या nil साथ एक सूची देता है

स्कैन (regex, string, options \\ [])

run/3 समान, लेकिन नियमित अभिव्यक्ति के सभी मैचों को इकट्ठा करते हुए कई बार लक्ष्य को स्कैन करता है

source(regex)

बाइनरी के रूप में रेगेक्स स्रोत लौटाता है

विभाजन (regex, string, options \\ [])

दिए गए लक्ष्य को दिए गए पैटर्न के आधार पर और दिए गए भागों में विभाजित करता है

version()

अंतर्निहित रेगेक्स इंजन का संस्करण लौटाता है

प्रकार

टी ()

t() :: %Regex{
  opts: binary(),
  re_pattern: term(),
  re_version: term(),
  source: binary()
}

कार्य

संकलित करें (स्रोत, विकल्प \\ "")

compile!(binary(), binary() | [term()]) :: t()

नियमित अभिव्यक्ति Regex.CompileError है और त्रुटियों के मामले में Regex.CompileError को उठाता है।

संकलन (स्रोत, विकल्प \\ "")

compile(binary(), binary() | [term()]) :: {:ok, t()} | {:error, any()}

नियमित अभिव्यक्ति संकलित करता है।

दिए गए विकल्प या तो अक्षर के साथ एक द्विआधारी हो सकते हैं, जो उसी आरजीक्स विकल्प को देखते हुए ~r sigil या विकल्पों की सूची में दिए गए हैं, जैसा कि Erlang के :re मॉड्यूल द्वारा अपेक्षित है।

यह सफलता के मामले में {:ok, regex} देता है, {:error, reason} अन्यथा।

उदाहरण

iex> Regex.compile("foo")
{:ok, ~r/foo/}

iex> Regex.compile("*foo")
{:error, {'nothing to repeat', 0}}

भागने (स्ट्रिंग)

escape(String.t()) :: String.t()

एक स्ट्रिंग का शाब्दिक रूप से एक रेक्स में मिलान किया जाता है।

उदाहरण

iex> Regex.escape(".")
"\\."

iex> Regex.escape("\\what if")
"\\\\what\\ if"

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

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

एक बूलियन को इंगित करता है कि एक मैच था या नहीं।

उदाहरण

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

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

name_captures (regex, string, options \\ [])

named_captures(t(), String.t(), [term()]) :: map() | nil

दिए गए कैप्चर को एक नक्शे या nil रूप में लौटाता है यदि कोई कैप्चर नहीं मिला है।

विकल्प

  • :return - सेट टू :index बाइट इंडेक्स और मैच की लंबाई वापस करने के लिए। डिफ़ॉल्ट :binary

उदाहरण

iex> Regex.named_captures(~r/c(?<foo>d)/, "abcd")
%{"foo" => "d"}

iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)/, "abcd")
%{"bar" => "d", "foo" => "b"}

iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)/, "efgh")
nil

नाम (regex)

names(t()) :: [String.t()]

रेगेक्स में नामों की सूची लौटाता है।

उदाहरण

iex> Regex.names(~r/(?<foo>bar)/)
["foo"]

opts (regex)

opts(t()) :: String.t()

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

उदाहरण

iex> Regex.opts(~r(foo)m)
"m"

re_pattern (regex)

re_pattern(t()) :: term()

नियमित अभिव्यक्ति में अंतर्निहित re_pattern लौटाता है।

recompile! (regex) (1.4.0 से)

recompile!(t()) :: t()

मौजूदा रेगुलर एक्सप्रेशन को Regex.CompileError कंपाइल करता है और त्रुटियों के मामले में Regex.CompileError को बढ़ाता है।

recompile (regex) (1.4.0 से)

recompile(t()) :: t()

यदि आवश्यक हो तो मौजूदा नियमित अभिव्यक्ति को फिर से एकत्र करता है।

यह नियमित अभिव्यक्ति में संग्रहीत संस्करण की जांच करता है और संस्करण बेमेल के मामले में regex को recompiles करता है।

regex? (शब्द)

regex?(any()) :: boolean()

यदि दिया गया term रेगीक्स true तो true है। अन्यथा false लौट आता false

उदाहरण

iex> Regex.regex?(~r/foo/)
true

iex> Regex.regex?(0)
false

बदलें (regex, string, प्रतिस्थापन, विकल्प \\ [])

replace(t(), String.t(), String.t() | (... -> String.t()), [term()]) ::
  String.t()

एक रेगेक्स, एक बाइनरी और एक प्रतिस्थापन प्राप्त करता है, एक नया बाइनरी देता है जहां सभी मैचों को प्रतिस्थापन द्वारा प्रतिस्थापित किया जाता है।

प्रतिस्थापन या तो एक स्ट्रिंग या एक फ़ंक्शन हो सकता है। स्ट्रिंग का उपयोग हर मैच के प्रतिस्थापन के रूप में किया जाता है और यह विशिष्ट कैप्चर को \N या \g{N} माध्यम से एक्सेस करने की अनुमति देता है, जहां N कैप्चर होता है। यदि केस में \0 का उपयोग किया जाता है, तो पूरा मैच डाला जाता है। ध्यान दें कि बैकस्लैश में बैकस्लैश से बचने की आवश्यकता है, इसलिए अभ्यास में आपको \\N और \\g{N}

जब प्रतिस्थापन एक फ़ंक्शन होता है, तो फ़ंक्शन में arity N हो सकता है जहां प्रत्येक तर्क कैप्चर करने के लिए मैप करता है, जिसमें पहला तर्क पूरे मैच का होता है। यदि फ़ंक्शन को प्राप्त किए गए कैप्चर की तुलना में अधिक तर्क की उम्मीद है, तो शेष तर्क "" प्राप्त करेंगे।

विकल्प

  • :global - जब false , केवल पहली घटना की जगह लेता है ( true लिए चूक)

उदाहरण

iex> Regex.replace(~r/d/, "abc", "d")
"abc"

iex> Regex.replace(~r/b/, "abc", "d")
"adc"

iex> Regex.replace(~r/b/, "abc", "[\\0]")
"a[b]c"

iex> Regex.replace(~r/a(b|d)c/, "abcadc", "[\\1]")
"[b][d]"

iex> Regex.replace(~r/\.(\d)$/, "500.5", ".\\g{1}0")
"500.50"

iex> Regex.replace(~r/a(b|d)c/, "abcadc", fn _, x -> "[#{x}]" end)
"[b][d]"

iex> Regex.replace(~r/a/, "abcadc", "A", global: false)
"Abcadc"

चलाएँ (regex, string, options \\ [])

run(t(), binary(), [term()]) :: nil | [binary()] | [{integer(), integer()}]

पहले मैच तक दिए गए स्ट्रिंग के खिलाफ नियमित अभिव्यक्ति चलाता है। यदि कोई मैच नहीं हुआ, तो यह सभी कैप्चर या nil साथ एक सूची देता है।

विकल्प

  • :return - सेट टू :index बाइट इंडेक्स और मैच की लंबाई वापस करने के लिए। डिफ़ॉल्ट :binary
  • :capture - परिणाम में क्या कैप्चर करना है। संभावित कैप्चर मान देखने के लिए Regex लिए moduledoc की जाँच करें।

उदाहरण

iex> Regex.run(~r/c(d)/, "abcd")
["cd", "d"]

iex> Regex.run(~r/e/, "abcd")
nil

iex> Regex.run(~r/c(d)/, "abcd", return: :index)
[{2, 2}, {3, 1}]

स्कैन (regex, string, options \\ [])

scan(t(), String.t(), [term()]) :: [[String.t()]]

run/3 समान, लेकिन नियमित अभिव्यक्ति के सभी मैचों को इकट्ठा करते हुए कई बार लक्ष्य को स्कैन करता है।

सूचियों की एक सूची दी गई है, जहां प्राथमिक सूची में प्रत्येक प्रविष्टि एक मैच का प्रतिनिधित्व करती है और माध्यमिक सूची में प्रत्येक प्रविष्टि कैप्चर की गई सामग्री का प्रतिनिधित्व करती है।

विकल्प

  • :return - सेट टू :index बाइट इंडेक्स और मैच की लंबाई वापस करने के लिए। डिफ़ॉल्ट :binary
  • :capture - परिणाम में क्या कैप्चर करना है। संभावित कैप्चर मान देखने के लिए Regex लिए moduledoc की जाँच करें।

उदाहरण

iex> Regex.scan(~r/c(d|e)/, "abcd abce")
[["cd", "d"], ["ce", "e"]]

iex> Regex.scan(~r/c(?:d|e)/, "abcd abce")
[["cd"], ["ce"]]

iex> Regex.scan(~r/e/, "abcd")
[]

iex> Regex.scan(~r/\p{Sc}/u, "$, £, and €")
[["$"], ["£"], ["€"]]

iex> Regex.scan(~r/=+/, "=ü†ƒ8===", return: :index)
[[{0, 1}], [{9, 3}]]

स्रोत (regex)

source(t()) :: String.t()

बाइनरी के रूप में रेगेक्स स्रोत लौटाता है।

उदाहरण

iex> Regex.source(~r(foo))
"foo"

विभाजन (regex, string, options \\ [])

split(t(), String.t(), [term()]) :: [String.t()]

दिए गए लक्ष्य को दिए गए पैटर्न के आधार पर और दिए गए भागों में विभाजित करता है।

विकल्प

  • :parts - निर्दिष्ट होने पर, स्ट्रिंग को दिए गए भागों की संख्या में विभाजित करता है। यदि निर्दिष्ट नहीं किया गया है :parts चूक :infinity , जो स्ट्रिंग को दिए गए पैटर्न के आधार पर अधिकतम संभव भागों में विभाजित करेगा।

  • :trim - जब true होता true , परिणाम से खाली स्ट्रिंग्स ( "" ) को हटा देता है। false अवहेलना।

  • :on - निर्दिष्ट करता है जो स्ट्रिंग को विभाजित करने के लिए कैप्चर करता है, और किस क्रम में। चूक :first जिसका अर्थ है रेगेक्स के अंदर कब्जा करना विभाजन प्रक्रिया को प्रभावित नहीं करता है।

  • :include_captures - जब true , परिणाम में नियमित अभिव्यक्ति के मैच शामिल हैं। false अवहेलना।

उदाहरण

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

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

iex> Regex.split(~r{-}, "abc")
["abc"]

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

iex> Regex.split(~r{a(?<second>b)c}, "abc")
["", ""]

iex> Regex.split(~r{a(?<second>b)c}, "abc", on: [:second])
["a", "c"]

iex> Regex.split(~r{(x)}, "Elixir", include_captures: true)
["Eli", "x", "ir"]

iex> Regex.split(~r{a(?<second>b)c}, "abc", on: [:second], include_captures: true)
["a", "b", "c"]

संस्करण () (1.4.0 के बाद से)

version() :: term()

अंतर्निहित रेगेक्स इंजन का संस्करण लौटाता है।