加载中...

elixir

其中 Y=elixir

源代码下载： learnelixir-cn.ex

Elixir 是一门构建在Erlang VM 之上的函数式编程语言。Elixir 完全兼容 Erlang, 另外还提供了更标准的语法，特性。

  1. # 这是单行注释, 注释以井号开头
  3. # 没有多行注释
  4. # 但你可以堆叠多个注释。
  6. # elixir shell 使用命令 `iex` 进入。
  7. # 编译模块使用 `elixirc` 命令。
  9. # 如果安装正确，这些命令都会在环境变量里
  11. ## ---------------------------
  12. ## -- 基本类型
  13. ## ---------------------------
  15. # 数字
  16. 3    # 整型
  17. 0x1F # 整型
  18. 3.0  # 浮点类型
  20. # 原子(Atoms)，以 `:`开头
  21. :hello # atom
  23. # 元组(Tuple) 在内存中的存储是连续的
  24. {1,2,3} # tuple
  26. # 使用`elem`函数访问元组(tuple)里的元素:
  27. elem({1, 2, 3}, 0) #=> 1
  29. # 列表(list)
  30. [1,2,3] # list
  32. # 可以用下面的方法访问列表的头尾元素:
  33. [head | tail] = [1,2,3]
  34. head #=> 1
  35. tail #=> [2,3]
  37. # 在elixir,就像在Erlang, `=` 表示模式匹配 (pattern matching) 
  38. # 不是赋值。
  39. #
  40. # 这表示会用左边的模式(pattern)匹配右侧
  41. # 
  42. # 上面的例子中访问列表的头部和尾部就是这样工作的。
  44. # 当左右两边不匹配时，会返回error, 在这个
  45. # 例子中，元组大小不一样。
  46. # {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
  48. # 还有二进制类型 (binaries)
  49. <<1,2,3>> # binary
  51. # 字符串(Strings) 和 字符列表(char lists)
  52. "hello" # string
  53. 'hello' # char list
  55. # 多行字符串
  56. """
  57. I'm a multi-line
  58. string.
  59. """
  60. #=> "I'm a multi-line\nstring.\n"
  62. # 所有的字符串(Strings)以UTF-8编码：
  63. "héllò" #=> "héllò"
  65. # 字符串(Strings)本质就是二进制类型(binaries), 字符列表(char lists)本质是列表(lists)
  66. <<?a, ?b, ?c>> #=> "abc"
  67. [?a, ?b, ?c]   #=> 'abc'
  69. # 在 elixir中，`?a`返回 `a` 的 ASCII 整型值  
  70. ?a #=> 97
  72. # 合并列表使用 `++`, 对于二进制类型则使用 `<>`
  73. [1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
  74. 'hello ' ++ 'world'  #=> 'hello world'
  76. <<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
  77. "hello " <> "world"  #=> "hello world"
  79. ## ---------------------------
  80. ## -- 操作符(Operators)
  81. ## ---------------------------
  83. #  一些数学运算
  84. 1 + 1  #=> 2
  85. 10 - 5 #=> 5
  86. 5 * 2  #=> 10
  87. 10 / 2 #=> 5.0
  89. # 在 elixir 中，操作符 `/` 返回值总是浮点数。
  91. # 做整数除法使用 `div`
  92. div(10, 2) #=> 5
  94. # 为了得到余数使用 `rem`
  95. rem(10, 3) #=> 1
  97. # 还有 boolean 操作符: `or`, `and` and `not`.
  98. # 第一个参数必须是boolean 类型
  99. true and true #=> true
  100. false or true #=> true
  101. # 1 and true    #=> ** (ArgumentError) argument error
  103. # Elixir 也提供了 `||`, `&&` 和  `!` 可以接受任意的类型
  104. # 除了`false` 和 `nil` 其它都会被当作true.
  105. 1 || true  #=> 1
  106. false && 1 #=> false
  107. nil && 20  #=> nil
  109. !true #=> false
  111. # 比较有: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` 和 `>`
  112. 1 == 1 #=> true
  113. 1 != 1 #=> false
  114. 1 < 2  #=> true
  116. # `===` 和 `!==` 在比较整型和浮点类型时更为严格:
  117. 1 == 1.0  #=> true
  118. 1 === 1.0 #=> false
  120. # 我们也可以比较两种不同的类型:
  121. 1 < :hello #=> true
  123. # 总的排序顺序定义如下:
  124. # number < atom < reference < functions < port < pid < tuple < list < bit string
  126. # 引用Joe Armstrong ：“实际的顺序并不重要，
  127. # 但是，一个整体排序是否经明确界定是非常重要的。”
  129. ## ---------------------------
  130. ## -- 控制结构(Control Flow)
  131. ## ---------------------------
  133. # `if` 表达式
  134. if false do
  135.   "This will never be seen"
  136. else
  137.   "This will"
  138. end
  140. # 还有 `unless`
  141. unless true do
  142.   "This will never be seen"
  143. else
  144.   "This will"
  145. end
  147. # 在Elixir中，很多控制结构都依赖于模式匹配
  149. # `case` 允许我们把一个值与多种模式进行比较:
  150. case {:one, :two} do
  151.   {:four, :five} ->
  152.     "This won't match"
  153.   {:one, x} ->
  154.     "This will match and assign `x` to `:two`"
  155.   _ ->
  156.     "This will match any value"
  157. end
  159. # 模式匹配时，如果不需要某个值，通用的做法是把值 匹配到 `_` 
  160. # 例如，我们只需要要列表的头元素:
  161. [head | _] = [1,2,3]
  162. head #=> 1
  164. # 下面的方式效果一样，但可读性更好
  165. [head | _tail] = [:a, :b, :c]
  166. head #=> :a
  168. # `cond` 可以检测多种不同的分支
  169. # 使用 `cond` 代替多个`if` 表达式嵌套
  170. cond do
  171.   1 + 1 == 3 ->
  172.     "I will never be seen"
  173.   2 * 5 == 12 ->
  174.     "Me neither"
  175.   1 + 2 == 3 ->
  176.     "But I will"
  177. end
  179. # 经常可以看到最后一个条件等于'true'，这将总是匹配。
  180. cond do
  181.   1 + 1 == 3 ->
  182.     "I will never be seen"
  183.   2 * 5 == 12 ->
  184.     "Me neither"
  185.   true ->
  186.     "But I will (this is essentially an else)"
  187. end
  189. # `try/catch` 用于捕获被抛出的值, 它也支持 `after` 子句，
  190. # 无论是否值被捕获，after 子句都会被调用
  191. # `try/catch` 
  192. try do
  193.   throw(:hello)
  194. catch
  195.   message -> "Got #{message}."
  196. after
  197.   IO.puts("I'm the after clause.")
  198. end
  199. #=> I'm the after clause
  200. # "Got :hello"
  202. ## ---------------------------
  203. ## -- 模块和函数(Modules and Functions)
  204. ## ---------------------------
  206. # 匿名函数 (注意点)
  207. square = fn(x) -> x * x end
  208. square.(5) #=> 25
  210. # 也支持接收多个子句和卫士(guards).
  211. # Guards 可以进行模式匹配
  212. # Guards 使用 `when` 关键字指明:
  213. f = fn
  214.   x, y when x > 0 -> x + y
  215.   x, y -> x * y
  216. end
  218. f.(1, 3)  #=> 4
  219. f.(-1, 3) #=> -3
  221. # Elixir 提供了很多内建函数
  222. # 在默认作用域都是可用的
  223. is_number(10)    #=> true
  224. is_list("hello") #=> false
  225. elem({1,2,3}, 0) #=> 1
  227. # 你可以在一个模块里定义多个函数，定义函数使用 `def`
  228. defmodule Math do
  229.   def sum(a, b) do
  230.     a + b
  231.   end
  233.   def square(x) do
  234.     x * x
  235.   end
  236. end
  238. Math.sum(1, 2)  #=> 3
  239. Math.square(3) #=> 9
  241. # 保存到 `math.ex`，使用 `elixirc` 编译你的 Math 模块
  242. # 在终端里: elixirc math.ex
  244. # 在模块中可以使用`def`定义函数，使用 `defp` 定义私有函数
  245. # 使用`def` 定义的函数可以被其它模块调用
  246. # 私有函数只能在本模块内调用
  247. defmodule PrivateMath do
  248.   def sum(a, b) do
  249.     do_sum(a, b)
  250.   end
  252.   defp do_sum(a, b) do
  253.     a + b
  254.   end
  255. end
  257. PrivateMath.sum(1, 2)    #=> 3
  258. # PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
  260. # 函数定义同样支持 guards 和 多重子句：
  261. defmodule Geometry do
  262.   def area({:rectangle, w, h}) do
  263.     w * h
  264.   end
  266.   def area({:circle, r}) when is_number(r) do
  267.     3.14 * r * r
  268.   end
  269. end
  271. Geometry.area({:rectangle, 2, 3}) #=> 6
  272. Geometry.area({:circle, 3})       #=> 28.25999999999999801048
  273. # Geometry.area({:circle, "not_a_number"})
  274. #=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
  276. #由于不变性，递归是Elixir的重要组成部分
  277. defmodule Recursion do
  278.   def sum_list([head | tail], acc) do
  279.     sum_list(tail, acc + head)
  280.   end
  282.   def sum_list([], acc) do
  283.     acc
  284.   end
  285. end
  287. Recursion.sum_list([1,2,3], 0) #=> 6
  289. # Elixir 模块支持属性，模块内建了一些属性，你也可以自定义属性
  290. defmodule MyMod do
  291.   @moduledoc """
  292.   内置的属性，模块文档
  293.   """
  295.   @my_data 100 # 自定义属性
  296.   IO.inspect(@my_data) #=> 100
  297. end
  299. ## ---------------------------
  300. ## -- 记录和异常(Records and Exceptions)
  301. ## ---------------------------
  303. # 记录就是把特定值关联到某个名字的结构体
  304. defrecord Person, name: nil, age: 0, height: 0
  306. joe_info = Person.new(name: "Joe", age: 30, height: 180)
  307. #=> Person[name: "Joe", age: 30, height: 180]
  309. # 访问name的值
  310. joe_info.name #=> "Joe"
  312. # 更新age的值
  313. joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
  315. # 使用 `try` `rescue` 进行异常处理
  316. try do
  317.   raise "some error"
  318. rescue
  319.   RuntimeError -> "rescued a runtime error"
  320.   _error -> "this will rescue any error"
  321. end
  323. # 所有的异常都有一个message
  324. try do
  325.   raise "some error"
  326. rescue
  327.   x in [RuntimeError] ->
  328.     x.message
  329. end
  331. ## ---------------------------
  332. ## -- 并发(Concurrency)
  333. ## ---------------------------
  335. # Elixir 依赖于 actor并发模型。在Elixir编写并发程序的三要素：
  336. # 创建进程，发送消息，接收消息
  338. # 启动一个新的进程使用`spawn`函数，接收一个函数作为参数
  340. f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
  341. spawn(f) #=> #PID<0.40.0>
  343. # `spawn` 函数返回一个pid(进程标识符)，你可以使用pid向进程发送消息。
  344. # 使用 `<-` 操作符发送消息。
  345. #  我们需要在进程内接收消息，要用到 `receive` 机制。
  347. defmodule Geometry do
  348.   def area_loop do
  349.     receive do
  350.       {:rectangle, w, h} ->
  351.         IO.puts("Area = #{w * h}")
  352.         area_loop()
  353.       {:circle, r} ->
  354.         IO.puts("Area = #{3.14 * r * r}")
  355.         area_loop()
  356.     end
  357.   end
  358. end
  360. # 编译这个模块，在shell中创建一个进程，并执行 `area_looop` 函数。
  361. pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
  363. # 发送一个消息给 `pid`， 会在receive语句进行模式匹配
  364. pid <- {:rectangle, 2, 3}
  365. #=> Area = 6
  366. #   {:rectangle,2,3}
  368. pid <- {:circle, 2}
  369. #=> Area = 12.56000000000000049738
  370. #   {:circle,2}
  372. # shell也是一个进程(process), 你可以使用`self`获取当前 pid 
  373. self() #=> #PID<0.27.0>

参考文献

还没有评论.