Elixir模式匹配 #

iex(1)> x = 1
1

iex(2)> 1 = x
1

iex(3)> 2 = x
** (MatchError) no match of right hand side value: 1

iex(1)> {a, b, c} = {1, 2, 3}
{1, 2, 3}

iex(2)> a
1

iex(3)> b
2

iex(4)> c
3

iex(1)> {a, b} = {1, 2}
{1, 2}

iex(2)> {a, b} = {1, c}
** (CompileError) undefined variable "c"

iex(1)> {a, b, c} = {1, 2, 3}
{1, 2, 3}

iex(2)> {a, b} = {1, 2, 3}
** (MatchError) no match of right hand side value: {1, 2, 3}

iex(1)> {a, _, c} = {1, 2, 3}
{1, 2, 3}

iex(2)> a
1

iex(3)> c
3

iex(1)> {a, {b, c}} = {1, {2, 3}}
{1, {2, 3}}

iex(2)> a
1

iex(3)> b
2

iex(4)> c
3

iex(1)> {:ok, result} = {:ok, "Success"}
{:ok, "Success"}

iex(2)> result
"Success"

iex(3)> {:error, reason} = {:error, "Not found"}
{:error, "Not found"}

iex(4)> reason
"Not found"

iex(1)> [head | tail] = [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

iex(2)> head
1

iex(3)> tail
[2, 3, 4, 5]

iex(1)> [a, b | rest] = [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

iex(2)> a
1

iex(3)> b
2

iex(4)> rest
[3, 4, 5]

iex(1)> [] = []
[]

iex(2)> [head | tail] = []
** (MatchError) no match of right hand side value: []

defmodule ListUtils do
  def sum([]), do: 0
  def sum([head | tail]), do: head + sum(tail)

  def length([]), do: 0
  def length([_ | tail]), do: 1 + length(tail)

  def map([], _func), do: []
  def map([head | tail], func), do: [func.(head) | map(tail, func)]
end

iex(1)> %{name: name, age: age} = %{name: "Alice", age: 30}
%{age: 30, name: "Alice"}

iex(2)> name
"Alice"

iex(3)> age
30

iex(1)> %{name: name} = %{name: "Alice", age: 30, city: "NYC"}
%{age: 30, city: "NYC", name: "Alice"}

iex(2)> name
"Alice"

iex(1)> %{address: %{city: city}} = %{name: "Alice", address: %{city: "NYC", zip: "10001"}}
%{address: %{city: "NYC", zip: "10001"}, name: "Alice"}

iex(2)> city
"NYC"

iex(1)> %{key => value} = %{name: "Alice", age: 30}
%{age: 30, name: "Alice"}

iex(2)> key
:age

iex(3)> value
30

iex(1)> %{name: name, rest} = %{name: "Alice", age: 30, city: "NYC"}
%{age: 30, city: "NYC", name: "Alice"}

iex(2)> name
"Alice"

iex(3)> rest
%{age: 30, city: "NYC"}

iex(1)> <<a, b, c>> = <<1, 2, 3>>
<<1, 2, 3>>

iex(2)> a
1

iex(3)> b
2

iex(4)> c
3

iex(1)> <<a::size(8), b::size(8)>> = <<255, 128>>
<<255, 128>>

iex(2)> a
255

iex(3)> b
128

iex(1)> <<first::utf8, rest::binary>> = "Hello"
"Hello"

iex(2)> first
72

iex(3)> rest
"ello"

iex(4)> <<first::utf8, _rest::binary>> = "你好"
"你好"

iex(5)> first
20320

defmodule BinaryParser do
  def parse_header(<<
    magic::binary-size(4),
    version::size(32),
    flags::size(32),
    rest::binary
  >>) do
    %{
      magic: magic,
      version: version,
      flags: flags,
      data: rest
    }
  end
end

iex(1)> x = 1
1

iex(2)> ^x = 1
1

iex(3)> ^x = 2
** (MatchError) no match of right hand side value: 2

iex(1)> expected = 1
1

iex(2)> {^expected, result} = {1, "Success"}
{1, "Success"}

iex(3)> result
"Success"

iex(4)> {^expected, result} = {2, "Success"}
** (MatchError) no match of right hand side value: {2, "Success"}

defmodule Example do
  def greet(%{name: name, language: "elixir"}) do
    "Welcome to Elixir, #{name}!"
  end

  def greet(%{name: name, language: "erlang"}) do
    "Welcome to Erlang, #{name}!"
  end

  def greet(%{name: name}) do
    "Hello, #{name}!"
  end
end

iex(1)> key = :name
:name

iex(2)> %{^key => value} = %{name: "Alice", age: 30}
%{age: 30, name: "Alice"}

iex(3)> value
"Alice"

defmodule Math do
  def zero?(0), do: true
  def zero?(_), do: false

  def sign(n) when n > 0, do: 1
  def sign(n) when n < 0, do: -1
  def sign(0), do: 0
end

defmodule User do
  def full_name(%{first: first, last: last}) do
    "#{first} #{last}"
  end

  def greet(%{name: name, age: age}) when age >= 18 do
    "Hello, #{name}!"
  end

  def greet(%{name: name}) do
    "Hi, #{name}!"
  end
end

defmodule Recursion do
  def factorial(0), do: 1
  def factorial(n) when n > 0, do: n * factorial(n - 1)

  def fib(0), do: 0
  def fib(1), do: 1
  def fib(n) when n > 1, do: fib(n - 1) + fib(n - 2)

  def reverse([]), do: []
  def reverse([head | tail]), do: reverse(tail) ++ [head]
end

iex(1)> case {1, 2, 3} do
...>   {1, x, 3} -> "Matched with x = #{x}"
...>   {4, 5, 6} -> "Won't match"
...>   _ -> "Match anything"
...> end
"Matched with x = 2"

iex(1)> case {1, 2, 3} do
...>   {1, x, 3} when x > 0 -> "x is positive"
...>   {1, x, 3} when x < 0 -> "x is negative"
...>   _ -> "No match"
...> end
"x is positive"

def handle_response(response) do
  case response do
    {:ok, data} ->
      process_data(data)

    {:error, :not_found} ->
      {:error, "Resource not found"}

    {:error, reason} ->
      {:error, reason}
  end
end

iex(1)> with {:ok, a} <- {:ok, 1},
...>      {:ok, b} <- {:ok, 2},
...>      {:ok, c} <- {:ok, 3} do
...>   a + b + c
...> end
6

def fetch_user(id) do
  with {:ok, user} <- Repo.get(User, id),
       {:ok, posts} <- Repo.get_posts(user),
       {:ok, comments} <- Repo.get_comments(posts) do
    {:ok, %{user: user, posts: posts, comments: comments}}
  end
end

def create_user(params) do
  with {:ok, user} <- validate_params(params),
       {:ok, user} <- insert_user(user),
       {:ok, token} <- generate_token(user) do
    {:ok, %{user: user, token: token}}
  else
    {:error, :invalid_params} ->
      {:error, "Invalid parameters"}

    {:error, :duplicate_email} ->
      {:error, "Email already exists"}

    {:error, reason} ->
      {:error, reason}
  end
end