Clojure学习笔记

Clojure是一门基于JVM的LISP方言， 为了LISP而学习。 在跟这篇文章起名的时候，考虑将其放在JAVA大类下， 不过一门语言最重要的应该是思想吧， 遂将其放在LISP的大类下。

这只是一个简单的笔记， 原文点击这里.

Reader

Macro characters宏

reader的行为是由一系列built-in的结构与被称为read table的拓展系统。整个read table有被称为宏的字符进行索引。

Quote(‘)

'form ===> (quote form)

Character(\)

like \newline, \space, \tab

Comment(;)

Deref(@)

@form ===> (deref form)

Metadata(^)

元数据学习

Dispatch(#)

这个宏会使reader从另一个表出去。

#{} 集合， 阅读上面的集合

正则模式 (#”pattern”)

变量quote(#’) 例如 #’x ===> (var x)

匿名函数

#(...) ===> (fn [args] (...))

忽略下一个form(#_)

Syntax-quote语义引用

`, note, “backquote” 字符. unquote(~) (unquote-splicing ~@)

除了字符， vectors， sets， maps。 `x 与 ‘x相同.

extensible data notation(edn)

under active development

The REPL and main entry points

reference过于抽象， 这里换个教程

Essentials

Clojure语言基础

表达式， 标识符(locals, vars)

let forms

scalars

functions

基础的数据类型

引入不可变的数据结构

Clojure的reference 类型概述

循环与递归

基本的Clojure宏

Scalars

nil, true, false

Data Structures

[1 2 3] ; A vector

[1 :two "three"] ; Put anyting into them you like.

[:a 1 :b 2] ; A hasmap

#{:a :b :c} ; A set (unorderd, and contains no duplicates)

'(1 2 3) ; A list (linked-list)

Abstractions

Clojure的一些抽象：

Collection (Lists, vectors, maps, and sets are all collections)

Sequential (Lists and vectors are ordered collections)

Associative (Hashmaps associate keys with values)

Indexed

宏与特殊的Forms

如何一个表达式开始一个开放的括号， Clojure首先检查是否为一个宏或者特殊form. 这些特殊的forms并不遵循估值规则， 被特殊对待。

宏的调用在编译时期被打开， 准确来说， 是在你的代码被编译之前。 不过Clojurede的内置特殊form(let, def, and if)被硬编码在编译器中。 而不是被定义为宏。 此处不再说明宏。

流程控制

Functions: Defining Your Own

You can create a function using fn, and give it a name using def:

(def my-func

(fn [a b]

(println "adding them!")

(+ a b)))

Language Guides

函数

定义函数

调用函数

Multi-arity

可变函数

Higher order函数

其他相关技巧

定义函数

(defn round

[d precision]

(let [factor (Math/pow 10 precision)]

(/ (Math/floor (* d factor)) factor)))

(defn round

"Round down a double to the given precision (number of significant digits)"

[d precision]

(let [factor (Math/pow 10 precision)]

(/ (Math/floor (* d factor)) factor)))

匿名函数

匿名函数使用fn特殊form进行定义

(let [f (fn [x]

(* 2 x))]

(map f (range 0 10)))

(let [f #(* 2 %)]

(map f (range 0 10)))

Multi-arity 函数

(defn tax-amount

([amount]

(tax-amount amount 35))

([amount rate]

(Math/round (double (* amount (/ rate 100))))))

Overview of clojure.core, the standard Clojure library

Binding

let

Let bindings are immutable and can be destructured.

(let [bindings*] expres*)

(let [x 1]

(println x) ; prints 1

(let [x 2]

(println x))) ; prints 2

def

(def symbol doc-string? init?)

declare

forward declarations. defs the supplied symbols with no init values.

([& names])

defn

([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?])

(def func (fn [x] x))

;; same as:

(defn func [x]

x)

;; with metadata added by defn

(def ^{:doc "documentation!"} ^{:arglists '([x])} func (fn [x] x))

;;same as

(defn func

"documentation!"

[x]

x)

Branching

if

(if test then else?)

(if (nil? (= 1 2)) "second" "third") ; differentiate between nil and false if needed

when

([test & body])

Looping

recur

recur 接受一定数量的indentical的递归点。

(recur exprs*)

(defn count-up

[result x y]

(if (= x y)

result

(recur (conj result x) (inc x) y)))

;; ⇒ [0 1 2 3 4 5 6 7 8 9]

loop

多了一个Let

(loop [bindings*] exprs*)

(defn count-up

[start total]

(loop [result []

x start

y total]

(if (= x y)

result

(recur (conj result x) (inc x) y))))

;; ⇒ [0 1 2 3 4 5 6 7 8 9]

集合与队列的修改

conj

(conj '(1 2) 3)

;; ==> (3 1 2)

(conj [1 2] 3)

;; ==> [1 2 3]

(conj {:a 1 :b 2 :c 3} [:d 4])

;; ==> {:d 4, :a 1 :b 2 :c 3}

(conj #{1 4} 5)

;; ==> #{1 4 5}

(conj #{:a :b :c} :b :c :d :e)

;; ==> #{:a :b :c :d :e}

empty

(empty [1 2 3])

;; ==> []

(empty {:a 1 :b 2 :c 3})

;; ==> {}

assoc

dissoc

都是跟map有关的

集合或队列的信息

count

(count "Hello")

;; ==> 5

(count [1 2 3 4 5 6 7])

;; ⇒ 7

(count nil)

;; ⇒ 0

empty? 是否为空

not-empty

集合或队列中的元素

first

rest

get

contains?

keys

vals

take

filter

(filter even? (range 10))

操作集合和队列

函数组合与应用

juxt

与java交互