Clojure 参考值

Clojure 是一种现代的 Lisp 方言，支持并发编程和函数式编程范式，旨在提高程序员的生产力和代码可读性。Clojure 运行于 Java 平台上，可以与 Java 无缝集成。

基础语法

Clojure 的基础语法大部分来自于 Lisp。下面是一些基础语法的例子：

定义变量

(def x 10)
(def y (+ x 5))

定义函数

(defn greet [name]
  (println (str "Hello, " name "!")))

控制流程

(if (< x 5)
  (println "x 小于 5")
  (println "x 大于等于 5"))
  
(when (not (empty? my-list))
  (println "列表不为空"))
  
(let [x 10
      y 5]
  (if (< x y)
    (println "x 小于 y")
    (println "x 大于等于 y")))

数据类型

;; 数字、字符串等
(def x 10)
(def s "Hello, World!")

;; 列表
(def my-list '(1 2 3 4))
(first my-list) ;; 返回 1
(rest my-list) ;; 返回 (2 3 4)

;; 向量
(def my-vector [1 2 3 4])
(get my-vector 0) ;; 返回 1

;; 数组
(def my-array (int-array [1 2 3 4]))
(aget my-array 0) ;; 返回 1

;; Map
(def my-map {:name "John"
             :age 30})
(get my-map :name) ;; 返回 "John"

操作符

;; 加、减、乘、除
(+ 1 2) ;; 返回 3
(- 5 2) ;; 返回 3
(* 2 3) ;; 返回 6
(/ 10 2) ;; 返回 5

;; 比较
(< 5 7) ;; 返回 true
(<= 2 2) ;; 返回 true
(> 5 7) ;; 返回 false
(>= 2 2) ;; 返回 true
(= 2 2) ;; 返回 true

;; 逻辑
(and true false) ;; 返回 false
(or true false) ;; 返回 true
(not false) ;; 返回 true

;; 连接字符串
(str "Hello," " " "World!") ;; 返回 "Hello, World!"

函数式编程

Clojure 提供了强大的函数式编程支持。函数是 Clojure 中的一等公民，也就是说，函数可以像任何其他值一样被赋值、传递和返回。下面是一些函数式编程的例子：

匿名函数

((fn [x] (+ x 1)) 4) ;; 返回 5
((fn [x] (* x x)) 5) ;; 返回 25

高阶函数

(defn apply-twice [f x]
  (f (f x)))

(apply-twice (fn [x] (+ x 1)) 4) ;; 返回 6
(apply-twice (fn [x] (* x x)) 5) ;; 返回 625

map 和 reduce

;; map: 对列表中的每个元素都应用相同的函数，返回一个新的列表
(map (fn [x] (* x 2)) '(1 2 3 4)) ;; 返回 (2 4 6 8)

;; reduce: 将列表中的元素合并为一个值
(reduce (fn [acc x] (+ acc x)) 0 '(1 2 3 4)) ;; 返回 10
(reduce (fn [acc x] (* acc x)) 1 '(1 2 3 4)) ;; 返回 24

函数组合

(defn add-one [x]
  (+ x 1))

(defn double [x]
  (* x 2))

(def add-one-and-double (comp double add-one)) ;; 组合 add-one 和 double
(add-one-and-double 4) ;; 返回 10

并发编程

Clojure 内置支持并发编程，提供了多个并发编程的库和工具。下面是一些并发编程的例子：

锁和原子

;; 锁: 用于保护共享状态
(def lock (ref {}))
(dosync (alter lock assoc :name "John"))
(dosync (alter lock assoc :age 30))
@lock ;; 返回 {:name "John", :age 30}

;; 原子: 用于保护单个的值
(def counter (atom 0))
(swap! counter inc)
(swap! counter inc)
@counter ;; 返回 2

通道

;; 定义通道
(def ch (chan))

;; 启动生产者
(go
  (dotimes [i 10]
    (>!! ch i)))

;; 启动消费者
(go-loop []
  (when-let [msg (<! ch)]
    (println msg)
    (recur)))

总结

Clojure 是一种强大、现代的语言，支持函数式编程和并发编程。它的基础语法来自于 Lisp，但也借鉴了其他语言的最佳实践。如果你正在寻找一种崇尚简洁、高效和易读的编程语言，那么 Clojure 一定不会让你失望。