Map var可以是映射中的键吗？

在本例中，我已经创建了var

nextStudentNumber

，我希望映射在学生身上更改的键

(def nextStudentNumber 1000)

(defn s
  [lastName firstName]
  (let [student {:nextStudentNumber {:lastName lastName
                                     :firstName firstName
                                     :grades {}
                                     :id (inc nextStudentNumber)}}]

我想您希望将其转换为如下内容：

{:nextStudentNumber {:lastName lastName
                     :firstName firstName
                     :grades {}
                     :id (inc nextStudentNumber)}

在这种情况下，您需要：

{:1000 {:lastName lastName
        :firstName firstName
        :grades {}
        :id (inc nextStudentNumber)}

还有一些其他臭味的东西，比如骆驼壳和

inc

。我们在clojure中使用悬浮蛇，因此

lastName

将是

lastName

。我不知道你在用

inc

做什么，但它发出了强烈的命令式的氛围

我想您希望将其转换为如下内容：

{:nextStudentNumber {:lastName lastName
                     :firstName firstName
                     :grades {}
                     :id (inc nextStudentNumber)}

在这种情况下，您需要：

{:1000 {:lastName lastName
        :firstName firstName
        :grades {}
        :id (inc nextStudentNumber)}

还有一些其他臭味的东西，比如骆驼壳和

inc

。我们在clojure中使用悬浮蛇，因此

lastName

将是

lastName

。我不知道你在用

inc

做什么，但它发出了强烈的命令式的氛围

我想您希望将其转换为如下内容：

{:nextStudentNumber {:lastName lastName
                     :firstName firstName
                     :grades {}
                     :id (inc nextStudentNumber)}

在这种情况下，您需要：

{:1000 {:lastName lastName
        :firstName firstName
        :grades {}
        :id (inc nextStudentNumber)}

还有一些其他臭味的东西，比如骆驼壳和

inc

。我们在clojure中使用悬浮蛇，因此

lastName

将是

lastName

。我不知道你在用

inc

做什么，但它发出了强烈的命令式的氛围

我想您希望将其转换为如下内容：

{:nextStudentNumber {:lastName lastName
                     :firstName firstName
                     :grades {}
                     :id (inc nextStudentNumber)}

在这种情况下，您需要：

{:1000 {:lastName lastName
        :firstName firstName
        :grades {}
        :id (inc nextStudentNumber)}

---

还有一些其他臭味的东西，比如骆驼壳和

inc

。我们在clojure中使用悬浮蛇，因此

lastName

将是

lastName

。我不知道你在用

inc

做什么，但它发出了强烈的命令性的振动。

是的，就像任何对象一样，var可以是地图中的一个键：

{(keyword (str nextStudentNumber)) {:lastName lastName
                                    :firstName firstName
                                    :grades {}
                                    :id (inc nextStudentNumber)}

由于这对您没有帮助，下面是您的问题的示例构造：

{#'foo 42}
=> {#'user/foo 42}

请注意，这个示例有点多余（因为可以通过使用索引调用向量来直接在向量中执行索引查找）

然而，它展示了处理不可变数据的基本思想：在独立的步骤中生成ID并进行分组。您可以通过多种方式组合这些步骤，例如为新学员生成ID，将他们添加到现有学员的集合中，并按ID对他们进行分组。请注意，

（groupby:ID）

step的工作方式与ID的生成方式无关，并且允许两名学生拥有相同ID，然后您可以检测和处理这些ID

命令式方法在功能性Clojure世界中非常不典型。如果您有许多分配学生的函数（在您的想法中应该调用

s

），而是让他们变得纯粹，让他们返回学生集合，并给他们命名，如

从文件中加载学生

，

生成ID

，并使用

concat

等结构，

进入

组合它们返回的集合，而无需弄乱状态，直到您对学生数据进行I/O

如果出于好奇，您仍然想搞乱状态，那么下面是另一个（相当不规则的）代码示例：

(->> [{:name "Mara"} {:name "Lara"} {:name "Clara"}]
     (map-indexed #(assoc %2 :id %1)) ;; assign an ID to each student
     (group-by :id)) ;; Create a hash-map where students can be looked up by ID
=> {0 [{:name "Mara, :id 0}], 1 [{:name "Lara", :id 1}]
    2 [{:name "Clara", :id 2}]}

例如：

(def student-count (atom 0))
(def students-by-id (atom {}))

(defn add-student! [first-name last-name]
   (let [next-id (swap! student-count inc)]
     (swap! students-by-id
            assoc next-id {:first-name first-name, :last-name last-name
                           :id next-id})))

---

正如您所看到的，这里的一切都是一步完成的。

是的，就像任何对象一样，变量可以是映射中的键：

{(keyword (str nextStudentNumber)) {:lastName lastName
                                    :firstName firstName
                                    :grades {}
                                    :id (inc nextStudentNumber)}

由于这对您没有帮助，下面是您的问题的示例构造：

{#'foo 42}
=> {#'user/foo 42}

请注意，这个示例有点多余（因为可以通过使用索引调用向量来直接在向量中执行索引查找）

然而，它展示了处理不可变数据的基本思想：在独立的步骤中生成ID并进行分组。您可以通过多种方式组合这些步骤，例如为新学员生成ID，将他们添加到现有学员的集合中，并按ID对他们进行分组。请注意，

（groupby:ID）

step的工作方式与ID的生成方式无关，并且允许两名学生拥有相同ID，然后您可以检测和处理这些ID

命令式方法在功能性Clojure世界中非常不典型。如果您有许多分配学生的函数（在您的想法中应该调用

s

），而是让他们变得纯粹，让他们返回学生集合，并给他们命名，如

从文件中加载学生

，

生成ID

，并使用

concat

等结构，

进入

组合它们返回的集合，而无需弄乱状态，直到您对学生数据进行I/O

如果出于好奇，您仍然想搞乱状态，那么下面是另一个（相当不规则的）代码示例：

(->> [{:name "Mara"} {:name "Lara"} {:name "Clara"}]
     (map-indexed #(assoc %2 :id %1)) ;; assign an ID to each student
     (group-by :id)) ;; Create a hash-map where students can be looked up by ID
=> {0 [{:name "Mara, :id 0}], 1 [{:name "Lara", :id 1}]
    2 [{:name "Clara", :id 2}]}

例如：

(def student-count (atom 0))
(def students-by-id (atom {}))

(defn add-student! [first-name last-name]
   (let [next-id (swap! student-count inc)]
     (swap! students-by-id
            assoc next-id {:first-name first-name, :last-name last-name
                           :id next-id})))

---

正如您所看到的，这里的一切都是一步完成的。

是的，就像任何对象一样，变量可以是映射中的键：

{(keyword (str nextStudentNumber)) {:lastName lastName
                                    :firstName firstName
                                    :grades {}
                                    :id (inc nextStudentNumber)}

由于这对您没有帮助，下面是您的问题的示例构造：

{#'foo 42}
=> {#'user/foo 42}

请注意，这个示例有点多余（因为可以通过使用索引调用向量来直接在向量中执行索引查找）

然而，它展示了处理不可变数据的基本思想：在独立的步骤中生成ID并进行分组。您可以通过多种方式组合这些步骤，例如为新学员生成ID，将他们添加到现有学员的集合中，并按ID对他们进行分组。请注意，

（groupby:ID）

step的工作方式与ID的生成方式无关，并且允许两名学生拥有相同ID，然后您可以检测和处理这些ID

命令式方法在功能性Clojure世界中非常不典型。如果您有许多分配学生的函数（在您的想法中应该调用

s

），而是让他们变得纯粹，让他们返回学生集合，并给他们命名，如

从文件中加载学生

，

生成ID

，并使用

concat

等结构，

进入

组合它们返回的集合，而无需弄乱状态，直到您对学生数据进行I/O

如果出于好奇，您仍然想搞乱状态，那么下面是另一个（相当不规则的）代码示例：

(->> [{:name "Mara"} {:name "Lara"} {:name "Clara"}]
     (map-indexed #(assoc %2 :id %1)) ;; assign an ID to each student
     (group-by :id)) ;; Create a hash-map where students can be looked up by ID
=> {0 [{:name "Mara, :id 0}], 1 [{:name "Lara", :id 1}]
    2 [{:name "Clara", :id 2}]}

例如：

(def student-count (atom 0))
(def students-by-id (atom {}))

(defn add-student! [first-name last-name]
   (let [next-id (swap! student-count inc)]
     (swap! students-by-id
            assoc next-id {:first-name first-name, :last-name last-name
                           :id next-id})))

正如你所看到的，一切