Unearthing ClojureScript สำหรับการพัฒนาส่วนหน้า

เผยแพร่แล้ว: 2022-03-11

อาจมีสองความคิดหลักในหัวของคุณในขณะที่คุณอ่านบทนำนี้:

  1. ClojureScript คืออะไร?
  2. สิ่งนี้ไม่เกี่ยวข้องกับความสนใจของฉัน

แต่เดี๋ยวก่อน! นั่นคือสิ่งที่คุณคิดผิด—และฉันจะพิสูจน์ให้คุณเห็น หากคุณยินดีสละเวลา 10 นาที ฉันจะแสดงให้คุณเห็นว่า ClojureScript สามารถทำให้การเขียนแอปพลิเคชันส่วนหน้าและ React-y เป็นเรื่องสนุก รวดเร็ว และที่สำคัญที่สุดคือ ใช้งาน ได้อย่างไร

ข้อกำหนดเบื้องต้นของการสอน ClojureScript

  • ไม่จำเป็นต้องมีความรู้เสียงกระเพื่อม ฉันจะพยายามอธิบายตัวอย่างโค้ดที่กระจัดกระจายในโพสต์บล็อกนี้อย่างเต็มที่
  • อย่างไรก็ตาม หาก คุณ ต้องการอ่านล่วงหน้าสักเล็กน้อย ฉันขอแนะนำ https://www.braveclojure.com/ ร้านค้าครบวงจรสำหรับการเริ่มต้นกับ Clojure (และโดยส่วนขยายคือ ClojureScript)
  • Clojure และ ClojureScript ใช้ภาษาเดียวกัน—ฉันมักจะอ้างถึงสิ่งเหล่านี้พร้อมกันกับ Clojure[Script]
  • ฉัน คิดว่าคุณมีความรู้เกี่ยวกับ React และความรู้ส่วนหน้าทั่วไป

วิธีการเรียนรู้ ClojureScript: เวอร์ชันสั้น

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

จากเว็บไซต์ ClojureScript: ClojureScript เป็นคอมไพเลอร์สำหรับ Clojure ที่กำหนดเป้าหมายไปที่ JavaScript มันส่งรหัส JavaScript ซึ่งเข้ากันได้กับโหมดการรวบรวมขั้นสูงของคอมไพเลอร์การเพิ่มประสิทธิภาพ Google Closure

เหนือสิ่งอื่นใด ClojureScript มีหลายสิ่งให้คุณ:

  • เป็นภาษาโปรแกรมแบบหลายกระบวนทัศน์ที่มีการเขียนโปรแกรมเชิงฟังก์ชันแบบลีน การเขียนโปรแกรมเชิงฟังก์ชันเป็นที่รู้จักในการ ปรับปรุงความชัดเจนของโค้ด รวมทั้งช่วยให้คุณ เขียนได้มากขึ้นโดยใช้โค้ดน้อยลง
  • รองรับความไม่เปลี่ยนรูปตามค่าเริ่มต้น—บอกลาปัญหารันไทม์ทั้งชุด!
  • เน้นข้อมูล: รหัสคือข้อมูล ใน ClojureScript แอปพลิเคชัน Clojure[สคริปต์] ส่วนใหญ่สามารถลดขนาดลงเป็นชุดของฟังก์ชันที่ทำงานบนโครงสร้างข้อมูลพื้นฐานบางอย่าง ซึ่งทำให้การดีบักเป็นเรื่องง่ายและโค้ดที่อ่านง่าย
  • มันง่าย! เริ่มต้นใช้งาน ClojureScript ได้ง่าย—ไม่มีคีย์เวิร์ดที่แฟนซีและมีเวทย์มนตร์เพียงเล็กน้อย
  • มีห้องสมุดมาตรฐานที่ยอดเยี่ยม สิ่งนี้มีทุกอย่าง

ด้วยวิธีนั้น เรามาเปิดเวิร์มกระป๋องนี้ด้วยตัวอย่าง:

 (defn component [] [:div "Hello, world!"])

หมายเหตุสำหรับผู้ที่ไม่คุ้นเคยกับ Lisp dialect หรือ ClojureScript: ส่วนที่สำคัญที่สุดของตัวอย่างนี้คือ :div , [] และ () :div เป็นคีย์เวิร์ดที่แสดงองค์ประกอบ <div> [] เป็นเวกเตอร์ เหมือนกับ ArrayList ใน Java และ () เป็นลำดับ เหมือนกับ LinkedList ฉันจะพูดถึงรายละเอียดเพิ่มเติมในภายหลังในโพสต์นี้!

นี่เป็นรูปแบบพื้นฐานที่สุดขององค์ประกอบ React ใน ClojureScript แค่นั้นแหละ—แค่คีย์เวิร์ด สตริง และรายการทั้งหมด

ฮี้ คุณบอกว่าไม่ต่างจาก "สวัสดีชาวโลก" ใน JSX หรือ TSX มากนัก:

 function component() { return ( <div> "Hello, world!" </div> ); }

อย่างไรก็ตาม มีความแตกต่างที่สำคัญบางประการที่เราสามารถมองเห็นได้จากตัวอย่างพื้นฐานนี้:

  • ไม่มีภาษาฝังตัว ทุกอย่างในตัวอย่าง ClojureScript เป็นสตริง คีย์เวิร์ด หรือรายการ
  • มัน รัดกุม ; รายการให้การแสดงออกทั้งหมดที่เราต้องการโดยไม่ต้องมีความซ้ำซ้อนของแท็กปิด HTML

ความแตกต่างเล็กๆ น้อยๆ ทั้งสองนี้มีผลที่ตามมาอย่างมาก ไม่ใช่แค่วิธี เขียน โค้ดเท่านั้น แต่ยังส่งผลต่อการแสดงออกด้วย!

เป็นอย่างไรบ้าง คุณถาม? มาเริ่มการต่อสู้กันและดูว่า ClojureScript มีอะไรอีกบ้างที่รอเราอยู่...

ที่เกี่ยวข้อง:
  • เริ่มต้นใช้งาน Elm Programming Language
  • เริ่มต้นใช้งาน Elixir Programming Language

การก่อสร้างตึก

ตลอดบทช่วยสอน ClojureScript นี้ ฉันจะพยายามไม่เจาะลึกถึงสิ่งที่ทำให้ Clojure[Script] ยอดเยี่ยม (ซึ่งมีหลายอย่าง แต่ฉันพูดนอกเรื่อง) อย่างไรก็ตาม มันจะมีประโยชน์ที่จะครอบคลุมแนวคิดพื้นฐานบางประการ ดังนั้นจึงเป็นไปได้ที่จะเข้าใจความกว้างของสิ่งที่เราสามารถทำได้ที่นี่

สำหรับผู้มีประสบการณ์ Clojuristas และ Lispians อย่าลังเลที่จะข้ามไปยังส่วนถัดไป!

มีสามแนวคิดหลักที่ฉันจะต้องกล่าวถึงก่อน:

คีย์เวิร์ด

Clojure[สคริปต์] มีแนวคิดที่เรียกว่าคำหลัก มันอยู่ที่ไหนสักแห่งระหว่างสตริงคงที่ (เช่นใน Java) และคีย์ สิ่งเหล่านี้เป็น ตัวระบุเชิงสัญลักษณ์ที่ประเมินด้วยตนเอง

ตัวอย่างเช่น คีย์เวิร์ด :cat จะอ้างอิงถึง :cat เสมอ และไม่พูดถึงอย่างอื่น เช่นเดียวกับใน Java คุณอาจพูดว่า:

 private static const String MY_KEY = "my_key"; // ... myMap.put(MY_KEY, thing); // ... myMap.get(MY_KEY);

…ใน Clojure คุณจะมี:

 (assoc my-map :my-key thing) (my-map :my-key) ; equivalent to (:my-key my-map) ...nice and flexible!

หมายเหตุเพิ่มเติม: ใน Clojure แผนที่เป็นทั้งคอลเลกชั่น (ของคีย์สู่ค่า เช่นเดียวกับ Java HashMap ) และฟังก์ชันสำหรับเข้าถึงเนื้อหา ประณีต!

รายการ

Clojure[สคริปต์] เป็นภาษา Lisp หมายความว่ามันให้ความสำคัญกับรายการเป็นอย่างมาก ดังที่ได้กล่าวไว้ข้างต้น มีสองสิ่งสำคัญที่ควรทราบ:

  1. [] เป็นเวกเตอร์ เหมือนกับ ArrayList
  2. () เป็นซีเควนซ์ เหมือนกับ LinkedList

ในการสร้างรายการสิ่งต่าง ๆ ใน Clojure[Script] คุณทำดังต่อไปนี้:

 [1 2 3 4] ["hello" "world"] ["my" "list" "contains" 10 "things"] ; you can mix and match types ; in Clojure lists!

สำหรับซีเควนซ์ จะต่างออกไปเล็กน้อย:

 '(1 2 3 4) '("hello" "world")

คำนำ ' จะอธิบายในหัวข้อถัดไป

ฟังก์ชั่น

ในที่สุด เราก็มีฟังก์ชั่น ฟังก์ชันใน Clojure[Script] คือ ลำดับ ที่พิมพ์ โดยไม่ต้องเติม ' องค์ประกอบแรกของรายการนั้นเป็นฟังก์ชัน และองค์ประกอบต่อไปนี้ทั้งหมดจะเป็น อาร์กิวเมนต์ ตัวอย่างเช่น:

 (+ 1 2 3 4) ; -> 10 (str "hello" " " "world") ; -> "hello world" (println "hi!") ; prints "hi!" to the console (run-my-function) ; runs the function named `run-my-function`

ผลสืบเนื่องประการหนึ่งของพฤติกรรมนี้คือคุณสามารถสร้างคำจำกัดความของฟังก์ชันโดยไม่ต้องดำเนินการจริง! เฉพาะลำดับ 'เปล่า' เท่านั้นที่จะถูกดำเนินการเมื่อโปรแกรมได้รับการประเมิน

 (+ 1 1) ; -> 2 '(+ 1 1); -> a list of a function and two numbers

สิ่งนี้จะมีความเกี่ยวข้องในภายหลัง!

ฟังก์ชั่นสามารถกำหนดได้สองสามวิธี:

 ; A normal function definition, assigning the function ; to the symbol `my-function` (defn my-function [arg1 arg2] (+ arg1 arg2)) ; An anonymous function that does the same thing as the above (fn [arg1 arg2] (+ arg1 arg2)) ; Another, more concise variation of the above #(+ %1 %2)

การตรวจสอบอย่างใกล้ชิด

ตอนนี้เราได้ครอบคลุมพื้นฐานแล้ว เรามาเจาะลึกรายละเอียดกันมากขึ้นเพื่อดูว่าเกิดอะไรขึ้นที่นี่

โดยทั่วไป React ใน ClojureScript จะทำโดยใช้ไลบรารีชื่อ Reagent รีเอเจนต์ใช้ Hiccup และไวยากรณ์เพื่อแสดง HTML จากวิกิของ Hiccup repo:

“ฮิคคัพเปลี่ยนโครงสร้างข้อมูล Clojure แบบนี้:”

 [:a {:href "http://github.com"} "GitHub"]

“เป็นสตริงของ HTML เช่นนี้:”

 <a href="http://github.com">GitHub</a>

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

องค์ประกอบสามารถซ้อนกันภายในกันได้เพียงแค่ซ้อนภายในรายการของผู้ปกครอง! เห็นได้ง่ายที่สุดด้วยตัวอย่าง:

 [:div [:h1 "This is a header"] [:p "And in the next element we have 1 + 1"] [:p (+ 1 1)]]

สังเกตว่าเราสามารถใส่ฟังก์ชันเก่าหรือไวยากรณ์ Clojure ทั่วไปภายในโครงสร้างของเราได้อย่างไรโดยไม่ต้องประกาศวิธีการฝังอย่างชัดเจน มันเป็นเพียงรายการหลังจากทั้งหมด!

และยิ่งไปกว่านั้น ค่านี้มีค่าเท่ากับอะไร ณ รันไทม์

 [:div [:h1 "This is a header"] [:p "And in the next element we have 1 + 1"] [:p 2]]

รายการคีย์เวิร์ดและเนื้อหาแน่นอน! ไม่มีประเภทตลก ๆ ไม่มีวิธีการซ่อนเวทย์มนตร์ มันเป็นเพียงรายการเก่าธรรมดาของสิ่งต่าง ๆ คุณสามารถประกบและเล่นกับรายการนี้ได้มากเท่าที่คุณต้องการ—สิ่งที่คุณเห็นคือสิ่งที่คุณได้รับ

เมื่อ Hiccup ทำเลย์เอาต์และรีเอเจนต์ทำการประมวลผลตรรกะและเหตุการณ์ เราก็ได้สภาพแวดล้อม React ที่ทำงานได้อย่างสมบูรณ์

ตัวอย่างที่ซับซ้อนมากขึ้น

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

สมมติว่าเราสร้างส่วนประกอบง่ายๆ ที่แสดงปุ่มและตรรกะง่ายๆ บางอย่าง:

 ; widget.cljs (defn component [polite?] [:div [:p (str "Do not press the button" (when polite? ", please."))] [:input {:type "button" :value "PUSH ME" :on-click #(js/alert "What did I tell you?")}]])

บันทึกย่อเกี่ยวกับการตั้งชื่อ: โดยปกติ โมดูลใน Clojure จะถูกเนมสเปซ ดังนั้น widget.cljs อาจถูกนำเข้าภายใต้ widget เนมสเปซ ซึ่งหมายความว่าจะเข้าถึงฟังก์ชัน component ระดับบนสุดเป็น widget/component ฉันชอบที่จะมีองค์ประกอบระดับบนสุดเพียงองค์ประกอบเดียวต่อโมดูล แต่นี่เป็นการกำหนดลักษณะรูปแบบ—คุณอาจต้องการตั้งชื่อฟังก์ชันองค์ประกอบของคุณบางอย่าง เช่น polite-component หรือ widget-component

องค์ประกอบที่เรียบง่ายนี้นำเสนอวิดเจ็ตแบบสุภาพ (when polite? ", please.") ประเมินเป็น ", please." เมื่อ polite? == true polite? == true และ to nil เมื่อเป็น false

ตอนนี้เรามาฝังสิ่งนี้ไว้ใน app.cljs ของเรา:

 (defn app [] [:div [:h1 "Welcome to my app"] [widget/component true]])

ที่นี่เราฝังวิดเจ็ตของเราไว้ในองค์ประกอบแอปของเราโดยเรียกมันว่าเป็นรายการแรกของรายการ เช่นเดียวกับคำหลัก HTML! จากนั้นเราสามารถส่งลูกหรือพารามิเตอร์ไปยังส่วนประกอบโดยกำหนดให้เป็นองค์ประกอบอื่นๆ ในรายการเดียวกัน ที่นี่เราเพียงแค่ผ่าน true ดังนั้นในวิดเจ็ตของเรา polite? == true polite? == true ดังนั้นเราจึงได้รับเวอร์ชันที่สุภาพ

หากเราต้องประเมินฟังก์ชันแอปของเราตอนนี้ เราจะได้สิ่งต่อไปนี้:

 [:div [:h1 "Welcome to my app"] [widget/component true]] ; <- widget/component would look more like a ; function reference, but I have kept it ; clean for legibility.

โปรดทราบว่า widget/component ยังไม่ได้รับการประเมิน! (ดูส่วนฟังก์ชันหากคุณสับสน)

ส่วนประกอบภายในแผนผัง DOM ของคุณจะถูกประเมินเท่านั้น (และจะถูกแปลงเป็นวัตถุ React จริงเบื้องหลัง) หากได้รับการอัปเดต ซึ่งช่วยให้สิ่งต่างๆ ดูดีและฉับไว และลดความซับซ้อนที่คุณต้องจัดการเมื่อใดก็ได้

รายละเอียดเพิ่มเติมเกี่ยวกับเรื่องนี้สำหรับผู้ที่สนใจสามารถหาได้ในเอกสารรีเอเจนต์

รายการลงจนสุด

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

เพราะ ทุกสิ่งที่คุณสามารถทำได้กับฟังก์ชันหรือรายการ คุณสามารถทำกับส่วนประกอบได้

นี่คือที่ที่คุณเริ่มรับผลตอบแทนแบบทบต้นโดยใช้ภาษา Lisp เช่น ClojureScript: ส่วนประกอบและองค์ประกอบ HTML ของคุณกลายเป็นออบเจ็กต์ชั้นหนึ่งที่คุณสามารถจัดการได้เหมือนกับข้อมูลทั่วไปอื่น ๆ ให้ฉันพูดอีกครั้ง:

ส่วนประกอบและองค์ประกอบ HTML เป็นอ็อบเจกต์ที่รองรับระดับเฟิร์สคลาสภายในภาษา Clojure!

ถูกต้องคุณได้ยินฉัน เกือบจะเหมือนกับ Lisps ได้รับการออกแบบมาเพื่อประมวลผลรายการ (คำใบ้: พวกเขาเป็น)

ซึ่งรวมถึงสิ่งต่างๆ เช่น

  • การทำแผนที่เหนือองค์ประกอบของรายการลำดับเลข:
 (def words ["green" "eggs" "and" "ham"]) (defn li-shout [x] [:li (string/uppercase x)) (concat [:ol] (map li-shout words) ; becomes [:ol [:li "GREEN"] [:li "EGGS"] [:li "AND"] [:li "HAM"]]
  • ส่วนประกอบห่อหุ้ม:
 ; in widget.cljs (defn greeting-component [name] [:div [:p (str "Hiya " name "!")]]) ; ... (def shouty-greeting-component #(widget/greeting-component (string/uppercase %))) (defn app [] [:div [:h1 "My App"] [shouty-greeting-component "Luke"]]) ; <- will show Hiya LUKE!
  • คุณสมบัติการฉีด:
 (def default-btn-attrs {:type "button" :value "I am a button" :class "my-button-class"}) (defn two-button-component [] [:div [:input (assoc default-btn-attrs :on-click #(println "I do one thing"))] [:input (assoc default-btn-attrs :on-click #(println "I do a different thing"))]])

การจัดการกับประเภทข้อมูลธรรมดาๆ อย่างรายการและแผนที่นั้นง่ายกว่าอย่างมากเมื่อเทียบกับคลาสใด ๆ และจบลงด้วยประสิทธิภาพที่มากกว่าในระยะยาว!

รูปแบบโผล่ออกมา

โอเค มาสรุปกัน บทช่วยสอน ClojureScript ของเราแสดงให้เห็นอะไรบ้าง?

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

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

เริ่มมีสไตล์

ตอนนี้เรารู้วิธีสร้างแอปพลิเคชันด้วยฟังก์ชันพื้นฐานแล้ว มาดูวิธีทำให้แอปพลิเคชันดูดีกันดีกว่า มีสองวิธีในการดำเนินการนี้ วิธีที่ง่ายที่สุดคือใช้สไตล์ชีตและอ้างอิงคลาสในคอมโพเนนต์ของคุณ:

 .my-class { color: red; }
 [:div {:class "my-class"} "Hello, world!"]

สิ่งนี้จะเป็นไปตามที่คุณคาดไว้โดยนำเสนอ "สวัสดีชาวโลก!" ที่สวยงามสีแดง ข้อความ.

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

ทำไมไม่เขียน CSS เป็น โค้ดในส่วนประกอบของเรา (ดูธีมที่นี่) สิ่งนี้จะให้ข้อดีหลายประการแก่เรา:

  • ทุกอย่างที่กำหนดองค์ประกอบอยู่ในที่เดียวกัน
  • ชื่อคลาสสามารถรับประกันได้ว่าไม่ซ้ำใครผ่านการสร้างที่ชาญฉลาด
  • CSS สามารถเป็นไดนามิก โดยเปลี่ยนแปลงเมื่อข้อมูลของเราเปลี่ยนแปลง

รสชาติที่ฉันชอบที่สุดของ CSS-in-code คือ Clojure Style Sheets (cljss) CSS แบบฝังจะมีลักษณะดังนี้:

 ;; -- STYLES ------------------------------------------------------------ (defstyles component-style [] {:color "red" :width "100%"}) ;; -- VIEW -------------------------------------------------------------- (defn component [] [:div {:class (component-style)} "Hello, world!"])

defstyles สร้างฟังก์ชันซึ่งจะสร้างชื่อคลาสเฉพาะสำหรับเรา (ซึ่งเหมาะสำหรับทุกคนที่นำเข้าส่วนประกอบของเรา)

มีสิ่งอื่นอีกมากมายที่ cljss สามารถทำได้สำหรับคุณ (สไตล์การเขียน แอนิเมชั่น การแทนที่องค์ประกอบ ฯลฯ) ที่ฉันจะไม่ลงรายละเอียดที่นี่ ฉันแนะนำให้คุณตรวจสอบด้วยตัวเอง!

การประกอบชิ้นส่วนของแอพ ClojureScript

สุดท้าย มีกาวที่ต้องติดทั้งหมดนี้เข้าด้วยกัน โชคดีที่นอกเหนือจากไฟล์โครงการและ index.html แล้ว อย่างน้อยสำเร็จรูปก็อยู่ที่นี่

คุณต้องการ:

  • ไฟล์นิยามโปรเจ็กต์ของคุณ project.clj แก่นของโปรเจ็กต์ Clojure ซึ่งจะกำหนดการอ้างอิงของคุณ—แม้โดยตรงจาก GitHub—และคุณสมบัติบิลด์อื่นๆ (คล้ายกับ build.gradle หรือ package.json )
  • index.html ที่ทำหน้าที่เป็นจุดผูกสำหรับแอปพลิเคชันรีเอเจนต์
  • รหัสการตั้งค่าบางอย่างสำหรับสภาพแวดล้อม dev และสุดท้ายสำหรับการเริ่มต้นแอปพลิเคชัน Reagent ของคุณ

คุณจะพบตัวอย่างโค้ดแบบเต็มสำหรับบทช่วยสอน ClojureScript นี้มีอยู่ใน GitHub

แค่นั้นเอง (ในตอนนี้) หวังว่า อย่างน้อยฉันก็ได้กระตุ้นความอยากรู้อยากเห็นของคุณเล็กน้อย ไม่ว่าจะเป็นการดูภาษา Lisp (Clojure[สคริปต์] หรืออย่างอื่น) หรือแม้แต่ลองใช้มือของคุณในการสร้างแอปพลิเคชัน Reagent ของคุณเอง! ฉันสัญญาว่าคุณจะไม่เสียใจ

เข้าร่วมติดตามบทความ Getting Into a State ที่ฉันพูดถึงการจัดการสถานะโดยใช้ re-frame—ทักทาย Redux ใน ClojureScript!