Elixir 备忘清单

IO.puts("Hello world from Elixir")

Elixir 运行命令

$ elixir hello.exs

# 这是一个单行注释

iex> name = "Sean"
iex> "Hello #{name}"
"Hello Sean"

iex> "Hello " <> "world!"
"Hello world!"

x = 1
# => x 现在等于 1

{a, b} = {1, 2}
# => a 等于 1，b 等于 2

在 Elixir 中，使用 = 来进行赋值操作，但实际上是模式匹配。左边是模式，右边是值

:ok

原子是常量，它们的名称就是它们的值

list = [1, 2, 3]

tuple = {:ok, "value"}

defmodule MyModule do
  def my_function(parameter) do
    # 函数体
  end
end

add = fn a, b -> a + b end

import List, only: [duplicate: 2]

result = data
         |> process1()
         |> process2()

|> 用于链式调用函数，将前一个函数的结果作为下一个函数的第一个参数

比较运算符 ：==, !=, ===, !==, <=, >=, < 和 >

iex> 1 > 2
false
iex> 1 != 2
true
iex> 2 == 2
true
iex> 2 <= 3
true

iex> {3.14, :pie, "Apple"}
{3.14, :pie, "Apple"}

iex> [foo: "bar", hello: "world"]
[foo: "bar", hello: "world"]
iex> [{:foo, "bar"}, {:hello, "world"}]
[foo: "bar", hello: "world"]

关键字列表非常重要，它有以下的特性：

• 键（key）都是原子（atom）
• 键（key）是有序的（定义后，顺序不会改变）
• 键（key）不必是唯一的

因为这些原因，常见的用法是作为参数传递给函数

Elixir 的映射（maps）是键值对结构的第一选择，和关键字列表（keywords）不同，映射允许任意类型的数据作为键，而且数据并不严格排序。 你可以使用 %{} 来定义映射：

iex> map = %{:foo => "bar", "hello" => :world}
%{:foo => "bar", "hello" => :world}
iex> map[:foo]
"bar"
iex> map["hello"]
:world

iex> {a, b, c} = {:hello, "world", 42}
{:hello, "world", 42}
iex> a
:hello
iex> b
"world"

iex> [a, b, c] = [1, 2, 3]
[1, 2, 3]
iex> a
1

iex> [head | tail] = [1, 2, 3]
[1, 2, 3]
iex> head
1
iex> tail
[2, 3]

pin 操作符，就是用已经绑定的值去匹配，而不是重新绑定一个新值。

iex> {x, ^x} = {2, 1}
{2, 1}
iex> x
2

iex> [head | _] = [1, 2, 3]
[1, 2, 3]
iex> head
1

if condition do
  # 条件成立时执行的代码
else
  # 条件不成立时执行的代码
end

case expression do
  pattern1 -> # 匹配 pattern1 时执行的代码
  pattern2 -> # 匹配 pattern2 时执行的代码
  _ -> # 其他情况执行的代码
end

cond do
  condition1 -> # 条件1成立时执行的代码
  condition2 -> # 条件2成立时执行的代码
  true -> # 如果没有任何条件成立，执行这里的代码
end

unless condition do
  # 条件为假时执行的代码
end

try do
  # 可能会引发异常的代码
rescue
  pattern1 -> # 匹配 pattern1 的异常处理代码
  pattern2 -> # 匹配 pattern2 的异常处理代码
  _ -> # 其他异常处理代码
end

当我们需要根据条件进行匹配而不是值时，类似于其他语言的 else if 或 elsif，可以使用 cond 控制结构。

iex> cond do
  2 + 2 == 5 ->
    "This will not be true"
  2 * 2 == 3 ->
    "Nor this"
  1 + 1 == 2 ->
    "But this will"
end
"But this will"

如果所有的条件都返回 nil 或 false，则会引发一个错误（CondClauseError）。因此，需要添加一个 final 条件，等于 true，它将始终匹配：

iex> cond do
  2 + 2 == 5 ->
    "This is never true"
  2 * 2 == 3 ->
    "Nor this"
  true ->
    "这始终为真（等同于 else）"
end
"这始终为真（等同于 else）"

如果在if、case和类似的构造中声明或更改了任何变量，则声明和更改将只在构造中可见。

iex> x = 1
1
if true do
  x = x + 1
end
2
iex> x
1

如果要更改值，则必须从if返回值：

iex> x = 1
1
iex> x = if true do
  x + 1
else
  x
end
2

def function_name(param1, param2) do
  # 函数体
end

示例：

def sum(a, b) do
  a + b
end

module_name.function_name(arg1, arg2)

示例：

Enum.map([1, 2, 3], &(&1 * 2))

def function_name(parameter \\ 默认值) do
  # 函数体
end

示例：

def greet(name \\ "World") do
  "Hello, #{name}!"
end

def function_name(param1, param2 \\ []) do
  # 函数体
end

示例：

def sum(numbers) do
  Enum.sum(numbers)
end

@doc """
这是函数的文档。
"""

示例：

@doc """
Adds two numbers together.

## 示例

    iex> MyModule.add(1, 2)
    3
"""
def add(a, b) do
  a + b
end

这些是 Elixir 函数语法的基本要点，可以帮助你开始编写函数。

iex> sum = fn (a, b) -> a + b end
iex> sum.(2, 3)
5

可以使用 & 语法来简化匿名函数的定义：

iex> sum = &(&1 + &2)
iex> sum.(2, 3)
5

匿名函数去引用外部的变量，这通常被称为闭包。

iex> double = fn a -> add.(a, a) end
#Function<6.71889879/1 in :erl_eval.expr/5>
double.(2)
4

闭包与守卫

iex> f = fn
  x, y when x > 0 -> x + y
  x, y -> x * y
end

iex> f.(1, 3)
4
iex> f.(-1, 3)
-3

命名函数是通过 def 关键字定义在某个模块中

defmodule Greeter do
  def hello(name) do
    "Hello, " <> name
  end
end

iex> Greeter.hello("Sean")
"Hello, Sean"

简写为一行：

defmodule Greeter do
  def hello(name), do: "Hello, " <> name
end

私有函数

defmodule Greeter do
  def hello(name), do: phrase <> name
  # 使用defp来定义私有函数
  defp phrase, do: "Hello, " 
end

函数的默认参数：使用 \\ 来定义默认参数

defmodule Greeter do
  def hello(name, language_code \\ "en") do
    phrase(language_code) <> name
  end

  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end

Enum 模块提供了对集合的常用操作，如 map、filter、reduce、sort、chunk、join、into 等。

iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
[2, 4, 6]
iex> Enum.map(%{1 => 2, 3 => 4}, fn {k, v} -> k * v end)
[2, 12]

作为Enum的替代品，Elixir提供了支持懒惰操作的Stream模块

iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum()
7500000000

流文件操作

iex> stream = File.stream!("path/to/file")
%File.Stream{
  line_or_bytes: :line,
  modes: [:raw, :read_ahead, :binary],
  path: "path/to/file",
  raw: true
}
Enum.take(stream, 10)

# 上面的例子将提取所选文件的前10行。这意味着流对于处理大型文件甚至是网络资源等慢速资源非常有用。