Clojure基础课程2-Clojure中的数据长啥样?
本文来自网易云社区
作者：李诺
” Clojure is elegant and pragmatic; it helps me focus more on solving business problems.”
不同于Java这类静态语言, Clojure是动态语言，动态类型意味着这些类型会在代码运行时由Clojure动态的推导出来，编译时不作任何限制。
user=> (defn f1 [a b] (+ "1" 2))#'user/f1
user=> (f1 1 2) ClassCastException java.lang.String cannot be cast to java.lang.Number clojure.lang.Numbers.add (Numbers.java:128)
对比上面的两端代码，即使函数f1中含有类型有误的表达式(+ “1” 2)也是可以定义的。然而一旦运行的时候(我们随意给了两个没有用到的参数)，函数+会尝试将”1″和2投射(cast)到Java中的Number类，这时候代码中的类型错误就会以ClassCastException抛出来，因为字符串”1″是无法被投射到Number类的。
注意: 投射(cast)和转换(convert)并不一样，cast一般是将一个子类的成员投射到它的超类上，而像Javascript中”1″ + 2 = 3所做的就是隐式转换了。Clojure的原生函数没有使用隐式转换。
所以我们在写代码的时候一般不需要给定数据类型，但这不意味着类型就不重要了。
为了更好地认识Clojure的类型，首先要会用一个函数: type
user=> (doc type) ------------------------- clojure.core/type([x]) Returns the :type metadata of x, or its Class if nonenil
我们可以用这个函数获取定义中的元数据中的:type项，如果没有这项，那么就返回它的类名。
基本数据类型
我们先来看一些常见的值被推导的默认类型:
数值
-
整数 1,2,3…
-
user=> (type 1) java.lang.Long
Clojure的整数默认使用Java中的Long基础类型，
-
小数 1.414,π…
-
user=> (type Math/PI) java.lang.Double
小数使用Java中的Double类型。
如果我们想要使用其他一些java中的基本类型的整数或者浮点数，我们可以使用
user=> (type (int 1)) java.lang.Integer user=> (type (float 3.14)) java.lang.Float
这类强制转换(Coerce)函数来生成。
有兴趣的同学可以去试试 (type 1111111111111111111111111111111111111111) 和 (type (/ 1 2)) 是什么类型的。
字符串
user=> (type \a) java.lang.Character user=> (type "Hello") java.lang.String
字符和字符串同样也是来自Java。
关键词
可以看到，数字，字符串都使用的是Java的类型，而Clojure中也有一些独有的内建基础类型，如关键词，
user=> (type :hello) clojure.lang.Keyword
如类似:a,:book,:code这样的关键词。关键词的相等性测试非常快，所以关键词常见的使用场景是map类型(之后会详细介绍)中的key。
在下面的这个benchmark中，我们对比了从两种map中获取key对应的value的调用时间，使用关键词做key的map比另一个使用字符串做key的map快了50%，
insight.main=> (def t {:hello 1})
:hella#'insight.main/t
insight.main=> (quick-bench (get t :hello))WARNING: Final GC required 76.32000953339649 % of runtimeEvaluation count : 55186818 in 6 samples of 9197803 calls. Execution time mean : 10.005364 ns Execution time std-deviation : 1.900011 ns Execution time lower quantile : 8.087005 ns ( 2.5%)
Execution time upper quantile : 12.200609 ns (97.5%)
Overhead used : 2.154486 ns
nil
insight.main=> (def t1 {"hello" 1})
#'insight.main/t1
insight.main=> (quick-bench (get t1 "hello"))WARNING: Final GC required 71.39921475186507 % of runtimeEvaluation count : 39262944 in 6 samples of 6543824 calls. Execution time mean : 15.356626 ns Execution time std-deviation : 0.589740 ns Execution time lower quantile : 14.530609 ns ( 2.5%)
Execution time upper quantile : 16.016271 ns (97.5%)
Overhead used : 2.154486 nsFound 1 outliers in 6 samples (16.6667 %)
low-severe 1 (16.6667 %)
Variance from outliers : 13.8889 % Variance is moderately inflated by outliersnil
insight.main=>
集合(Collections)
要看懂Clojure的代码，只有前面的这些类型还不够，还需要一些基本的数据结构，如Vector,List,Map,Set等等，因为Clojure的代码即数据。
List
List的是函数式语言里常见的一种数据结构，我们可以有两种基本的方法构成
user=> (type '(1 2 3)) clojure.lang.PersistentListuser=> (type (list 1 2 3)) clojure.lang.PersistentList
事实上，list的显示是不需要'(quote)或者list的
user=> (map inc '(1 2 3)) (2 3 4)
那为什么在构建list的时候不能这样写呢？其实原因很简单，
list是构成Clojure代码的重要组成部分!
回看Clojure这类Lisp语言的语法，到处可见如(type 1)，(+ 1 2)这样的list形式的代码，其实形如
(operator operand1 operand2 ... operandn)
这样的代码中，第一项operator会被当做可执行的函数, 后面的n项operands则是operator的参数。简单的来说，就是以list的形式写的表达式，默认会被当成一个函数应用(function application)的表达式求值(evaluate), 而’，也就是quote函数，能阻止求值。
求值:
user=> (list 1 (+ 1 2) 3) (1 3 3)
不求值:
user=> '(1 (+ 1 2) 3) (1 (+ 1 2) 3)
Clojure语言具有同像性(homoiconicity)，也就是说，代码一般是以数据的形式组织在一起的，这让操作代码变得和操作数据一样容易，方便了元编程(Clojure中可以编写宏)。
回到list的类型上，list在Clojure里面被叫做 PersistentList 也就是”持久化的list”，是不可变数据类型的一种。Clojure的持久化的数据结构方便了在数据不可变的前提下，对于基于已有数据结构的“修改”操作(数据不可变，“修改”本质上来说是新数据的创建)，能够尽可能的结构共享(structure sharing)。
持久化list的结构共享可以用下面的这个例子解释(来自Wiki):
(def xs '(0 1 2)) (def ys '(3 4 5))
将这两个list做联结合并(concat)
(def zs (concat xs ys))
可以看到xs和ys都存留了下来，在内存中只有xs做了复制，而ys被共享了，因为图中蓝色的部分和xs并不完全一样
Vector
Vector是Clojure里一般被理解作类似Java里的ArrayList的数据结构。
user=> (type [0 1 2]) clojure.lang.PersistentVector
Vector同样也是持久化的数据类型。
事实上Vector是以树形结构储存的数组，它每一层最多有32个子节点，所以它的随机访问是O(log32n)的(也就是O(logn))。有兴趣的朋友可以看Understanding Clojure’s Persistent Vectors, pt. 1里关于如何增加，删减元素的非常详尽的介绍。
类似地，我们也可以用
user=> (vector 1 2 3)[1 2 3]
来组成Vector，或是用
user=> (vec '(1 2 3))[1 2 3]
将list或其他结构转换成vector。
我们一般也可以把vector视作和array类似的，添加，更新，查询都只要O(1)的结构。
Vector也是一个经常用于组织代码，如在函数定义中
(defn plus [a b] (+ a b))
函数名字和函数体之间的函数参数就是以vector的形式给出的。其他的还有let中
(defn f1 [a b] (let [sum (+ a b) diff (- a b)] (* sum diff)))
我们需要给出一个有偶数对成员的且满足一些特殊条件的vector。
Set
在Clojure中，Set也是内建的数据结构，有特别的书写形式
user=> (type #{1 2 3})clojure.lang.PersistentHashSet
Set的成员具有唯一性，我们可以直接把它当做一个函数使用，判断一个值是否是集合中的一员
user=> (def s1 #{1 3 5 7})#'user/s1user=> (s1 3)3user=> (s1 4)
nil
当这个成员存在于集合中，会返回它自身，不然则返回nil(等同于null)。
Map
Map是Clojure中使用频率非常高的数据结构，对于简单的map，我们可以直接在{“}中写偶数个成员, key和value均不用使用同一类型，
user=> (type {:name "doge" "age" 2})
clojure.lang.PersistentArrayMap
默认的map类型为ArrayMap, 它的结构和Vector比较类似，里面的条目是按照创建的顺序排列的，如果要创建HashMap,我们可以用
user=> (hash-map :name "X" :age "10")
{:age "10", :name "X"}
user=> (type (hash-map :name "X" :age "10"))
clojure.lang.PersistentHashMap
Map同样可以被当做函数执行，
user=> (def m1 {:name "X" :age "10"})#'user/m1user=> (m1 :name)"X"user=> (m1 :title)niluser=> (m1 :title "default value")"default value"
会在map中寻找第一个给入的参数作为key的value，如果没有，默认返回nil，如果有第二个参数，会代替nil返回。
Clojure给Map的操作提供了不少便捷的函数，我们可以用get来获取某个key对应的value
user=> (def m1 {:age 10 :name {:firstname "John" :surname "Smith"}})#'user/m1user=> (get m1 :name)
{:firstname "John", :surname "Smith"}
而当我们需要查询更深层的value时候，我们可以使用get-in，搭配上一个按顺序给出的keys的vector
user=> (get-in m1 [:name :surname])"Smith"
当我们要插入或是覆盖某个key对应的value时，我们可以使用assoc
user=> (assoc m1 :height 150)
{:age 10, :name {:firstname "John", :surname "Smith"}, :height 150}
如果需要更新某个value，可以使用update
user=> (update m1 :age (fn [x] (+ x 1)))
{:age 11, :name {:firstname "John", :surname "Smith"}}
update和assoc的区别在于update可以把原来的值作为生成新的值的一个参数，其实他也等同于你用get之后再用assoc，用下面的等式来表达
(update m k f) = (assoc m k (f (get m k)))
在使用的时候，使用最贴合代码逻辑的写法，会更有利于代码的可读性和可维护性。后面的写法如果要等于左边m和k都出现了两次，潜在的增加了修改时的风险。但是后面的写法有时会显得更为灵活。
和get类似，Clojure也提供了assoc-in和update-in，配合上一个常用的宏->使用，可以让map的操作写起来非常简洁直观
user=> (-> {:name {:fullname "Xiao Wang"} :from {:Country "China" :City "Beijing"}} #_=> (assoc :age 30)
#_=> (assoc-in [:from :City] "Shanghai")
#_=> (update-in [:name :fullname] (fn [full-name] (clojure.string/split full-name #" ")))
#_=> ){:name {:fullname ["Xiao" "Wang"]}, :from {:Country "China", :City "Shanghai"}, :age 30}
总结
认识了这些基本的数据类型之后，Clojure的代码将会变得非常容易上手，欢迎感兴趣的朋友们尝试Clojure，Clojure的简洁和直观一定能够让你印象深刻,让你能够更focus在解决真正的问题上。安装的方法可以参考之前我写的这篇，
答案
user=> (type 111111111111111111111111111111111111111111111111111) clojure.lang.BigInt user=> (type (/ 1 2)) clojure.lang.Ratio
网易云新用户大礼包：https://www.163yun.com/gift
本文来自网易云社区，经作者李诺授权发布。
相关文章：
【推荐】 一份ECMAScript2015的代码规范（上）