REPL交互环境 #

┌─────────────────────────────────────────┐
│                                         │
│   Read  →  Eval  →  Print  →  Loop     │
│    ↓        ↓        ↓        ↓        │
│   读取    求值    打印    循环          │
│                                         │
└─────────────────────────────────────────┘

clj

lein repl

lein repl :headless

user=> (+ 1 2 3)
6

user=> (defn square [x] (* x x))
#'user/square

user=> (square 5)
25

user=> (defn greet
  #_=>   [name]
  #_=>   (str "Hello, " name "!"))
#'user/greet

user=> *ns*
#object[clojure.lang.Namespace 0x... "user"]

user=> (ns my-app.core)
nil

my-app.core=> *ns*
#object[clojure.lang.Namespace 0x... "my-app.core"]

user=> (in-ns 'my-app.utils)
#object[clojure.lang.Namespace 0x... "my-app.utils"]

my-app.utils=> (ns user)
nil

user=> (ns-publics 'clojure.string)
{:split #'clojure.string/split, :join #'clojure.string/join, ...}

user=> (ns-interns 'user)
{greet #'user/greet, square #'user/square}

user=> (ns-map 'user)
{...}

user=> (doc map)
-------------------------
clojure.core/map
([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])
  Returns a lazy sequence consisting of the result of applying f to
  the set of first items of each coll, followed by applying f to the
  set of second items in each coll, until any one of the colls is
  exhausted. ...

user=> (source when)
(defmacro when
  [test & body]
  (list 'if test (cons 'do body)))

user=> (find-doc "string")
user=> (find-doc #"regex")

user=> (apropos "map")
(map map? mapcat mapv ...)

user=> (meta #'map)
{:arglists ([f coll] [f c1 c2] ...),
 :doc "Returns a lazy sequence...",
 :line 2713,
 :column 1,
 :file "clojure/core.clj",
 :name map,
 :ns #object[clojure.lang.Namespace ...]}

user=> (defn process [x]
         (println "Input:" x)
         (let [result (* x 2)]
           (println "Result:" result)
           result))

user=> (process 5)
Input: 5
Result: 10
10

user=> (pr {:a 1 :b 2})
{:a 1, :b 2}

user=> (prn {:a 1 :b 2})
{:a 1, :b 2}
nil

user=> (/ 1 0)
ArityException...

user=> (pst)
ArityException Dividing by zero
    clojure.lang.Numbers.divide (Numbers.java:163)
    user/eval123 (NO_SOURCE_FILE:1)
    ...
nil

user=> (add-tap println)
#object[...]
user=> (tap> {:debug "data"})
{:debug "data"}
true
user=> (remove-tap println)

user=> (load-file "src/my_app/core.clj")

user=> (use 'my-app.core :reload)

user=> (require '[my-app.core :as core] :reload)

user=> (require '[clojure.tools.namespace.repl :refer [refresh]])

user=> (refresh)
:reloading (my-app.core my-app.utils)
:ok

M-x cider-jack-in

user=> (set! *print-length* 10)
10

user=> (range 100)
(0 1 2 3 4 5 6 7 8 9 ...)

user=> (try
         (/ 1 0)
         (catch Exception e
           (str "Error: " (.getMessage e))))
"Error: Divide by zero"

user=> (time (reduce + (range 1000000)))
"Elapsed time: 23.456 msecs"
499999500000

user=> (class "hello")
java.lang.String

user=> (class 42)
java.lang.Long

user=> (class [1 2 3])
clojure.lang.PersistentVector

user=> (require '[clojure.repl :refer [doc source pst]])

user=> (doc map)

user=> (source when)

user=> (pst)

user=> (require '[clojure.test :refer [deftest is run-tests]])

user=> (deftest my-test
         (is (= 1 1))
         (is (= 2 (+ 1 1))))

user=> (run-tests)

user=> (require '[clojure.pprint :refer [pprint]])

user=> (pprint {:a 1 :b {:c 2 :d 3}})
{:a 1,
 :b {:c 2,
     :d 3}}

(defn process-data
  [data]
  (let [cleaned (filter valid? data)
        transformed (map transform cleaned)]
    transformed))

user=> (ns my-test
         (:require [my-app.core :as core]))

my-test=> (core/process ...)