Elixir 基础教程

IO.puts("Hello, Elixir!")
IO.puts("Elixir 是函数式编程语言")
IO.inspect([1, 2, 3], label: "列表")

name = "Elixir"
version = 1.17
IO.puts("语言：#{name}")
IO.puts("版本：#{version}")

version = 2.0
IO.puts("重新绑定版本：#{version}")

status = :ok
error = :error
is_ready = true

IO.puts("状态：#{status}")
IO.puts("错误：#{error}")
IO.puts("就绪：#{is_ready}")
IO.puts("原子相等：#{:ok == status}")

IO.write("请输入一个整数：")
input = IO.gets("") |> String.trim()
n = String.to_integer(input)
IO.puts("#{n} 的平方是 #{n * n}")

a = 17
b = 5
IO.puts("和：#{a + b}")
IO.puts("差：#{a - b}")
IO.puts("积：#{a * b}")
IO.puts("整除商：#{div(a, b)}")
IO.puts("余数：#{rem(a, b)}")
IO.puts("2 的 10 次方：#{Integer.pow(2, 10)}")

r = 7.5
circumference = 2 * :math.pi() * r
area = :math.pi() * r * r

IO.puts("周长：#{Float.round(circumference, 4)}")
IO.puts("面积：#{Float.round(area, 4)}")

a = 8
b = 12
IO.puts("a > b：#{a > b}")
IO.puts("a != b：#{a != b}")
IO.puts("a<10 && b>10：#{a < 10 && b > 10}")
IO.puts("!(a == 8)：#{not (a == 8)}")

list = [1, 2, 3, 4]
IO.puts("列表：#{inspect(list)}")
IO.puts("头部：#{hd(list)}")
IO.puts("尾部：#{inspect(tl(list))}")
IO.puts("长度：#{length(list)}")

tuple = {:ok, "success"}
{:ok, message} = tuple
IO.puts("元组消息：#{message}")
IO.puts("元组大小：#{tuple_size(tuple)}")

score = 85
case score do
  s when s >= 90 -> IO.puts("优秀")
  s when s >= 80 -> IO.puts("良好")
  s when s >= 60 -> IO.puts("及格")
  _ -> IO.puts("不及格")
end

score = 85
cond do
  score >= 90 -> IO.puts("优秀")
  score >= 80 -> IO.puts("良好")
  score >= 60 -> IO.puts("及格")
  true -> IO.puts("不及格")
end

n = 15
if rem(n, 2) == 0 do
  IO.puts("#{n} 是偶数")
else
  IO.puts("#{n} 是奇数")
end

age = 17
unless age >= 18 do
  IO.puts("未成年")
end

defmodule Demo do
  def classify(n) when n > 100, do: "大整数 #{n}"
  def classify(n) when n > 0, do: "正数 #{n}"
  def classify(n) when n < 0, do: "负数 #{n}"
  def classify(_), do: "零"
end

IO.puts(Demo.classify(200))
IO.puts(Demo.classify(42))
IO.puts(Demo.classify(-5))
IO.puts(Demo.classify(0))

add = fn a, b -> a + b end
IO.puts("add.(10, 20) = #{add.(10, 20)}")

square = &(&1 * &1)
IO.puts("square.(7) = #{square.(7)}")

defmodule Math do
  def add(a, b), do: a + b

  def greet(name, greeting \\ "你好") do
    "#{greeting}，#{name}！"
  end
end

IO.puts("add(10, 20) = #{Math.add(10, 20)}")
IO.puts(Math.greet("小明"))
IO.puts(Math.greet("小红", "早上好"))

defmodule Sum do
  def sum(0), do: 0
  def sum(n) when n > 0, do: n + sum(n - 1)
end

IO.puts("1 到 100 的和：#{Sum.sum(100)}")
IO.puts("1 到 10 的和：#{Sum.sum(10)}")

defmodule Fact do
  def factorial(n), do: factorial(n, 1)
  defp factorial(0, acc), do: acc
  defp factorial(n, acc), do: factorial(n - 1, acc * n)

  def sum_list(list), do: sum_list(list, 0)
  defp sum_list([], acc), do: acc
  defp sum_list([head | tail], acc), do: sum_list(tail, acc + head)
end

IO.puts("5! = #{Fact.factorial(5)}")
IO.puts("列表求和：#{Fact.sum_list([1, 2, 3, 4, 5])}")

nums = [12, 45, 7, 89, 33]
nums2 = nums ++ [60]
IO.puts("原列表：#{inspect(nums)}")
IO.puts("添加后：#{inspect(nums2)}")
IO.puts("大小：#{length(nums2)}")
IO.puts("最大值：#{Enum.max(nums2)}")
IO.puts("排序：#{inspect(Enum.sort(nums2))}")

nums = [1, 2, 3, 4, 5, 6]

doubled = Enum.map(nums, fn n -> n * 2 end)
IO.puts("翻倍：#{inspect(doubled)}")

evens = Enum.filter(nums, &(rem(&1, 2) == 0))
IO.puts("偶数：#{inspect(evens)}")

sum = Enum.reduce(nums, 0, fn n, acc -> acc + n end)
IO.puts("总和：#{sum}")

nums
|> Enum.map(&(&1 * 10))
|> Enum.filter(&(&1 > 30))
|> Enum.each(&IO.puts("管道值：#{&1}"))

ages = %{zhang: 20, li: 22}
ages = Map.put(ages, :wang, 24)
ages = Map.put(ages, :li, 23)
ages = Map.delete(ages, :wang)

Enum.each(ages, fn {name, age} ->
  IO.puts("#{name}：#{age} 岁")
end)

IO.puts("张三年龄：#{Map.get(ages, :zhang)}")
IO.puts("键列表：#{inspect(Map.keys(ages))}")

scores = [55, 90, 72, 88, 45, 98]

groups = Enum.group_by(scores, fn s -> if s >= 60, do: "及格", else: "不及格" end)
Enum.each(groups, fn {k, v} -> IO.puts("#{k}：#{length(v)} 人") end)

IO.puts("最高分：#{Enum.max(scores)}")

text = "elixir is functional elixir is concurrent elixir is fun"
words = String.split(text)
freq = Enum.frequencies(words)
IO.puts("词频：#{inspect(freq)}")

top = Enum.max_by(freq, fn {_, c} -> c end)
IO.puts("出现最多：#{elem(top, 0)}，#{elem(top, 1)} 次")

result = [1, 2, 3, 4, 5, 6]
|> Enum.filter(&(rem(&1, 2) == 0))
|> Enum.map(&(&1 * &1))
|> Enum.sum()

IO.puts("偶数平方和：#{result}")

" hello, elixir "
|> String.trim()
|> String.upcase()
|> IO.puts()

double = &(&1 * 2)
IO.puts("double.(5) = #{double.(5)}")

add = &(&1 + &2)
IO.puts("add.(3, 4) = #{add.(3, 4)}")

nums = [1, 2, 3, 4]
IO.puts("map 翻倍：#{inspect(Enum.map(nums, &(&1 * 2)))}")

defmodule Higher do
  def apply_twice(x, fun), do: fun.(fun.(x))

  def apply_to_list(list, fun), do: Enum.map(list, fun)
end

inc = &(&1 + 1)
IO.puts("apply_twice(3, +1) = #{Higher.apply_twice(3, inc)}")

IO.puts("批量应用：#{inspect(Higher.apply_to_list([1, 2, 3], &(&1 * 10)))}")

sum = [1, 2, 3, 4, 5]
|> Enum.reduce(0, fn n, acc -> acc + n end)
IO.puts("reduce 求和：#{sum}")

[first | rest] = [10, 20, 30, 40]
IO.puts("头部：#{first}")
IO.puts("尾部：#{inspect(rest)}")

process = fn
  [] -> "空列表"
  [head | _] when head > 100 -> "大头部 #{head}"
  [head | _] -> "普通头部 #{head}"
end
IO.puts(process.([]))
IO.puts(process.([200, 1]))
IO.puts(process.([5, 6]))

defmodule Calculator do
  @doc "计算两数之和"
  def add(a, b), do: a + b

  def add_list(list), do: Enum.sum(list)

  defp format(n), do: "结果：#{n}"

  def show(a, b) do
    add(a, b) |> format()
  end
end

IO.puts(Calculator.add(3, 4))
IO.puts(Calculator.add_list([1, 2, 3]))
IO.puts(Calculator.show(5, 6))

defmodule User do
  defstruct name: "", age: 0
end

u = %User{name: "小明", age: 20}
IO.puts("姓名：#{u.name}，年龄：#{u.age}")

u2 = %{u | age: 21}
IO.puts("更新后：#{u2.age}")

IO.puts("默认结构：#{inspect(%User{})}")

defprotocol Shape do
  def area(shape)
end

defmodule Circle do
  defstruct radius: 0
end

defmodule Square do
  defstruct side: 0
end

defimpl Shape, for: Circle do
  def area(c), do: :math.pi() * c.radius * c.radius
end

defimpl Shape, for: Square do
  def area(s), do: s.side * s.side
end

IO.puts("圆面积：#{Float.round(Shape.area(%Circle{radius: 3}), 4)}")
IO.puts("方面积：#{Shape.area(%Square{side: 4})}")

defmodule Greeter do
  @callback greet(name :: String.t()) :: String.t()
end

defmodule PoliteGreeter do
  @behaviour Greeter

  @impl Greeter
  def greet(name), do: "你好，#{name}！"
end

defmodule CasualGreeter do
  @behaviour Greeter

  @impl Greeter
  def greet(name), do: "嗨，#{name}~"
end

IO.puts(PoliteGreeter.greet("小明"))
IO.puts(CasualGreeter.greet("小红"))

defmodule Demo do
  def safe_div(a, b) do
    try do
      a / b
    rescue
      ArithmeticError -> "除数不能为 0"
    after
      IO.puts("运算完成")
    end
  end
end

IO.puts(Demo.safe_div(10, 2))
IO.puts(Demo.safe_div(10, 0))

defmodule Login do
  def validate_user(%{name: name}) when name != "", do: {:ok, name}
  def validate_user(_), do: {:error, "用户名为空"}

  def validate_age(%{age: age}) when age >= 18, do: {:ok, age}
  def validate_age(_), do: {:error, "未成年"}
end

result = with {:ok, name} <- Login.validate_user(%{name: "alice"}),
             {:ok, age} <- Login.validate_age(%{age: 25}) do
  {:ok, "#{name}（#{age} 岁）登录成功"}
else
  {:error, reason} -> {:error, reason}
end

IO.puts(inspect(result))

defmodule Demo do
  def check_score(score) do
    if score < 0 or score > 100 do
      raise ArgumentError, "非法分数：#{score}"
    else
      "分数 #{score} 合法"
    end
  end
end

for s <- [85, 120] do
  try do
    IO.puts(Demo.check_score(s))
  rescue
    e in ArgumentError -> IO.puts("异常：#{e.message}")
  end
end

defmodule Safe do
  def parse_score(s) do
    case Integer.parse(s) do
      {n, ""} when n >= 0 and n <= 100 -> {:ok, n}
      _ -> {:error, "无法解析或越界"}
    end
  end
end

for s <- ["85", "120", "abc"] do
  IO.puts("#{s} -> #{inspect(Safe.parse_score(s))}")
end

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

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

IO.puts("递归求和：#{ListDemo.sum([1, 2, 3, 4, 5])}")
IO.puts("递归长度：#{ListDemo.len([1, 2, 3, 4, 5])}")

defmodule MyEnum do
  def my_map([], _fun), do: []
  def my_map([head | tail], fun), do: [fun.(head) | my_map(tail, fun)]

  def my_filter([], _fun), do: []
  def my_filter([head | tail], fun) do
    if fun.(head), do: [head | my_filter(tail, fun)], else: my_filter(tail, fun)
  end
end

IO.puts("my_map 翻倍：#{inspect(MyEnum.my_map([1, 2, 3], &(&1 * 2)))}")
IO.puts("my_filter 偶数：#{inspect(MyEnum.my_filter([1, 2, 3, 4], &(rem(&1, 2) == 0)))}")

fib = Stream.unfold({0, 1}, fn {a, b} -> {a, {b, a + b}} end)
IO.puts("斐波那契前 10：#{inspect(Enum.take(fib, 10))}")

nums = Stream.iterate(1, &(&1 + 1))
IO.puts("前 5 个偶数平方：#{inspect(nums |> Stream.filter(&(rem(&1, 2) == 0)) |> Stream.map(&(&1 * &1)) |> Enum.take(5))}")

defmodule Fast do
  def sum_to(n), do: sum_to(n, 0)
  defp sum_to(0, acc), do: acc
  defp sum_to(n, acc), do: sum_to(n - 1, acc + n)
end

IO.puts("尾递归 1 到 10000 的和：#{Fast.sum_to(10000)}")

parent = self()

spawn(fn ->
  Process.sleep(100)
  send(parent, {:greet, "你好，我是子进程"})
end)

receive do
  {:greet, message} -> IO.puts("收到：#{message}")
end

parent = self()

spawn(fn ->
  receive do
    {:ask, question} ->
      send(parent, {:answer, "你问的是：#{question}"})
  end
end)

send(self(), {:ask, "Elixir 好吗？"})
receive do
  {:ask, q} -> send(pid(0, 0, 0), {:ask, q})
end

# 简化：直接对已知 pid 通信
pid = spawn(fn ->
  receive do
    {:ask, question} ->
      send(self(), {:answer, "你问的是：#{question}"})
  end
end)
send(pid, {:ask, "Elixir 好吗？"})
receive do
  {:answer, ans} -> IO.puts("回答：#{ans}")
after
  1000 -> IO.puts("超时")
end

task1 = Task.async(fn ->
  Process.sleep(100)
  10
end)

task2 = Task.async(fn ->
  Process.sleep(100)
  20
end)

sum = Task.await(task1) + Task.await(task2)
IO.puts("两个任务结果之和：#{sum}")

{:ok, counter} = Agent.start_link(fn -> 0 end)

Agent.update(counter, &(&1 + 1))
Agent.update(counter, &(&1 + 1))
Agent.update(counter, &(&1 + 1))

value = Agent.get(counter, & &1)
IO.puts("计数：#{value}")

defmodule MyMacros do
  defmacro unless(condition, do: block) do
    quote do
      if !unquote(condition), do: unquote(block)
    end
  end
end

defmodule Demo do
  require MyMacros

  def check(n) do
    MyMacros.unless n > 10 do
      "#{n} 不大于 10"
    end
  end
end

IO.puts(Demo.check(5))
IO.puts(Demo.check(15))

ast = quote do
  1 + 2 * 3
end
IO.puts("AST：#{inspect(ast)}")

num = 42
ast2 = quote do
  unquote(num) + 1
end
IO.puts("unquote AST：#{inspect(ast2)}")
IO.puts("求值：#{Code.eval_quoted(ast2) |> elem(0)}")

text = "elixir is powerful, elixir is concurrent, elixir is fun"

words = String.split(text, ~r/[,\s]+/, trim: true)
IO.puts("单词数：#{length(words)}")

freq = Enum.frequencies(words)
IO.puts("词频：#{inspect(freq)}")

replaced = String.replace(text, "elixir", "Elixir")
IO.puts("替换后：#{replaced}")

IO.puts("大写：#{String.upcase(String.slice(text, 0, 10))}")

defmodule Times do
  defmacro n_times(n, do: block) do
    quote do
      Enum.each(1..unquote(n), fn _ -> unquote(block) end)
    end
  end
end

defmodule Demo do
  require Times

  def run do
    Times.n_times 3 do
      IO.puts("重复执行！")
    end
  end
end

Demo.run()

defmodule Student do
  defstruct name: "", chinese: 0.0, math: 0.0

  def average(s), do: (s.chinese + s.math) / 2
end

students = [
  %Student{name: "张三", chinese: 90, math: 85},
  %Student{name: "李四", chinese: 78, math: 92},
  %Student{name: "王五", chinese: 88, math: 76}
]

sorted = Enum.sort_by(students, &(-Student.average(&1)))
IO.puts("姓名\t语文\t数学\t平均")
Enum.each(sorted, fn s ->
  IO.puts("#{s.name}\t#{s.chinese}\t#{s.math}\t#{Float.round(Student.average(s), 1)}")
end)

avg = Enum.sum(Enum.map(students, &Student.average(&1))) / length(students)
IO.puts("全班平均：#{Float.round(avg, 1)}")
IO.puts("第一名：#{hd(sorted).name}")

text = "elixir is functional elixir is concurrent elixir is fun"
words = String.split(text)

freq = Enum.frequencies(words)
Enum.sort_by(freq, fn {_, c} -> -c end)
|> Enum.each(fn {w, c} -> IO.puts("#{w}：#{c}") end)

top = Enum.max_by(freq, fn {_, c} -> c end)
IO.puts("出现最多：#{elem(top, 0)}，#{elem(top, 1)} 次")

download = fn name ->
  Process.sleep(200)
  "#{name} 下载完成"
end

files = ["文件1", "文件2", "文件3", "文件4"]

tasks = Enum.map(files, fn f -> Task.async(fn -> download.(f) end) end)
results = Enum.map(tasks, &Task.await/1)

Enum.each(results, &IO.puts/1)
IO.puts("全部完成：#{length(results)} 个任务")

defmodule Calc do
  def calculate(expr) do
    parts = String.split(expr)
    case parts do
      [a, op, b] ->
        {num_a, ""} = Integer.parse(a)
        {num_b, ""} = Integer.parse(b)
        case op do
          "+" -> {:ok, num_a + num_b}
          "-" -> {:ok, num_a - num_b}
          "*" -> {:ok, num_a * num_b}
          "/" when num_b != 0 -> {:ok, num_a / num_b}
          "/" -> {:error, "除数不能为 0"}
          _ -> {:error, "不支持的运算符：#{op}"}
        end
      _ -> {:error, "格式错误"}
    end
  end
end

for expr <- ["10 + 5", "10 * 3", "10 / 0", "abc + 1"] do
  case Calc.calculate(expr) do
    {:ok, v} -> IO.puts("#{expr} = #{v}")
    {:error, e} -> IO.puts("#{expr} -> 错误：#{e}")
  end
end