clojure-基本语法-函数定义

July 28, 2015 21:12 PM

1.创建函数

1.fn 匿名函数

举例如下：

user=> (fn [] "hello")
#<user$eval756$fn__757 user$eval756$fn__757@7413e8>
user=> ((fn [] "hello"))
"hello"
user=> ((fn [x] x) "hello") ; 带参数
"hello"
user=>

简短的函数可以使用#()，%表示唯一的参数；%1、%2 ..表示第1、2、..个参数；%&表示所有参数，如下：

user=> (#(/ % 3) 4)
4/3
user=> (#(/ % 3) 4);结果为4/3
4/3
user=> (#(/ %2 %1) 3 4);结果为4/3
4/3
user=> (#(apply / %&) 3 5 7);结果为3/5/7
3/35
user=>

2.defn 公有函数 ns外可见

举例如下：

user=> (defn f2 [x] (format "hello %s" x));定义一个参数函数
#‘user/f2
user=> (f2 "girl")
"hello girl"

user=> (defn f4 "f4 function" [] (println "f4 function"));带注释的函数
#‘user/f4
user=> (f4)
f4 function
nil
user=> (doc f4);通过doc查看函数注释信息
-------------------------
user/f4
([])
  f4 function
nil

user=> (defn f5 ([]     (str "no parameter"))
  #_=>          ([name] (str "my name is " name)));定义重载的函数
#‘user/f5
user=> (f5)
"no parameter"
user=>  (f5 "clojure")
"my name is clojure"
user=>

user=> (defn f1 [& a] a);定义变参函数
#‘user/f1
user=> (f1 1 2 3)
(1 2 3)

user=> (defn m [& arg] (str arg ", size=" (count arg)));定义变参函数
#‘user/m
user=>  (m 1 2 3 4 5)
"(1 2 3 4 5), size=5"
user=> (m "a" 1 2.3 -1)
"(\"a\" 1 2.3 -1), size=4"
user=>

user=>  (defn f [a f1 b f2 c] (f2 (f1 a b) c));函数作为参数
#‘user/f
user=> (f 5 - 2 + 3)
6

user=> (defn f [a] (fn [b] (- a b)));函数作为返回值
#‘user/f
user=> ((f 7) 4)
3
user=>

3.defn- 私有函数 ns外不可见

举例如下：

user=> (ns test1);ns的意思是切换到指定的命名空间，如果不存在，则新建该命名空间
nil
test1=> (defn- foo [] "world");定义私有函数foo，返回字符串world
#‘test1/foo
test1=> (defn bar [] (str "hello " (foo)));定义公有函数bar，并调用私有函数foo
#‘test1/bar
test1=>

test1=> (foo);当前命名空间内调用foo函数
"world"
test1=>  (bar);当前命名空间内调用bar函数
"hello world"
test1=>

test1=>

test1=>  (ns test2);切换到test2命名空间中
nil
test2=>  (test1/bar);调用test1命名空间的bar函数，返回成功
"hello world"
test2=>  (test1/foo);调用test1命名空间的foo函数，出现异常，提示test1的foo函数不是公开的

CompilerException java.lang.IllegalStateException: var: #‘test1/foo is not public, compiling:(NO_SOURCE_PATH:1:1)
test2=> (ns user)
nil
user=>

4.comp 组合函数

形如：
((comp f1 f2 .. fn) arg1 arg2 .. argn)

就是对参数从右到左组合执行所有函数，可以转变为：
(f1 (f2 (.. (fn arg1 arg2 .. argn))))

举例如下：

计算 -(2 * 4)

user=> (defn f [x y] (- (* x y)));使用defn定义函数方式
;;#user/f
user=> (f 2 4)
;;-8

user=> (def fc (comp - *));使用comp定义组合函数方式
;;#user/fc
user=> (fc 2 4)
;;-8

5.partial 偏函数 或者“部分完整函数”，因为它是不完整的，定义也用def而不是defn。

形如：
((partial f arg1 arg2 .. argn) arga argb .. argz)

就是执行：
(f arg1 arg2 .. argn arga argb .. argz)

举例如下：

user=> (defn f [n] (* n 10));正常函数
;;#‘user/f
user=> (f 2)
;;20 

;;user=> (def fp (partial * 10));偏函数
;;#‘user/fp
user=> (fp 2)
;;20

6.constantly 恒量函数 接受一个参数x,返回一个变参函数,当 调用该 变参函数后,无论传入多少个任意参数,都返回x

user=>  (def consf (constantly "a"))
#‘user/consf
user=> (consf 1 2 3)
"a"
user=> (consf [1 2 3])
"a"
user=>

2.调用函数

1.-> 也称为 “thread” 宏: 调用一系列的函数，后一个函数迭代使用前一个函数返回结果作为第1个入参,返回最后一次的函数调用值

user=> (first (.split (.replace (.toUpperCase "a b c d") "A" "X") " "))
"X"
user=> (-> "a b c d" .toUpperCase (.replace "A" "X") (.split " ") first)
"X"
user=>

2.->> 调用一系列的函数，后一个函数迭代使用前一个函数返回结果作为最后一个入参,返回最后一次的函数调用值

user=> (-> 3 (/ 4))
3/4
user=> (-> 3 (/ 4) (/ 5))
3/20

user=> (->> 3 (/ 4))
4/3
user=> (->> 3 (/ 4) (/ 5))
15/4

3.eval函数 解析表达式数据结构(不是字符串!) 并返回结果.

举例如下：

user=> (doc eval)
-------------------------
clojure.core/eval
([form])
  Evaluates the form data structure (not text!) and returns the result.
nil
user=> (eval (+ 1 2))
3
user=> (doc read-string)
-------------------------
clojure.core/read-string
([s])
  Reads one object from the string s.

  Note that read-string can execute code (controlled by *read-eval*),
  and as such should be used only with trusted sources.

  For data structure interop use clojure.edn/read-string
nil
user=> (read-string "(println 1)")
(println 1)
user=> (eval (read-string "(println 1)"))
1
nil
user=>

4.apply函数 一次性地把一个集合里面的所有元素指定给后面的那个函数作为参数调用

举例如下：

user=> (apply + [1 2 3 4])
10

3.函数检查

fn?