加载中...

clojure

其中 Y=clojure

源代码下载： learnclojure-cn.clj

Clojure是运行在JVM上的Lisp家族中的一员。她比Common Lisp更强调纯函数式编程，且自发布时便包含了一组工具来处理状态。

这种组合让她能十分简单且自动地处理并发问题。

(你需要使用Clojure 1.2或更新的发行版)

  1. ; 注释以分号开始。
  3. ; Clojure代码由一个个form组成， 即写在小括号里的由空格分开的一组语句。
  4. ; Clojure解释器会把第一个元素当做一个函数或者宏来调用，其余的被认为是参数。
  6. ; Clojure代码的第一条语句一般是用ns来指定当前的命名空间。
  7. (ns learnclojure)
  9. ; 更基本的例子:
  11. ; str会使用所有参数来创建一个字符串
  12. (str "Hello" " " "World") ; => "Hello World"
  14. ; 数学计算比较直观
  15. (+ 1 1) ; => 2
  16. (- 2 1) ; => 1
  17. (* 1 2) ; => 2
  18. (/ 2 1) ; => 2
  20. ; 等号是 =
  21. (= 1 1) ; => true
  22. (= 2 1) ; => false
  24. ; 逻辑非
  25. (not true) ; => false
  27. ; 嵌套的form工作起来应该和你预想的一样
  28. (+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
  30. ; 类型
  31. ;;;;;;;;;;;;;
  33. ; Clojure使用Java的Object来描述布尔值、字符串和数字
  34. ; 用函数 `class` 来查看具体的类型
  35. (class 1) ; 整形默认是java.lang.Long类型
  36. (class 1.); 浮点默认是java.lang.Double类型的
  37. (class ""); String是java.lang.String类型的，要用双引号引起来
  38. (class false) ; 布尔值是java.lang.Boolean类型的
  39. (class nil); "null"被称作nil
  41. ; 如果你想创建一组数据字面量，用单引号(')来阻止form被解析和求值
  42. '(+ 1 2) ; => (+ 1 2)
  43. ; (单引号是quote的简写形式，故上式等价于(quote (+ 1 2)))
  45. ; 可以对一个引用列表求值
  46. (eval '(+ 1 2)) ; => 3
  48. ; 集合（Collection）和序列
  49. ;;;;;;;;;;;;;;;;;;;
  51. ; List的底层实现是链表，Vector的底层实现是数组
  52. ; 二者也都是java类
  53. (class [1 2 3]); => clojure.lang.PersistentVector
  54. (class '(1 2 3)); => clojure.lang.PersistentList
  56. ; list本可以写成(1 2 3), 但必须用引用来避免被解释器当做函数来求值。
  57. ; (list 1 2 3)等价于'(1 2 3)
  59. ; 集合其实就是一组数据
  60. ; List和Vector都是集合:
  61. (coll? '(1 2 3)) ; => true
  62. (coll? [1 2 3]) ; => true
  64. ; 序列 (seqs) 是数据列表的抽象描述
  65. ; 只有列表才可称作序列。
  66. (seq? '(1 2 3)) ; => true
  67. (seq? [1 2 3]) ; => false
  69. ; 序列被访问时只需要提供一个值，所以序列可以被懒加载——也就意味着可以定义一个无限序列：
  70. (range 4) ; => (0 1 2 3)
  71. (range) ; => (0 1 2 3 4 ...) (无限序列)
  72. (take 4 (range)) ;  (0 1 2 3)
  74. ; cons用以向列表或向量的起始位置添加元素
  75. (cons 4 [1 2 3]) ; => (4 1 2 3)
  76. (cons 4 '(1 2 3)) ; => (4 1 2 3)
  78. ; conj将以最高效的方式向集合中添加元素。
  79. ; 对于列表，数据会在起始位置插入，而对于向量，则在末尾位置插入。
  80. (conj [1 2 3] 4) ; => [1 2 3 4]
  81. (conj '(1 2 3) 4) ; => (4 1 2 3)
  83. ; 用concat来合并列表或向量
  84. (concat [1 2] '(3 4)) ; => (1 2 3 4)
  86. ; 用filter来过滤集合中的元素，用map来根据指定的函数来映射得到一个新的集合
  87. (map inc [1 2 3]) ; => (2 3 4)
  88. (filter even? [1 2 3]) ; => (2)
  90. ; recuce使用函数来规约集合
  91. (reduce + [1 2 3 4])
  92. ; = (+ (+ (+ 1 2) 3) 4)
  93. ; => 10
  95. ; reduce还能指定一个初始参数
  96. (reduce conj [] '(3 2 1))
  97. ; = (conj (conj (conj [] 3) 2) 1)
  98. ; => [3 2 1]
  100. ; 函数
  101. ;;;;;;;;;;;;;;;;;;;;;
  103. ; 用fn来创建函数。函数的返回值是最后一个表达式的值
  104. (fn [] "Hello World") ; => fn
  106. ; (你需要再嵌套一组小括号来调用它)
  107. ((fn [] "Hello World")) ; => "Hello World"
  109. ; 你可以用def来创建一个变量（var）
  110. (def x 1)
  111. x ; => 1
  113. ; 将函数定义为一个变量（var）
  114. (def hello-world (fn [] "Hello World"))
  115. (hello-world) ; => "Hello World"
  117. ; 你可用defn来简化函数的定义
  118. (defn hello-world [] "Hello World")
  120. ; 中括号内的内容是函数的参数。
  121. (defn hello [name]
  122.   (str "Hello " name))
  123. (hello "Steve") ; => "Hello Steve"
  125. ; 你还可以用这种简写的方式来创建函数：
  126. (def hello2 #(str "Hello " %1))
  127. (hello2 "Fanny") ; => "Hello Fanny"
  129. ; 函数也可以有多个参数列表。
  130. (defn hello3
  131.   ([] "Hello World")
  132.   ([name] (str "Hello " name)))
  133. (hello3 "Jake") ; => "Hello Jake"
  134. (hello3) ; => "Hello World"
  136. ; 可以定义变参函数，即把&后面的参数全部放入一个序列
  137. (defn count-args [& args]
  138.   (str "You passed " (count args) " args: " args))
  139. (count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
  141. ; 可以混用定参和变参（用&来界定）
  142. (defn hello-count [name & args]
  143.   (str "Hello " name ", you passed " (count args) " extra args"))
  144. (hello-count "Finn" 1 2 3)
  145. ; => "Hello Finn, you passed 3 extra args"
  147. ; 哈希表
  148. ;;;;;;;;;;
  150. ; 基于hash的map和基于数组的map（即arraymap）实现了相同的接口，hashmap查询起来比较快，
  151. ; 但不保证元素的顺序。
  152. (class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
  153. (class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
  155. ; arraymap在足够大的时候，大多数操作会将其自动转换成hashmap，
  156. ; 所以不用担心(对大的arraymap的查询性能)。
  158. ; map支持很多类型的key，但推荐使用keyword类型
  159. ; keyword类型和字符串类似，但做了一些优化。
  160. (class :a) ; => clojure.lang.Keyword
  162. (def stringmap {"a" 1, "b" 2, "c" 3})
  163. stringmap  ; => {"a" 1, "b" 2, "c" 3}
  165. (def keymap {:a 1, :b 2, :c 3})
  166. keymap ; => {:a 1, :c 3, :b 2}
  168. ; 顺便说一下，map里的逗号是可有可无的，作用只是提高map的可读性。
  170. ; 从map中查找元素就像把map名作为函数调用一样。
  171. (stringmap "a") ; => 1
  172. (keymap :a) ; => 1
  174. ; 可以把keyword写在前面来从map中查找元素。
  175. (:b keymap) ; => 2
  177. ; 但不要试图用字符串类型的key来这么做。
  178. ;("a" stringmap)
  179. ; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
  181. ; 查找不存在的key会返回nil。
  182. (stringmap "d") ; => nil
  184. ; 用assoc函数来向hashmap里添加元素
  185. (def newkeymap (assoc keymap :d 4))
  186. newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
  188. ; 但是要记住的是clojure的数据类型是不可变的！
  189. keymap ; => {:a 1, :b 2, :c 3}
  191. ; 用dissoc来移除元素
  192. (dissoc keymap :a :b) ; => {:c 3}
  194. ; 集合（Set）
  195. ;;;;;;
  197. (class #{1 2 3}) ; => clojure.lang.PersistentHashSet
  198. (set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
  200. ; 用conj新增元素
  201. (conj #{1 2 3} 4) ; => #{1 2 3 4}
  203. ; 用disj移除元素
  204. (disj #{1 2 3} 1) ; => #{2 3}
  206. ; 把集合当做函数调用来检查元素是否存在:
  207. (#{1 2 3} 1) ; => 1
  208. (#{1 2 3} 4) ; => nil
  210. ; 在clojure.sets模块下有很多相关函数。
  212. ; 常用的form
  213. ;;;;;;;;;;;;;;;;;
  215. ; clojure里的逻辑控制结构都是用宏（macro）实现的，这在语法上看起来没什么不同。
  216. (if false "a" "b") ; => "b"
  217. (if false "a") ; => nil
  219. ; 用let来创建临时的绑定变量。
  220. (let [a 1 b 2]
  221.   (> a b)) ; => false
  223. ; 用do将多个语句组合在一起依次执行
  224. (do
  225.   (print "Hello")
  226.   "World") ; => "World" (prints "Hello")
  228. ; 函数定义里有一个隐式的do
  229. (defn print-and-say-hello [name]
  230.   (print "Saying hello to " name)
  231.   (str "Hello " name))
  232. (print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
  234. ; let也是如此
  235. (let [name "Urkel"]
  236.   (print "Saying hello to " name)
  237.   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
  239. ; 模块
  240. ;;;;;;;;;;;;;;;
  242. ; 用use来导入模块里的所有函数
  243. (use 'clojure.set)
  245. ; 然后就可以使用set相关的函数了
  246. (intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
  247. (difference #{1 2 3} #{2 3 4}) ; => #{1}
  249. ; 你也可以从一个模块里导入一部分函数。
  250. (use '[clojure.set :only [intersection]])
  252. ; 用require来导入一个模块
  253. (require 'clojure.string)
  255. ; 用/来调用模块里的函数
  256. ; 下面是从模块`clojure.string`里调用`blank?`函数。
  257. (clojure.string/blank? "") ; => true
  259. ; 在`import`里你可以给模块名指定一个较短的别名。
  260. (require '[clojure.string :as str])
  261. (str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
  262. ; (#""用来表示一个正则表达式)
  264. ; 你可以在一个namespace定义里用:require的方式来require（或use，但最好不要用）模块。
  265. ; 这样的话你无需引用模块列表。
  266. (ns test
  267.   (:require
  268.     [clojure.string :as str]
  269.     [clojure.set :as set]))
  271. ; Java
  272. ;;;;;;;;;;;;;;;;;
  274. ; Java有大量的优秀的库，你肯定想学会如何用clojure来使用这些Java库。
  276. ; 用import来导入java类
  277. (import java.util.Date)
  279. ; 也可以在ns定义里导入
  280. (ns test
  281.   (:import java.util.Date
  282.            java.util.Calendar))
  284. ; 用类名末尾加`.`的方式来new一个Java对象
  285. (Date.) ; <a date object>
  287. ; 用`.`操作符来调用方法，或者用`.method`的简化方式。
  288. (. (Date.) getTime) ; <a timestamp>
  289. (.getTime (Date.)) ; 和上例一样。
  291. ; 用`/`调用静态方法
  292. (System/currentTimeMillis) ; <a timestamp> (system is always present)
  294. ; 用`doto`来更方便的使用（可变）类。
  295. (import java.util.Calendar)
  296. (doto (Calendar/getInstance)
  297.   (.set 2000 1 1 0 0 0)
  298.   .getTime) ; => A Date. set to 2000-01-01 00:00:00
  300. ; STM
  301. ;;;;;;;;;;;;;;;;;
  303. ; 软件内存事务（Software Transactional Memory）被clojure用来处理持久化的状态。
  304. ; clojure里内置了一些结构来使用STM。
  305. ; atom是最简单的。给它传一个初始值
  306. (def my-atom (atom {}))
  308. ; 用`swap!`更新atom。
  309. ; `swap!`会以atom的当前值为第一个参数来调用一个指定的函数，
  310. ; `swap`其余的参数作为该函数的第二个参数。
  311. (swap! my-atom assoc :a 1) ; Sets my-atom to the result of (assoc {} :a 1)
  312. (swap! my-atom assoc :b 2) ; Sets my-atom to the result of (assoc {:a 1} :b 2)
  314. ; 用`@`读取atom的值
  315. my-atom  ;=> Atom<#...> (返回Atom对象)
  316. @my-atom ; => {:a 1 :b 2}
  318. ; 下例是一个使用atom实现的简单计数器
  319. (def counter (atom 0))
  320. (defn inc-counter []
  321.   (swap! counter inc))
  323. (inc-counter)
  324. (inc-counter)
  325. (inc-counter)
  326. (inc-counter)
  327. (inc-counter)
  329. @counter ; => 5
  331. ; 其他STM相关的结构是ref和agent.
  332. ; Refs: http://clojure.org/refs
  333. ; Agents: http://clojure.org/agents

进阶读物

本文肯定不足以讲述关于clojure的一切，但是希望足以让你迈出第一步。

Clojure.org官网有很多文章: http://clojure.org/

Clojuredocs.org有大多数核心函数的文档，还带了示例哦:http://clojuredocs.org/quickref/Clojure%20Core

4Clojure是个很赞的用来练习clojure/FP技能的地方: http://www.4clojure.com/

Clojure-doc.org (你没看错)有很多入门级的文章: http://clojure-doc.org/

还没有评论.