Clojure For 循环索引号

Question

我怎样才能在这段代码中得到这个 for 循环的索引：

(def numbers [:one :two :three :four :five])
(def colors  [:green :red :blue :pink :yellow])
(def letters [:A :B :C :D :E])

(for [x numbers
      i colors
      j letters]
    (println (str x " - " i " - " j)))

此代码将打印 125 行，我希望每一行都有索引号。

Answer 1

你需要map-indexed ：

(def numbers [:one :two :three :four :five])
(def colors  [:green :red :blue :pink :yellow])
(def letters [:A :B :C :D :E])

(->> (for [x numbers
           i colors
           j letters]
       (str x " - " i " - " j))
     (map-indexed (fn [index value] 
                    (str "Index: " index " : " value)))
     (run! println))

(fn [index value]...)的较短版本：

(map-indexed #(str "Index: " %1" : " %2))

还可以考虑用一个长字符串调用一个println而不是调用 125x println ，它似乎更快：

(->> (for [x numbers
           i colors
           j letters]
       (str x " - " i " - " j))
     (map-indexed #(str "Index: " %1 " : " %2 "\n"))
     str/join
     println)

（ str/join是clojure.string/join ）

Answer 2

Clojure 不鼓励使用原子，但我认为这是最简单的方法：

(let [index (atom 0)]
  (for [x numbers
        i colors
        j letters]
    (do (swap! index inc)
        (println (str @index ": " x " - " i " - " j)))))

Answer 3

有很多选择。 这里有一些：

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test)
  (:require
    [clojure.string :as str]
    [tupelo.core :as t]
    ))


(def numbers [:one :two :three :four :five])
(def colors [:green :red :blue :pink :yellow])
(def letters [:A :B :C :D :E])

(verify
  ; The tupelo.core/indexed function will add a 0-based index to each element in a sequence
  (is= (t/indexed [:a :b :c])
    [[0 :a]
     [1 :b]
     [2 :c]]))

tupelo.core/indexed function 将为序列中的每个元素添加一个从 0 开始的索引，这通常很方便。

(verify
  ; tupelo.core/map-let allows you to assign a local name to each item from multiple sequences
  ; but behaves like `map`, not `for`
  (let [vecs (t/map-let [n numbers
                         c colors
                         l letters]
               [n c l]) ; return a vector containing each item in sequence
        ]
    (is= vecs
      [[:one :green :A]
       [:two :red :B]
       [:three :blue :C]
       [:four :pink :D]
       [:five :yellow :E]])))

使用t/map-let允许您为每个序列的元素指定一个本地名称，但不会像for那样创建笛卡尔积。

(verify
  (t/let-spy-pretty ; or just `let` to suppress the "spy" printing
    [
     ; using (mapv vector ...) will also place each triple into a vector
     vecs     (mapv vector numbers colors letters)

     strs     (mapv #(str/join " - " %) vecs)
     strs-idx (t/indexed strs)
     lines    (t/forv [[the-idx the-str] strs-idx]
                (str the-idx ": " the-str))]
    (is= vecs
      [[:one :green :A]
       [:two :red :B]
       [:three :blue :C]
       [:four :pink :D]
       [:five :yellow :E]])
    (is= strs
      [":one - :green - :A"
       ":two - :red - :B"
       ":three - :blue - :C"
       ":four - :pink - :D"
       ":five - :yellow - :E"])
    (is= strs-idx
      [[0 ":one - :green - :A"]
       [1 ":two - :red - :B"]
       [2 ":three - :blue - :C"]
       [3 ":four - :pink - :D"]
       [4 ":five - :yellow - :E"]])
    (is= lines
      ["0: :one - :green - :A"
       "1: :two - :red - :B"
       "2: :three - :blue - :C"
       "3: :four - :pink - :D"
       "4: :five - :yellow - :E"])))