Clojure - คู่มือฉบับย่อ

Clojure เป็นภาษาการเขียนโปรแกรมเชิงฟังก์ชันระดับสูง Clojure ได้รับการออกแบบโดยใช้ภาษาการเขียนโปรแกรม LISP และมีคอมไพเลอร์ซึ่งทำให้รันบนสภาพแวดล้อมรันไทม์ของ Java และ. Net

ก่อนที่เราจะพูดถึง Clojure ขอเพียงมีคำอธิบายสั้น ๆ เกี่ยวกับภาษาโปรแกรม LISP LISP มีแกนภาษาเล็ก ๆ แทบไม่มีไวยากรณ์และมีมาโครที่มีประสิทธิภาพ ด้วยคุณสมบัติเหล่านี้คุณสามารถโค้งงอ LISP เพื่อให้ตรงกับการออกแบบของคุณแทนที่จะใช้วิธีอื่น LISP มีมานานแล้วตั้งแต่ปีพ. ศ. 2501

LISP ทั่วไปอ่านในนิพจน์ประเมินค่าและพิมพ์ผลลัพธ์ออกมา ตัวอย่างเช่นหากคุณต้องการคำนวณค่าของนิพจน์ทางคณิตศาสตร์อย่างง่ายเป็น 4 + 6 ให้พิมพ์

USER(1) (+ 4 6)

Clojure มีวัตถุประสงค์หลักระดับสูงดังต่อไปนี้เป็นภาษาโปรแกรม

  • มันขึ้นอยู่กับภาษาโปรแกรม LISP ซึ่งทำให้คำสั่งรหัสมีขนาดเล็กกว่าภาษาโปรแกรมทั่วไป

  • มันเป็นภาษาโปรแกรมที่ใช้งานได้

  • มุ่งเน้นไปที่ความไม่เปลี่ยนรูปซึ่งเป็นแนวคิดที่ว่าคุณไม่ควรทำการเปลี่ยนแปลงใด ๆ กับวัตถุที่สร้างขึ้นในสถานที่

  • สามารถจัดการสถานะของแอปพลิเคชันสำหรับโปรแกรมเมอร์

  • รองรับการทำงานพร้อมกัน

  • มันรวบรวมภาษาโปรแกรมที่มีอยู่ ตัวอย่างเช่น Clojure สามารถใช้ประโยชน์จากระบบนิเวศ Java ทั้งหมดสำหรับการจัดการการทำงานของโค้ดผ่าน JVM

เว็บไซต์อย่างเป็นทางการของ Clojure คือ https://clojure.org/

มีหลายวิธีในการทำงานกับ Clojure เป็นภาษาโปรแกรม เราจะดูสองวิธีในการทำงานกับการเขียนโปรแกรม Clojure

  • Leiningen - Leiningen เป็นเครื่องมือสำคัญในการสร้างสร้างและดำเนินโครงการ Clojure โดยอัตโนมัติ

  • Eclipse Plugin - มีปลั๊กอินที่เรียกว่า CounterClockwise ซึ่งพร้อมใช้งานสำหรับ Eclipse เพื่อดำเนินการพัฒนา Clojure ใน Eclipse IDE

การติดตั้ง Leiningen

ตรวจสอบให้แน่ใจว่าตรงตามข้อกำหนดของระบบต่อไปนี้ก่อนดำเนินการติดตั้ง

ความต้องการของระบบ

JDK JDK 1.7 ขึ้นไป
หน่วยความจำ RAM 2 GB (แนะนำ)

Step 1- ดาวน์โหลดการติดตั้งไบนารี ไปที่ลิงค์http://leiningen-wininstallerเพื่อรับ Windows Installer คลิกที่ตัวเลือกเพื่อเริ่มดาวน์โหลดโปรแกรมติดตั้ง Groovy

Step 2 - เปิดโปรแกรมติดตั้งและคลิกปุ่มถัดไป

Step 3 - ระบุตำแหน่งสำหรับการติดตั้งและคลิกปุ่มถัดไป

Step 4- การตั้งค่าจะตรวจหาตำแหน่งของการติดตั้ง Java ที่มีอยู่ คลิกปุ่มถัดไปเพื่อดำเนินการต่อ

Step 5 - คลิกปุ่มติดตั้งเพื่อเริ่มการติดตั้ง

หลังจากการติดตั้งเสร็จสิ้นจะมีตัวเลือกให้คุณเปิด Clojure REPL ซึ่งเป็นสภาพแวดล้อมที่สามารถใช้สร้างและทดสอบโปรแกรม Clojure ของคุณได้

การติดตั้ง Eclipse

ตรวจสอบให้แน่ใจว่าตรงตามข้อกำหนดของระบบต่อไปนี้ก่อนดำเนินการติดตั้ง

ความต้องการของระบบ

JDK JDK 1.7 ขึ้นไป
คราส คราส 4.5 (ดาวอังคาร)

Step 1- เปิด Eclipse แล้วคลิกรายการเมนู คลิก Help → Eclipse Marketplace

Step 2- พิมพ์คำสำคัญ Clojure ในกล่องโต้ตอบที่ปรากฏขึ้นและกดปุ่ม "ไป" ตัวเลือกสำหรับทวนเข็มนาฬิกาจะปรากฏขึ้นให้คลิกปุ่มติดตั้งเพื่อเริ่มการติดตั้งปลั๊กอินนี้

Step 3 - ในกล่องโต้ตอบถัดไปให้คลิกปุ่มยืนยันเพื่อเริ่มการติดตั้ง

Step 4- ในกล่องโต้ตอบถัดไปคุณจะได้รับการร้องขอให้ยอมรับข้อตกลงใบอนุญาต ยอมรับข้อตกลงสิทธิ์การใช้งานและคลิกปุ่มเสร็จสิ้นเพื่อดำเนินการติดตั้งต่อไป

การติดตั้งจะเริ่มขึ้นและเมื่อเสร็จสิ้นระบบจะแจ้งให้คุณรีสตาร์ท Eclipse

เมื่อเริ่ม Eclipse ใหม่คุณจะเห็นตัวเลือกใน Eclipse เพื่อสร้างโปรเจ็กต์ Clojure ใหม่

เพื่อให้เข้าใจไวยากรณ์พื้นฐานของ Clojure เรามาดูโปรแกรม Hello World แบบง่ายๆกันก่อน

Hello World เป็นโปรแกรมที่สมบูรณ์

เขียน 'Hello world' ในโปรแกรม Clojure ที่สมบูรณ์ ต่อไปนี้เป็นตัวอย่าง

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))
(defn hello-world []
   (println "Hello World"))
(hello-world)

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • โปรแกรมจะเขียนในไฟล์ชื่อ main.clj นามสกุล 'clj' เป็นชื่อส่วนขยายของไฟล์รหัส clojure ในตัวอย่างข้างต้นชื่อของไฟล์เรียกว่า main.clj

  • คำหลัก 'defn' ใช้เพื่อกำหนดฟังก์ชัน เราจะเห็นฟังก์ชั่นโดยละเอียดในอีกบทหนึ่ง แต่สำหรับตอนนี้โปรดทราบว่าเรากำลังสร้างฟังก์ชันที่เรียกว่า helloworld ซึ่งจะมีรหัส Clojure หลักของเรา

  • ในรหัส Clojure ของเราเราใช้คำสั่ง 'println' เพื่อพิมพ์“ Hello World” ไปยังเอาต์พุตคอนโซล

  • จากนั้นเราจะเรียกใช้ฟังก์ชัน hello-world ซึ่งจะเรียกใช้คำสั่ง 'println'

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

Hello World

รูปแบบทั่วไปของคำชี้แจง

รูปแบบทั่วไปของคำสั่งใด ๆ จำเป็นต้องได้รับการประเมินในวงเล็บปีกกาดังที่แสดงในตัวอย่างต่อไปนี้

(+ 1 2)

ในตัวอย่างข้างต้นนิพจน์ทั้งหมดอยู่ในวงเล็บปีกกา ผลลัพธ์ของข้อความข้างต้นคือ 3 ตัวดำเนินการ + ทำหน้าที่เหมือนฟังก์ชันใน Clojure ซึ่งใช้สำหรับการบวกตัวเลข ค่าของ 1 และ 2 เรียกว่า parameters to the function.

ขอให้เราพิจารณาอีกตัวอย่างหนึ่ง ในตัวอย่างนี้ 'str' คือตัวดำเนินการที่ใช้เพื่อเชื่อมสองสตริงเข้าด้วยกัน สตริง“ Hello” และ“ World” ใช้เป็นพารามิเตอร์

(str "Hello" "World")

ตัวอย่าง

หากเรารวมสองคำสั่งข้างต้นและเขียนโปรแกรมจะมีลักษณะดังต่อไปนี้

(ns clojure.examples.hello
   (:gen-class))
(defn Example []
   (println (str "Hello World"))
   (println (+ 1 2)))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

Hello World
3

เนมสเปซ

เนมสเปซถูกใช้เพื่อกำหนดขอบเขตตรรกะระหว่างโมดูลที่กำหนดใน Clojure

เนมสเปซปัจจุบัน

สิ่งนี้กำหนดเนมสเปซปัจจุบันที่มีโค้ด Clojure ปัจจุบันอยู่

ไวยากรณ์

*ns*

ตัวอย่าง

ในหน้าต่างคำสั่ง REPL ให้รันคำสั่งต่อไปนี้

*ns*

เอาต์พุต

เมื่อเรารันคำสั่งด้านบนผลลัพธ์จะเลื่อนออกไปขึ้นอยู่กับเนมสเปซปัจจุบันคืออะไร ต่อไปนี้เป็นตัวอย่างของผลลัพธ์ เนมสเปซของรหัส Clojure คือ -

clojure.examples.hello

(ns clojure.examples.hello
   (:gen-class))
(defn Example []
   (println (str "Hello World"))
   (println (+ 1 2)))
(Example)

ต้องการคำชี้แจงใน Clojure

รหัส Clojure บรรจุในไลบรารี ไลบรารี Clojure แต่ละไลบรารีเป็นของเนมสเปซซึ่งคล้ายคลึงกับแพ็คเกจ Java คุณสามารถโหลดไลบรารี Clojure ด้วยคำสั่ง 'Require'

ไวยากรณ์

(require quoted-namespace-symbol)

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการใช้คำสั่งนี้

(ns clojure.examples.hello
   (:gen-class))
(require ‘clojure.java.io’)
(defn Example []
   (.exists (file "Example.txt")))
(Example)

ในโค้ดด้านบนเราใช้คีย์เวิร์ด 'require' เพื่อนำเข้าเนมสเปซ clojure.java.io ซึ่งมีฟังก์ชันทั้งหมดที่จำเป็นสำหรับฟังก์ชันอินพุต / เอาต์พุต เนื่องจากเราไม่มีไลบรารีที่ต้องการเราจึงสามารถใช้ฟังก์ชัน 'file' ในโค้ดด้านบนได้

ความคิดเห็นใน Clojure

ข้อคิดเห็นใช้ในการจัดทำเอกสารรหัสของคุณ ความคิดเห็นบรรทัดเดียวถูกระบุโดยใช้ ;; ที่ตำแหน่งใดก็ได้ในบรรทัด ต่อไปนี้เป็นตัวอย่าง

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println "Hello World"))
(Example)

ตัวคั่น

ใน Clojure ข้อความสามารถแบ่งหรือคั่นได้โดยใช้วงเล็บปีกกาแบบโค้งหรือแบบเหลี่ยม

ตัวอย่าง

ต่อไปนี้เป็นสองตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println (+ 1 2 3)))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

6

ตัวอย่าง

ต่อไปนี้เป็นอีกตัวอย่างหนึ่ง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println [+ 1 2 3]))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

[#object[clojure.core$_PLUS_ 0x10f163b "clojure.core$_PLUS_@10f163b"] 1 2 3]

ช่องว่าง

สามารถใช้ช่องว่างใน Clojure เพื่อแยกส่วนประกอบต่างๆของคำสั่งเพื่อความชัดเจนที่ดีขึ้น ซึ่งสามารถทำได้ด้วยความช่วยเหลือของตัวดำเนินการลูกน้ำ (,)

ตัวอย่างเช่นสองคำสั่งต่อไปนี้เทียบเท่ากันและผลลัพธ์ของทั้งสองคำสั่งจะเป็น 15

(+ 1 2 3 4 5)
(+ 1, 2, 3, 4, 5)

แม้ว่า Clojure จะละเว้นเครื่องหมายจุลภาค แต่บางครั้งก็ใช้เพื่อทำให้โปรแกรมเมอร์อ่านสิ่งต่างๆได้ง่ายขึ้น

ตัวอย่างเช่นหากคุณมีแผนที่แฮชดังต่อไปนี้ (def a-map {: a 1: b 2: c 3}) และถามค่าของมันในหน้าต่าง REPL Clojure จะพิมพ์ผลลัพธ์เป็น {: a 1, : b 2,: c 3}

ผลลัพธ์จะอ่านได้ง่ายขึ้นโดยเฉพาะอย่างยิ่งหากคุณกำลังดูข้อมูลจำนวนมาก

สัญลักษณ์

ใน Clojure สัญลักษณ์จะเทียบเท่ากับตัวระบุในภาษาโปรแกรมอื่น ๆ แต่แตกต่างจากภาษาโปรแกรมอื่น ๆ คอมไพเลอร์มองว่าสัญลักษณ์เป็นค่าสตริงจริง เนื่องจากสัญลักษณ์เป็นค่าสัญลักษณ์สามารถเก็บไว้ในคอลเลกชั่นส่งผ่านเป็นอาร์กิวเมนต์ไปยังฟังก์ชัน ฯลฯ เช่นเดียวกับวัตถุอื่น ๆ

สัญลักษณ์สามารถมีได้เฉพาะอักขระที่เป็นตัวเลขและตัวอักษรและ '* +! /. : - _? ' แต่ต้องไม่ขึ้นต้นด้วยตัวเลขหรือลำไส้ใหญ่

ต่อไปนี้เป็นตัวอย่างสัญลักษณ์ที่ถูกต้อง

tutorial-point!
TUTORIAL
+tutorial+

โครงสร้างโครงการ Clojure

ในที่สุดเรามาพูดถึงโครงสร้างโครงการทั่วไปสำหรับโครงการ Clojure เนื่องจากโค้ด Clojure ทำงานบนเครื่องเสมือน Java โครงสร้างโปรเจ็กต์ส่วนใหญ่ภายใน Clojure จึงคล้ายกับสิ่งที่คุณจะพบในโปรเจ็กต์ java ต่อไปนี้เป็นภาพรวมของโครงสร้างโครงการตัวอย่างใน Eclipse สำหรับโครงการ Clojure

สิ่งสำคัญต่อไปนี้ต้องสังเกตเกี่ยวกับโครงสร้างโปรแกรมข้างต้น

  • demo_1 - นี่คือแพ็คเกจที่ใส่ไฟล์รหัส Clojure

  • core.clj - นี่คือไฟล์รหัส Clojure หลักซึ่งจะมีรหัสสำหรับแอปพลิเคชัน Clojure

  • โฟลเดอร์ Leiningen มีไฟล์เช่น clojure-1.6.0.jar ซึ่งจำเป็นสำหรับการเรียกใช้แอปพลิเคชันที่ใช้ Clojure

  • ไฟล์ pom.properties จะมีข้อมูลเช่น groupId, artifactId และเวอร์ชันของโปรเจ็กต์ Clojure

  • ไฟล์ project.clj มีข้อมูลเกี่ยวกับแอปพลิเคชัน Clojure เอง ต่อไปนี้เป็นตัวอย่างเนื้อหาของไฟล์โครงการ

(defproject demo-1 "0.1.0-SNAPSHOT"
   :description "FIXME: write description"
   :url "http://example.com/FIXME"
   :license {
      :name "Eclipse Public License"
      :url "http://www.eclipse.org/legal/epl-v10.html"
   }
   :dependencies [[org.clojure/clojure "1.6.0"]])

REPL (read-eval-print loop) เป็นเครื่องมือสำหรับทดลองโค้ด Clojure ช่วยให้คุณสามารถโต้ตอบกับโปรแกรมที่กำลังทำงานอยู่และลองใช้งานได้อย่างรวดเร็วว่าสิ่งต่างๆได้ผลตามที่ควรหรือไม่ ทำได้โดยแสดงข้อความแจ้งที่คุณสามารถป้อนรหัสได้ จากนั้นจะอ่านข้อมูลที่คุณป้อนประเมินมันพิมพ์ผลลัพธ์และวนซ้ำเพื่อแสดงข้อความแจ้งอีกครั้ง

กระบวนการนี้เปิดใช้รอบการตอบกลับอย่างรวดเร็วซึ่งไม่สามารถทำได้ในภาษาอื่น ๆ ส่วนใหญ่

เริ่มเซสชัน REPL

สามารถเริ่มเซสชัน REPL ใน Leiningen ได้โดยพิมพ์คำสั่งต่อไปนี้ในบรรทัดคำสั่ง

lein repl

ซึ่งจะเริ่มหน้าต่าง REPL ต่อไปนี้

จากนั้นคุณเริ่มประเมินคำสั่ง Clojure ในหน้าต่าง REPL ตามต้องการ

ในการเริ่มเซสชัน REPL ใน Eclipse ให้คลิกตัวเลือกเมนูไปที่ Run As → Clojure Application

การดำเนินการนี้จะเริ่มต้นเซสชัน REPL ใหม่ในหน้าต่างแยกต่างหากพร้อมกับเอาต์พุตคอนโซล

ตามแนวคิดแล้ว REPL คล้ายกับ Secure Shell (SSH) ในลักษณะเดียวกับที่คุณสามารถใช้ SSH เพื่อโต้ตอบกับเซิร์ฟเวอร์ระยะไกล Clojure REPL ช่วยให้คุณโต้ตอบกับกระบวนการ Clojure ที่กำลังทำงานอยู่ คุณสมบัตินี้มีประสิทธิภาพมากเพราะคุณสามารถแนบ REPL เข้ากับแอปการผลิตสดและแก้ไขโปรแกรมของคุณได้ในขณะที่ทำงาน

ตัวแปรพิเศษใน REPL

REPL ประกอบด้วยตัวแปรที่มีประโยชน์ตัวแปรที่ใช้กันอย่างแพร่หลายคือตัวแปรพิเศษ * 1, * 2 และ * 3 สิ่งเหล่านี้ใช้เพื่อประเมินผลลัพธ์ของนิพจน์ล่าสุดสามรายการ

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าตัวแปรเหล่านี้สามารถใช้งานได้อย่างไร

user => "Hello"
Hello
user => "World"
World
user => (str *2 *1)
HelloWorld

ในตัวอย่างข้างต้นสตริงสองสายแรกจะถูกส่งไปยังหน้าต่างเอาต์พุต REPL เป็น“ Hello” และ“ World” ตามลำดับ จากนั้นตัวแปร * 2 และ * 1 จะถูกใช้เพื่อเรียกคืน 2 นิพจน์ที่ประเมินล่าสุด

Clojure นำเสนอไฟล์ built-in data types.

ประเภทข้อมูลในตัว

ต่อไปนี้เป็นรายการประเภทข้อมูลที่กำหนดไว้ใน Clojure

  • Integers - ต่อไปนี้เป็นตัวแทนของจำนวนเต็มที่มีอยู่ใน Clojure

    • Decimal Integers (Short, Long and Int)- ใช้แทนจำนวนเต็ม ตัวอย่างเช่น 1234

    • Octal Numbers- ใช้แทนตัวเลขในการแทนค่าฐานแปด ตัวอย่างเช่น 012

    • Hexadecimal Numbers- ใช้เพื่อแสดงตัวเลขในการแทนค่า ตัวอย่างเช่น 0xff

    • Radix Numbers- ใช้เพื่อแสดงตัวเลขในการแทนค่ารัศมี ตัวอย่างเช่น 2r1111 โดยที่ radix เป็นจำนวนเต็มระหว่าง 2 ถึง 36 รวมอยู่ด้วย

  • Floating point

    • ค่าเริ่มต้นใช้เพื่อแสดงตัวเลขทศนิยม 32 บิต ตัวอย่างเช่น 12.34

    • การแสดงอื่น ๆ คือสัญกรณ์ทางวิทยาศาสตร์ ตัวอย่างเช่น 1.35e-12

  • char- สิ่งนี้กำหนดลิเทอรัลอักขระเดียว อักขระถูกกำหนดด้วยสัญลักษณ์ฟันเฟือง ตัวอย่างเช่น / e.

  • Boolean - แสดงถึงค่าบูลีนซึ่งอาจเป็นจริงหรือเท็จก็ได้

  • String- เหล่านี้เป็นตัวอักษรที่แสดงในรูปแบบของตัวอักษร ตัวอย่างเช่น“ Hello World”

  • Nil - ใช้เพื่อแสดงค่า NULL ใน Clojure

  • Atom- อะตอมเป็นวิธีจัดการสถานะที่ใช้ร่วมกันซิงโครนัสและเป็นอิสระ เป็นประเภทอ้างอิงเช่น refs และ vars

ค่านิยม

เนื่องจากประเภทข้อมูลทั้งหมดใน Clojure สืบทอดมาจาก Java ค่าขอบเขตจึงเหมือนกับในภาษาโปรแกรม Java ตารางต่อไปนี้แสดงค่าสูงสุดที่อนุญาตสำหรับตัวอักษรตัวเลขและทศนิยม

ตัวอักษร ช่วง
สั้น -32,768 ถึง 32,767
int -2,147,483,648 ถึง 2,147,483,647
ยาว -9,223,372,036,854,775,808 ถึง +9,223,372,036,854,775,807
ลอย 1.40129846432481707e-45 ถึง 3.40282346638528860e + 38
สองเท่า 4.94065645841246544e-324d ถึง 1.79769313486231570e + 308d

ประเภทตัวเลขของคลาส

นอกเหนือจากประเภทดั้งเดิมแล้วยังอนุญาตให้ใช้ประเภทออบเจ็กต์ต่อไปนี้ (บางครั้งเรียกว่าประเภท wrapper)

ชื่อ
java.lang Byte
java.lang. สั้น
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double

ตัวอย่าง

โปรแกรมต่อไปนี้แสดงโค้ด clojure ที่รวมไว้เพื่อสาธิตประเภทข้อมูลใน Clojure

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   ;; The below code declares a integer variable
   (def x 1)
   
   ;; The below code declares a float variable
   (def y 1.25)
   
   ;; The below code declares a string variable
   (def str1 "Hello")
   (println x)
   (println y)
   (println str1))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

1
1.25
Hello

ใน Clojure variables ถูกกำหนดโดย ‘def’คำสำคัญ. มันแตกต่างกันเล็กน้อยตรงที่แนวคิดของตัวแปรเกี่ยวข้องกับการผูกมัดมากกว่า ใน Clojure ค่าจะถูกผูกไว้กับตัวแปร สิ่งสำคัญอย่างหนึ่งที่ควรทราบใน Clojure คือตัวแปรไม่เปลี่ยนรูปซึ่งหมายความว่าเพื่อให้ค่าของตัวแปรเปลี่ยนไปจำเป็นต้องทำลายและสร้างใหม่อีกครั้ง

ต่อไปนี้เป็นประเภทพื้นฐานของตัวแปรใน Clojure

  • short- ใช้เพื่อแสดงตัวเลขสั้น ๆ ตัวอย่างเช่น 10.

  • int- ใช้แทนจำนวนเต็ม ตัวอย่างเช่น 1234

  • long- ใช้เพื่อแสดงจำนวนยาว ตัวอย่างเช่น 10000090

  • float- ใช้เพื่อแสดงตัวเลขทศนิยม 32 บิต ตัวอย่างเช่น 12.34

  • char- สิ่งนี้กำหนดลิเทอรัลอักขระเดียว ตัวอย่างเช่น "/ a"

  • Boolean - แสดงถึงค่าบูลีนซึ่งอาจเป็นจริงหรือเท็จก็ได้

  • String- เหล่านี้เป็นตัวอักษรที่แสดงในรูปแบบของตัวอักษร ตัวอย่างเช่น“ Hello World”

การประกาศตัวแปร

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของการกำหนดตัวแปร

ไวยากรณ์

(def var-name var-value)

โดยที่ 'var-name' คือชื่อของตัวแปรและ 'var-value' คือค่าที่ผูกไว้กับตัวแปร

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการประกาศตัวแปร

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   ;; The below code declares a integer variable
   (def x 1)
   
   ;; The below code declares a float variable
   (def y 1.25)

   ;; The below code declares a string variable
   (def str1 "Hello")
   
   ;; The below code declares a boolean variable
   (def status true))
(Example)

การตั้งชื่อตัวแปร

ชื่อของตัวแปรสามารถประกอบด้วยตัวอักษรตัวเลขและอักขระขีดล่าง ต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง อักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กมีความแตกต่างกันเนื่องจาก Clojure เช่นเดียวกับ Java เป็นภาษาโปรแกรมที่คำนึงถึงตัวพิมพ์เล็กและใหญ่

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างบางส่วนของการตั้งชื่อตัวแปรใน Clojure

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   ;; The below code declares a Boolean variable with the name of status
   (def status true)
   
   ;; The below code declares a Boolean variable with the name of STATUS
   (def STATUS false)
   
   ;; The below code declares a variable with an underscore character.
   (def _num1 2))
(Example)

Note - ในข้อความข้างต้นเนื่องจากความอ่อนไหวของตัวพิมพ์สถานะและสถานะเป็นตัวแปรที่แตกต่างกันสองตัวกำหนดใน Clojure

ตัวอย่างข้างต้นแสดงวิธีกำหนดตัวแปรด้วยอักขระขีดล่าง

การพิมพ์ตัวแปร

เนื่องจาก Clojure ใช้สภาพแวดล้อม JVM คุณจึงสามารถใช้ฟังก์ชัน "println" ได้ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   ;; The below code declares a integer variable
   (def x 1)
   
   ;; The below code declares a float variable
   (def y 1.25)
   
   ;; The below code declares a string variable
   (def str1 "Hello")
   (println x)
   (println y)
   (println str1))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

1
1.25
Hello

อัน operator เป็นสัญลักษณ์ที่บอกให้คอมไพเลอร์ดำเนินการทางคณิตศาสตร์หรือตรรกะเฉพาะ

Clojure มีตัวดำเนินการประเภทต่อไปนี้ -

  • ตัวดำเนินการเลขคณิต
  • ตัวดำเนินการเชิงสัมพันธ์
  • ตัวดำเนินการทางตรรกะ
  • ตัวดำเนินการ Bitwise

Note - ใน Clojure ตัวดำเนินการและตัวถูกดำเนินการจะทำงานในลักษณะไวยากรณ์ต่อไปนี้

ไวยากรณ์

(operator operand1 operand2 operandn)

ตัวอย่างเช่น,

ตัวอย่าง

(+ 1 2)

ตัวอย่างข้างต้นทำการคำนวณเลขคณิตกับตัวเลข 1 และ 2

ตัวดำเนินการเลขคณิต

ภาษา Clojure สนับสนุนตัวดำเนินการเลขคณิตปกติเป็นภาษาใดก็ได้ ต่อไปนี้เป็นตัวดำเนินการทางคณิตศาสตร์ที่มีอยู่ใน Clojure

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
+ การเพิ่มตัวถูกดำเนินการสองตัว (+ 1 2) จะให้ 3
- ลบตัวถูกดำเนินการที่สองจากตัวแรก (- 2 1) จะให้ 1
* การคูณของตัวถูกดำเนินการทั้งสอง (* 2 2) จะให้ 4
/ การหารตัวเศษด้วยตัวส่วน (float (/ 3 2)) จะให้ 1.5
รวม ตัวดำเนินการที่เพิ่มขึ้นใช้เพื่อเพิ่มค่าของตัวถูกดำเนินการโดย 1 inc 5 จะให้ 6
ธ.ค. ตัวดำเนินการที่เพิ่มขึ้นใช้เพื่อลดค่าของตัวถูกดำเนินการโดย 1 5 ธ.ค. จะให้ 4
สูงสุด ส่งคืนอาร์กิวเมนต์ที่ใหญ่ที่สุด สูงสุด 1 2 3 จะคืนค่า 3
นาที ส่งคืนอาร์กิวเมนต์ที่เล็กที่สุด ขั้นต่ำ 1 2 3 จะส่งกลับ 1
rem ส่วนที่เหลือของการหารจำนวนแรกด้วยตัวที่สอง rem 3 2 จะให้ 1

ตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการเชิงสัมพันธ์อนุญาตให้เปรียบเทียบวัตถุ ต่อไปนี้เป็นตัวดำเนินการเชิงสัมพันธ์ที่มีอยู่ใน Clojure

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
= ทดสอบความเท่าเทียมกันระหว่างสองวัตถุ (= 2 2) จะให้เป็นจริง
ไม่ = ทดสอบความแตกต่างระหว่างสองวัตถุ (not = 3 2) จะให้เป็นจริง
< ตรวจสอบว่าวัตถุด้านซ้ายน้อยกว่าตัวถูกดำเนินการด้านขวาหรือไม่ (<2 3) จะให้เป็นจริง
<= ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ (<= 2 3) จะให้เป็นจริง
> ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายมีค่ามากกว่าตัวถูกดำเนินการด้านขวาหรือไม่ (> 3 2) จะให้เป็นจริง
> = ตรวจสอบว่าวัตถุทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ (> = 3 2) จะให้เป็นจริง

ตัวดำเนินการทางตรรกะ

ตัวดำเนินการทางตรรกะใช้เพื่อประเมินนิพจน์บูลีน ต่อไปนี้เป็นตัวดำเนินการเชิงตรรกะที่มีอยู่ใน Groovy

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
and นี่คือโอเปอเรเตอร์“ และ” เชิงตรรกะ (หรือจริงจริง) จะให้จริง
or นี่คือโอเปอเรเตอร์“ หรือ” เชิงตรรกะ (และจริงเท็จ) จะให้เท็จ
not นี่คือโอเปอเรเตอร์ "ไม่ใช่" เชิงตรรกะ (ไม่เท็จ) จะให้เป็นจริง

ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ตัวดำเนินการต่างๆ

ตัวดำเนินการ Bitwise

Clojure มีตัวดำเนินการสี่บิต ต่อไปนี้เป็นตัวดำเนินการระดับบิตที่มีอยู่ใน Clojure

แสดงตัวอย่าง

ซีเนียร์ ตัวดำเนินการและคำอธิบาย
1

bit-and

นี่คือโอเปอเรเตอร์“ และ” แบบบิต

2

bit-or

นี่คือโอเปอเรเตอร์“ หรือ” แบบบิต

3

bit-xor

นี่คือตัวดำเนินการ "xor" หรือ Exclusive "หรือ" ในระดับบิต

4

bit-not

นี่คือตัวดำเนินการปฏิเสธแบบบิต

ต่อไปนี้เป็นตารางความจริงที่แสดงตัวดำเนินการเหล่านี้

q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

ลำดับความสำคัญของตัวดำเนินการ

เช่นเดียวกับกรณีของ LISP โดยทั่วไปไม่จำเป็นต้องกังวลเกี่ยวกับลำดับความสำคัญของตัวดำเนินการ นี่คือประโยชน์อย่างหนึ่งของ S-Expressions และสัญลักษณ์นำหน้า ฟังก์ชั่นทั้งหมดประเมินจากซ้ายไปขวาและภายในออก โอเปอเรเตอร์ใน Clojure เป็นเพียงฟังก์ชันเท่านั้นและทุกอย่างจะอยู่ในวงเล็บทั้งหมด

จนถึงตอนนี้เราได้เห็นข้อความที่ดำเนินการทีละคำสั่งในลักษณะตามลำดับ นอกจากนี้คำสั่งยังมีให้ใน Clojure เพื่อปรับเปลี่ยนโฟลว์ของการควบคุมในตรรกะของโปรแกรม จากนั้นจะจัดประเภทเป็นโฟลว์ของงบควบคุมซึ่งเราจะเห็นโดยละเอียด

ซีเนียร์ ลูปและคำอธิบาย
1 ในขณะที่คำชี้แจง

'while' คำสั่งถูกดำเนินการโดยการประเมินนิพจน์เงื่อนไขก่อน (ค่าบูลีน) และถ้าผลลัพธ์เป็นจริงคำสั่งในลูป while จะถูกดำเนินการ

2 คำชี้แจง Doseq

‘doseq’คำสั่งคล้ายกับคำสั่ง 'for each' ซึ่งพบในภาษาโปรแกรมอื่น ๆ อีกมากมาย โดยทั่วไปแล้วคำสั่ง doseq จะใช้เพื่อทำซ้ำตามลำดับ

3 คำชี้แจง Dotimes

‘dotimes’ คำสั่งใช้เพื่อดำเนินการคำสั่ง 'x' จำนวนครั้ง

4 คำชี้แจงแบบวนซ้ำ

รูปแบบพิเศษของลูปไม่เหมือนไฟล์ ‘for’วน. การใช้ลูปเหมือนกับการผูกแบบ let อย่างไรก็ตามลูปกำหนดจุดการเรียกซ้ำ

Decision-making structures กำหนดให้โปรแกรมเมอร์ระบุเงื่อนไขอย่างน้อยหนึ่งเงื่อนไขที่จะประเมินหรือทดสอบโดยโปรแกรมพร้อมกับคำสั่งหรือคำสั่งที่จะดำเนินการหากเงื่อนไขถูกกำหนดให้เป็นจริงและเป็นทางเลือกที่จะเรียกใช้คำสั่งอื่น ๆ หากเงื่อนไขถูกกำหนดให้ เป็นเท็จ

ซีเนียร์ วิธีการและคำอธิบาย
1 ถ้า Statement

ใน Clojure เงื่อนไขคือนิพจน์ที่ประเมินว่าเป็นจริงหรือเท็จ 'If' เงื่อนไขเป็นจริงจากนั้นคำสั่ง # 1 จะถูกเรียกใช้มิฉะนั้นคำสั่ง # 2 จะถูกดำเนินการ

2 If / do Expression

‘if-do’ นิพจน์ใน Clojure ใช้เพื่ออนุญาตให้ดำเนินการหลายนิพจน์สำหรับแต่ละสาขาของคำสั่ง 'if'

3 คำสั่งซ้อนหาก

หลายรายการ 'if' ข้อความที่ฝังอยู่ภายในซึ่งกันและกัน

4 คำชี้แจงกรณี

Clojure นำเสนอไฟล์ ‘case’ ซึ่งคล้ายกับคำสั่ง ‘switch’ คำสั่งที่มีอยู่ในภาษาโปรแกรม Java

5 คำชี้แจงเงื่อนไข

Clojure เสนอคำชี้แจงการประเมินอื่นที่เรียกว่า ‘cond’คำให้การ. คำสั่งนี้ใช้ชุดของคู่การทดสอบ / นิพจน์

Clojure เป็นที่รู้จักกันในชื่อภาษาโปรแกรมที่ใช้งานได้ดังนั้นคุณจึงคาดหวังว่าจะได้เห็นความสำคัญอย่างมากเกี่ยวกับการทำงานของฟังก์ชันใน Clojure บทนี้ครอบคลุมถึงสิ่งที่สามารถทำได้ด้วยฟังก์ชันใน Clojure

ซีเนียร์ ฟังก์ชั่นและคำอธิบาย
1 การกำหนดฟังก์ชัน

ฟังก์ชันถูกกำหนดโดยใช้ ‘defn’ มาโคร

2 ฟังก์ชันที่ไม่ระบุตัวตน

ฟังก์ชันนิรนามคือฟังก์ชันที่ไม่มีชื่อเกี่ยวข้อง

3 ฟังก์ชันที่มีหลายอาร์กิวเมนต์

ฟังก์ชัน Clojure สามารถกำหนดได้โดยมีพารามิเตอร์เป็นศูนย์หรือมากกว่า ค่าที่คุณส่งผ่านไปยังฟังก์ชันจะถูกเรียกใช้argumentsและอาร์กิวเมนต์สามารถเป็นประเภทใดก็ได้

4 ฟังก์ชัน Variadic

Clojure เสนอคำสั่ง 'case' ซึ่งคล้ายกับคำสั่ง 'switch' ที่มีอยู่ในภาษาโปรแกรม Java

5 ฟังก์ชั่นการสั่งซื้อที่สูงขึ้น

ฟังก์ชันลำดับที่สูงขึ้น (HOF) คือฟังก์ชันที่ใช้ฟังก์ชันอื่นเป็นอาร์กิวเมนต์ HOF เป็นเทคนิคการเขียนโปรแกรมเชิงฟังก์ชันที่สำคัญและมักใช้ใน Clojure

Numbers ประเภทข้อมูลใน Clojure มาจากคลาส Java

Clojure รองรับจำนวนเต็มและตัวเลขทศนิยม

  • จำนวนเต็มคือค่าที่ไม่รวมเศษส่วน

  • ตัวเลขทศนิยมคือค่าทศนิยมที่มีเศษทศนิยม

ต่อไปนี้เป็นตัวอย่างของตัวเลขใน Clojure

(def x 5)
(def y 5.25)

โดยที่ 'x' เป็นประเภท Integer และ 'y' คือ float.

ใน Java คลาสต่อไปนี้แนบกับตัวเลขที่กำหนดไว้ใน Clojure

หากต้องการดูว่าตัวเลขใน Clojure ได้มาจากคลาส Java ให้ใช้โปรแกรมต่อไปนี้เพื่อดูประเภทของตัวเลขที่กำหนดเมื่อใช้คำสั่ง 'def'

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (def x 5)
   (def y 5.25)
   (println (type x))
   (println (type y)))
(Example)

‘type’ คำสั่งใช้เพื่อส่งออกคลาสที่เกี่ยวข้องกับค่าที่กำหนดให้กับตัวแปร

เอาต์พุต

โค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้

Java.lang.long
Java.lang.double

การทดสอบหมายเลข

ฟังก์ชันการทดสอบต่อไปนี้พร้อมใช้งานสำหรับตัวเลข

ซีเนียร์ ตัวเลขและคำอธิบาย
1 ศูนย์?

ส่งคืนจริงถ้าตัวเลขเป็นศูนย์มิฉะนั้นเป็นเท็จ

2 ท่า?

ส่งคืนค่าจริงถ้าจำนวนมากกว่าศูนย์มิฉะนั้นเป็นเท็จ

3 นิก?

ส่งคืนค่าจริงถ้าจำนวนน้อยกว่าศูนย์มิฉะนั้นเป็นเท็จ

4 แม้?

ส่งคืนค่าจริงหากตัวเลขเป็นเลขคู่และแสดงข้อยกเว้นหากตัวเลขนั้นไม่ใช่จำนวนเต็ม

5 แปลก?

ส่งคืนจริงหากตัวเลขเป็นเลขคี่และแสดงข้อยกเว้นหากตัวเลขนั้นไม่ใช่จำนวนเต็ม

6 จำนวน?

ส่งคืนค่าจริงหากตัวเลขนั้นเป็นตัวเลขจริงๆ

7 จำนวนเต็ม?

ส่งคืนจริงหากตัวเลขเป็นจำนวนเต็ม

8 ลอย?

ส่งคืนจริงหากตัวเลขเป็นจำนวนทศนิยม

เราได้เห็นคำสั่งซ้ำในหัวข้อก่อนหน้านี้และในขณะที่การวนซ้ำ 'for' นั้นค่อนข้างเหมือนลูป recur เป็นวงที่แท้จริงใน Clojure

หากคุณมีพื้นฐานการเขียนโปรแกรมคุณอาจเคยได้ยินเกี่ยวกับการเรียกซ้ำหางซึ่งเป็นคุณสมบัติหลักของภาษาที่ใช้งานได้ แบบฟอร์มพิเศษที่เกิดซ้ำนี้เป็นแบบที่ใช้การเรียกซ้ำหาง เนื่องจากคำว่า "tail recursion" ระบุว่าต้องเรียกซ้ำในตำแหน่งหาง กล่าวอีกนัยหนึ่งการเกิดซ้ำต้องเป็นสิ่งสุดท้ายที่จะได้รับการประเมิน

ตัวอย่างที่ง่ายที่สุดของคำสั่งซ้ำใช้ภายในลูป 'for' ในตัวอย่างต่อไปนี้คำสั่งซ้ำใช้เพื่อเปลี่ยนค่าของตัวแปร 'i' และป้อนค่าของตัวแปรกลับไปที่นิพจน์ลูป

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (loop [i 0]
      (when (< i 5)
      (println i)
      (recur (inc i)))))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

0
1
2
3
4

Clojure มีวิธีการช่วยเหลือหลายอย่างเมื่อทำงานกับ I / O มีคลาสที่ง่ายกว่าในการจัดเตรียมฟังก์ชันต่อไปนี้สำหรับไฟล์

  • การอ่านไฟล์
  • การเขียนไฟล์
  • ดูว่าไฟล์เป็นไฟล์หรือไดเร็กทอรี

ลองสำรวจการทำงานของไฟล์ที่ Clojure มีให้

การอ่านเนื้อหาของไฟล์เป็นสตริงทั้งหมด

หากคุณต้องการรับเนื้อหาทั้งหมดของไฟล์เป็นสตริงคุณสามารถใช้ไฟล์ clojure.core.slurpวิธี. คำสั่ง slurp จะเปิดโปรแกรมอ่านบนไฟล์และอ่านเนื้อหาทั้งหมดโดยส่งคืนสตริง

ต่อไปนี้เป็นตัวอย่างของวิธีการนี้

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (def string1 (slurp "Example.txt"))
   (println string1))
(Example)

หากไฟล์มีบรรทัดต่อไปนี้จะถูกพิมพ์เป็น -

line : Example1
line : Example2

การอ่านเนื้อหาของไฟล์ทีละบรรทัด

หากคุณต้องการรับเนื้อหาทั้งหมดของไฟล์เป็นสตริงทีละบรรทัดคุณสามารถใช้ไฟล์ clojure.java.io/readerวิธี. คลาส clojure.java.io/reader สร้างบัฟเฟอร์ผู้อ่านซึ่งใช้ในการอ่านแต่ละบรรทัดของไฟล์

ต่อไปนี้เป็นตัวอย่างที่แสดงให้เห็นว่าสามารถทำได้อย่างไร

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (with-open [rdr (clojure.java.io/reader "Example.txt")]
   (reduce conj [] (line-seq rdr))))
(Example)

หากไฟล์มีบรรทัดต่อไปนี้จะถูกพิมพ์เป็น -

line : Example1
line : Example2

ผลลัพธ์จะแสดงเป็น -

["line : Example1" "line : Example2"]

การเขียนไฟล์ 'to'

หากคุณต้องการเขียนไฟล์ 'ถึง' คุณสามารถใช้ไฟล์ clojure.core.spitคำสั่งเพื่อพ่นสตริงทั้งหมดลงในไฟล์ คำสั่ง spit ตรงข้ามกับวิธี slurp วิธีนี้เปิดไฟล์ในฐานะนักเขียนเขียนเนื้อหาจากนั้นปิดไฟล์

ต่อไปนี้เป็นตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (spit "Example.txt"
      "This is a string"))

ในตัวอย่างข้างต้นหากคุณเห็นเนื้อหาของไฟล์ Example.txt คุณจะเห็นเนื้อหาของ“ นี่คือสตริง”

การเขียน 'ถึง' ไฟล์ทีละบรรทัด

หากคุณต้องการเขียนไฟล์ 'ถึง' ทีละบรรทัดคุณสามารถใช้ไฟล์ clojure.java.io.writerชั้นเรียน. คลาส clojure.java.io.writer ถูกใช้เพื่อสร้างสตรีมนักเขียนโดยไบต์ของข้อมูลจะถูกป้อนเข้าไปในสตรีมจากนั้นลงในไฟล์

ต่อไปนี้เป็นตัวอย่างที่แสดงวิธีใช้คำสั่ง spit

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (with-open [w (clojure.java.io/writer "Example.txt" :append true)]
      (.write w (str "hello" "world"))))
(Example)

เมื่อโค้ดด้านบนถูกเรียกใช้บรรทัด "hello world" จะปรากฏในไฟล์ Example.txt ตัวเลือก append: true คือการผนวกข้อมูลเข้ากับไฟล์ หากไม่ได้ระบุตัวเลือกนี้ไฟล์จะถูกเขียนทับทุกครั้งที่มีการเขียนข้อมูลลงในไฟล์

กำลังตรวจสอบว่ามีไฟล์อยู่หรือไม่

ในการตรวจสอบว่ามีไฟล์อยู่หรือไม่ไฟล์ clojure.java.io.fileคลาสสามารถใช้เพื่อตรวจสอบการมีอยู่ของไฟล์ ต่อไปนี้เป็นตัวอย่างที่แสดงให้เห็นว่าสามารถทำได้อย่างไร

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println (.exists (clojure.java.io/file "Example.txt"))))
(Example)

หากไฟล์ Example.txt มีอยู่ผลลัพธ์จะเป็นจริง

อ่านจากคอนโซล

ในการอ่านข้อมูลจากคอนโซลไฟล์ read-lineสามารถใช้คำสั่งได้ ต่อไปนี้เป็นตัวอย่างที่แสดงให้เห็นว่าสามารถใช้ได้อย่างไร

หากคุณป้อนคำสั่ง (read-line) ในหน้าต่าง REPL คุณจะมีโอกาสป้อนข้อมูลบางอย่างในหน้าต่างคอนโซล

user->(read-line)
Hello World

โค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้

“Hello World”

Stringลิเทอรัลถูกสร้างขึ้นใน Clojure โดยการใส่ข้อความสตริงในใบเสนอราคา ต้องสร้างสตริงใน Clojure โดยใช้เครื่องหมายคำพูดคู่เช่น "Hello World"

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการใช้สตริงใน Clojure

(ns clojure.examples.hello
   (:gen-class))
(defn hello-world []
   (println "Hello World")
   (println "This is a demo application"))
(hello-world)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

Hello World
This is a demo application

การใช้งานสตริงพื้นฐาน

Clojure มีการดำเนินการหลายอย่างที่สามารถดำเนินการกับสตริงได้ ต่อไปนี้คือการดำเนินการ

ซีเนียร์ การดำเนินการและคำอธิบายสตริง
1 str

การต่อสายอักขระสามารถทำได้โดยใช้ฟังก์ชัน str อย่างง่าย

2 รูปแบบ

การจัดรูปแบบของสตริงสามารถทำได้โดยฟังก์ชันรูปแบบง่าย ฟังก์ชันรูปแบบจัดรูปแบบสตริงโดยใช้java.lang.String.format.

3 นับ

ส่งคืนจำนวนอักขระในสตริง

4 ย่อย

ส่งคืนสตริงย่อยของ 's' ที่เริ่มต้นที่จุดเริ่มต้นรวมและสิ้นสุดที่ส่วนท้าย (ค่าเริ่มต้นคือความยาวของสตริง) โดยเฉพาะ

5 เปรียบเทียบ

ส่งคืนจำนวนลบศูนย์หรือจำนวนบวกเมื่อ 'x' เป็นตรรกะ 'น้อยกว่า' 'เท่ากับ' หรือ 'มากกว่า' 'y'

6 ตัวพิมพ์เล็ก

แปลงสตริงเป็นตัวพิมพ์เล็กทั้งหมด

7 ตัวพิมพ์ใหญ่

แปลงสตริงเป็นตัวพิมพ์ใหญ่ทั้งหมด

8 เข้าร่วม

ส่งคืนสตริงขององค์ประกอบทั้งหมดในคอลเลกชันตามที่ส่งคืนโดย (seq collection) คั่นด้วยตัวคั่นเผื่อเลือก

9 แยก

แยกสตริงในนิพจน์ทั่วไป

10 แยกบรรทัด

การแยกสตริงขึ้นอยู่กับอักขระหลีก \ n หรือ \ r \ n

11 ย้อนกลับ

กลับอักขระในสตริง

12 แทนที่

แทนที่อินสแตนซ์ทั้งหมดของการจับคู่ในสตริงด้วยสตริงแทนที่

13 ตัดแต่ง

ลบช่องว่างจากปลายทั้งสองด้านของสตริง

14 triml

ลบช่องว่างจากด้านซ้ายมือของสตริง

15 trimr

ลบช่องว่างจากด้านขวามือของสตริง

Listเป็นโครงสร้างที่ใช้ในการจัดเก็บชุดข้อมูล ใน Clojure รายการจะใช้ไฟล์ISeqอินเตอร์เฟซ. รายการถูกสร้างขึ้นใน Clojure โดยใช้ฟังก์ชันรายการ

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการสร้างรายการตัวเลขใน Clojure

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (println (list 1 2 3 4)))
(example)

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

(1 2 3 4)

ต่อไปนี้เป็นตัวอย่างของการสร้างรายชื่อตัวละครใน Clojure

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (println (list 'a 'b 'c 'd)))
(example)

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

(a b c d)

ต่อไปนี้เป็นวิธีรายการที่มีอยู่ใน Clojure

ซีเนียร์ รายการและคำอธิบาย
1 รายการ*

สร้างรายการใหม่ที่มีรายการที่อยู่ข้างหน้าส่วนที่เหลือรายการสุดท้ายจะถือว่าเป็นลำดับ

2 อันดับแรก

ฟังก์ชันนี้ส่งคืนรายการแรกในรายการ

3 ที่ n

ฟังก์ชันนี้จะส่งคืนรายการในตำแหน่ง "ที่ n" ในรายการ

4 ข้อเสีย

ส่งคืนรายการใหม่ที่มีการเพิ่มองค์ประกอบที่จุดเริ่มต้นของรายการ

5 ผัน

ส่งคืนรายการใหม่โดยที่รายการอยู่ที่จุดเริ่มต้นและองค์ประกอบที่จะต่อท้ายจะอยู่ที่ส่วนท้าย

6 พักผ่อน

ส่งคืนรายการที่เหลือในรายการหลังรายการแรก

Setsใน Clojure คือชุดของค่าเฉพาะ ชุดถูกสร้างขึ้นใน Clojure ด้วยความช่วยเหลือของคำสั่ง set

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการสร้างชุดใน Clojure

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (println (set '(1 1 2 2))))
(example)

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

#{1,2}

ต่อไปนี้เป็นวิธีการที่มีอยู่ใน Clojure สำหรับชุด

ซีเนียร์ ชุดและคำอธิบาย
1 จัดเรียงชุด

ส่งคืนชุดองค์ประกอบที่เรียงลำดับ

2 ได้รับ

ส่งคืนองค์ประกอบที่ตำแหน่งดัชนี

3 ประกอบด้วย?

ค้นหาว่าชุดนั้นมีองค์ประกอบบางอย่างหรือไม่

4 ผัน

ผนวกองค์ประกอบเข้ากับชุดและส่งคืนชุดองค์ประกอบใหม่

5 disj

ไม่เข้าร่วมองค์ประกอบจากชุด

6 สหภาพแรงงาน

ส่งคืนชุดที่เป็นสหภาพของชุดอินพุต

7 ความแตกต่าง

ส่งคืนชุดที่เป็นชุดแรกโดยไม่มีองค์ประกอบของชุดที่เหลือ

8 สี่แยก

ส่งคืนชุดที่เป็นจุดตัดของชุดอินพุต

9 เซตย่อย?

set1 เป็นส่วนย่อยของ set2 หรือไม่?

10 superset?

set1 เป็น superset ของ set2 หรือไม่?

Vectorคือชุดของค่าที่จัดทำดัชนีโดยจำนวนเต็มติดกัน เวกเตอร์ถูกสร้างขึ้นโดยใช้วิธีเวกเตอร์ใน Clojure

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการสร้างเวกเตอร์ใน Clojure

(ns clojure.examples.example
   (:require [clojure.set :as set])
   (:gen-class))
(defn example []
   (println (vector 1 2 3)))
(example)

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

[1 2 3]

ต่อไปนี้เป็นวิธีการที่มีอยู่ใน Clojure

ซีเนียร์ เวกเตอร์และคำอธิบาย
1 เวกเตอร์ของ

สร้างเวกเตอร์ใหม่ของประเภทดั้งเดิมเดี่ยว 't' โดยที่ 't' เป็นหนึ่งใน: int: long: float: double: byte: short: char หรือ: boolean

2 ที่ n

ฟังก์ชันนี้จะส่งคืนรายการในตำแหน่งที่ n ในเวกเตอร์

3 ได้รับ

ส่งคืนองค์ประกอบที่ตำแหน่งดัชนีในเวกเตอร์

4 ผัน

ผนวกองค์ประกอบเข้ากับเวกเตอร์และส่งกลับชุดองค์ประกอบเวกเตอร์ใหม่

5 ป๊อป

สำหรับรายการหรือคิวส่งคืนรายการ / คิวใหม่โดยไม่มีรายการแรกสำหรับเวกเตอร์จะส่งคืนเวกเตอร์ใหม่โดยไม่มีรายการสุดท้าย

6 subvec

ส่งคืนเวกเตอร์ย่อยจากดัชนีเริ่มต้นและสิ้นสุด

Mapเป็นคอลเล็กชันที่จับคู่คีย์กับค่า มีแผนที่สองประเภทที่แตกต่างกัน - แฮชและจัดเรียงHashMaps ต้องการคีย์ที่รองรับ hashCode อย่างถูกต้องและเท่ากับ SortedMaps ต้องการคีย์ที่ใช้การเปรียบเทียบหรืออินสแตนซ์ของตัวเปรียบเทียบ

แผนที่สามารถสร้างได้สองวิธีวิธีแรกคือผ่านวิธีแฮชแมป

การสร้าง - HashMaps

HashMaps มีความสัมพันธ์ของค่าคีย์โดยทั่วไปและสร้างขึ้นโดยใช้ฟังก์ชันแฮชแมป

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (def demokeys (hash-map "z" "1" "b" "2" "a" "3"))
   (println demokeys))
(example)

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

{z 1, b 2, a 3}

การสร้าง - SortedMaps

SortedMaps มีลักษณะเฉพาะของการจัดเรียงองค์ประกอบตามองค์ประกอบหลัก ต่อไปนี้เป็นตัวอย่างที่แสดงวิธีสร้างแผนที่ที่เรียงลำดับโดยใช้ฟังก์ชันแผนที่เรียงลำดับ

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (def demokeys (sorted-map "z" "1" "b" "2" "a" "3"))
   (println demokeys))
(example)

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

{a 3, b 2, z 1}

จากโปรแกรมด้านบนคุณจะเห็นได้อย่างชัดเจนว่าองค์ประกอบในแผนที่ถูกจัดเรียงตามค่าคีย์ ต่อไปนี้เป็นวิธีการที่ใช้ได้สำหรับแผนที่

ซีเนียร์ แผนที่และคำอธิบาย
1 ได้รับ

ส่งคืนค่าที่แมปกับคีย์ไม่พบหรือศูนย์หากไม่มีคีย์

2 ประกอบด้วย?

ดูว่าแผนที่มีคีย์ที่จำเป็นหรือไม่

3 หา

ส่งคืนรายการแผนที่สำหรับคีย์

4 คีย์

ส่งคืนรายการคีย์ในแผนที่

5 vals

ส่งกลับรายการค่าในแผนที่

6 ผิด

แยกการป้อนค่าคีย์จากแผนที่

7 ผสาน

รวมรายการแผนที่สองรายการให้เป็นรายการแผนที่เดียว

8 ผสานกับ

ส่งคืนแผนที่ที่ประกอบด้วยส่วนที่เหลือของแผนที่ conj-ed ในรายการแรก

9 เลือกปุ่ม

ส่งคืนแผนที่ที่มีเฉพาะรายการเหล่านั้นในแผนที่ซึ่งมีคีย์อยู่ในคีย์

10 เปลี่ยนชื่อคีย์

เปลี่ยนชื่อคีย์ใน HashMap ปัจจุบันเป็นคีย์ที่กำหนดใหม่

11 แผนที่กลับด้าน

แปลงแผนที่เพื่อให้ค่าต่างๆกลายเป็นกุญแจและในทางกลับกัน

Namespacesใน Clojure ใช้เพื่อแยกความแตกต่างของคลาสออกเป็นโลจิคัลสเปซแยกกันเช่นเดียวกับใน Java พิจารณาข้อความต่อไปนี้

(:require [clojure.set :as set])

ในข้อความข้างต้น 'clojure.set' คือเนมสเปซที่มีคลาสและวิธีการต่างๆที่จะใช้ในโปรแกรม ตัวอย่างเช่นเนมสเปซข้างต้นมีฟังก์ชันที่เรียกว่า map-invert ซึ่งใช้ในการแปลงแมปของคีย์ - ค่า เราไม่สามารถใช้ฟังก์ชันนี้ได้เว้นแต่เราจะแจ้งให้โปรแกรมของเรารวมเนมสเปซนี้อย่างชัดเจน

มาดูวิธีการต่างๆสำหรับเนมสเปซ

ซีเนียร์ วิธีการและคำอธิบาย
1 * ns *

ใช้เพื่อดูเนมสเปซปัจจุบันของคุณ

2 ns

ใช้เพื่อสร้างเนมสเปซใหม่และเชื่อมโยงกับโปรแกรมที่กำลังทำงานอยู่

3 นามแฝง

เพิ่มนามแฝงในเนมสเปซปัจจุบันไปยังเนมสเปซอื่น อาร์กิวเมนต์เป็นสองสัญลักษณ์: นามแฝงที่จะใช้และชื่อสัญลักษณ์ของเนมสเปซเป้าหมาย

4 all-ns

ส่งคืนรายการเนมสเปซทั้งหมด

5 หา -ns

ค้นหาและส่งคืนเนมสเปซเฉพาะ

6 ns- ชื่อ

ส่งคืนชื่อของเนมสเปซเฉพาะ

7 ns-aliases

ส่งคืนนามแฝงซึ่งเชื่อมโยงกับเนมสเปซใด ๆ

8 ns- แผนที่

ส่งคืนแผนที่ของการแม็พทั้งหมดสำหรับเนมสเปซ

9 ยกเลิกนามแฝง

ส่งคืนแผนที่ที่มีเฉพาะรายการเหล่านั้นในแผนที่ซึ่งมีคีย์อยู่ในคีย์

Exception handlingจำเป็นต้องใช้ในภาษาโปรแกรมใด ๆ เพื่อจัดการกับข้อผิดพลาดรันไทม์เพื่อให้สามารถรักษาขั้นตอนปกติของแอปพลิเคชันได้ โดยปกติข้อยกเว้นจะขัดขวางขั้นตอนปกติของแอปพลิเคชันซึ่งเป็นเหตุผลว่าทำไมเราจึงต้องใช้การจัดการข้อยกเว้นในแอปพลิเคชันของเรา

ข้อยกเว้นแบ่งออกเป็นประเภทกว้าง ๆ ดังต่อไปนี้ -

  • Checked Exception- คลาสที่ขยายคลาส Throwable ยกเว้น RuntimeException และ Error เรียกว่าข้อยกเว้นที่ตรวจสอบ เช่น IOException, SQLException ฯลฯ ข้อยกเว้นที่ตรวจสอบจะถูกตรวจสอบในเวลาคอมไพล์

ลองพิจารณาโปรแกรมต่อไปนี้ซึ่งดำเนินการกับไฟล์ชื่อ Example.txt อย่างไรก็ตามอาจมีบางกรณีที่ไฟล์ Example.txt ไม่มีอยู่

(ns clojure.examples.example
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (def string1 (slurp "Example.txt"))
   (println string1))
(Example)

ถ้าไฟล์ Example.txt ไม่มีอยู่โปรแกรมจะสร้างข้อยกเว้นต่อไปนี้

Caused by: java.io.FileNotFoundException: Example.txt (No such file or
directory)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
at java.io.FileInputStream.<init>(FileInputStream.java:138)
at clojure.java.io$fn__9185.invoke(io.clj:229) at clojure.java.io$fn__9098$G__9091__9105.invoke(io.clj:69) at clojure.java.io$fn__9197.invoke(io.clj:258)
at clojure.java.io$fn__9098$G__9091__9105.invoke(io.clj:69)

จากข้อยกเว้นข้างต้นเราจะเห็นได้ชัดเจนว่าโปรแกรมยก FileNotFoundException

  • Unchecked Exception- คลาสที่ขยาย RuntimeException เรียกว่าข้อยกเว้นที่ไม่ได้เลือก ตัวอย่างเช่น ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException เป็นต้นข้อยกเว้นที่ไม่ได้ตรวจสอบจะไม่ถูกตรวจสอบในเวลาคอมไพล์ แต่จะถูกตรวจสอบที่รันไทม์

กรณีคลาสสิกอย่างหนึ่งคือ ArrayIndexOutOfBoundsException ซึ่งเกิดขึ้นเมื่อคุณพยายามเข้าถึงดัชนีของอาร์เรย์ที่มากกว่าความยาวของอาร์เรย์ ต่อไปนี้เป็นตัวอย่างทั่วไปของความผิดพลาดประเภทนี้

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (try
      (aget (int-array [1 2 3]) 5)
      (catch Exception e (println (str "caught exception: " (.toString e))))
      (finally (println "This is our final block")))
   (println "Let's move on"))
(Example)

เมื่อดำเนินการโค้ดข้างต้นข้อยกเว้นต่อไปนี้จะถูกเพิ่มขึ้น

caught exception: java.lang.ArrayIndexOutOfBoundsException: 5
This is our final block
Let's move on

ข้อผิดพลาด

ข้อผิดพลาดไม่สามารถกู้คืนได้เช่น OutOfMemoryError, VirtualMachineError, AssertionError เป็นต้นซึ่งเป็นข้อผิดพลาดที่โปรแกรมไม่สามารถกู้คืนได้และจะทำให้โปรแกรมหยุดทำงาน ตอนนี้เราต้องการกลไกบางอย่างเพื่อตรวจจับข้อยกเว้นเหล่านี้เพื่อให้โปรแกรมทำงานต่อไปได้หากมีข้อยกเว้นเหล่านี้

แผนภาพต่อไปนี้แสดงวิธีการจัดลำดับชั้นของข้อยกเว้นใน Clojure ทั้งหมดขึ้นอยู่กับลำดับชั้นที่กำหนดไว้ใน Java

การจับข้อยกเว้น

เช่นเดียวกับภาษาโปรแกรมอื่น ๆ Clojure มีบล็อก 'try-catch' ตามปกติเพื่อตรวจจับข้อยกเว้นเมื่อเกิดขึ้น

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของบล็อก try-catch

(try
   (//Protected code)
   catch Exception e1)
(//Catch block)

รหัสทั้งหมดของคุณที่อาจทำให้เกิดข้อยกเว้นจะอยู่ในไฟล์ Protected code block.

ใน catch blockคุณสามารถเขียนโค้ดที่กำหนดเองเพื่อจัดการข้อยกเว้นของคุณเพื่อให้แอปพลิเคชันสามารถกู้คืนจากข้อยกเว้นได้

ลองดูตัวอย่างก่อนหน้านี้ของเราซึ่งสร้างข้อยกเว้นที่ไม่พบไฟล์และดูว่าเราสามารถใช้บล็อก try catch เพื่อตรวจจับข้อยกเว้นที่โปรแกรมยกขึ้นได้อย่างไร

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (try
      (def string1 (slurp "Example.txt"))
      (println string1)
      (catch Exception e (println (str "caught exception: " (.getMessage e))))))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

caught exception: Example.txt (No such file or directory)

จากรหัสด้านบนเราสรุปรหัสที่ผิดพลาดในไฟล์ try block. ในบล็อก catch เราเพิ่งจับข้อยกเว้นของเราและแสดงข้อความว่ามีข้อยกเว้นเกิดขึ้น ดังนั้นตอนนี้เรามีวิธีที่มีความหมายในการจับข้อยกเว้นซึ่งสร้างขึ้นโดยโปรแกรม

หลาย Catch Blocks

หนึ่งสามารถมีหลายบล็อกเพื่อจัดการกับข้อยกเว้นหลายประเภท สำหรับแต่ละบล็อกจับขึ้นอยู่กับประเภทของข้อยกเว้นที่เพิ่มขึ้นคุณจะเขียนโค้ดเพื่อจัดการตามนั้น

มาแก้ไขโค้ดก่อนหน้าของเราเพื่อรวมบล็อกการจับสองบล็อกซึ่งเป็นข้อยกเว้นเฉพาะสำหรับไฟล์ของเราไม่พบข้อยกเว้นและอีกอันใช้สำหรับบล็อกข้อยกเว้นทั่วไป

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (try
      (def string1 (slurp "Example.txt"))
      (println string1)
      
      (catch java.io.FileNotFoundException e (println (str "caught file
         exception: " (.getMessage e))))
      
      (catch Exception e (println (str "caught exception: " (.getMessage e)))))
   (println "Let's move on"))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

caught file exception: Example.txt (No such file or directory)
Let's move on

จากผลลัพธ์ข้างต้นเราจะเห็นได้อย่างชัดเจนว่าข้อยกเว้นของเราถูกจับโดยบล็อกการจับ 'FileNotFoundException' ไม่ใช่ข้อยกเว้นทั่วไป

สุดท้ายบล็อก

บล็อกสุดท้ายจะเป็นไปตามบล็อกลองหรือบล็อกจับ ในที่สุดบล็อกโค้ดจะดำเนินการเสมอโดยไม่คำนึงถึงการเกิดข้อยกเว้น

การใช้บล็อกในที่สุดช่วยให้คุณสามารถเรียกใช้คำสั่งประเภทการล้างข้อมูลที่คุณต้องการดำเนินการได้ไม่ว่าจะเกิดอะไรขึ้นในรหัสที่ได้รับการป้องกัน ต่อไปนี้เป็นไวยากรณ์สำหรับบล็อกนี้

(try
   (//Protected code)
   catch Exception e1)
(//Catch block)
(finally
   //Cleanup code)

มาแก้ไขโค้ดด้านบนและเพิ่มบล็อคโค้ดในที่สุด ต่อไปนี้เป็นข้อมูลโค้ด

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (try
      (def string1 (slurp "Example.txt"))
      (println string1)
      
      (catch java.io.FileNotFoundException e (println (str "caught file
         exception: " (.getMessage e))))
      
      (catch Exception e (println (str "caught exception: " (.getMessage e))))
      (finally (println "This is our final block")))
   (println "Let's move on"))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

caught file exception: Example.txt (No such file or directory)
This is our final block
Let's move on

จากโปรแกรมข้างต้นคุณจะเห็นว่าบล็อกสุดท้ายยังถูกนำไปใช้หลังจากบล็อก catch จับข้อยกเว้นที่จำเป็น

เนื่องจาก Clojure ได้รับการจัดการข้อยกเว้นจาก Java ซึ่งคล้ายกับ Java จึงมีวิธีการต่อไปนี้ใน Clojure เพื่อจัดการข้อยกเว้น

  • public String getMessage()- แสดงข้อความโดยละเอียดเกี่ยวกับข้อยกเว้นที่เกิดขึ้น ข้อความนี้เริ่มต้นในตัวสร้าง Throwable

  • public Throwable getCause() - ส่งกลับสาเหตุของข้อยกเว้นที่แสดงโดยวัตถุ Throwable

  • public String toString() - ส่งคืนชื่อของคลาสที่เชื่อมต่อกับผลลัพธ์ของ getMessage ()

  • public void printStackTrace() - พิมพ์ผลลัพธ์ของ toString () พร้อมกับการติดตามสแต็กไปยัง System.err สตรีมเอาต์พุตข้อผิดพลาด

  • public StackTraceElement [] getStackTrace()- ส่งคืนอาร์เรย์ที่มีแต่ละองค์ประกอบในการติดตามสแต็ก องค์ประกอบที่ดัชนี 0 แสดงถึงด้านบนสุดของ call stack และองค์ประกอบสุดท้ายในอาร์เรย์แสดงถึงวิธีการที่ด้านล่างของ call stack

  • public Throwable fillInStackTrace() - เติมสแต็กแทร็กของอ็อบเจ็กต์ Throwable นี้ด้วยการติดตามสแต็กปัจจุบันโดยเพิ่มข้อมูลก่อนหน้านี้ในการติดตามสแต็ก

ต่อไปนี้เป็นโค้ดตัวอย่างที่ใช้วิธีการบางอย่างที่ระบุไว้ข้างต้น

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (try
      (def string1 (slurp "Example.txt"))
      (println string1)
      
      (catch java.io.FileNotFoundException e (println (str "caught file
         exception: " (.toString e))))
      
      (catch Exception e (println (str "caught exception: " (.toString e))))
   (finally (println "This is our final block")))
   (println "Let's move on"))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

caught file exception: java.io.FileNotFoundException: Example.txt (No such file
or directory)
This is our final block
Let's move on

Sequences ถูกสร้างขึ้นด้วยความช่วยเหลือของไฟล์ ‘seq’คำสั่ง ต่อไปนี้เป็นตัวอย่างง่ายๆของการสร้างลำดับ

(ns clojure.examples.example
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println (seq [1 2 3])))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

(1 2 3)

ต่อไปนี้เป็นวิธีการต่างๆสำหรับลำดับ

ซีเนียร์ วิธีการและคำอธิบาย
1 ข้อเสีย

ส่งคืนลำดับใหม่โดยที่ 'x' เป็นองค์ประกอบแรกและ 'seq' คือส่วนที่เหลือ

2 ผัน

ส่งคืนลำดับใหม่โดยที่ 'x' คือองค์ประกอบที่ถูกเพิ่มที่ส่วนท้ายของลำดับ

3 concat

สิ่งนี้ใช้เพื่อรวมสองลำดับเข้าด้วยกัน

4 ชัดเจน

ใช้เพื่อให้แน่ใจว่ามีการเพิ่มองค์ประกอบที่แตกต่างกันในลำดับเท่านั้น

5 ย้อนกลับ

ย้อนกลับองค์ประกอบในลำดับ

6 อันดับแรก

ส่งคืนองค์ประกอบแรกของลำดับ

7 ล่าสุด

ส่งคืนองค์ประกอบสุดท้ายของลำดับ

8 พักผ่อน

ส่งคืนลำดับทั้งหมดยกเว้นองค์ประกอบแรก

9 เรียงลำดับ

ส่งคืนลำดับขององค์ประกอบที่เรียงลำดับ

10 หล่น

วางองค์ประกอบจากลำดับตามจำนวนองค์ประกอบที่ต้องนำออก

11 กินเวลาสุดท้าย

รับรายการองค์ประกอบสุดท้ายจากลำดับ

12 ใช้เวลา

รับรายการองค์ประกอบแรกจากลำดับ

13 แยกที่

แบ่งลำดับของรายการออกเป็นสองส่วน มีการระบุตำแหน่งที่การแยกควรเกิดขึ้น

regular expressionเป็นรูปแบบที่ใช้ในการค้นหาสตริงย่อยในข้อความ นิพจน์ทั่วไปใช้ในภาษาโปรแกรมต่างๆและใช้กันมากในภาษาโปรแกรมประเภท LISP

ต่อไปนี้เป็นตัวอย่างของนิพจน์ทั่วไป

//d+

นิพจน์ทั่วไปข้างต้นใช้เพื่อค้นหาตัวเลขในสตริง อักขระ // ใช้เพื่อให้แน่ใจว่าอักขระ 'd' และ '+' ถูกใช้เพื่อแสดงนิพจน์ทั่วไป

โดยทั่วไปนิพจน์ทั่วไปจะทำงานร่วมกับชุดของกฎต่อไปนี้

  • มีอักขระตำแหน่งพิเศษสองตัวที่ใช้เพื่อแสดงจุดเริ่มต้นและจุดสิ้นสุดของบรรทัด: คาเร็ต (∧) และเครื่องหมายดอลลาร์ ($):

  • นิพจน์ทั่วไปยังสามารถรวมตัวระบุปริมาณ เครื่องหมายบวก (+) แทนหนึ่งครั้งขึ้นไปซึ่งใช้กับองค์ประกอบก่อนหน้าของนิพจน์ เครื่องหมายดอกจัน (*) ใช้เพื่อแสดงถึงเหตุการณ์ที่เกิดขึ้นเป็นศูนย์หรือมากกว่า เครื่องหมายคำถาม (?) หมายถึงศูนย์หรือครั้งเดียว

  • metacharacter {and} ใช้เพื่อจับคู่อินสแตนซ์จำนวนเฉพาะของอักขระที่อยู่ข้างหน้า

  • ในนิพจน์ทั่วไปสัญลักษณ์จุด (.) สามารถแทนอักขระใดก็ได้ สิ่งนี้อธิบายว่าเป็นอักขระตัวแทน

  • นิพจน์ทั่วไปอาจรวมถึงคลาสอักขระ ชุดอักขระสามารถกำหนดให้เป็นลำดับของอักขระที่อยู่ในอักขระเมตาคาแร็กเตอร์ [และ] เช่นเดียวกับ [aeiou] สำหรับช่วงตัวอักษรหรือตัวเลขคุณสามารถใช้ตัวคั่นเส้นประเช่น [a – z] หรือ [a – mA – M] ส่วนเติมเต็มของคลาสอักขระแสดงด้วยเครื่องหมายคาเร็ตนำหน้าในวงเล็บเหลี่ยมเช่นเดียวกับ [∧a – z] และแทนอักขระทั้งหมดที่นอกเหนือจากที่ระบุ

มีวิธีการต่อไปนี้สำหรับนิพจน์ทั่วไป

ซีเนียร์ วิธีการและคำอธิบาย
1 รูปแบบใหม่

ส่งคืนอินสแตนซ์ของ java.util.regex.Pattern จากนั้นจะใช้ในวิธีการอื่น ๆ สำหรับการจับคู่รูปแบบ

2 ขัดเกลา

ส่งคืนการจับคู่ regex ถัดไปถ้ามีของสตริงเป็นรูปแบบโดยใช้ java.util.regex.Matcher.find ()

3 แทนที่

ฟังก์ชันแทนที่ใช้เพื่อแทนที่สตริงย่อยในสตริงด้วยค่าสตริงใหม่ การค้นหาสตริงย่อยทำได้โดยใช้รูปแบบ

4 แทนที่ - ก่อน

ฟังก์ชันแทนที่ใช้เพื่อแทนที่สตริงย่อยในสตริงด้วยค่าสตริงใหม่ แต่สำหรับสตริงย่อยที่เกิดขึ้นครั้งแรกเท่านั้น การค้นหาสตริงย่อยทำได้โดยใช้รูปแบบ

Predicatesเป็นฟังก์ชันที่ประเมินเงื่อนไขและให้ค่าเป็นจริงหรือเท็จ เราได้เห็นฟังก์ชันเพรดิเคตในตัวอย่างของบทเกี่ยวกับตัวเลข เราได้เห็นฟังก์ชันเช่น 'even?' ซึ่งใช้ในการทดสอบว่าตัวเลขเป็นเลขคู่หรือไม่หรือ "ลบ" ซึ่งใช้ในการทดสอบว่าตัวเลขมีค่ามากกว่าศูนย์หรือไม่ ฟังก์ชันทั้งหมดนี้ส่งคืนค่าจริงหรือเท็จ

ต่อไปนี้เป็นตัวอย่างของเพรดิเคตใน Clojure

(ns clojure.examples.example
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (def x (even? 0))
   (println x)
   
   (def x (neg? 2))
   (println x)
   
   (def x (odd? 3))
   (println x)
   
   (def x (pos? 3))
   (println x))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

true
false
true
true

นอกเหนือจากฟังก์ชันเพรดิเคตปกติ Clojure ยังมีฟังก์ชันเพิ่มเติมสำหรับเพรดิเคต มีวิธีการต่อไปนี้สำหรับเพรดิเคต

ซีเนียร์ วิธีการและคำอธิบาย
1 ทุกประการ

รับชุดเพรดิเคตและส่งคืนฟังก์ชัน 'f' ที่ส่งคืนค่าจริงหากเพรดิเคตที่เขียนทั้งหมดส่งคืนค่าจริงเชิงตรรกะเทียบกับอาร์กิวเมนต์ทั้งหมดมิฉะนั้นจะคืนค่าเป็นเท็จ

2 ทุกๆ?

ส่งคืนจริงหากเพรดิเคตเป็นจริงสำหรับทุกค่ามิฉะนั้นเป็นเท็จ

3 บาง

ส่งคืนค่าจริงตรรกะแรกสำหรับค่าเพรดิเคตของ x ในคอลเล็กชันของค่า

4 ไม่ใด ๆ?

ส่งคืนเท็จหากเพรดิเคตใด ๆ ของค่าในคอลเลกชันเป็นจริงอย่างมีเหตุผลหรือเป็นจริง

Destructuring เป็นฟังก์ชันการทำงานภายใน Clojure ซึ่งช่วยให้สามารถดึงค่าจากโครงสร้างข้อมูลเช่นเวกเตอร์และผูกเข้ากับสัญลักษณ์ได้โดยไม่ต้องสำรวจโครงสร้างข้อมูลอย่างชัดเจน

ลองดูตัวอย่างของความหมายของการทำลายล้างและมันเกิดขึ้นได้อย่างไร

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def my-vector [1 2 3 4])
   (let [[a b c d] my-vector]
   (println a b c d)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

1 2 3 4

ในตัวอย่างข้างต้นจะต้องสังเกตสิ่งต่อไปนี้ -

  • เรากำลังกำหนดเวกเตอร์ของจำนวนเต็มเป็น 1, 2, 3 และ 4

  • จากนั้นเราจะใช้ไฟล์ ‘let’ คำสั่งเพื่อกำหนดตัวแปร 4 ตัว (a, b, c และ d) ให้กับตัวแปร my-vector โดยตรง

  • หากเราเรียกใช้ไฟล์ ‘println’ คำสั่งเกี่ยวกับตัวแปรทั้งสี่เราจะเห็นว่ามีการกำหนดให้กับค่าในเวกเตอร์ตามลำดับแล้ว

ดังนั้น clojure ได้ทำลายตัวแปร my-vector ซึ่งมีค่าสี่ค่าเมื่อถูกกำหนดโดยใช้คำสั่ง 'let' จากนั้นค่าสี่ค่าที่แยกโครงสร้างออกมาจะถูกกำหนดให้กับพารามิเตอร์ทั้งสี่ตามนั้น

หากมีตัวแปรส่วนเกินที่ไม่มีค่าที่สอดคล้องกันซึ่งสามารถกำหนดให้ได้ตัวแปรเหล่านั้นจะถูกกำหนดค่าของศูนย์ ตัวอย่างต่อไปนี้ทำให้ประเด็นนี้ชัดเจน

ตัวอย่าง

(ns clojure.examples.hello
   (:gen-class))
(defn Example []
   (def my-vector [1 2 3 4])
   (let [[a b c d e] my-vector]
   (println a b c d e)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ คุณสามารถดูได้จากผลลัพธ์ว่าเนื่องจากตัวแปรสุดท้าย 'e' ไม่มีค่าที่สอดคล้องกันในเวกเตอร์จึงมีค่าเป็นศูนย์

เอาต์พุต

1 2 3 4 nil

ส่วนที่เหลือ

ตัวแปร 'the-rest' ใช้ในการจัดเก็บค่าที่เหลือซึ่งไม่สามารถกำหนดให้กับตัวแปรใด ๆ ได้

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def my-vector [1 2 3 4])
   (let [[a b & the-rest] my-vector]
   (println a b the-rest)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ จากผลลัพธ์คุณจะเห็นได้อย่างชัดเจนว่าค่าของ 3 และ 4 ไม่สามารถกำหนดให้กับตัวแปรใด ๆ ได้ดังนั้นจึงถูกกำหนดให้กับตัวแปร "ส่วนที่เหลือ"

เอาต์พุต

1 2 (3 4)

แผนที่ทำลายล้าง

เช่นเดียวกับเวกเตอร์แผนที่สามารถทำลายโครงสร้างได้เช่นกัน ต่อไปนี้เป็นตัวอย่างของการดำเนินการนี้

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def my-map {"a" 1 "b" 2})
   (let [{a "a" b "b"} my-map]
   (println a b)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ จากโปรแกรมคุณจะเห็นได้อย่างชัดเจนว่าค่าแผนที่ของ "a" และ "b" ถูกกำหนดให้กับตัวแปรของ a และ b

เอาต์พุต

1 2

ในกรณีของเวกเตอร์หากไม่มีค่าที่สอดคล้องกันในแผนที่เมื่อการทำลายเกิดขึ้นตัวแปรจะถูกกำหนดค่าเป็นศูนย์

ต่อไปนี้เป็นตัวอย่าง

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def my-map {"a" 1 "b" 2})
   (let [{a "a" b "b" c "c"} my-map]
   (println a b c)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

1 2 nil

เนื่องจากเฟรมเวิร์ก Clojure มาจากคลาส Java จึงสามารถใช้คลาสวันที่และเวลาที่มีอยู่ใน Java ใน Clojure class date แสดงถึงช่วงเวลาที่เฉพาะเจาะจงโดยมีความแม่นยำระดับมิลลิวินาที

ต่อไปนี้เป็นวิธีการที่ใช้ได้สำหรับคลาสวันเวลา

java.util.Date

ใช้เพื่อสร้างวัตถุวันที่ใน Clojure

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

java.util.Date.

Parameters - ไม่มี

Return Value - จัดสรรออบเจ็กต์ Date และกำหนดค่าเริ่มต้นเพื่อให้แสดงเวลาที่จัดสรรโดยวัดเป็นมิลลิวินาทีที่ใกล้ที่สุด

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns example)
(defn Example []
   (def date (.toString (java.util.Date.)))
   (println date))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ สิ่งนี้จะขึ้นอยู่กับวันที่และเวลาปัจจุบันบนระบบที่โปรแกรมกำลังทำงานอยู่

Tue Mar 01 06:11:17 UTC 2016

java.text.SimpleDateFormat

ใช้เพื่อจัดรูปแบบเอาต์พุตวันที่

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(java.text.SimpleDateFormat. format dt)

Parameters- 'รูปแบบ' คือรูปแบบที่จะใช้ในการจัดรูปแบบวันที่ "dt" คือวันที่ที่ต้องจัดรูปแบบ

Return Value - เอาต์พุตวันที่ที่จัดรูปแบบ

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns example)
(defn Example []
   (def date (.format (java.text.SimpleDateFormat. "MM/dd/yyyy") (new java.util.Date)))
   (println date))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ สิ่งนี้จะขึ้นอยู่กับวันที่และเวลาปัจจุบันบนระบบที่โปรแกรมกำลังทำงานอยู่

03/01/2016

getTime

ส่งคืนจำนวนมิลลิวินาทีตั้งแต่วันที่ 1 มกราคม 1970 00:00:00 GMT แทนด้วยวัตถุ Date นี้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(.getTime)

Parameters - ไม่มี

Return Value - จำนวนมิลลิวินาทีตั้งแต่วันที่ 1 มกราคม 1970 00:00:00 GMT แทนด้วยวันที่นี้

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns example)
(import java.util.Date)
(defn Example []
   (def date (.getTime (java.util.Date.)))
   (println date))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ สิ่งนี้จะขึ้นอยู่กับวันที่และเวลาปัจจุบันบนระบบที่โปรแกรมกำลังทำงานอยู่

1456812778160

Atomsเป็นชนิดข้อมูลใน Clojure ที่มีวิธีจัดการสถานะที่ใช้ร่วมกันซิงโครนัสและเป็นอิสระ อะตอมก็เหมือนกับประเภทอ้างอิงในภาษาโปรแกรมอื่น ๆ การใช้อะตอมหลักคือการเก็บโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปของ Clojure ค่าที่ถือโดยอะตอมจะเปลี่ยนไปด้วยswap! method.

ภายในแลกเปลี่ยน! อ่านค่าปัจจุบันใช้ฟังก์ชันกับมันและพยายามเปรียบเทียบและตั้งค่าในเนื่องจากเธรดอื่นอาจมีการเปลี่ยนแปลงค่าในช่วงเวลาที่แทรกแซงจึงอาจต้องลองใหม่อีกครั้งและทำเช่นนั้นในการหมุนวน เอฟเฟกต์สุทธิคือค่าจะเป็นผลลัพธ์ของการประยุกต์ใช้ฟังก์ชันที่ให้มากับค่าปัจจุบันเสมอในทางอะตอม

ตัวอย่าง

อะตอมถูกสร้างขึ้นด้วยความช่วยเหลือของวิธีอะตอม ตัวอย่างเดียวกันจะแสดงในโปรแกรมต่อไปนี้

(ns clojure.examples.example
   (:gen-class))
(defn example []
   (def myatom (atom 1))
   (println @myatom))
(example)

เอาต์พุต

โปรแกรมข้างต้นให้ผลลัพธ์ดังต่อไปนี้

1

ค่าของอะตอมเข้าถึงได้โดยใช้สัญลักษณ์ @ Clojure มีการดำเนินการบางอย่างที่สามารถทำได้กับอะตอม ต่อไปนี้คือการดำเนินการ

ซีเนียร์ การดำเนินงานและคำอธิบาย
1 รีเซ็ต!

ตั้งค่าของอะตอมเป็นค่าใหม่โดยไม่คำนึงถึงค่าปัจจุบัน

2 เปรียบเทียบและตั้งค่า!

ตั้งค่าอะตอมเป็นค่าใหม่ในกรณีที่ค่าปัจจุบันของอะตอมเหมือนกันกับค่าเก่าที่อะตอมถืออยู่ ส่งคืนค่า true หาก set เกิดขึ้นมิฉะนั้นจะคืนค่าเป็นเท็จ

3 แลก!

สลับค่าของอะตอมด้วยอะตอมใหม่ตามฟังก์ชันเฉพาะ

ใน Clojure metadataใช้เพื่อใส่คำอธิบายประกอบข้อมูลในคอลเลกชันหรือสำหรับข้อมูลที่จัดเก็บในสัญลักษณ์ โดยปกติจะใช้เพื่อใส่คำอธิบายประกอบข้อมูลเกี่ยวกับประเภทไปยังคอมไพลเลอร์พื้นฐาน แต่ยังสามารถใช้สำหรับนักพัฒนาได้ ข้อมูลเมตาไม่ถือว่าเป็นส่วนหนึ่งของมูลค่าของวัตถุ ในขณะเดียวกันข้อมูลเมตาก็ไม่เปลี่ยนรูป

การดำเนินการต่อไปนี้เป็นไปได้ใน Clojure เกี่ยวกับข้อมูลเมตา

ซีเนียร์ การดำเนินงานและคำอธิบาย
1 meta-with

ฟังก์ชันนี้ใช้เพื่อกำหนดแผนที่ข้อมูลเมตาสำหรับวัตถุใด ๆ

2 เมตา

ฟังก์ชันนี้ใช้เพื่อดูว่าข้อมูลเมตาใด ๆ เชื่อมโยงกับวัตถุหรือไม่

3 meta ที่แตกต่างกัน

ส่งคืนอ็อบเจ็กต์ประเภทและค่าเดียวกันกับอ็อบเจ็กต์ดั้งเดิม แต่มีเมทาดาทารวม

StructMapsใช้สำหรับสร้างโครงสร้างใน Clojure ตัวอย่างเช่นหากคุณต้องการสร้างโครงสร้างที่ประกอบด้วยชื่อพนักงานและรหัสพนักงานคุณสามารถทำได้ด้วย StructMaps

การดำเนินการต่อไปนี้เป็นไปได้ใน Clojure เกี่ยวกับ StructMaps

ซีเนียร์ การดำเนินงานและคำอธิบาย
1 ขัดขวาง

ฟังก์ชันนี้ใช้สำหรับกำหนดโครงสร้างที่จำเป็น

2 โครงสร้าง

ฟังก์ชันนี้ใช้เพื่อกำหนดอ็อบเจ็กต์โครงสร้างของชนิดซึ่งสร้างขึ้นโดยการดำเนินการ Defstruct

3 โครงสร้างแผนที่

ฟังก์ชันนี้ใช้เพื่อกำหนดค่าโดยเฉพาะให้กับค่าคีย์โดยกำหนดอย่างชัดเจนว่าจะกำหนดค่าใดให้กับคีย์ใดในโครงสร้าง

4 การเข้าถึงแต่ละฟิลด์

แต่ละฟิลด์ของโครงสร้างสามารถเข้าถึงได้โดยการเข้าถึงคีย์พร้อมกับออบเจ็กต์โครงสร้าง

5 ธรรมชาติที่ไม่เปลี่ยนรูป

ตามค่าเริ่มต้นโครงสร้างยังไม่เปลี่ยนรูปดังนั้นหากเราพยายามเปลี่ยนค่าของคีย์ใดคีย์หนึ่งก็จะไม่เปลี่ยนแปลง

6 การเพิ่มคีย์ใหม่ให้กับโครงสร้าง

เนื่องจากโครงสร้างไม่เปลี่ยนรูปวิธีเดียวที่สามารถเพิ่มคีย์อื่นเข้าไปในโครงสร้างได้คือการสร้างโครงสร้างใหม่ ตัวอย่างวิธีการนี้จะแสดงในโปรแกรมต่อไปนี้

ดังที่ได้กล่าวไว้หลายครั้ง Clojure เป็นภาษาโปรแกรมที่ประเภทข้อมูลหลายชนิดไม่เปลี่ยนรูปซึ่งหมายความว่าวิธีเดียวที่เราสามารถเปลี่ยนค่าของตัวแปรได้คือการสร้างตัวแปรใหม่และกำหนดค่าใหม่ให้กับมัน อย่างไรก็ตาม Clojure มีองค์ประกอบบางอย่างซึ่งสามารถสร้างสถานะที่เปลี่ยนแปลงได้ เราได้เห็นว่าสิ่งนี้สามารถทำได้ด้วยชนิดข้อมูลอะตอม วิธีอื่นที่สามารถทำได้คือผ่านตัวแทน

Agentsให้การเปลี่ยนแปลงสถานที่แต่ละแห่งเป็นอิสระแบบอะซิงโครนัส ตัวแทนถูกผูกไว้กับที่เก็บข้อมูลเดียวตลอดอายุการใช้งานและอนุญาตให้เกิดการกลายพันธุ์ของตำแหน่งนั้น (เป็นสถานะใหม่) อันเป็นผลมาจากการกระทำเท่านั้น การดำเนินการคือฟังก์ชัน (ที่มีอาร์กิวเมนต์เพิ่มเติมเป็นทางเลือก) ที่ใช้กับสถานะของตัวแทนแบบอะซิงโครนัสและค่าที่ส่งคืนจะกลายเป็นสถานะใหม่ของตัวแทน

การดำเนินการต่อไปนี้เป็นไปได้ใน Clojure เกี่ยวกับตัวแทน

ซีเนียร์ การดำเนินงานและคำอธิบาย
1 ตัวแทน

เอเจนต์ถูกสร้างขึ้นโดยใช้คำสั่งเอเจนต์

2 ส่ง

ฟังก์ชันนี้ใช้เพื่อส่งข้ามค่าไปยังเอเจนต์

3 ปิดตัวแทน

ฟังก์ชันนี้ใช้เพื่อปิดเอเจนต์ที่รันอยู่

4 ส่งออก

มีบางกรณีที่ตัวแทนถูกกำหนดฟังก์ชันซึ่งเป็นการปิดกั้นโดยธรรมชาติ

5 รอคอย

เนื่องจากมีความล่าช้าเมื่อมีการอัพเดตค่าของเอเจนต์ Clojure จึงจัดเตรียมฟังก์ชัน 'await-for' ซึ่งใช้เพื่อระบุเวลาเป็นมิลลิวินาทีเพื่อรอให้เอเจนต์ได้รับการอัพเดต

6 รอ

บล็อกเธรดปัจจุบัน (ไม่มีกำหนด!) จนกว่าการดำเนินการทั้งหมดที่ส่งจนถึงตอนนี้จากเธรดหรือเอเจนต์นี้ไปยังเอเจนต์จะเกิดขึ้น จะบล็อกตัวแทนที่ล้มเหลว

7 ข้อผิดพลาดของตัวแทน

ส่งคืนข้อยกเว้นที่เกิดขึ้นระหว่างการดำเนินการแบบอะซิงโครนัสของเอเจนต์หากเอเจนต์ล้มเหลว ส่งคืนค่าศูนย์ถ้าเอเจนต์ไม่ล้มเหลว

Watchersเป็นฟังก์ชันที่เพิ่มให้กับประเภทตัวแปรเช่นอะตอมและตัวแปรอ้างอิงซึ่งเรียกใช้เมื่อค่าของประเภทตัวแปรเปลี่ยนแปลง ตัวอย่างเช่นหากโปรแกรมเรียกใช้เปลี่ยนค่าของตัวแปรอะตอมและหากฟังก์ชันผู้เฝ้าดูติดอยู่กับตัวแปรอะตอมฟังก์ชันจะถูกเรียกใช้ทันทีที่ค่าของอะตอมเปลี่ยนไป

ฟังก์ชั่นต่อไปนี้มีอยู่ใน Clojure for Watchers

เพิ่มนาฬิกา

เพิ่มฟังก์ชั่นนาฬิกาให้กับการอ้างอิงตัวแทน / อะตอม / var / ref นาฬิกา‘fn’ต้องเป็น 'fn' จาก 4 args: คีย์การอ้างอิงสถานะเก่าสถานะใหม่ เมื่อใดก็ตามที่สถานะของการอ้างอิงอาจมีการเปลี่ยนแปลงนาฬิกาที่ลงทะเบียนใด ๆ จะมีฟังก์ชันที่เรียกว่า

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(add-watch variable :watcher
   (fn [key variable-type old-state new-state]))

Parameters- 'variable' คือชื่อของอะตอมหรือตัวแปรอ้างอิง 'variable-type' คือประเภทของตัวแปรทั้งอะตอมหรือตัวแปรอ้างอิง 'old-state & new-state' คือพารามิเตอร์ที่จะเก็บค่าเก่าและใหม่ของตัวแปรโดยอัตโนมัติ "คีย์" จะต้องไม่ซ้ำกันต่อการอ้างอิงและสามารถใช้เพื่อถอดนาฬิกาออกด้วยการถอดนาฬิกา

Return Value - ไม่มี

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def x (atom 0))
   (add-watch x :watcher
      (fn [key atom old-state new-state]
      (println "The value of the atom has been changed")
      (println "old-state" old-state)
      (println "new-state" new-state)))
(reset! x 2))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

The value of the atom has been changed
old-state 0
new-state 2

ถอดนาฬิกา

นำนาฬิกาที่ติดอยู่กับตัวแปรอ้างอิงออก

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(remove-watch variable watchname)

Parameters- 'variable' คือชื่อของอะตอมหรือตัวแปรอ้างอิง 'watchname' คือชื่อที่กำหนดให้กับนาฬิกาเมื่อมีการกำหนดฟังก์ชันนาฬิกา

Return Value - ไม่มี

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def x (atom 0))
   (add-watch x :watcher
      (fn [key atom old-state new-state]
         (println "The value of the atom has been changed")
         (println "old-state" old-state)
         (println "new-state" new-state)))
   (reset! x 2)
   (remove-watch x :watcher)
(reset! x 4))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

The value of the atom has been changed
old-state 0
new-state 2

คุณสามารถเห็นได้อย่างชัดเจนจากโปรแกรมด้านบนว่าคำสั่งรีเซ็ตครั้งที่สองไม่ทริกเกอร์ผู้เฝ้าดูเนื่องจากถูกลบออกจากรายการของผู้เฝ้าดู

ในภาษาใดก็ได้ Macrosใช้ในการสร้างรหัสแบบอินไลน์ Clojure ไม่มีข้อยกเว้นและมีสิ่งอำนวยความสะดวกมาโครที่เรียบง่ายสำหรับนักพัฒนา มาโครใช้ในการเขียนรูทีนการสร้างโค้ดซึ่งทำให้นักพัฒนามีวิธีที่มีประสิทธิภาพในการปรับแต่งภาษาตามความต้องการของนักพัฒนา

ต่อไปนี้เป็นวิธีการที่ใช้ได้สำหรับมาโคร

defmacro

ฟังก์ชันนี้ใช้เพื่อกำหนดมาโครของคุณ มาโครจะมีชื่อแมโครรายการพารามิเตอร์และเนื้อหาของแมโคร

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(defmacro name [params*] body)

Parameters- 'name' คือชื่อของมาโคร 'params' คือพารามิเตอร์ที่กำหนดให้กับมาโคร 'body' คือส่วนสำคัญของมาโคร

Return Value - ไม่มี

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (defmacro Simple []
      (println "Hello"))
   (macroexpand '(Simple)))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

Hello

จากโปรแกรมด้านบนคุณจะเห็นว่ามาโคร 'Simple' ถูกขยายในบรรทัดเป็น 'println'“ Hello” มาโครคล้ายกับฟังก์ชันโดยมีข้อแตกต่างเพียงประการเดียวที่อาร์กิวเมนต์ของฟอร์มจะได้รับการประเมินในกรณีของมาโคร

ขยายมาโคร

ใช้เพื่อขยายมาโครและวางโค้ดแบบอินไลน์ในโปรแกรม

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์

(macroexpand macroname)

Parameters - 'macroname' คือชื่อของมาโครที่ต้องขยาย

Return Value - มาโครขยาย

ตัวอย่าง

ตัวอย่างวิธีการใช้จะแสดงในโปรแกรมต่อไปนี้

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (defmacro Simple []
      (println "Hello"))
   (macroexpand '(Simple)))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

Hello

มาโครที่มีอาร์กิวเมนต์

มาโครสามารถใช้ในการโต้แย้งได้ มาโครสามารถรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถใช้อาร์กิวเมนต์ได้อย่างไร

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (defmacro Simple [arg]
      (list 2 arg))
   (println (macroexpand '(Simple 2))))
(Example)

ตัวอย่างข้างต้นวางอาร์กิวเมนต์ไว้ในมาโครแบบง่ายจากนั้นใช้อาร์กิวเมนต์เพื่อเพิ่มค่าอาร์กิวเมนต์ให้กับรายการ

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

(2 2)

Reference valuesเป็นอีกวิธีหนึ่งที่ Clojure สามารถทำงานกับความต้องการที่จะมีตัวแปรที่เปลี่ยนแปลงได้ Clojure จัดเตรียมชนิดข้อมูลที่เปลี่ยนแปลงได้เช่นอะตอมเอเจนต์และชนิดอ้างอิง

ต่อไปนี้เป็นการดำเนินการสำหรับค่าอ้างอิง

ซีเนียร์ การดำเนินงานและคำอธิบาย
1 อ้างอิง

ใช้เพื่อสร้างค่าอ้างอิง เมื่อสร้างค่าอ้างอิงมีตัวเลือกในการจัดเตรียมฟังก์ชันตัวตรวจสอบความถูกต้องซึ่งจะตรวจสอบความถูกต้องของค่าที่สร้างขึ้น

2 ตั้งค่าใหม่

ฟังก์ชันนี้ใช้เพื่อกำหนดค่าของการอ้างอิงเป็นค่าใหม่โดยไม่คำนึงว่าค่าใดจะเก่ากว่า

3 เปลี่ยนแปลง

ฟังก์ชันนี้ใช้เพื่อเปลี่ยนค่าของประเภทการอ้างอิง แต่ในลักษณะที่ปลอดภัย สิ่งนี้ถูกรันในเธรดซึ่งไม่สามารถเข้าถึงได้โดยกระบวนการอื่น

4 dosync

รันนิพจน์ (in an implicit do) ในธุรกรรมที่รวมนิพจน์และการเรียกที่ซ้อนกัน

5 การเดินทาง

การเดินทางยังใช้เพื่อเปลี่ยนค่าของประเภทการอ้างอิงเช่นเดียวกับการเปลี่ยนแปลงและการตั้งค่าอ้างอิง

ในการใช้ฟังก์ชันฐานข้อมูลโปรดดาวน์โหลดไฟล์ jdbc files จาก url ต่อไปนี้ - https://codeload.github.com/clojure/java.jdbc/zip/master

คุณจะพบไฟล์ zip ซึ่งมีไดรเวอร์ที่จำเป็นสำหรับ Clojure เพื่อให้มีความสามารถในการเชื่อมต่อกับฐานข้อมูล เมื่อแตกไฟล์ zip แล้วให้แน่ใจว่าได้เพิ่มตำแหน่งที่คลายซิปลงใน classpath ของคุณ

ไฟล์หลักสำหรับการเชื่อมต่อฐานข้อมูลคือไฟล์ที่เรียกว่า jdbc.clj ในตำแหน่ง clojure / java

ตัวเชื่อมต่อ clojure jdbc รองรับฐานข้อมูลที่หลากหลายซึ่งบางส่วนมีดังต่อไปนี้

  • H2Database
  • Oracle
  • Microsoft SQL Server
  • MySQL
  • PostgreSQL

ในตัวอย่างของเราเราจะใช้ MySQL DB เป็นตัวอย่าง

การดำเนินการต่อไปนี้เป็นไปได้ใน Clojure เกี่ยวกับฐานข้อมูล

การเชื่อมต่อฐานข้อมูล

ก่อนเชื่อมต่อกับฐานข้อมูล MySQL โปรดตรวจสอบสิ่งต่อไปนี้ -

  • คุณได้สร้างฐานข้อมูล TESTDB

  • คุณได้สร้างตาราง EMPLOYEE ใน TESTDB

  • ตารางนี้มีฟิลด์ FIRST_NAME, LAST_NAME, AGE, SEX และ INCOME

  • ID ผู้ใช้ "testuser" และรหัสผ่าน "test123" ถูกตั้งค่าให้เข้าถึง TESTDB

  • ตรวจสอบให้แน่ใจว่าคุณได้ดาวน์โหลด 'mysql jar file' และเพิ่มไฟล์ลงใน classpath ของคุณ

  • คุณได้ผ่าน MySQL กวดวิชาที่จะเข้าใจMySQL ข้อมูลพื้นฐานเกี่ยวกับ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์สำหรับสร้างการเชื่อมต่อใน Clojure

(def connection_name {
   :subprotocol “protocol_name”
   :subname “Location of mysql DB”
   :user “username” :password “password” })

Parameters- 'connection_name' คือชื่อที่กำหนดให้กับการเชื่อมต่อ 'subprotocol' คือโปรโตคอลที่จะใช้สำหรับการเชื่อมต่อ โดยค่าเริ่มต้นเราจะใช้โปรโตคอล mysql 'subname' คือ url สำหรับเชื่อมต่อกับ mysql db พร้อมกับชื่อฐานข้อมูล 'user' คือชื่อผู้ใช้ที่ใช้เชื่อมต่อกับฐานข้อมูล 'รหัสผ่าน' คือรหัสผ่านที่ใช้เชื่อมต่อกับฐานข้อมูล

Return Value - สิ่งนี้จะให้สตริงการเชื่อมต่อซึ่งสามารถใช้ในการดำเนินการ mysql ในภายหลัง

ตัวอย่างต่อไปนี้แสดงวิธีการเชื่อมต่อกับตารางในสคีมาข้อมูลและดึงข้อมูลทั้งหมดในตาราง

ตัวอย่าง

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/information_schema"
      :user "root"
      :password "shakinstev"})
   (println (sql/query mysql-db
      ["select table_name from tables"]
      :row-fn :table_name)))

การสืบค้นข้อมูล

การสืบค้นข้อมูลบนฐานข้อมูลใด ๆ หมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล เมื่อสร้างการเชื่อมต่อฐานข้อมูลแล้วคุณก็พร้อมที่จะทำการสืบค้นในฐานข้อมูลนี้ ต่อไปนี้เป็นไวยากรณ์ที่สามารถสืบค้นข้อมูลได้โดยใช้ Clojure

ไวยากรณ์

clojure.java.jdbc/query dbconn
["query"]
   :row-fn :sequence

Parameters- 'dbconn' คือชื่อของการเชื่อมต่อที่ใช้เชื่อมต่อกับฐานข้อมูล 'query' คือสตริงการสืบค้นที่ใช้ดึงข้อมูลจากฐานข้อมูล ': Sequence' เป็นค่าเริ่มต้นของข้อมูลทุกแถวที่ดึงมาจากฐานข้อมูลและจะส่งคืนเป็นลำดับ จากนั้นการดำเนินการที่จำเป็นในลำดับสามารถทำได้เพื่อดูว่ามีการดึงข้อมูลใดบ้าง

Return Value - สิ่งนี้จะส่งคืนลำดับซึ่งจะมีแถวของข้อมูลจากการดำเนินการสืบค้น

ตัวอย่างต่อไปนี้แสดงวิธีเชื่อมต่อกับตารางพนักงานและดึงคอลัมน์ first_name ของแถวในตาราง

ตัวอย่าง

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/query mysql-db
      ["select first_name from employee"]
      :row-fn :first_name)))

จากโค้ดด้านบนเราจะเห็นว่า

  • ข้อความค้นหาของ“ เลือกชื่อแรกจากพนักงาน” จะถูกส่งเป็นสตริงข้อความค้นหา

  • : first_name คือลำดับซึ่งส่งคืนเป็นผลมาจากการดำเนินการดึงข้อมูล

หากเราสมมติว่ามีเพียงแถวเดียวในฐานข้อมูลของเราซึ่งมีค่า first_name ของ John ต่อไปนี้จะเป็นผลลัพธ์ของโปรแกรมด้านบน

(John)

การแทรกข้อมูล

จำเป็นเมื่อคุณต้องการสร้างระเบียนของคุณลงในตารางฐานข้อมูล ต่อไปนี้เป็นไวยากรณ์ที่สามารถแทรกข้อมูลโดยใช้ Clojure ซึ่งทำได้โดยใช้ไฟล์‘insert!’ ฟังก์ชัน

ไวยากรณ์

clojure.java.jdbc/insert!
   :table_name {:column_namen columnvalue}

Parameters- ': table_name' คือชื่อของตารางที่จะต้องทำการแทรก '{: column_namen columnvalue}' คือแผนผังของชื่อคอลัมน์และค่าทั้งหมดซึ่งจำเป็นต้องเพิ่มเป็นแถวในตาราง

Return Value - สิ่งนี้จะคืนค่าศูนย์หากทำการแทรกสำเร็จ

ตัวอย่างต่อไปนี้แสดงวิธีการแทรกระเบียนลงในตารางพนักงานในฐานข้อมูล testdb

ตัวอย่าง

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (sql/insert! mysql-db
      :employee {:first_name "John" :last_name "Mark" :sex "M" :age 30 :income 30}))

หากคุณตรวจสอบฐานข้อมูล MySQL และตารางพนักงานแล้วคุณจะเห็นว่าแถวด้านบนจะถูกแทรกลงในตารางได้สำเร็จ

การลบข้อมูล

สามารถลบแถวออกจากตารางได้โดยใช้ไฟล์ ‘delete!’ฟังก์ชัน ต่อไปนี้เป็นไวยากรณ์เกี่ยวกับวิธีการดำเนินการนี้

ไวยากรณ์

clojure.java.jdbc/delete!
   :table_name [condition]

Parameters- ': table_name' คือชื่อของตารางที่จะต้องทำการแทรก 'condition' คือเงื่อนไขที่ใช้ในการกำหนดว่าจะต้องลบแถวใดออกจากตาราง

Return Value - จะส่งคืนจำนวนแถวที่ถูกลบ

ตัวอย่างต่อไปนี้แสดงวิธีการลบเรกคอร์ดจากตารางพนักงานในฐานข้อมูล testdb ตัวอย่างจะลบแถวออกจากตารางตามเงื่อนไขว่าอายุเท่ากับ 30

ตัวอย่าง

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/delete! mysql-db
      :employee ["age = ? " 30])))

หากคุณมีระเบียนที่มีแถวอายุเท่ากับค่า 30 แถวนั้นจะถูกลบ

กำลังอัปเดตข้อมูล

สามารถอัปเดตแถวจากตารางได้โดยใช้ไฟล์ ‘update!’ฟังก์ชัน ต่อไปนี้เป็นไวยากรณ์เกี่ยวกับวิธีการดำเนินการนี้

ไวยากรณ์

clojure.java.jdbc/update!
   :table_name
{setcondition}
[condition]

Parameters- ': table_name' คือชื่อของตารางที่จะต้องทำการแทรก 'setcondition' คือคอลัมน์ที่ต้องได้รับการอัปเดตตามที่กล่าวไว้ในแง่ของแผนที่ 'condition' คือเงื่อนไขที่ใช้ในการกำหนดว่าจะต้องลบแถวใดออกจากตาราง

Return Value - จะส่งคืนจำนวนแถวที่อัปเดต

ตัวอย่างต่อไปนี้แสดงวิธีการลบเรกคอร์ดจากตารางพนักงานในฐานข้อมูล testdb ตัวอย่างจะอัปเดตแถวจากตารางตามเงื่อนไขว่าอายุเท่ากับ 30 และอัปเดตมูลค่ารายได้เป็น 40

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/update! mysql-db
      :employee
      {:income 40}
      ["age = ? " 30])))

หากคุณมีระเบียนที่มีแถวที่มีอายุเท่ากับค่า 30 แถวนั้นจะได้รับการอัปเดตโดยมูลค่าของรายได้จะถูกกำหนดเป็น 40

ธุรกรรม

ธุรกรรมเป็นกลไกที่ทำให้ข้อมูลมีความสอดคล้องกัน ธุรกรรมมีคุณสมบัติสี่ประการดังต่อไปนี้ -

  • Atomicity - ไม่ว่าธุรกรรมจะเสร็จสมบูรณ์หรือไม่มีอะไรเกิดขึ้นเลย

  • Consistency - ธุรกรรมต้องเริ่มต้นในสถานะที่สอดคล้องกันและปล่อยให้ระบบอยู่ในสถานะที่สอดคล้องกัน

  • Isolation - ผลลัพธ์ระดับกลางของธุรกรรมจะไม่ปรากฏนอกธุรกรรมปัจจุบัน

  • Durability - เมื่อทำธุรกรรมแล้วผลกระทบจะคงอยู่แม้ระบบจะล้มเหลวก็ตาม

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงวิธีใช้ธุรกรรมใน Clojure การดำเนินการใด ๆ ที่ต้องดำเนินการในธุรกรรมจะต้องฝังอยู่ในไฟล์‘with-dbtransaction’ อนุประโยค

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (sql/with-db-transaction [t-con mysql-db]
      (sql/update! t-con
         :employee
         {:income 40}
         ["age = ? " 30])))

อย่างที่เราทราบกันดีอยู่แล้วว่าโค้ด Clojure ทำงานบนสภาพแวดล้อมเสมือน Java ในตอนท้าย ดังนั้นจึงมีเหตุผลเพียงว่า Clojure สามารถใช้ฟังก์ชันทั้งหมดจาก Java ได้ ในบทนี้เราจะมาพูดถึงความสัมพันธ์ระหว่าง Clojure และ Java

การเรียกใช้ Java Methods

สามารถเรียกเมธอด Java ได้โดยใช้สัญกรณ์จุด ตัวอย่างคือสตริง เนื่องจากสตริงทั้งหมดใน Clojure เป็นสตริง Java คุณสามารถเรียกใช้เมธอด Java ปกติบนสตริงได้

ตัวอย่างวิธีการทำจะแสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (println (.toUpperCase "Hello World")))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ คุณสามารถดูได้จากรหัสว่าถ้าคุณเรียกสัญกรณ์จุดสำหรับวิธีสตริงใด ๆ มันก็จะทำงานใน Clojure เช่นกัน

เอาต์พุต

HELLO WORLD

การเรียกใช้ Java Methods ด้วยพารามิเตอร์

คุณยังสามารถเรียกใช้เมธอด Java ด้วยพารามิเตอร์ ตัวอย่างวิธีการทำจะแสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (println (.indexOf "Hello World","e")))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ คุณสามารถดูได้จากโค้ดด้านบนว่าเรากำลังส่งพารามิเตอร์“ e” ไปยังเมธอด indexOf โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

1

การสร้าง Java Objects

สามารถสร้างออบเจ็กต์ใน Clojure ได้โดยใช้คีย์เวิร์ด 'new' คล้ายกับที่ทำใน Java

ตัวอย่างวิธีการทำจะแสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (def str1 (new String "Hello"))
   (println str1))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ คุณสามารถดูได้จากโค้ดด้านบนว่าเราสามารถใช้คีย์เวิร์ด 'new' เพื่อสร้างอ็อบเจกต์ใหม่จากคลาส String ที่มีอยู่จาก Java เราสามารถส่งผ่านค่าในขณะที่สร้างวัตถุได้เช่นเดียวกับที่เราทำใน Java โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

Hello

ต่อไปนี้เป็นอีกตัวอย่างหนึ่งที่แสดงให้เห็นว่าเราสามารถสร้างออบเจ็กต์ของคลาส Integer ได้อย่างไรและใช้ในคำสั่ง Clojure ปกติ

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (def my-int(new Integer 1))
   (println (+ 2 my-int)))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

3

นำเข้าคำสั่ง

เรายังสามารถใช้คำสั่ง import เพื่อรวมไลบรารี Java ไว้ในเนมสเปซเพื่อให้เข้าถึงคลาสและเมธอดได้ง่าย

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าเราสามารถใช้คำสั่ง import ได้อย่างไร ในตัวอย่างเราใช้คำสั่ง import เพื่ออิมพอร์ตคลาสจากไฟล์java.util.stackห้องสมุด. จากนั้นเราสามารถใช้วิธีการพุชและป๊อปของคลาสสแตกได้ตามที่เป็นอยู่

ตัวอย่าง

(ns Project
   (:gen-class))
(import java.util.Stack)
(defn Example []
   (let [stack (Stack.)]
   (.push stack "First Element")
   (.push stack "Second Element")
   (println (first stack))))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

First Element

การรันโค้ดโดยใช้คำสั่ง Java

โค้ด Clojure สามารถรันได้โดยใช้คำสั่ง Java ต่อไปนี้เป็นไวยากรณ์ของวิธีการนี้

java -jar clojure-1.2.0.jar -i main.clj

คุณต้องพูดถึงไฟล์ Clojure jar ดังนั้นคลาสที่ใช้ Clojure ทั้งหมดจะถูกโหลดใน JVM ไฟล์ 'main.clj' คือไฟล์รหัส Clojure ซึ่งจำเป็นต้องดำเนินการ

ฟังก์ชัน Java ในตัว

Clojure สามารถใช้ฟังก์ชันในตัวของ Java ได้หลายอย่าง บางคนเป็น -

Math PI function- Clojure สามารถใช้วิธีการทางคณิตศาสตร์กับค่าของ PI ต่อไปนี้เป็นโค้ดตัวอย่าง

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (println (. Math PI)))
(Example)

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

3.141592653589793

System Properties- Clojure ยังสามารถสอบถามคุณสมบัติของระบบได้ ต่อไปนี้เป็นโค้ดตัวอย่าง

ตัวอย่าง

(ns Project
   (:gen-class))
(defn Example []
   (println (.. System getProperties (get "java.version"))))
(Example)

ขึ้นอยู่กับเวอร์ชันของ Java บนระบบค่าที่เกี่ยวข้องจะปรากฏขึ้น ต่อไปนี้เป็นผลลัพธ์ตัวอย่าง

เอาต์พุต

1.8.0_45

ในการเขียนโปรแกรม Clojure ชนิดข้อมูลส่วนใหญ่ไม่เปลี่ยนรูปดังนั้นเมื่อพูดถึงการเขียนโปรแกรมพร้อมกันรหัสที่ใช้ประเภทข้อมูลเหล่านี้ค่อนข้างปลอดภัยเมื่อโค้ดทำงานบนโปรเซสเซอร์หลายตัว แต่หลายครั้งมีข้อกำหนดในการแบ่งปันข้อมูลและเมื่อพูดถึงข้อมูลที่ใช้ร่วมกันระหว่างโปรเซสเซอร์หลายตัวจำเป็นต้องตรวจสอบให้แน่ใจว่าสถานะของข้อมูลได้รับการดูแลในแง่ของความสมบูรณ์เมื่อทำงานกับโปรเซสเซอร์หลายตัว นี้เรียกว่าconcurrent programming และ Clojure ให้การสนับสนุนสำหรับการเขียนโปรแกรมดังกล่าว

ระบบหน่วยความจำธุรกรรมซอฟต์แวร์ (STM) ที่เปิดเผยผ่าน dosync, ref, set, alter และอื่น ๆ รองรับการแบ่งปันสถานะการเปลี่ยนระหว่างเธรดในลักษณะซิงโครนัสและประสานงานกัน ระบบเอเจนต์สนับสนุนการแบ่งปันสถานะการเปลี่ยนแปลงระหว่างเธรดในลักษณะอะซิงโครนัสและอิสระ ระบบอะตอมสนับสนุนการแบ่งปันสถานะการเปลี่ยนแปลงระหว่างเธรดในลักษณะซิงโครนัสและอิสระ ในขณะที่ระบบ var แบบไดนามิกที่เปิดเผยผ่าน def การโยง ฯลฯ สนับสนุนการแยกสถานะการเปลี่ยนแปลงภายในเธรด

ภาษาโปรแกรมอื่น ๆ ยังเป็นไปตามแบบจำลองสำหรับการเขียนโปรแกรมพร้อมกัน

  • พวกเขามีการอ้างอิงโดยตรงไปยังข้อมูลซึ่งสามารถเปลี่ยนแปลงได้

  • หากจำเป็นต้องมีการเข้าถึงแบบแบ่งใช้อ็อบเจ็กต์จะถูกล็อคค่าจะเปลี่ยนไปและกระบวนการจะดำเนินต่อไปสำหรับการเข้าถึงค่านั้นในครั้งถัดไป

ใน Clojure ไม่มีการล็อก แต่เป็นการอ้างอิงโดยอ้อมไปยังโครงสร้างข้อมูลถาวรที่ไม่เปลี่ยนรูป

การอ้างอิงใน Clojure มีสามประเภท

  • Vars - การเปลี่ยนแปลงจะแยกได้ในเธรด

  • Refs - การเปลี่ยนแปลงจะซิงโครไนซ์และประสานงานระหว่างเธรด

  • Agents - เกี่ยวข้องกับการเปลี่ยนแปลงอิสระแบบอะซิงโครนัสระหว่างเธรด

การดำเนินการต่อไปนี้เป็นไปได้ใน Clojure เกี่ยวกับการเขียนโปรแกรมพร้อมกัน

ธุรกรรม

ภาวะพร้อมกันใน Clojure ขึ้นอยู่กับธุรกรรม การอ้างอิงสามารถเปลี่ยนแปลงได้ภายในธุรกรรมเท่านั้น กฎต่อไปนี้ใช้ในการทำธุรกรรม

  • การเปลี่ยนแปลงทั้งหมดเป็นปรมาณูและโดดเดี่ยว
  • ทุกการเปลี่ยนแปลงในการอ้างอิงเกิดขึ้นในธุรกรรม
  • ไม่มีธุรกรรมใดที่เห็นผลของธุรกรรมอื่น
  • ธุรกรรมทั้งหมดจะอยู่ในบล็อก dosync

เราได้เห็นแล้วว่าบล็อก dosync ทำอะไรได้บ้างลองดูอีกครั้ง

dosync

รันนิพจน์ (in an implicit do) ในธุรกรรมที่รวมนิพจน์และการเรียกที่ซ้อนกัน เริ่มต้นธุรกรรมหากไม่มีการรันบนเธรดนี้ ข้อยกเว้นใด ๆ ที่ไม่ถูกจับจะยกเลิกการทำธุรกรรมและการไหลออกจาก dosync

ต่อไปนี้เป็นไวยากรณ์

ไวยากรณ์

(dosync expression)

Parameters - 'expression' คือชุดของนิพจน์ที่จะอยู่ในบล็อก dosync

Return Value - ไม่มี

ลองดูตัวอย่างที่เราพยายามเปลี่ยนค่าของตัวแปรอ้างอิง

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def names (ref []))
   (alter names conj "Mark"))
(Example)

เอาต์พุต

โปรแกรมข้างต้นเมื่อรันให้ข้อผิดพลาดต่อไปนี้

Caused by: java.lang.IllegalStateException: No transaction running
   at clojure.lang.LockingTransaction.getEx(LockingTransaction.java:208)
   at clojure.lang.Ref.alter(Ref.java:173)
   at clojure.core$alter.doInvoke(core.clj:1866)
   at clojure.lang.RestFn.invoke(RestFn.java:443)
   at clojure.examples.example$Example.invoke(main.clj:5) at clojure.examples.example$eval8.invoke(main.clj:7)
   at clojure.lang.Compiler.eval(Compiler.java:5424)
   ... 12 more

จากข้อผิดพลาดคุณจะเห็นได้อย่างชัดเจนว่าคุณไม่สามารถเปลี่ยนค่าของประเภทการอ้างอิงได้โดยไม่ต้องทำธุรกรรมก่อน

เพื่อให้โค้ดด้านบนทำงานได้เราต้องวางคำสั่ง alter ในบล็อก dosync ตามที่ทำในโปรแกรมต่อไปนี้

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def names (ref []))
   
   (defn change [newname]
      (dosync
         (alter names conj newname)))
   (change "John")
   (change "Mark")
   (println @names))
(Example)

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

[John Mark]

ลองดูตัวอย่างอื่นของ dosync

ตัวอย่าง

(ns clojure.examples.example
   (:gen-class))
(defn Example []
   (def var1 (ref 10))
   (def var2 (ref 20))
   (println @var1 @var2)
   
   (defn change-value [var1 var2 newvalue]
      (dosync
         (alter var1 - newvalue)
         (alter var2 + newvalue)))
   (change-value var1 var2 20)
   (println @var1 @var2))
(Example)

ในตัวอย่างข้างต้นเรามีค่าสองค่าที่กำลังเปลี่ยนแปลงในบล็อก dosync หากการทำธุรกรรมสำเร็จค่าทั้งสองจะเปลี่ยนไปมิฉะนั้นธุรกรรมทั้งหมดจะล้มเหลว

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

เอาต์พุต

10 20
-10 40

Clojure มีไลบรารีที่สนับสนุนซึ่งมีการเปิดใช้งานสำหรับการสร้าง Desktop และ Web-based applications. เรามาพูดคุยกัน

ซีเนียร์ การใช้งานและคำอธิบาย
1 เดสก์ท็อป - เห็นเลื่อย

See-saw เป็นไลบรารีที่สามารถใช้สำหรับสร้างแอปพลิเคชันบนเดสก์ท็อป

2 เดสก์ท็อป - การเปลี่ยนค่าของข้อความ

ค่าของเนื้อหาในหน้าต่างสามารถเปลี่ยนแปลงได้โดยใช้ ‘config!’ตัวเลือก ในตัวอย่างต่อไปนี้ config! ตัวเลือกนี้ใช้เพื่อเปลี่ยนเนื้อหาหน้าต่างเป็นค่าใหม่ของ“ Good Bye”

3 เดสก์ท็อป - กำลังแสดงกล่องโต้ตอบโมดอล

กล่องโต้ตอบโมดอลสามารถแสดงได้โดยใช้วิธีการแจ้งเตือนของคลาส see-saw เมธอดรับค่าข้อความซึ่งจะต้องแสดงในกล่องโต้ตอบโมดอล

4 เดสก์ท็อป - กำลังแสดงปุ่ม

ปุ่มสามารถแสดงได้ด้วยความช่วยเหลือของคลาสปุ่ม

5 เดสก์ท็อป - การแสดงฉลาก

ป้ายกำกับสามารถแสดงได้ด้วยความช่วยเหลือของคลาสเลเบล

6 เดสก์ท็อป - การแสดงฟิลด์ข้อความ

เขตข้อมูลข้อความสามารถแสดงได้ด้วยความช่วยเหลือของคลาสข้อความ

แอปพลิเคชันบนเว็บ - บทนำ

ในการสร้างเว็บแอปพลิเคชันใน Clojure คุณต้องใช้ไลบรารีแอปพลิเคชัน Ring ซึ่งมีอยู่ที่ลิงค์ต่อไปนี้ https://github.com/ring-clojure/ring

คุณต้องแน่ใจว่าคุณดาวน์โหลดขวดโหลที่จำเป็นจากไซต์และตรวจสอบให้แน่ใจว่าได้เพิ่มเป็นข้อมูลอ้างอิงสำหรับแอปพลิเคชัน Clojure

Ring framework มีความสามารถดังต่อไปนี้ -

  • ตั้งค่าสิ่งต่างๆเพื่อให้คำขอ http เข้ามาในเว็บแอปพลิเคชันของคุณเป็น Clojure HashMap ปกติและในทำนองเดียวกันทำให้คุณสามารถตอบกลับเป็น HashMap ได้

  • ระบุข้อกำหนดที่อธิบายว่าคำขอและแผนที่ตอบกลับควรมีลักษณะอย่างไร

  • นำไปตามเว็บเซิร์ฟเวอร์ (ท่าเทียบเรือ) และเชื่อมต่อเว็บแอปพลิเคชันของคุณกับมัน

เฟรมเวิร์ก Ring สามารถเริ่มต้นเว็บเซิร์ฟเวอร์โดยอัตโนมัติและทำให้มั่นใจว่าแอปพลิเคชัน Clojure ทำงานบนเซิร์ฟเวอร์นี้ จากนั้นเราสามารถใช้กรอบงาน Compojure สิ่งนี้ช่วยให้สามารถสร้างเส้นทางซึ่งปัจจุบันเป็นวิธีการพัฒนาเว็บแอปพลิเคชันที่ทันสมัยที่สุด

Creating your first Clojure application - ตัวอย่างต่อไปนี้แสดงวิธีสร้างเว็บแอปพลิเคชันแรกของคุณใน Clojure

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

มาดูด้านต่อไปนี้ของโปรแกรม -

  • ‘defroutes’ ใช้ในการสร้างเส้นทางเพื่อให้สามารถส่งคำขอไปยังเว็บแอปพลิเคชันไปยังเส้นทางต่างๆไปยังฟังก์ชันต่างๆในแอปพลิเคชัน Clojure ของคุณได้

  • ในตัวอย่างข้างต้น“ /” เรียกว่าเส้นทางเริ่มต้นดังนั้นเมื่อคุณเรียกดูฐานของเว็บแอปพลิเคชันของคุณสตริง“ Hello World” จะถูกส่งไปยังเว็บเบราว์เซอร์

  • หากผู้ใช้พบ url ใด ๆ ที่แอปพลิเคชัน Clojure ไม่สามารถประมวลผลได้ผู้ใช้จะแสดงสตริง "Not Found"

เมื่อคุณเรียกใช้แอปพลิเคชัน Clojure โดยค่าเริ่มต้นแอปพลิเคชันของคุณจะโหลดเป็น localhost: 3000 ดังนั้นหากคุณเรียกดูตำแหน่งนี้คุณจะได้รับผลลัพธ์ต่อไปนี้

แอปพลิเคชันเว็บ - การเพิ่มเส้นทางเพิ่มเติมให้กับแอปพลิเคชันเว็บของคุณ

คุณยังสามารถเพิ่มเส้นทางไปยังเว็บแอปพลิเคชันของคุณได้อีกด้วย ตัวอย่างต่อไปนี้แสดงวิธีการบรรลุเป้าหมายนี้

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (GET "/Tutorial" [] "This is a tutorial on Clojure")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

คุณจะเห็นได้ว่าการเพิ่มเส้นทางในแอปพลิเคชันนั้นง่ายดายเพียงแค่เพิ่มฟังก์ชัน GET อื่นด้วยเส้นทาง url (GET "/ บทช่วยสอน" [] "นี่คือการสอนเกี่ยวกับ Clojure")

หากคุณเรียกดูสถานที่ http://localhost:3000/Tutorialคุณจะได้รับผลลัพธ์ต่อไปนี้

ในบทนี้เราจะมาพูดถึงตัวเลือกการทดสอบอัตโนมัติที่ Clojure มีให้

การทดสอบแอปพลิเคชันไคลเอนต์

ในการใช้การทดสอบสำหรับ Clojure framework คุณต้องใช้การอ้างอิงที่อยู่ที่ https://github.com/slagyr/speclj#manual-installation

URL นี้ให้ไฟล์ specljเฟรมเวิร์กซึ่งใช้เป็นเฟรมเวิร์กการทดสอบที่ขับเคลื่อนด้วยข้อมูลหรือพฤติกรรมสำหรับ Clojure คุณต้องแน่ใจว่าคุณใช้เฟรมเวิร์ก Clojure 1.7.0 เมื่อใช้ไลบรารี 'speclj' ใด ๆ โดยค่าเริ่มต้นไฟล์ทดสอบจะแตกต่างจากไฟล์โค้ด Clojure และจำเป็นต้องวางไว้ในไดเร็กทอรี 'spec'

ต่อไปนี้เป็นโค้ดตัวอย่างสำหรับไฟล์ทดสอบ

(ns change.core-spec
   (:require [speclj.core :refer :all]))
(describe "Truth"
   (it "is true"
   (should true))
   (it "is not false"
   (should-not false)))
(run-specs)

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับรหัสด้านบน -

  • ก่อนอื่นเราต้องตรวจสอบให้แน่ใจว่าได้ใช้คำสั่ง 'require' เพื่อรวมไลบรารีหลักทั้งหมดในกรอบงาน 'speclj'

  • ถัดไปคือฟังก์ชัน 'อธิบาย' ใช้เพื่อให้คำอธิบายสำหรับกรณีทดสอบที่สร้างขึ้น

  • ฟังก์ชันถัดไปคือฟังก์ชัน 'it' ซึ่งเป็นกรณีทดสอบจริง ในกรณีทดสอบแรกสตริง "เป็นจริง" คือชื่อที่กำหนดให้กับกรณีทดสอบ

  • สิ่งที่ควรและไม่ควรเรียกว่า assertions. การยืนยันทั้งหมดเริ่มต้นด้วยควร ข้อควรและไม่ควรเป็นเพียงสองข้อยืนยันที่มีอยู่ ทั้งคู่ใช้นิพจน์ที่จะตรวจสอบความจริงและความเท็จตามลำดับ

หากคุณเรียกใช้กรณีทดสอบคุณจะได้ผลลัพธ์ดังต่อไปนี้ เอาต์พุตจะแสดงเวลาที่ใช้เป็นมิลลิวินาทีเพื่อให้กรณีทดสอบทำงาน

←[32m.←[0m←[32m.←[0m
Finished in 0.00014 seconds

การทดสอบแอปพลิเคชันบนเว็บ

Seleniumเป็นหนึ่งในกรอบสำคัญที่ใช้สำหรับการทดสอบแอปพลิเคชันบนเว็บในปัจจุบัน นอกจากนี้ยังมีไลบรารี Clojure ซึ่งสามารถใช้สำหรับการทดสอบแอปพลิเคชันบนเว็บ

มาดูกันว่าเราจะใช้ไลบรารี Selenium เพื่อทดสอบแอปพลิเคชันบนเว็บ Clojure ได้อย่างไร

Step 1- ขั้นตอนแรกคือตรวจสอบให้แน่ใจว่าเรากำลังใช้กรอบงาน Ring และ Compojure เพื่อสร้างแอปพลิเคชันบนเว็บซึ่งจะต้องมีการทดสอบ ลองใช้หนึ่งในตัวอย่างจากบทก่อนหน้าของเรา โค้ดต่อไปนี้เป็นเว็บแอปพลิเคชันธรรมดาซึ่งแสดงคำว่า“ Hello World” ในเบราว์เซอร์

(ns my-webapp.handler
   (:require [compojure.core :refer :all]
      [compojure.route :as route]
      [ring.middleware.defaults :refer [wrap-defaults site-defaults]]))
(defroutes app-routes
   (GET "/" [] "Hello World")
   (route/not-found "Not Found"))
(def app
   (wrap-defaults app-routes site-defaults))

Step 2 - ถัดไปอย่าลืมดาวน์โหลดไฟล์ซีลีเนียม jar https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-server/2.47.0 และรวมไว้ใน classpath ของคุณ

Step 3 - ตรวจสอบให้แน่ใจว่าได้ดาวน์โหลดไดรเวอร์เว็บ 'clj' ซึ่งจะใช้สำหรับการเรียกใช้การทดสอบเว็บจากตำแหน่งต่อไปนี้

https://clojars.org/clj-webdriver/versions/0.7.1

Step 4 - ในไดเร็กทอรีโปรเจ็กต์ของคุณให้สร้างไดเร็กทอรีอื่นที่เรียกว่าคุณสมบัติและสร้างไฟล์ชื่อ 'config.clj'

Step 5 - จากนั้นเพิ่มรหัสต่อไปนี้ในไฟล์ 'config.clj' ที่สร้างในขั้นตอนก่อนหน้านี้

ns clj-webdriver-tutorial.features.config)
(def test-port 3000)
(def test-host "localhost")
(def test-base-url (str "http://" test-host ":" test-port "/"))

โค้ดด้านบนโดยทั่วไปจะบอกกรอบการทดสอบเว็บเพื่อทดสอบแอปพลิเคชันซึ่งโหลดที่ URL http://localhost:3000

Step 6 - สุดท้ายมาเขียนโค้ดของเราเพื่อทำการทดสอบ

(ns clj-webdriver-tutorial.features.homepage
   (:require [clojure.test :refer :all]
      [ring.adapter.jetty :refer [run-jetty]]
      [clj-webdriver.taxi :refer :all]
      [clj-webdriver-tutorial.features.config :refer :all]
      [clj-webdriver-tutorial.handler :refer [app-routes]]))
(ns clj-webdriver-tutorial.features.homepage
   (:require [clojure.test :refer :all]
      [ring.adapter.jetty :refer [run-jetty]]
      [clj-webdriver.taxi :refer :all]
      [clj-webdriver-tutorial.features.config :refer :all]
      [clj-webdriver-tutorial.handler :refer [app-routes]]))
(defn start-server []
   (loop [server (run-jetty app-routes {:port test-port, :join? false})]
      (if (.isStarted server)
         server
         (recur server))))
(defn stop-server [server]
   (.stop server))
(defn start-browser []
   (set-driver! {:browser :firefox}))
(defn stop-browser []
   (quit))
(deftest homepage-greeting
   (let [server (start-server)]
      (start-browser)
      (to test-base-url)
      (is (= (text "body") "Hello World"))
      (stop-browser)
      (stop-server server)))

โค้ดด้านบนจะดำเนินการต่อไปนี้ -

  • เริ่มต้นเซิร์ฟเวอร์สำหรับแอปพลิเคชัน
  • เปิดรูทพา ธ ในเบราว์เซอร์
  • ตรวจสอบว่ามีข้อความ "Hello World" อยู่บนหน้าหรือไม่
  • ปิดเบราว์เซอร์
  • ปิดเซิร์ฟเวอร์

สิ่งหนึ่งที่ทำให้ไลบรารี Clojure มีประสิทธิภาพมากคือจำนวนไลบรารีที่พร้อมใช้งานสำหรับเฟรมเวิร์ก Clojure เราได้เห็นไลบรารีจำนวนมากที่ใช้ในตัวอย่างก่อนหน้านี้สำหรับการทดสอบเว็บการพัฒนาเว็บการพัฒนาแอพพลิเคชั่นแบบสวิงไลบรารี jdbc สำหรับเชื่อมต่อกับฐานข้อมูล MySQL ต่อไปนี้เป็นเพียงตัวอย่างบางส่วนของไลบรารีอีกสองสามแห่ง

data.xml

ไลบรารีนี้อนุญาตให้ Clojure ทำงานกับข้อมูล XML เวอร์ชันไลบรารีที่จะใช้คือ org.clojure / data.xml "0.0.8" data.xml รองรับการแยกวิเคราะห์และเปล่ง XML ฟังก์ชันการแยกวิเคราะห์จะอ่าน XML จาก Reader หรือ InputStream

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการประมวลผลข้อมูลจากสตริงเป็น XML

(ns clojure.examples.example
   (use 'clojure.data.xml)
   (:gen-class))
(defn Example []
   (let [input-xml (java.io.StringReader. "<?xml version = \"1.0\"
      encoding = \"UTF-8\"?><example><clo><Tutorial>The Tutorial
      value</Tutorial></clo></example>")]
      (parse input-xml)))

#clojure.data.xml.Element{
   :tag :example, :attrs {}, :content (#clojure.data.xml.Element {
      :tag :clo, :attrs {}, :content (#clojure.data.xml.Element {
         :tag :Tutorial, :attrs {},:content ("The Tutorial value")})})}
(Example)

data.json

ไลบรารีนี้อนุญาตให้ Clojure ทำงานกับข้อมูล JSON เวอร์ชันไลบรารีที่จะใช้คือ org.clojure / data.json "0.2.6"

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างการใช้ไลบรารีนี้

(ns clojure.examples.example
   (:require [clojure.data.json :as json])
   (:gen-class))
(defn Example []
   (println (json/write-str {:a 1 :b 2})))
(Example)

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้

{\"a\":1,\"b\":2}

data.csv

ไลบรารีนี้อนุญาตให้ Clojure ทำงานร่วมกับ ‘csv’ข้อมูล. เวอร์ชันไลบรารีที่จะใช้คือ org.clojure / data.csv "0.1.3"

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างการใช้ไลบรารีนี้

(ns clojure.examples.example
   (require '[clojure.data.csv :as csv]
      '[clojure.java.io :as io])
   (:gen-class))
(defn Example []
   (with-open [in-file (io/reader "in-file.csv")]
      (doall
      (csv/read-csv in-file)))
   (with-open [out-file (io/writer "out-file.csv")]
   (csv/write-csv out-file
      [[":A" "a"]
      [":B" "b"]])))
(Example)

ในโค้ดด้านบนฟังก์ชัน 'csv' จะอ่านไฟล์ที่เรียกว่า in-file.csvและใส่ข้อมูลทั้งหมดลงในตัวแปรในไฟล์ ต่อไปเรากำลังใช้ฟังก์ชัน write-csv เพื่อเขียนข้อมูลทั้งหมดไปยังไฟล์ที่เรียกว่าout-file.csv.