Clojure基础课程2-Clojure中的数据长啥样?

Posted zyfd

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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

本文来自网易实践者社区,经作者李诺品授权发布。

 


相关文章:
【推荐】 餐饮行业的利器——大数据
【推荐】 如何准确又通俗易懂地解释大数据及其应用价值?

















以上是关于Clojure基础课程2-Clojure中的数据长啥样?的主要内容,如果未能解决你的问题,请参考以下文章

如何使用assoc-in更新地图中的多个值? (Clojure的)

有没有一种惯用的方法来避免长的 Clojure 字符串文字?

《Learn Clojure》直播第二期:Clojure 数据类型介绍

Clojure:gen-class并在java中导入它;包,路径,类路径

clojure 中的预聚合数据结构

Clojure 测试中的数据库模拟