Programming Clojure笔记之二——探索Clojure

Forms

Clojure具有同像性（homoiconic），即代码与其数据的结构一致。Clojure代码主要由以下形式（Forms）构成。这些形式可以理解为其他程序设计语言中的数据类型。

Form Example(s) Boolean true, false Character \a Keyword :tag, :doc List (1 2 3), (println “hello”) Map {:name “Bill”, :age 42} Nil nil Number 1, 4.2 Set #{:snap :crackle :pop} String “hello” Symbol user/foo, java.lang.String Vector [1 2 3]

数值(Number)

数值的字面量是一种Form，对其求值得到本身。

42-> 42;vector is a form[1 2 3]-> [1 2 3];list is a form，此处解析为函数调用(+ 1 2)-> 3(+)-> 0(concat [1 2] [3 4])-> [1 2 3 4](> 5 2)-> true;整数相除得到一个Clojure类型Ratio(/ 22 7)-> 22/7;如果需要实际的除法运算，使用浮点数字面量(/ 22.0 7)-> 3.142857142857143;或者这样得到整数相除的商和余数(quot 22 7)-> 3(rem 22 7)-> 1;任意精度的浮点数运算在数字后加上M，结果是一个BigDecimal(+ 1 (/ 0.00001 1000000000000000000))-> 1.0(+ 1 (/ 0.00001M 1000000000000000000))-> 1.00000000000000000000001M;任意精度的整数运算，则在其中一个数字后加上N即可，结果是一个BigInt(* 1000N 1000 1000 1000 1000 1000 1000)-> 1000000000000000000000N

符号(Symbol)

符号用来给Clojure中的事物命名，如：
- 类似str和concat的函数。
- 类型+和-的操作符，本质上也是函数。
- Java类，如java.lang.String
- 名字空间如clojure.core和Java包如java.lang
- 数据结构和引用

String和Character

String也是一种Form。Clojure中的String就是Java中的String。

(.toUpperCase "hello")-> "HELLO"

函数前的点表明这是调用的Java方法而不是Clojure函数。Clojure没有封装所有的函数，但是toString得到了封装。这就是str函数。(str & args)
该函数将多个参数并在一起，并且可以略过nil。

(str 1 2 nil 3)-> "123"

Clojure中的字符也是Java字符。字面量表达方式为\{letter}

(str \h \e \y \space \y \o \u)-> "hey you"

Clojure也没有封装Java的字符函数。只能直接使用Java方法。

(Character/toUpperCase \s)-> \S

字符串就是字符序列。在字符串上调用序列函数就得到了一个字符序列。例如交插两个字符串：

(interleave "Attack at midnight" "The purple elephant chortled")-> (\A \T \t \h \t \e \a \space \c \p \k \u \space \r \a \p \t \l \space \e \m \space \i \e \d \l \n \e \i \p \g \h \h \a \t \n);如果要将结果转为字符串，不能简单的使用str(str (interleave "Attack at midnight" "The purple elephant chortled"))-> "clojure.lang.LazySeq@d4ea9f36";应该使用apply函数(apply str (interleave "Attack at midnight" "The purple elephant chortled"))-> "ATthtea cpku raptl em iedlneipghhatn";最后，将交插的结果还原(apply str (take-nth 2 "ATthtea cpku raptl em iedlneipghhatn"))-> "Attack at midnight"

Booleans和nil

• true 的值为true，false的值为false
• nil在布尔上下文中被解析为false
• 除了false和nil，其他所有值在布尔上下文中解析为true
  谓词函数（一般以?结尾的函数）用于判定表达式的真实值。

(true? true)-> true(true? "foo")-> false(zero? 0.0)-> true(zero? (/ 22 7))-> false

Maps、Keywords和Records

;定义一个Map(def inventors {"Lisp" "McCarthy" "Clojure" "Hickey"})-> #'user/inventors;或者在键值对之间加上逗号（Clojure将之视为空格）(def inventors {"Lisp" "McCarthy", "Clojure" "Hickey"})-> #'user/inventors;Map是函数，传入键，得到相应的值(inventors "Lisp")-> "McCarthy"(inventors "Foo")-> nil;或者使用get函数，可以传入一个缺省值(get inventors "Lisp" "I dunno!")-> "McCarthy"(get inventors "Foo" "I dunno!")-> "I dunno!";Keyword类似于symbol，不过以冒号开头。并且总是解析为自身，symbol则指向其他值。使用Keyword作为Map的键(def inventors {:Lisp "McCarthy" :Clojure "Hickey"})-> #'user/inventors;使用keyword获取map中关联的值(inventors :Clojure)-> "Hickey";keyword也是函数，因而这样也可以获取map中的值。(:Clojure inventors)-> "Hickey";如果很多map有相同的键，这时可以定义一个record(defrecord Book [title author])-> user.Book;实例化一个记录并且绑定到变量b(def b (->Book "Anathem" "Neal Stephenson"));另一种实例化record的方法(Book. "Anathem" "Neal Stephenson")-> #user.Book{:title "Anathem", :author "Neal Stephenson"}  ;从变量b中获取值(:title b)-> "Anathem"

Reader macros

Clojure中的forms是由reader读取并转化为数据结构的。reader被一些特殊的字符触发后的特殊行为称之为reader macro。最典型的例子就是注释，这时macro字符就是分号，触发的特殊行为就是，忽略直到行尾的所有内容。
reader macros一般是冗长list forms的省略形式。阻止求值的单引号就是其中之一。

'(1 2)-> (1 2);'(1 2) is equivalent to the longer (quote (1 2)):(quote (1 2))-> (1 2)

下表列出了其他的reader macro。

Reader Macro Example(s) 匿名函数(Anonymous function) #(.toUpperCase %) 注释(Comment) ;sigle-line comment 解引用(Deref) @form=>(deref form) 元数据(Metadata) ^metadata form 引用(Quote) ‘form=>(quote form) 正则表达式模式(Regex pattern) #"foo"=>a Syntax-quote `x Unquote ~ Unquote-splicing ~@ Var-quote #'x=>(var x)

函数

使用defn定义函数如下：

;基本形式(defn name doc-string? attr-map? [params*] body)(defn greeting"Returns a greeting of the form 'Hello, username.'"[username](str "Hello, " username));调用函数(greeting "world")-> "Hello, world";查看函数的文档(doc greeting);不提供参数调用greeting会产生异常。事实上，函数可以有多个参数列表和相应的函数体;以下是函数定义的完整形式(defn name doc-string? attr-map? ([params*] body)+)(defn greeting"Returns a greeting of the form 'Hello, username.'Default username is 'world'."([] (greeting "world"))([username] (str "Hello, " username)));函数的不定参数(defn date [person-1 person-2 & chaperones](println person-1 "and" person-2 "went out with" (count chaperones) "chaperones."))

匿名函数

;不使用匿名函数(defn indexable-word?     [word] (> (count word) 2))(require '[clojure.string :as str])(filter indexable-word? (str/split "A fine day it is" #"\W+"))-> ("fine" "day");匿名函数定义方式(fn [params*] body);使用匿名函数(filter (fn [w] (> (count w) 2)) (str/split "A fine day" #"\W+"))-> ("fine" "day");使用隐式参数(%1,%2...)使得匿名函数更加简洁;#(body)(filter #(> (count %) 2) (str/split "A fine day it is" #"\W+"))-> ("fine" "day");在函数内部将匿名函数绑定到symbol(defn indexable-words [text]    (let [indexable-word? (fn [w] (> (count w) 2))]        (filter indexable-word? (str/split text #"\W+"))));匿名函数作为返回值(defn make-greeter [greeting-prefix]    (fn [username] (str greeting-prefix ", " username)))

变量（var）、绑定（Binding）和命名空间（Namespace）

当使用def或者defn定义了一个对象时，该对象就存储在一个var中。

(def foo 10)-> #'user/foo;符号user/foo指向一个变量，变量绑定了值10。你可以直接引用一个var。(var foo)-> #'user/foo;引用一个var，更常见的是使用其reader macro形式(#')#'foo-> #'user/foo;一般情况下不需要直接引用var，可以忽略symbol和var的区别。;需要注意的是，var不仅仅只能存储值。还可以包含元数据等等。

绑定

var绑定到了名字，其他绑定还包括实参值绑定到了函数形参名。函数的参数绑定具有词法作用域（lexical scope），仅仅在函数体内可见。然而函数不是进行词法绑定的唯一方式。let这种特殊的form是专门用来进行词法绑定的。

(let [bindings*] exprs*);绑定在exprs有效,exprs中最后一个表达式的值就是let的值。(defn square-corners [bottom left size]    (let [top (+ bottom size) right (+ left size)] [[bottom left] [top left] [top right] [bottom right]]))

解构（Destructuring）

有时函数只需要容器数据结构的一部分数据，而不想将参数绑定到整个容器。Clojure中使用destructuring来解决这个问题

;使用解构前(defn greet-author-1 [author]    (println "Hello," (:first-name author)))(greet-author-1 {:last-name "Vinge" :first-name "Vernor"})| Hello, Vernor;使用解构后(defn greet-author-2 [{fname :first-name}]    (println "Hello," fname))(greet-author-2 {:last-name "Vinge" :first-name "Vernor"})| Hello, Vernor;前面使用map来解构关联容器，那么vector可以用来解构顺序容器。(let [[x y] [1 2 3]][x y])-> [1 2];依照惯例使用下划线绑定不关心的值(let [[_ _ z] [1 2 3]]z)-> 3;使用:as来同时绑定全部数据(let [[x y :as coords] [1 2 3 4 5 6]]  (str "x: " x ", y: " y ", total dimensions " (count coords)))-> "x: 1, y: 2, total dimensions 6";综合示例(require '[clojure.string :as str])(defn ellipsize [words]  (let [[w1 w2 w3] (str/split words #"\s+")]    (str/join " " [w1 w2 w3 "..."])))(ellipsize "The quick brown fox jumps over the lazy dog.")-> "The quick brown ..."

命名空间

;确认当前命名空间存在一个符号，不存在则返回nil(resolve 'foo)-> #'user/foo;切换命名空间，不存在则创建user=> (in-ns 'myapp) -> #<Namespace myapp> myapp=>;切换到新的命名空间后java.lang包会自动导入，然而需要手动导入clojure.coremyapp=> (clojure.core/use 'clojure.core)-> nil;导入其他Java包(import '(java.io InputStream File))-> java.io.File(.exists (File. "/tmp"))-> true;声明当前文件的命名空间并导入clojure和Java包(ns examples.exploring  (:require [clojure.string :as str])  (:import (java.io File)))

调用Java

;创建对象(def rnd (new java.util.Random))-> #'user/rnd;调用方法(. rnd nextInt 10)-> 8;静态方法(. Math PI)-> 3.141592653589793;javadoc函数(javadoc java.net.URL)

控制流

if分支

(defn is-small? [number]  (if (< number 100) "yes" "no"))

使用do引入副作用

;do接受任意数量的form并且依次求值，返回最后的form值(defn is-small? [number]   (if (< number 100)    "yes"   (do     (println "Saw a big number" number)      "no")))

使用loop/recur进行迭代

(loop [result [] x 5]   (if (zero? x)    result    (recur (conj result x) (dec x))))-> [5 4 3 2 1];一般不用loop/recur，使用下列方法作为替代(into [] (take 5 (iterate dec 5)))-> [5 4 3 2 1](into [] (drop-last (reverse (range 6))))-> [5 4 3 2 1](vec (reverse (rest (range 6))))-> [5 4 3 2 1]

for

;Clojure中的for用来sequence comprehension(defn index-filter [pred coll]   (when pred    (for [[idx elt] (indexed coll) :when (pred elt)] idx)))(index-filter #{\a \b} "abcdbbb")-> (0 1 4 5 6)(index-filter #{\a \b} "xyz")-> ()

元数据

;str变量的元数据(meta #'str)-> {:ns #<Namespace clojure.core>,    :name str,    :file "core.clj",    :line 313,    :arglists ([] [x] [x & ys]),    :tag java.lang.String,    :doc "With no args, ... etc."};使用元数据reader macro添加元数据，元数据由编译器添加到var中^metadata form;定义了shout函数，并添加了:tag元数据。表明函数接受String类型返回String类型。(defn ^{:tag String} shout [^{:tag String} s] (.toUpperCase s))-> #'user/shout;由于:tag键很常用，因此简写形式如下(defn ^String shout [^String s] (.toUpperCase s))-> #'user/shout;如果觉得元数据影响函数阅读，可以放到最后(defn shout  ([s] (.toUpperCase s))  {:tag String})