项目结构与实践 #

my-project/
├── project.clj
├── README.md
├── resources/
│   ├── public/
│   └── config.edn
├── src/
│   └── my_project/
│       ├── core.clj
│       ├── utils.clj
│       └── handlers/
│           └── api.clj
└── test/
    └── my_project/
        ├── core_test.clj
        └── utils_test.clj

src/
└── my_project/
    ├── core.clj          -> my-project.core
    ├── utils.clj         -> my-project.utils
    └── handlers/
        ├── api.clj       -> my-project.handlers.api
        └── web.clj       -> my-project.handlers.web

(ns my-project.core
  "Core functionality of the project."
  (:require [clojure.string :as str]
            [my-project.utils :as utils])
  (:import [java.util Date])
  (:gen-class))

(ns my-project.core
  (:require [clojure.string :as str]
            [clojure.set :refer [union intersection]]
            [my-project.utils :as u]))

(str/upper-case "hello")

(union #{1 2} #{2 3})

(u/helper)

(ns my-project.core
  (:require [clojure.string :as str]))

(str/split "a,b,c" #",")

(ns my-project.core
  (:require [clojure.string :refer [split upper-case lower-case]]))

(split "a,b,c" #",")

(ns my-project.core
  (:require [my-project.config :as config]
            [my-project.db :as db]
            [my-project.api :as api]
            [my-project.utils :as utils]))

(defn -main []
  (config/load!)
  (db/connect!)
  (api/start!))

(defn my-function
  [arg1 arg2]
  (let [result (+ arg1 arg2)]
    (when (pos? result)
      (println "Result:" result)
      result)))

(defn another-function
  [x]
  (if (even? x)
    "even"
    "odd"))

(defn function-name
  "Doc string describing the function."
  [param1 param2]
  (body))

(defn multi-arity
  ([x] (multi-arity x 1))
  ([x y] (+ x y)))

(let [a 1
      b 2
      c (+ a b)]
  (* c 2))

(-> value
    function1
    (function2 arg)
    function3)

(->> collection
     (map function1)
     (filter predicate)
     (reduce +))

(if condition
  then-expr
  else-expr)

(when condition
  expr1
  expr2)

(cond
  condition1 expr1
  condition2 expr2
  :else default)

(ns my-project.core-test
  (:require [clojure.test :refer [deftest is testing]]
            [my-project.core :as core]))

(deftest add-test
  (testing "basic addition"
    (is (= 4 (core/add 2 2))))
  (testing "edge cases"
    (is (= 0 (core/add 0 0)))
    (is (= -1 (core/add 1 -2)))))

(deftest assertions-test
  (is (= 1 1))
  (is (true? true))
  (is (thrown? Exception (throw (Exception. "error"))))
  (is (instance? String "hello"))
  (is (.startsWith "hello" "hel")))

(use-fixtures :each
  (fn [f]
    (setup-db)
    (f)
    (cleanup-db)))

(deftest with-fixture
  (is (db/connected?)))

(require '[clojure.test.check :as tc]
         '[clojure.test.check.generators :as gen]
         '[clojure.test.check.properties :as prop])

(def prop-add-commutative
  (prop/for-all [a gen/int
                 b gen/int]
    (= (core/add a b)
       (core/add b a))))

(tc/quick-check 100 prop-add-commutative)

(defn safe-divide [a b]
  (try
    (/ a b)
    (catch ArithmeticException e
      :division-by-zero)
    (catch Exception e
      (throw (ex-info "Division failed"
                      {:a a :b b}
                      e)))))

(defn validate-input [data]
  (when (empty? data)
    (throw (ex-info "Input cannot be empty"
                    {:input data}))))

(defn process [data]
  (try
    (validate-input data)
    (do-work data)
    (catch clojure.lang.ExceptionInfo e
      (let [{:keys [input]} (ex-data e)]
        (handle-error input)))))

(defn either [value]
  (if (instance? Exception value)
    {:error value}
    {:ok value}))

(defn bind [result f]
  (if (:ok result)
    (f (:ok result))
    result))

(defn safe-parse [s]
  (try
    {:ok (Integer/parseInt s)}
    (catch Exception e
      {:error e})))

(-> (safe-parse "42")
    (bind #(hash-map :ok (* % 2))))

{:database {:host "localhost"
            :port 5432
            :name "mydb"}
 :server {:port 3000
          :mode :dev}}

(ns my-project.config
  (:require [clojure.edn :as edn]
            [clojure.java.io :as io]))

(defn load-config []
  (-> "config.edn"
      io/resource
      slurp
      edn/read-string))

(def config (load-config))

(defn env [key default]
  (or (System/getenv key) default))

(def db-host (env "DB_HOST" "localhost"))
(def db-port (Integer/parseInt (env "DB_PORT" "5432")))

(ns my-project.core
  (:require [clojure.tools.logging :as log]))

(defn process [data]
  (log/info "Processing data:" data)
  (try
    (let [result (do-work data)]
      (log/debug "Result:" result)
      result)
    (catch Exception e
      (log/error e "Processing failed")
      (throw e))))

(log/trace "Very detailed info")
(log/debug "Debug information")
(log/info "General information")
(log/warn "Warning message")
(log/error "Error message")

(defn ^String process [^String s]
  (.toUpperCase s))

(defn add [^Long a ^Long b]
  (+ a b))

(set! *warn-on-reflection* true)

(defn bad [s]
  (.length s))

(defn good [^String s]
  (.length s))

(defn process-large-data [data]
  (->> data
       (map expensive-op)
       (filter valid?)
       (take 100)))

(defn my-function
  "Brief description of the function.
  
  Parameters:
    x - description of x
    y - description of y
  
  Returns:
    Description of return value.
  
  Example:
    (my-function 1 2) => 3"
  [x y]
  (+ x y))