अमृत में आप इस तरह के अजगर के रूप में कैसे की जाँच करें:
>>> a = "test"
>>> type(a)
<type 'str'>
>>> b =10
>>> type(b)
<type 'int'>
मैंने अमृत में पढ़ा है कि 'is_bitstring', 'is_float', 'is_list', 'is_map' इत्यादि जैसे टाइप चेकर हैं, लेकिन अगर आपको अंदाजा नहीं है कि टाइप क्या हो सकता है?
जवाबों:
Elixir / Erlang में एक चर का प्रकार प्राप्त करने का कोई सीधा तरीका नहीं है।
आप आमतौर पर एक चर का प्रकार जानना चाहते हैं ताकि उसके अनुसार कार्य किया जा सके; आप is_*चर के प्रकार के आधार पर कार्य करने के लिए कार्यों का उपयोग कर सकते हैं ।
आप कुछ सीखें Erlang में Erlang (और इस प्रकार Elixir) में टाइप करने के बारे में एक अच्छा अध्याय है ।
is_*कार्यों के परिवार का उपयोग करने का सबसे मुहावरेदार तरीका संभवतः पैटर्न मैचों में उनका उपयोग करना होगा:
def my_fun(arg) when is_map(arg), do: ...
def my_fun(arg) when is_list(arg), do: ...
def my_fun(arg) when is_integer(arg), do: ...
# ...and so on
typeof(variable)?
foo = [1, "hello", [1, 2, 3]]कोड के साथ मैप नहीं किया जा सकता है Enum.map(foo, fn(x) -> IO.puts x end)क्योंकि [1,2, 3] को अक्षर के रूप में पढ़ा जाएगा (Whylang !!)? इसलिए हमें निरीक्षण का उपयोग करने के लिए मजबूर किया जाता है भले ही निरीक्षण केवल तभी आवश्यक हो जब यह एक सूची हो, अन्यथा अधिकांश समय हमें इसकी आवश्यकता नहीं होती है। टाइपो हमें बयानों (O (n)) को डिक्शनरी लुकअप (O (1)) में बदल देता है।
Printableप्रोटोकॉल को लागू कर सकते हैं जो रैपर्स और प्रिंटिंग के व्यवहार को बदल देता है जैसे पूर्णांकों की सूची। बस यह सुनिश्चित करें कि आप इसका उपयोग एर्लांग कोड के साथ नहीं करते हैं - या आप अपने सिर को खरोंचते हुए सोचेंगे कि संदेशों के बजाय आप पूर्णांकों की सूची क्यों देख रहे हैं।
अमृत 1.2 में शुरू होने iका मतलब है कि iex में एक कमांड है जो किसी भी अमृत चर के प्रकार और अधिक को सूचीबद्ध करेगा।
iex> foo = "a string"
iex> i foo
Term
"a string"
Data type
BitString
Byte size
8
Description
This is a string: a UTF-8 encoded binary. It's printed surrounded by
"double quotes" because all UTF-8 encoded codepoints in it are printable.
Raw representation
<<97, 32, 115, 116, 114, 105, 110, 103>>
Reference modules
String, :binary
यदि आप iकमांड के कोड में देखते हैं तो आप देखेंगे कि यह एक प्रोटोकॉल के माध्यम से लागू किया गया है।
https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/info.ex
यदि आप Elixir में किसी भी डेटा प्रकार के लिए कोई फ़ंक्शन लागू करना चाहते हैं, तो ऐसा करने का तरीका प्रोटोकॉल को परिभाषित करना है और उन सभी डेटा प्रकारों के लिए प्रोटोकॉल को लागू करना है, जिन्हें आप कार्य करना चाहते हैं। दुर्भाग्य से, आप गार्ड में प्रोटोकॉल फ़ंक्शन का उपयोग नहीं कर सकते। हालांकि, एक सरल "प्रकार" प्रोटोकॉल लागू करने के लिए बहुत सरल होगा।
undefined function i/1- जानकारी के लिए वही / 1
&i/1पर एक समारोह है IEx.Helpers। यदि आप इसे &IEx.Helpers.i/1अपने वेनिला अमृत में डालते हैं , तो आप CompileErrorतब तक उत्पन्न करेंगे जब तक कि आप अपने :iexआवेदन में इसे शामिल नहीं करते mix.exs।
एक अन्य दृष्टिकोण पैटर्न मिलान का उपयोग करना है। कहते हैं कि आप Timex का उपयोग कर रहे हैं, जो एक %DateTime{}संरचना का उपयोग करता है , और आप यह देखना चाहते हैं कि क्या तत्व एक है। आप विधि में पैटर्न मिलान का उपयोग करके एक मैच पा सकते हैं।
def is_a_datetime?(%DateTime{}) do
true
end
def is_a_datetime?(_) do
false
end
switch/ के द्वारा case।
मैं बस किसी को उम्मीद है कि वास्तव में एक समझदार संस्करण के लिए यहाँ छोड़ दूँगा। फिलहाल इस पर कोई अच्छा जवाब नहीं आ रहा है ...
defmodule Util do
def typeof(self) do
cond do
is_float(self) -> "float"
is_number(self) -> "number"
is_atom(self) -> "atom"
is_boolean(self) -> "boolean"
is_binary(self) -> "binary"
is_function(self) -> "function"
is_list(self) -> "list"
is_tuple(self) -> "tuple"
true -> "idunno"
end
end
endपूर्णता की खातिर, मामलों की जांच करें:
cases = [
1.337,
1337,
:'1337',
true,
<<1, 3, 3, 7>>,
(fn(x) -> x end),
{1, 3, 3, 7}
]
Enum.each cases, fn(case) ->
IO.puts (inspect case) <> " is a " <> (Util.typeof case)
endयहाँ प्रोटोकॉल के साथ एक समाधान है; मुझे यकीन नहीं है कि अगर वे तेज हैं (मुझे यकीन है कि वे सभी प्रकारों पर एक लूप नहीं कर रहे हैं), लेकिन यह बहुत बदसूरत है (और नाजुक; यदि वे एक मूल प्रकार या नाम जोड़ते हैं या हटाते हैं, तो यह इसे तोड़ देगा)।
defprotocol Typeable, do: def typeof(self)
defimpl Typeable, for: Atom, do: def typeof(_), do: "Atom"
defimpl Typeable, for: BitString, do: def typeof(_), do: "BitString"
defimpl Typeable, for: Float, do: def typeof(_), do: "Float"
defimpl Typeable, for: Function, do: def typeof(_), do: "Function"
defimpl Typeable, for: Integer, do: def typeof(_), do: "Integer"
defimpl Typeable, for: List, do: def typeof(_), do: "List"
defimpl Typeable, for: Map, do: def typeof(_), do: "Map"
defimpl Typeable, for: PID, do: def typeof(_), do: "PID"
defimpl Typeable, for: Port, do: def typeof(_), do: "Port"
defimpl Typeable, for: Reference, do: def typeof(_), do: "Reference"
defimpl Typeable, for: Tuple, do: def typeof(_), do: "Tuple"
IO.puts Typeable.typeof "Hi"
IO.puts Typeable.typeof :okमैं सिर्फ https://elixirforum.com/t/just-created-a-typeof-module/2583/5 :) से कोड पेस्ट करता हूं
defmodule Util do
types = ~w[function nil integer binary bitstring list map float atom tuple pid port reference]
for type <- types do
def typeof(x) when unquote(:"is_#{type}")(x), do: unquote(type)
end
endमैं एक ऐसी स्थिति में आया था जब पैरामीटर को जांचने की जरूरत है कि कुछ प्रकार के होने की आवश्यकता है। शायद बेहतर तरीके से सक्रिय हो सकता है।
ऐशे ही:
@required [{"body", "binary"},{"fee", "integer"}, ...]
defp match_desire?({value, type}) do
apply(Kernel, :"is_#{type}", [value])
end
उपयोग:
Enum.map(@required, &(match_desire?/1))
सिर्फ इसलिए कि किसी ने इसका उल्लेख नहीं किया है
IO.inspect/1
ऑब्जेक्ट कंसोल करने के लिए आउटपुट ... इसका लगभग JSON.stringify के बराबर है
बहुत उपयोगी है जब आप सिर्फ अपने जीवन के लिए यह पता नहीं लगा सकते हैं कि एक परीक्षण में कोई वस्तु कैसी दिखती है।