• 以不变应万变
    • 复习
    • 在 Clojure 里，值是不可变的。
    • 这里再介绍几个对集合进行操作的函数
      • 使用 cons 函数把一些元素添加到集合的头部
      • 使用 conj 函数来添加一些元素到集合中
        • 对于 vector 来说是末尾，但是对 list 来说是头部：
      • 使用 into 函数来把两个集合进行合并。

    以不变应万变

    一个抽象的过程就是寻找变化中的不变量

    在之前的学习中我们学习了如何定义我们的集合，一个很自然的想法就是修改这个集合。

    复习

    我们可以使用 assoc 函数来替换一个集合中的元素

    1. => (assoc ["第一个元素" "第二个元素"] 0 "first")
    2. ["first" "第二个元素"]

    assoc 函数的第一个参数是你要进行替换的集合，第二个参数是你要替换的元素所在“位置”，第三个参数是替换后的元素。

    （注意，索引位置以 0 开始。）

    返回值是修改过后的集合的值。

    然而，Clojure 里集合类型是不可变的。assoc 函数的替换其实并没有改变原集合元素的内容,它返回的是一个“新的”集合。

    （你不用担心浪费存储空间，这个“新”的集合大部分重用了“老”集合。）

    我们可以通过以下代码观察：

    1. => (def my-vec ["第一个元素" "第二个元素"])
    2. #'my-clojure-study.core/my-vec
    4. => (assoc my-vec 0 "first")
    5. ["first" "第二个元素"]
    7. => (print my-vec)
    8. [第一个元素 第二个元素]
    9. nil

    在这段代码中，我们首先定义了一个 vector，然后我们使用 assoc 函数来对这个 vector 进行“替换”。把 0 号元素替换为 “first"。看起来我们已经改动了这个 my-vec。但是当我们使用 print 函数来观察这个集合的时候却发现，他的值没有发生变化。

    那我们如何保存改变之后的值呢？

    我们可以再给这个改变之后的值取一个名字。

    1. => (def my-vec ["第一个元素" "第二个元素"])
    2. #'my-clojure-study.core/my-vec
    3. => (def modifyed-vec (assoc my-vec 0 "first"))
    4. #'my-clojure-study.core/modified-vec
    6. => (print my-vec)
    7. [第一个元素 第二个元素]
    8. nil
    10. => (print modifyed-vec)
    11. [first 第二个元素]
    12. nil

    更常见的做法是把这个改变作为一个值，传递给下一个需要这个值的表达式（如一个函数。我们在之后的定义函数一节里再进行详细介绍）

    在 Clojure 里，值是不可变的。

    我们为什么需要这种不可变的设计呢？

    一个很重要的原因就是，使用不可变的值可以更为简便的实现多线程，当你持有一个值的引用的时候，你不用担心会有其它线程修改你的值。

    （另一个“文绉绉”的说法是，这样更能实现一个“纯函数”，即不修改其它值或者其他状态的函数 [1] 。）

    这里再介绍几个对集合进行操作的函数

    不再一一叙述每个参数是什么，大家在代码中观察，以及在自己的机器上运行观察结果，然后修改部分参数观察是否符合预期。

    使用 cons 函数把一些元素添加到集合的头部

    1. => (def my-vec ["第一个元素" "第二个元素"])
    2. #'my-clojure-study.core/my-vec
    3. => (cons "第零个元素" my-vec)
    4. ("第零个元素" "第一个元素" "第二个元素")

    使用 conj 函数来添加一些元素到集合中

    1. => (def my-vec ["第一个元素" "第二个元素"])
    2. #'my-clojure-study.core/my-vec
    3. => (conj my-vec "第三个元素")
    4. ["第一个元素" "第二个元素" "第三个元素"]
    5. => (conj my-vec "第三个元素" "第四个元素")
    6. ["第一个元素" "第二个元素" "第三个元素" "第四个元素"]
    7. 　
    8. => my-vec
    9. ["第一个元素" "第二个元素"]
    10. my-vec 的值并没有发生改变。

    注意，conj 函数并不是把元素添加到末尾的位置，它只能保证以最快的速度添加进一种数据结构。

    对于 vector 来说是末尾，但是对 list 来说是头部：

    1. => (def my-list '("第一个元素" "第二个元素"))
    2. #'my-clojure-study.core/my-list
    3. => (conj my-list "第三个元素")
    4. ("第三个元素" "第一个元素" "第二个元素")
    5. => my-list
    6. ("第一个元素" "第二个元素")
    7. my-list 的值同样没有发生改变。

    使用 into 函数来把两个集合进行合并。

    和conj 函数一样，它只保证以最快的速度合并。

    1. => (def vec-1 ["一号元素"])
    2. #'my-clojure-study.core/vec-1
    3. => (def vec-2 ["二号元素" 3])
    4. #'my-clojure-study.core/vec-2
    5. 　
    6. => (into vec-1 vec-2)
    7. ["一号元素" "二号元素" 3]
    8. 　
    9. ；list 的情况
    10. => (def list-1 '("first"))
    11. #'my-clojure-study.core/list-1
    12. => (def list-2 '("second"))
    13. #'my-clojure-study.core/list-2
    14. 　
    15. => (into list-1 list-2)
    16. ("second" "first")

    如果你接触过其它“可变的”编程语言，那么你需要提醒自己，使用 def 定义的不是变量，而是一个不可变值。

    而当你真的需要在两个操作之间交换一些信息，比如在多线程中共享一些资源，那么 Clojure 单独提供了一些类型。我们在以后的多线程部分再做详细讲解。

    [1]: 即，没有副作用的函数。 ↩