Clojure för funktionell programmering och JVM-backendutveckling · Lektion

Grunderna i Leiningen och Deps.edn

Förstå grunderna i Leiningen och Deps.edn för att skapa projekt, hantera beroenden och automatisera uppgifter.

Lektion 1 av 412 steg

Grunderna i Leiningen och Deps.edn är en gratis lektion i Clojure för funktionell programmering och JVM-backendutveckling på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Clojure för funktionell programmering och JVM-backendutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Clojure för funktionell programmering och JVM-backendutveckling innehåller totalt 4 lektioner.

Varför Clojure behöver byggverktyg

I Clojure är byggverktyg nödvändiga för att automatisera uppgifter som att hantera beroenden, kompilera kod, köra tester och paketera applikationen. De förenklar projektkonfigurationen och säkerställer enhetlighet.

Utan dem skulle Ni behöva ladda ner bibliotek manuellt, konfigurera classpath och starta JVM manuellt, vilket snabbt blir omständligt för alla projekt som är mer än helt triviala.

Leiningen: Clojures arbetshäst

Leiningen är ett populärt och moget verktyg för byggautomatisering av Clojure-projekt. Det är inspirerat av Maven och hanterar allt från att skapa nya projekt till att distribuera dem.

Dess primära konfigurationsfil är project.clj, som själv är en Clojure-datastruktur, vilket gör den mycket flexibel.

Skapa ett Leiningen-projekt

Ni kan skapa ett nytt Leiningen-applikationsprojekt med kommandot lein new. Kommandot genererar snabbt en standardiserad katalogstruktur med grundläggande kod.

Kör kommandot i terminalen:

lein new app my-lein-app

I project.clj

Filen project.clj definierar projektets metadata och konfiguration. Viktiga delar är bland annat:

  • :dependencies: En lista över de externa bibliotek som projektet behöver.
  • :main: Anger applikationens huvudingångspunkt.
  • :version: Projektets aktuella version.

Filen är skriven med Clojure-syntax, vilket möjliggör kraftfulla och dynamiska konfigurationer.

(defproject my-lein-app "0.1.0-SNAPSHOT"
  :description "A sample Leiningen project."
  :url "http://example.com/FIXME"
  :dependencies [[org.clojure/clojure "1.11.1"]]
  :main ^:skip-aot my-lein-app.core
  :target-path "target/%s")

Första körningen med Leiningen

När projektet har skapats erbjuder Leiningen ett enkelt sätt att köra applikationen. Kommandot lein run kör huvudfunktionen som anges i project.clj.

Här är standardinnehållet i core.clj som lein new app genererar. Prova att köra det!

(ns my-lein-app.core
  (:gen-class))

(defn -main
  "The entry point for our Leiningen app."
  [& args]
  (println "Hello from Leiningen!"))

Deps.edn: det officiella verktyget

deps.edn är Clojures officiella och mer lättviktiga verktyg för beroendehantering och byggprocesser, vilket introducerades i och med Clojure 1.9. Det fokuserar enbart på att hantera beroenden och klassökvägar.

Verktyget använder EDN (Extensible Data Notation), en delmängd av Clojure, för sin konfiguration. Det gör konfigurationen mycket lättläst och enkel att tolka.

Konfigurera ett deps.edn-projekt

Till skillnad från Leiningen har deps.edn inget new-kommando för att skapa projektstruktur. Vanligtvis skapar ni de nödvändiga filerna och katalogerna manuellt.

Ett minimalt projekt kräver en deps.edn-fil i projektets rotkatalog och en källkatalog (till exempel src) för koden.

I deps.edn

Filen deps.edn definierar projektets beroenden och källsökvägar. Viktiga delar är bland annat:

  • :paths: En vektor med kataloger där källkoden finns.
  • :deps: En mappning av externa bibliotek och deras versioner, vanligtvis med Maven-koordinater.

Filen är enklare än project.clj och fokuserar på att bygga klassökvägen.

{:paths ["src"]
 :deps {org.clojure/clojure {:mvn/version "1.11.1"}
        org.clojure/tools.cli {:mvn/version "1.0.206"}}}

Första körningen med Deps.edn

För att köra ett deps.edn-projekt använder ni kommandot clj (Clojures CLI-verktyg). Ni anger huvudnamnrymden med -m.

Här är en enkel core.clj-fil som kan köras med clj -m my-deps-app.core. Prova den!

(ns my-deps-app.core
  (:gen-class))

(defn -main
  "The entry point for our deps.edn app."
  [& args]
  (println "Hello from deps.edn!"))

Leiningen jämfört med Deps.edn

Både Leiningen och deps.edn är utmärkta verktyg, men de bygger på något olika arbetssätt:

  • Leiningen: En komplett projekt202hanterare med omfattande stöd för insticksprogram och olika uppgifter, till exempel testning och distribution.
  • deps.edn: Ett enklare och mer fokuserat verktyg för hantering av beroenden och klassökvägar, som ofta används tillsammans med andra CLI-verktyg för specifika uppgifter.

Många moderna Clojure-projekt använder deps.edn eftersom det är enkelt och direkt, ibland tillsammans med Leiningen.

Kunskapskontroll: byggverktyg

Fundera över det huvudsakliga syftet med och konfigurationssättet för Leiningen och deps.edn.

Sammanfattning: grunderna i Leiningen och Deps.edn

Vi har gått igenom grunderna i Clojures två huvudsakliga byggverktyg:

  • Leiningen: Ett komplett verktyg som använder project.clj för konfiguration och erbjuder projektskapande och automatisering av uppgifter.
  • deps.edn: Ett lättviktigt, officiellt verktyg som använder deps.edn för hantering av klassökvägar och beroenden, vanligtvis tillsammans med Clojures CLI clj.

Båda är viktiga för att hantera Clojure-projekt effektivt och gör det möjligt att välja verktyg utifrån projektets behov.

Gratis att börja

Lär dig Clojure med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
12
Lektioner
48

Vanliga frågor

Är lektionen ”Grunderna i Leiningen och Deps.edn” gratis?

Ja – hela texten till ”Grunderna i Leiningen och Deps.edn” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Clojure för funktionell programmering och JVM-backendutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Clojure för funktionell programmering och JVM-backendutveckling innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i Leiningen och Deps.edn”?

Förstå grunderna i Leiningen och Deps.edn för att skapa projekt, hantera beroenden och automatisera uppgifter. Ni övar på Clojure för funktionell programmering och JVM-backendutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Clojure för funktionell programmering och JVM-backendutveckling?

Du behöver inga förkunskaper. Utbildningen i Clojure för funktionell programmering och JVM-backendutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grunderna i Leiningen och Deps.edn”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Clojure för funktionell programmering och JVM-backendutveckling-lektionen?

Ja. Varje Clojure för funktionell programmering och JVM-backendutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Grunderna i Leiningen och Deps.edn
  2. Hantera beroenden och plugins
  3. Bygga, testa och distribuera
  4. Hantera profiler, alias och miljöer
← Tillbaka till Clojure för funktionell programmering och JVM-backendutveckling