Làm thế nào để bạn kiểm tra loại biến trong Elixir

Trong Elixir, làm thế nào để bạn kiểm tra loại như trong Python:

>>> a = "test"
>>> type(a)
<type 'str'>
>>> b =10
>>> type(b)
<type 'int'>

Tôi đọc trong Elixir có các trình kiểm tra loại như 'is_bitopes', 'is_float', 'is_list', 'is_map', v.v., nhưng nếu bạn không biết loại này có thể là gì thì sao?

Không có cách trực tiếp nào để có được loại biến trong Elixir / Erlang.

Bạn thường muốn biết loại biến để hành động tương ứng; bạn có thể sử dụng các is_*hàm để hành động dựa trên loại biến.

Tìm hiểu về bạn Một số Erlang có một chương hay về cách gõ Erlang (và do đó trong Elixir).

Cách thành ngữ nhất để sử dụng is_*họ các hàm có thể là sử dụng chúng trong các khớp mẫu:

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

Bắt đầu từ elixir 1.2, có một ilệnh trong iex sẽ liệt kê loại và nhiều hơn bất kỳ biến Elixir nào.

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

Nếu bạn nhìn vào mã cho ilệnh, bạn sẽ thấy rằng điều này được thực hiện thông qua Giao thức.

https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/info.ex

Nếu bạn muốn triển khai một chức năng cho bất kỳ loại Dữ liệu nào trong Elixir, cách thực hiện là xác định Giao thức và triển khai Giao thức cho tất cả các loại dữ liệu bạn muốn chức năng hoạt động. Thật không may, bạn không thể sử dụng chức năng Giao thức trong bộ bảo vệ. Tuy nhiên, một giao thức "loại" đơn giản sẽ rất đơn giản để thực hiện.

Ngoài ra, với mục đích gỡ lỗi, nếu bạn không ở iex, bạn có thể gọi trực tiếp:

IEx.Info.info(5)
=> ["Data type": "Integer", "Reference modules": "Integer"]

Một cách tiếp cận khác là sử dụng khớp mẫu. Giả sử bạn đang sử dụng Timex, sử dụng một %DateTime{}cấu trúc và bạn muốn xem liệu một phần tử có phải là một thành phần không. Bạn có thể tìm thấy kết quả khớp bằng cách sử dụng khớp mẫu trong phương thức.

def is_a_datetime?(%DateTime{}) do
  true
end

def is_a_datetime?(_) do
  false
end

Tôi sẽ để nó ở đây vì lợi ích của ai đó hy vọng tìm ra một phiên bản thực sự lành mạnh. Hiện tại không có câu trả lời hay nào cho vấn đề này sắp xuất hiện trên google ...

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

Để hoàn thiện, các trường hợp thử nghiệm:

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

Đây là một giải pháp với các giao thức; Tôi không chắc liệu chúng có nhanh hơn không (tôi chắc chắn hy vọng chúng không thực hiện một vòng lặp trên tất cả các loại), nhưng nó khá xấu (và dễ vỡ; nếu chúng thêm hoặc xóa một loại cơ bản hoặc đổi tên, nó sẽ phá vỡ nó).

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

Tôi chỉ cần dán mã từ 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

Tôi đã gặp một tình huống cần kiểm tra tham số cần phải là loại nhất định. Có lẽ có thể hoạt động một cách tốt hơn.

Như thế này:

@required [{"body", "binary"},{"fee", "integer"}, ...]
defp match_desire?({value, type}) do
  apply(Kernel, :"is_#{type}", [value])
end

Sử dụng:

Enum.map(@required, &(match_desire?/1))

Chỉ vì không ai nhắc đến nó

IO.inspect/1

Đầu ra để điều khiển đối tượng ... nó gần như tương đương với JSON.opesify

Rất hữu ích khi bạn không thể tìm ra cuộc sống của một đối tượng trong một bài kiểm tra.