数据结构

Collection 和 Sequence

Clojure 常用的数据结构有 List, Map, Vector, Set.
他们都属于 Collection, 之间的关系大致是这样:

数据结构 - 图1

属于 Clojure 当中实现的数据结构都是 Collection. 编码当中会遇到 Host 平台的数据类型, 不属于 Collection.

实现了 Collection 的接口的数据结构都支持这些函数: =, count, conj, empty, seq.
实现了 Sequence 的接口的数据结构支持这些函数: first, rest, next.

关于数据结构的细节推荐阅读 Collections and Sequences in Clojure.

Clojure 中的数据结构被设计成不可变的, 用来配合函数式编程. 这和主流编程语言存在区别.

Sequence & List

Clojure 中的 List 是单链表. 适合从头部访问, 而不适合随机访问. Clojure 采用 Lisp 语法来定义 List:

  1. '(1 2 3 4)
  2. ; (1 2 3 4)
  3. (list? '(1 2 3 4))
  4. ; true

这个语法实际上等同于 quote:

  1. (quote (1 2 3 4))
  2. ; (1 2 3 4)

或者通过调用的写法可以创建 List:

  1. (list 1 2 3 4)
  2. ; (1 2 3 4)

Sequence 是一种抽象的数据结构, List 本身是一种 Sequence, 同时 Sequence 本身可以表示惰性的列表.

  1. (type (range))
  2. ; cljs.core/Range
  3. (seq? (range))
  4. ; true

可以用 seq 函数来创建 Sequence, 不过可以粗略地把它被 List 混在一起理解和使用:

  1. (seq [1 2 3])
  2. ; (1 2 3)

常用的操作:

  1. (first (list 1 2 3 4))
  2. ; 1
  3. (rest (list 1 2 3 4))
  4. ; (2 3 4)
  5. (cons 1 '(2 3 4 5 6))
  6. ; (1 2 3 4 5 6)

Vector

Vector 支持随机访问, 通过 [] 语法可以快速定义:

  1. [1 2 3 4]
  2. ; [1 2 3 4]
  3. (vector? [])
  4. ; true

也支持是用 vec 和 vector 函数通过调用的方式定义:

  1. (vector 1 2 3 4)
  2. ; [1 2 3 4]
  3. (vec '(1 2 3 4))
  4. ; [1 2 3 4]

常用的操作比如:

  1. (get [:a :b :c :d] 1)
  2. ; :b
  3. (nth [:a :b :c :d] 1)
  4. ; :b
  5. (peek [1 2 3 4])
  6. ; 4
  7. (pop [1 2 3])
  8. ; [1 2]
  9. (conj [1 2 3] 4)
  10. ; [1 2 3 4]
  11. (subvec [1 2 3] 1 2) ; 截取向量
  12. ; [2]

Map

Map 是关联列表, 可以通过 {} 语法定义 Map, 其中 , 等同于空白. 一般键和值的类型没有具体限制:

  1. {:a "a", "b" 3, 4 []}
  2. ; {:a "a", "b" 3, 4 []}
  3. (map? {})
  4. ; true

一般使用当中会用 Keyword 来作为键:

  1. {:name "Clojure", :born 2007}

除了通过语法, 也可以用 hash-map 等函数通过调用的方式创建:

  1. (hash-map 1 2 3 4)
  2. ; {1 2, 3 4}
  3. (zipmap [:a :b :c] [1 2 3])
  4. ; {:a 1, :b 2, :c 3}

常用的操作有:

  1. (:a {:a 1})
  2. ; 1
  3. (assoc {:a 1, :b 2} :c 3)
  4. ; {:a 1, :b 2, :c 3}
  5. (dissoc {:a 1} :b 2)
  6. ; {:a 1}
  7. (contains? {:a 1} :b)
  8. ; false
  9. (merge {:a 1} {:b 2})
  10. ; {:a 1, :b 2}
  11. (update {:a 1} :a inc)
  12. ; {:a 2}

Set

集合, 相同的元素之允许出现一次, 可以用 #{} 语法创建:

  1. #{1 2 3}
  2. ; #{1 2 3}
  3. (set? #{})
  4. ; true

或者通过调用的方式创建:

  1. (hash-set 1 2 3)
  2. ; #{1 2 3}
  3. (set [1 2 3])
  4. ; #{1 2 3}

常用的操作有:

  1. (conj #{1 2 3} 4)
  2. ; #{1 2 3 4}
  3. (disj #{1 2 3} 3)
  4. ; #{1 2}
  5. (contains? #{1 2 3} 4)
  6. ; false

此外 clojure.set 提供了其他一些集合的常用函数.

常用函数

推荐去 Cheatsheet 了解有哪些语言本身提供的函数.

  • into

除了前面提到的函数, 还可以通过 into 来做强制数据结构转换:

  1. (into [] '(1 2 3))
  2. ; [1 2 3]
  3. (into #{} '(1 2 3))
  4. ; #{1 2 3}
  5. (into '() [1 2 3])
  6. ; (3 2 1)
  7. (into {} [[:a 1] [:b 2]])
  8. ; {:a 1, :b 2}
  • first

first 取出 Sequence 的第一个元素, 但是对于 Map 来说能获取键值对:

  1. (first [1 2 3])
  2. ; 1
  3. (first '(1 2 3))
  4. ; 1
  5. (first #{1 2 3})
  6. ; 1
  7. (first {:a 1 :b 2})
  8. ; [:a 1]
  • map

注意 map 函数返回的是 Sequence, 并不是和原始的数据类型一致, 而且 reduce 等函数也是这样的:

  1. (map inc [1 2 3])
  2. ; (2 3 4)
  3. (map inc '(1 2 3))
  4. ; (2 3 4)
  5. (map inc #{1 2 3})
  6. ; (2 3 4)
  7. (map identity {:a 1 :b 2})
  8. ; ([:a 1] [:b 2])

具体到 Vector 的情况下, 可使用 mapv 来得到 Vector 类型的结果, 或者用 into 强行转换:

  1. (mapv identity {:a 1 :b 2})
  2. ; [[:a 1] [:b 2]]
  3. (into [] (map identity {:a 1 :b 2}))
  4. ; [[:a 1] [:b 2]]
  • peek, pop 和 conj

由于 Sequence 和 Vector 存在区别, 有些函数虽然通用, 但是效果并不一样:

  1. (peek [1 2 3])
  2. ; 3
  3. (peek '(1 2 3))
  4. ; 1
  5. (pop '(1 2 3))
  6. ; (2 3)
  7. (pop [1 2 3])
  8. ; [1 2]
  9. (conj [1 2 3] 4)
  10. ; [1 2 3 4]
  11. (conj '(1 2 3) 4)
  12. ; (4 1 2 3)
  • count
  1. (count '(1 2 3))
  2. ; 3
  3. (count [1 2 3])
  4. ; 3
  5. (count "123")
  6. ; 3
  7. (count #{1 2 3})
  8. ; 3
  9. (count {:a 1 :b 2 :c 3})
  10. ; 3

对于长度为 0 可以用 empty? 函数来判断:

  1. (empty? [])
  2. ; true
  3. (empty? {})
  4. ; true
  5. (empty? #{})
  6. ; true
  7. (empty? '())
  8. ; true
  • assoc-in 和 update-in

对于嵌套比较深的数据结构, 会用到这些函数, 主要是 Vector, Map 或者混用两种类型:

  1. (get-in {:a [1 2 3]} [:a 0])
  2. ; 1
  3. (assoc-in {:a [1 2 3]} [:a 0] 4)
  4. ; {:a [4 2 3]}
  5. (update-in {:a [1 2 3]} [:a 0] inc)
  6. ; {:a [2 2 3]}

更多的函数还是建议阅读 Cheatsheet