02.快速上手

快速上手

这一节让我们来了解一下那些“使用Clojure编程必须要掌握的东西”。

其实Clojure（以及其他lisp系语言）的学习曲线还是比较陡峭的。学习Clojure之前必须要掌握一些基础的数据结构和算法知识。

同像性

其实Lisp系语言的语法并没有什么可说的，因为Lisp系语言的代码实际上是由Lisp数据构成的。换句话说，当我们编写Lisp代码时，我们事实上是在描述一个数据结构。这种特性被称作同像性。例如，当我们在Lisp中调用函数时，实际上我们是写下了一个列表结构：

(+ 1 1) ; 函数调用
;=> 2
(class ‘(+ 1 1)) ; 查看(+ 1 1)的类型
;=> clojure.lang.PersistentList

可以看到，(+ 1 1)的类型实际上是一个PersistentList。

因此，学习Lisp的语法其实就是在学习Lisp的数据表示。

同向性带来的好处是我们可以像操作数据结构一样操作代码，这为lisp系语言带来了其他语言不可比拟的元编程能力。

形式（Form）

lisp的语法单元被称为形式。形式指那些能够被读取器读入的代码片段。诸如数值、字符串、列表以及其他复合结构都是形式。相对的，一个没有闭合的列表不是一个形式。

在Clojure中，有一类特殊形式，比如用于定义变量的def，它们是语言的基础组成部分。

数值类型

和绝大多数语言一样，Clojure中自然也有数值类型，对数值类型求值，当然也会返回这个数值本身（废话！）

除了常见的整型和浮点数外，Clojure还支持任意精度实数和任意精度整数：

(class 0.0000000000001M) ; 任意精度实数
;=> java.math.BigDecimal ; 它的实际类型
(class 999999999999999999N) ; 任意精度整数
;=> java.math.Bigint

除此之外，Clojure还支持“有理数”类型：

(/ 1 3)
;=> 1/3 ; 除法的结果以分数形式表示

相较于浮点数，有理数类型不会损失精度，但会带来一定的性能损失。

数值计算

Clojure的数值计算与普通的函数调用并无不同：

(+ 1 2) ;=> 3
(- 2 1) ;=> 1
(* 2 2) ;=> 4
(/ 4 2) ;=> 2
(* (+ 1 2) 3) ;=> 9

有趣的是，这些函数都是可以接受任意数量的参数的：

(+ 1 2 3 4) ;=> 10
(apply * [1 2 3 4]) ;=> 24
(- 1) ;=> -1
(+) ;=> 0
(*) ;=> 1

数值比较

数值比较在Clojure中也是函数：

(> 2 1) ; => true
(= 1 1) ;=> true

这些函数也可以接受任意参数，因此，我们可以用>=函数判断一个数列是否为降序：

(defn desc? [nums] (apply >= nums)) ; 定义函数desc?
;=> #'user/desc?
(desc? [4 3 2 1])
;=> true

注：在Clojure中有一个命名约定：返回值为布尔类型的函数应该以问号结尾。

布尔值与nil

布尔值只包含true和false两个值。在Clojure中，nil相当于java中的null。Clojure的真值判断遵循一个简单的规则：false、nil为假，其余值都为真。

！注意：在Clojure中，空列表不为假

条件判断

Clojure中自然也有分支跳转，需要用到一个叫if的特殊形式：

(if test then else?)

if十分简单，当test为真时返回then，为假时返回else（如果有的话）。注意，当test为假时，else是不会被求值的。

(if (= (+ 1 1) 2)
  "Math still works today!"
  (println "Never happens"))
;=> "Math still works today!"

与Java、C语言的if不同，Clojure的if是具有返回值的。因此其实它相当于其他语言的三元运算符。

if中的then块只能包含一个形式，如果需要执行多条语句可以使用when：

(when (= (+ 1 1) 2)
  (println "print something")
  "Math still works today!")
;; print something
;=> "Math still works today!"

注意：when没有else块，如果判断条件不满足，when会返回nil。

许多语言都有if-else if-else的语言结构，在Clojure中可以使用cond实现同样的效果：

(defn speak [x]
  (cond
    (= x :dog) "Woof!Woof!Woof!"
    (= x :cat) "Mew~"
    (= x :repeater) *1  ; *1是REPL的特殊变量，表示上一个在REPL中求得的值
    :else nil)) ; :else会被求值为真，因此当上述条件都不满足时就会返回nil
(speak :dog) ; => "Woof!Woof!Woof!"
(speak :repeater) ; => "Woof!Woof!Woof!"
(speak :cat) ; => “Mew~”
(speak :repeater) ; => “Mew~”
(speak :monkey) ; => nil

Clojure中也有类似switch的结构case，上述例子可以用case进行改写：

(defn speak2 [x]
  (case x
    :dog "Woof! Woof! Woof!"
    :cat "Mew~"
    :repeater *1
    nil)) ; 最后一行表示默认情况

符号与变量

Clojure中的符号类似其他语言中的标识符。除了能够使用字母、数字、下划线**（注：符号不能以数字开头）**以外，Clojure符号还能够使用一些特殊符号，如+、-、*、/、<、>、.等等。注意，除号（/）和句点（.）常被用于命名空间。

Clojure中可以使用特殊形式def声明一个变量：

(def myname "Khellendros")
;=> #'user/myname
myname
;=> "Khellendros"

变量的初始值不是必须的：

(def no-value)
no-value
#object[clojure.lang.Var$Unbound 0xcc0a548 "Unbound: #'user/no-value"]

使用def定义的变量都是全局变量，使用特殊形式let可以定义局部量，这些局部量只能在let范围内使用：

(let [myage 22, mygender :male]
  (do (println "Name: " myname)
  (println "Age: " myage)
  (println "Gender: " mygender)))
;; Name:  Khellendros
;; Age: 22
;; Gender: :male
;=> nil
myage
;=> CompilerException java.lang.RuntimeException: Unable to resolve symbol: myage in this context, compiling:(null:0:0)

关键字

关键字类似于符号，不同之处在于，符号通常都会引用其他事物（比如变量和函数名），而关键字仅仅代表它本身。关键字的命名规则与符号类似，但必须以冒号（:）开头，且数字可用紧跟着冒号。

:a-keywd
;=> :a-keywd
:1+!
;=> :1+!

关键字最常见的用法是充当关联结构（如map和set）的键值。在Python和JavaScript中，我们通常会用字符串充当键值，然而，比较两个字符串是相当低效的做法，关键字相当于是单例对象，只需要比较它们的内存地址就可以了，效率显然要高很多。此外，关键字也可以用于表示枚举值。

字符与字符串

在Clojure中，用反斜杠后面紧跟着一个字符表示字符类型：

(class \a)
;=> java.lang.Character

而字符串和java一样用双引号表示：

(class “Hello”)
;=> java.lang.String
字符串中间可以换行：
“Hello
world!”
;=> “Hello\nworld!”

str函数用以将一个值转化为字符串：

(str 1) ;=> “1”

str也可以接受多个参数，此时它会将参数转化为字符串后拼接起来，并且会跳过nil

(str 1 2 nil 3) ;=> “123”

正则表达式

在Clojure中可以使用井号（#）加字符串的方式定义一个正则表达式：

(def words #”\w+”)

也可以使用re-pattern函数，不过注意要对正则表达式中的特殊字符用双反斜杠（\)转义：

(def words2 (re-pattern \\w+))

使用re-seq可以找到字符串中所有的匹配项：

(re-seq words “aaa bbb|ccc,ddd”)
;=> (“aaa” “bbb” “ccc” “ddd”)

我们可以在正则表达式中添加分组：

(def middle-part #"\w+\-(\w+)\-\w+")
;=> #'user/middle-part
(re-seq middle-part "aaa-AAA-aaa bbb-BBB-bbb ccc-CCC-ccc")
;=> (["aaa-AAA-aaa" "AAA"] ["bbb-BBB-bbb" "BBB"] ["ccc-CCC-ccc" "CCC"])

此时re-seq将返回一个二维序列。

复合类型

Clojure提供了一组功能非常强大的容器，包括列表（list）、向量（vector）、映射表（map）、集合（set），由于篇幅有限这里仅对它们做一些简单的介绍。

所有这些Clojure容器都是不可变的，当我们使用诸如replace这样的函数改变容器内的元素时，我们将得到一个新的容器，而旧容器始终保持不变。

也许你会觉得这样的做法十分低效：“每次我要对容器进行更改时都需要把整个容器都复制一遍？”。其实恰恰相反，Clojure容器是十分高效的。不可变也意味着更容易实现“共享”——新旧容器之间可以共享大部分内容，当我们对容器做出更改时，通常只会生成一个新的根结点而不用拷贝整个容器。

**列表（list）**是Clojure（以及各种Lisp系语言）中最常见的结构，不过在Clojure中它的主要作用不是作为容器而是用来表示函数（或宏）调用。列表以一对括号表示，列表中的元素以空格或逗号分隔。

(+ 1 1)
;=> 2

在Clojure中，最常用的容器是向量（vector）。向量以一对中括号（[ ]）表示：

[1 2 3]
;=> [1 2 3]

向量的一大特点是它支持高效的随机访问。虽然向量的底层不是数组（array），但它进行随机访问的效率和数组相差无几。

(nth [1 2 3] 1) ; => 2
(get [1 2 3] 1) ; => 2

向量本身也可以当做函数使用，效果等同于nth：

([1 2 3] 1) ;=> 2

！但是注意，向量不能当成集合来使用，对向量使用contains?函数将永远返回true，哪怕该元素其实并不存在。

(contains? [1 2 3] 0) ;=> true

**映射表（map）**常用来表示一些相互关联的键值对，它使用花括号（{ }）来定义。

(def me {:name "Khellendros", :age 22, :gender :male})
;=> #’user/me

！注意：映射表中不能出现重复的键

使用get函数可以根据键查找值：

(get me :name)
;=> "Khellendros"

映射表也可以直接当成函数使用，效果等同于调用get函数：

(me :gender)
;=> :male

此外，关键字也能当成函数使用：

 (:age me)
;=> 22

使用关键字作为函数对映射表进行查询，是Clojure的一种惯用法。

映射表的键可以是任意类型，同时同一个映射表的键的类型也可以各不相同：

(def mess-map {
  :name "@#$$%",
  [1 2 3] "aaa",
  "?" 233 } )
;=> #'user/mess-map
(mess-map [1 2 3])
;=> "aaa"
(mess-map "?")
;=> 233

**集合（set）**相当于键和值相同的映射表。集合使用井号加花括号（#{ }）表示,集合的内容不能重复。

(def img-exts #{"jpg" "gif" "png" "bmp"})
;=> #'user/img-exts

集合通常用来判断其是否包含某个元素：

(contains? img-exts "jpg")
;=> true

集合自身也可以当做函数使用，效果等同于get

(img-exts "jpg")
;=> "jpg"
(img-exts "txt")
;=> nil

解构

复合类型可以进行解构。复合类型的构造可以看做是将多个量聚合成一个，而解构则是构造的逆过程，可以将复合解构拆解成多个量。

解构可以在许多地方发生，这里先以上面提到过的let为例：

(def nums [1 2 3])
;=> #’user/nums
(let [[a b c] nums] ; 解构nums
  (+ a b c))
;=> 6

可以看到，向量nums的第0、第1、第2项分别被绑定到了变量a、b、c上。

我们可以只取列表的前n项而忽略余项：

(def natural-nums (iterate inc 0)) ; 表示全体自然数
;=> #'user/natural-nums
(let [[a b c] natural-nums] (+ a b c))
;=> 3

在这里natural-nums表示全体自然数的总集，因此它是一个无限长的序列，但因为我们只取其前三项，因此不会出现无限循环。

如果要只区第2项，忽略第0和第1项可以这么写：

(let [[_ _ a] natural-nums] a)
;=> 2

下划线（_）是一个合法的符号名，使用下划线忽略某些我们不关心的值是一种惯用法。注意这里下划线被绑定了两次，因此它最终的值是1而不是0。

:as命令可以将整个结构绑定到一个局部量上：

(let [[a b c :as all] nums] (str "Sum of: " all " = " (+ a b c)))
;=> "Sum of: [1 2 3] = 6"

除了向量以外，映射表也可以进行绑定：

(let [{name :name, age :age} me] (str name " is " age " years old."))
:=> "Khellendros is 22 years old."

这种要把键名打两遍的做法略显繁琐，我们可以使用:keys命令进行简化：

(let [{:keys [name age]} me] (str name “ is “ age “ years old.”))
:=> "Khellendros is 22 years old."

除了let以外，其他可以绑定局部量的位置都可以进行解构，包括但不限于函数参数，

loop，for等（见下文）。

函数

Clojure中有许多定义函数的方式，最常见的是使用宏defn：

(defn hello ;定义函数
  "Say hello to someone." ;文档说明
  [name] ;函数参数
  (str "Hello, " name "!")) ;函数体
;=> #'user/hello
(hello "World")
;=> "Hello, World!"

函数可以有多个参数列表和函数体，此时各个参数列表的参数数量需要各不相同：

(defn vec-of
  ([a] [a])
  ([a b] [a b]))
;=> #'user/vec-of
(vec-of 1)
;=> [1]
(vec-of 1 2)
;=> [1 2]

在函数的参数声明处也可以对参数进行解构：

(defn third [[_ _ x]] x)
;=> #'user/first3
(third natural-nums)
;=> 2

代码块

函数体只能包含一个形式，如果我们要执行多个表达式怎么办呢？使用特殊形式do可以解决这个问题：

(do
  (println "first")
  (println "second")
  "not return"
  "return")
;;first
;;second
;=> "return"

block会将最后一个形式的值当做返回值。

匿名函数

一些函数会使用一个回调函数作为参数，回调函数通常都只有一两行代码，如果我们懒得给它们起名字，可以使用匿名函数。匿名函数使用fn定义：

(def double-n (fn [n] (* n 2)))
;=> #’user/double-n
(double-n 10)
;=> 20

匿名函数还有一种简写形式，称作原位函数：

(def double-n-2 #(* % 2))
;=> #’user/double-n-2
(double-n-2 10)
;=> 20

原位函数使用井号加括号（#( )）定义，其中%[n]表示第n个函数参数，%1表示第一个参数，%2表示第二个……以此类推。单独一个%等价于%1

递归

Clojure不提供类似java的while和for循环，需要进行迭代时可以使用递归。在Clojure中可以使用特殊形式recur进行尾递归：

(defn count-down [n]
  (when (pos? n) ; 如果n是正数就继续执行，否则返回nil
  (println n) ; 输出n
  (recur (dec n)))) ; 递减n，然后递归调用count-down
;=> #'user/count-down
(count-down 10)
;;10
;;9
;;8
;;…
;;1
;=> nil

recur类似于C语言的goto语句，“跳转点”默认为recur所在的函数开始处，我们也可以用特殊形式loop自定义跳转点：

(defn count [start end]
  (loop [n start, end end]
  (when (< n end)
  (println n)
  (recur (inc n) end))))
;=> #'user/count
(count 0 10)
;; 0
;; 1
;; 2
;; …
;; 9
;=> nil

在loop中，我们绑定了两个局部量：n和end，当recur被调用时，他会将参数传递给loop绑定的变量。

注意：recur只能放置在一个函数或loop的出口处

遍历

虽然没有传统意义上的while和for循环，但是Clojure提供了类似java的foreach循环的设施——doseq和for。为了方便理解，我们会通过对比java代码来对它们进行说明。

doseq主要用于产生副作用（比如输出到控制台）。我们通过一个实际的例子来讲解一下doseq的用法：

(doseq [n [1 2 3]] ; 将列表[1 2 3]中的每一个元素依次绑定到n
  (println n))
;; 1
;; 2
;; 3
;=> nil

下面是功能相同的java代码：

List<Integer> nums = Arrays.asList(1, 2, 3);
for (int num : nums) {
    System.out.println(num);
}

doseq还能对多个结构进行遍历：

(doseq [m [1 2], n [3 4]]
  (println
  (str m " + " n " = " (+ m n))))
;;1 + 3 = 4
;;1 + 4 = 5
;;2 + 3 = 5
;;2 + 4 = 6
;=> nil

上述例子清晰的展示了doseq是如何对两个向量进行遍历的。以下是等效的java代码：

List<Integer> nums1 = Arrays.asList(1, 2);
List<Integer> nums2 = Arrays.asList(3, 4);
for (int m : nums1) {
    for (int n : nums2) {
        String tmp = m + " + " + n + " = " + (m + n);
        System.out.println(tmp);
    }
}

for的功能比doseq更为强大，它拥有遍历、过滤、变换等多种功能。

; 求笛卡尔积
(for [m [1 2], n [\a \b]] [m n])
;=> ([1 \a] [1 \b] [2 \a] [2 \b])
; 变换
(for [num [1 2 3 4]] (inc num))
;=> (2 3 4 5)
;过滤出偶数
(for [n (range 0 10) :when (even? n)] n)
;=> (0 2 4 6 8)

遍历映射表

对映射表进行遍历时，会将映射表转化为二维序列：

(seq me)
([:name "Khellendros"] [:age 22] [:gender :male])

因此我们可以像操作普通二维序列一样遍历映射表。

需要注意的是，Clojure映射表的默认实现是哈希表，因此元素的遍历顺序是无法预期的。

与Java互操作

在Clojure中可以使用已有的java类库，包括调用静态方法，构造类实例对象，调用方法，读取、设置字段值等。

调用静态方法/静态字段

可以用(类名/静态方法名[方法参数…])的形式调用静态方法和静态字段：

(Math/PI)
;=> 3.141592653589793
(Math/abs -1)
;=> 1

构造实例对象

(类名. [构造方法参数…])或者(new类名[构造方法参数…])可以构造实例对象：

(def nums (java.util.ArrayList.))
;(def nums (new java.util.ArrayList))
;=> #’user/nums
nums
;=> []

方法调用

使用(.方法名对象[方法参数…])调用方法：

(.add nums 1)
;=> true
nums
;=> [1]

读取、设置字段

读取字段的方法是(.-字段名对象)：

(def point (java.awt.Point. 0 1))
;=> #’user/point
(.-x point)
;=> 0

使用set!函数可以设置字段值。

(set! (.-x point) 2)
;=> 2
(.-x point)
;=> 2

注：在Clojure中，以！结尾的函数往往意味着其会带来副作用（比如set!会改变对象的属性）。我们应该审慎的使用这些函数。

小试牛刀：index-of函数

我们上面提到contains?函数对向量无效，我们不妨自己实现一个功能类似的函数index-of。

index-of函数使用起来应该是这样的：

(index-of [1 1 4 5 1 4] 4)
;=> (2 5)
(index-of [1 1 4 5 1 4] 0)
;=> ()

如果序列内包含我们想要查找的目标，index-of会返回由所有匹配项的下表组成的序列。如果没有找到则返回空序列。

首先，我们需要将列表项与其对应的下标关联在一起。还记得我们之前定义的natural-nums吗？把它和向量结合起来就可以了：

(defn indexed-vec [vec]
  (map vector natural-nums vec))
;=> #’user/indexed-vec
(indexed-vec [\a \b \c \d])
;=> ([0 \a] [1 \b] [2 \c] [3 \d])

map函数用于将一个函数应用到一个序列的每一项上，例如：

(map inc [1 2 3])
;=> (2 3 4)

如果传递给map两个序列，那么它就可以通过一个二元函数将两个序列结合起来：

(map + [1 2 3] [3 2 1])
;=> (4 4 4)

同理，如果传入3个序列就要使用一个三元函数，以此类推。如果两个序列的长度不一致，较长的序列会被“截断”。

而vector函数的作用自然是构造一个向量，因此，(map vector natural-nums vec)就会把一个自然数序列（代表下标）和vec像拉链一样“拉”在一起。现在向量已经和下标关联起来了，我们就可以使用for简单的实现index-of了。

(defn index-of [vec item]
  (for [[index value] (indexed-vec vec) :when (= value item)] index) )
;=> #’user/index-of
(index-of [1 1 4 5 1 4] 4)
;=> (2 5)
(index-of [1 1 4 5 1 4] 0)
;=> ()

更进一步？

index-of工作的很好，但还不够通用。如果对映射表、集合都能用通用的接口进行调用就好了。

pos函数（通用版本的index-of）使用起来应该是这样的：

(pos [1 2 3 1] 1) ;=> (0 3)
(pos {:a 1, :b 2, :c 1} 1) ;=>(:a :c)
(pos #{1 2 3} 0) ;=> ()

要做到这一点，首先我们需要定义一个通用版本的indexed：

(defn indexed [xs]
  (cond
  (map? xs) (seq xs)
  (set? xs) (seq xs)
  :else (indexed-vec xs)))

pos相较于index-of只是把indexed-vec换成了indexed：

(defn pos [xs item]
   (for [[index value] (indexed xs) :when (= item value)] index))

再进一步，我们完全可以把item参数换成一个判断函数。来看看这个最终版本的pos-if吧：

(defn pos-if [xs pred]
  (for [[index value] (indexed xs) :when (pred value)] index))
;=> #’user/pos-if
(pos-if [1 2 3 1] #(> %1 1))
;=> (1 2)

最近更新于0001-01-01