Elixir 1.7

Record




elixir

Record

रिकॉर्ड के साथ काम करने, परिभाषित करने और आयात करने के लिए मॉड्यूल।

रिकॉर्ड्स केवल नलिकाएं हैं जहां पहला तत्व एक परमाणु है:

iex> Record.is_record({User, "john", 27})
true

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

अमृत ​​में, अभिलेखों का उपयोग ज्यादातर दो स्थितियों में किया जाता है:

  1. छोटे, आंतरिक डेटा के साथ काम करना
  2. Erlang रिकॉर्ड के साथ इंटरफ़ेस करने के लिए

defrecord/3 और defrecordp/3 का उपयोग रिकॉर्ड बनाने के लिए किया जा सकता है जबकि extract/2 और extract_all/1 का उपयोग extract_all/1 फाइलों से रिकॉर्ड निकालने के लिए किया जा सकता है।

प्रकार

प्रकार को record/2 मैक्रो (केवल टाइपस्पेस में उपलब्ध) के साथ ट्यूल के लिए परिभाषित किया जा सकता है। जैसा कि नीचे उदाहरण में देखा गया है, यह मैक्रो टूप्ले तक विस्तृत होगा:

defmodule MyModule do
  require Record
  Record.defrecord :user, name: "john", age: 25

  @type user :: record(:user, name: String.t, age: integer)
  # expands to: "@type user :: {:user, String.t, integer}"
end

सारांश

कार्य

defrecord/3

रिकॉर्ड पर बनाने, एक्सेस करने और पैटर्न मैच के लिए मैक्रोज़ के एक सेट को परिभाषित करता है

defrecordp/3

defrecord/3 समान लेकिन निजी मैक्रो उत्पन्न करता है

extract/2

अर्कलांग फ़ाइल से रिकॉर्ड जानकारी निकालता है

extract_all/1

Erlang फ़ाइल से सभी रिकॉर्ड जानकारी निकालता है

is_record(data)

यदि दिया गया data एक रिकॉर्ड है, तो जाँच करता है

is_record (डेटा, तरह)

यह जांचता है कि दिया गया data किस kind का रिकॉर्ड है

कार्य

डीफ़्रोकॉर्ड (नाम, टैग \\ nil, kv) (मैक्रो)

रिकॉर्ड पर बनाने, एक्सेस करने और पैटर्न मैच के लिए मैक्रोज़ के एक सेट को परिभाषित करता है।

उत्पन्न मैक्रोज़ का name होगा (जिसे एक परमाणु होना है)। tag भी एक परमाणु है और इसे रिकॉर्ड के लिए "टैग" के रूप में उपयोग किया जाता है (यानी, रिकॉर्ड टपल का पहला तत्व); डिफ़ॉल्ट रूप से (यदि nil ), यह name के समान है। kv name: default_value की एक कीवर्ड सूची है name: default_value नए रिकॉर्ड के लिए name: default_value फ़ील्ड।

निम्नलिखित मैक्रो उत्पन्न होते हैं:

  • name/0 सभी क्षेत्रों के लिए डिफ़ॉल्ट मानों के साथ एक नया रिकॉर्ड बनाने के लिए
  • दिए गए फ़ील्ड और मानों के साथ एक नया रिकॉर्ड बनाने के लिए name/1 रिकॉर्ड में दिए गए फ़ील्ड का शून्य-आधारित सूचकांक प्राप्त करने या दिए गए रिकॉर्ड को कीवर्ड सूची में बदलने के लिए
  • name/2 दिए गए फ़ील्ड और मूल्यों के साथ मौजूदा रिकॉर्ड को अपडेट करने के लिए या किसी दिए गए रिकॉर्ड में दिए गए फ़ील्ड को एक्सेस करने के लिए

ये सभी मैक्रोज़ सार्वजनिक मैक्रोज़ हैं (जैसा कि defmacro द्वारा परिभाषित किया गया है)।

उदाहरण के लिए "उदाहरण" अनुभाग देखें कि इन मैक्रो का उपयोग कैसे करें।

उदाहरण

defmodule User do
  require Record
  Record.defrecord :user, [name: "meg", age: "25"]
end

ऊपर दिए गए उदाहरण में, मैक्रोज़ नाम का एक सेट user नाम पर होगा और विभिन्न अभिलेखों के साथ अंतर्निहित रिकॉर्ड में हेरफेर करने के लिए परिभाषित किया जाएगा।

# Import the module to make the user macros locally available
import User

# To create records
record = user()        #=> {:user, "meg", 25}
record = user(age: 26) #=> {:user, "meg", 26}

# To get a field from the record
user(record, :name) #=> "meg"

# To update the record
user(record, age: 26) #=> {:user, "meg", 26}

# To get the zero-based index of the field in record tuple
# (index 0 is occupied by the record "tag")
user(:name) #=> 1

# Convert a record to a keyword list
user(record) #=> [name: "meg", age: 26]

जेनरेट किए गए मैक्रोज़ का उपयोग रिकॉर्ड्स पर मिलान करने और मैच के दौरान वेरिएबल्स को बाँधने के लिए भी किया जा सकता है:

record = user() #=> {:user, "meg", 25}

user(name: name) = record
name #=> "meg"

डिफ़ॉल्ट रूप से, अमृत टपल के पहले तत्व ("टैग") के रूप में रिकॉर्ड नाम का उपयोग करता है। हालांकि, एक रिकॉर्ड को परिभाषित करते समय एक अलग टैग निर्दिष्ट किया जा सकता है, जैसा कि निम्नलिखित उदाहरण में, जिसमें हम Customer को defrecord/3 के दूसरे तर्क के रूप में उपयोग करते हैं:

defmodule User do
  require Record
  Record.defrecord :user, Customer, name: nil
end

require User
User.user() #=> {Customer, nil}

मूल्यों में अनाम कार्यों के साथ निकाले गए रिकॉर्ड को परिभाषित करना

यदि कोई रिकॉर्ड डिफ़ॉल्ट मानों में एक अनाम फ़ंक्शन को परिभाषित करता है, तो एक ArgumentError उठाया जाएगा। ऐसा अनजाने में हो सकता है जब एक एर्लांग लाइब्रेरी से निकालने के बाद रिकॉर्ड को परिभाषित करना जो चूक के लिए अनाम कार्यों का उपयोग करता है।

Record.defrecord :my_rec, Record.extract(...)
#=> ** (ArgumentError) invalid value for record field fun_field,
#=>   cannot escape #Function<12.90072148/2 in :erl_eval.expr/5>.

इस त्रुटि के चारों ओर काम करने के लिए, अपने स्वयं के और एमएफ / एक फ़ंक्शन के साथ फ़ील्ड को फिर से परिभाषित करें, जैसे:

defmodule MyRec do
  require Record
  Record.defrecord :my_rec, Record.extract(...) |> Keyword.merge(fun_field: &__MODULE__.foo/2)
  def foo(bar, baz), do: IO.inspect({bar, baz})
end

डीफ़्रोकॉर्ड (नाम, टैग \\ nil, kv) (मैक्रो)

defrecord/3 समान लेकिन निजी मैक्रो उत्पन्न करता है।

अर्क (नाम, ऑप्स)

extract(name :: atom(), keyword()) :: keyword()

अर्कलांग फ़ाइल से रिकॉर्ड जानकारी निकालता है।

एक उद्धृत अभिव्यक्ति देता है जिसमें टुपल्स की सूची के रूप में फ़ील्ड शामिल हैं।

name , जो निकाले गए रिकॉर्ड का नाम है, संकलन समय पर एक परमाणु होने की उम्मीद है।

विकल्प

यह फ़ंक्शन निम्न विकल्पों को स्वीकार करता है, जो एक-दूसरे के लिए अनन्य हैं (यानी, उनमें से केवल एक ही कॉल में उपयोग किया जा सकता है):

  • :from - (एर्लंग फ़ाइल के लिए पथ का प्रतिनिधित्व करने वाला द्विआधारी) फ़ाइल जिसमें निकालने के लिए रिकॉर्ड परिभाषा शामिल है; इस विकल्प के साथ, यह फ़ंक्शन Erlang मॉड्यूल में उपयोग किए गए -include विशेषता द्वारा उपयोग किए गए उसी पथ लुकअप का उपयोग करता है।

  • :from_lib - (Erlang फ़ाइल में पथ जो एक फ़ाइल में पथ का प्रतिनिधित्व करता है) द्विआधारी जिसमें निकालने के लिए रिकॉर्ड परिभाषा होती है; इस विकल्प के साथ, यह फ़ंक्शन Erlang मॉड्यूल में उपयोग किए गए -include_lib विशेषता द्वारा उपयोग किए गए उसी पथ लुकअप का उपयोग करता है।

  • :includes - (बायनेरिज़ के रूप में निर्देशिकाओं की एक सूची) यदि निकाले जा रहे रिकॉर्ड रिश्तेदार पर निर्भर करता है, तो यह विकल्प डेवलपर्स को उन निर्देशिकाओं को निर्दिष्ट करने की अनुमति देता है जिनमें रिश्तेदार शामिल हैं।

  • :macros - (मैक्रो नामों और मूल्यों की कीवर्ड सूची) यदि रिकॉर्ड निकाला जा रहा है तो मैक्रोज़ के मूल्यों पर निर्भर करता है, यह विकल्प उन मैक्रोज़ के मूल्य को सेट करने की अनुमति देता है

इन विकल्पों के संकलन समय पर (बाइनरी मान सहित) शाब्दिक होने की उम्मीद है।

उदाहरण

iex> Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
[size: :undefined, type: :undefined, access: :undefined, atime: :undefined,
 mtime: :undefined, ctime: :undefined, mode: :undefined, links: :undefined,
 major_device: :undefined, minor_device: :undefined, inode: :undefined,
 uid: :undefined, gid: :undefined]

extract_all (opts)

extract_all(keyword()) :: [{name :: atom(), keyword()}]

Erlang फ़ाइल से सभी रिकॉर्ड जानकारी निकालता है।

{record_name, fields} की एक कीवर्ड सूची देता है {record_name, fields} जहां record_name एक निकाले गए रिकॉर्ड का नाम है और fields उस रिकॉर्ड के लिए फ़ील्ड्स का प्रतिनिधित्व करने वाले {field, value} record_name की एक सूची है।

विकल्प

यह फ़ंक्शन निम्न विकल्पों को स्वीकार करता है, जो एक-दूसरे के लिए अनन्य हैं (यानी, उनमें से केवल एक ही कॉल में उपयोग किया जा सकता है):

  • :from - (एर्लंग फ़ाइल के लिए पथ का प्रतिनिधित्व करते हुए बाइनरी) फ़ाइल जिसमें निकालने के लिए रिकॉर्ड परिभाषाएँ हैं; इस विकल्प के साथ, यह फ़ंक्शन Erlang मॉड्यूल में उपयोग किए गए -include विशेषता द्वारा उपयोग किए गए उसी पथ लुकअप का उपयोग करता है।
  • :from_lib - (उस फ़ाइल के लिए पथ का प्रतिनिधित्व करने वाला बाइनरी) :from_lib फ़ाइल का पथ जिसमें निकालने के लिए रिकॉर्ड परिभाषाएँ होती हैं; इस विकल्प के साथ, यह फ़ंक्शन Erlang मॉड्यूल में उपयोग किए गए -include_lib विशेषता द्वारा उपयोग किए गए उसी पथ लुकअप का उपयोग करता है।

इन विकल्पों के संकलन समय पर (बाइनरी मान सहित) शाब्दिक होने की उम्मीद है।

is_record (डेटा) (मैक्रो)

यदि दिया गया data एक रिकॉर्ड है, तो जाँच करता है।

इसे मैक्रो के रूप में लागू किया जाता है, इसलिए इसका उपयोग गार्ड क्लॉस में किया जा सकता है।

उदाहरण

iex> record = {User, "john", 27}
iex> Record.is_record(record)
true
iex> tuple = {}
iex> Record.is_record(tuple)
false

is_record (डेटा, तरह) (मैक्रो)

यह जांचता है कि दिया गया data किस kind का रिकॉर्ड है।

इसे मैक्रो के रूप में लागू किया जाता है, इसलिए इसका उपयोग गार्ड क्लॉस में किया जा सकता है।

उदाहरण

iex> record = {User, "john", 27}
iex> Record.is_record(record, User)
true