บทช่วยสอน Ruby on Rails

Rails ถูกสร้างขึ้นโดย David Heinemeier Hansson หรือที่รู้จักกันในชื่อ DHH เป็นหนึ่งในเครื่องมือที่มีอิทธิพลและได้รับความนิยมมากที่สุดสำหรับการสร้างเว็บแอปพลิเคชัน เว็บไซต์ใหญ่ๆ เช่น Airbnb, GitHub และ Shopify ก็ใช้ Rails เช่นกัน

ทำไมต้องเรลส์?

ก่อนติดตั้งชุดเครื่องมือ ควรทำความเข้าใจก่อนว่าทำไม Rails จึงยังคงเป็นตัวเลือกยอดนิยมสำหรับการพัฒนาซอฟต์แวร์ping แอปพลิเคชันเว็บทำงานได้อย่างรวดเร็ว

• Rails ถูกบรรจุอยู่ในรูปแบบของ Ruby gem และคุณสามารถใช้มันสร้างแอปพลิเคชันได้หลากหลายประเภท
• มันช่วยให้คุณสร้างเว็บแอปพลิเคชันทั่วไป เว็บไซต์อีคอมเมิร์ซ ระบบจัดการเนื้อหา และอื่นๆ อีกมากมาย
• Rails เป็นเฟรมเวิร์กแบบครบวงจรที่รวมทุกสิ่งที่คุณต้องการในการสร้างเว็บแอปพลิเคชันที่ขับเคลื่อนด้วยฐานข้อมูลโดยใช้รูปแบบ Model-View-Controller (MVC)
• ทุกเลเยอร์ได้รับการออกแบบให้ทำงานร่วมกันได้อย่างราบรื่น ดังนั้นโปรเจ็กต์ Rails จึงมักต้องการโค้ดจำนวนบรรทัดน้อยกว่าโปรเจ็กต์ที่เทียบเท่ากันในเฟรมเวิร์กอื่นๆ

วิธีดาวน์โหลดและติดตั้ง Ruby บน Windows

ขั้นตอนการติดตั้งขึ้นอยู่กับระบบปฏิบัติการของคุณ ส่วนต่อไปนี้จะกล่าวถึงการติดตั้ง Ruby บนระบบปฏิบัติการต่างๆ Windows, Mac และ ลินุกซ์.

ขั้นตอน 1) ดาวน์โหลด Rubyinstaller
วิธีที่ง่ายที่สุดในการติดตั้ง Ruby บนของคุณ Windows คอมพิวเตอร์เครื่องนี้ติดตั้งผ่าน Ruby Installer ซึ่งสามารถดาวน์โหลดได้ที่นี่ https://rubyinstaller.org/.

เมื่อดาวน์โหลดเสร็จแล้ว ให้เรียกใช้โปรแกรมติดตั้ง

ขั้นตอน 2) คลิกที่ไฟล์ติดตั้งที่ดาวน์โหลดมา
Double-คลิกไฟล์ติดตั้งที่ดาวน์โหลดมา ตัวอย่างเช่น rubyinstaller-2.4.1-2-x64.exe.

ขั้นตอน 3) ยอมรับข้อตกลงใบอนุญาต
เลือกตัวเลือก “ฉันยอมรับใบอนุญาต” แล้วคลิกปุ่ม “ถัดไป” คุณจะเห็นหน้าจอดังภาพด้านล่าง

ขั้นตอน 4) ทำเครื่องหมายในช่องทำเครื่องหมายสองช่องแรก
ทำเครื่องหมายในช่องกาเครื่องหมายสองช่องแรกเพื่อให้การรันสคริปต์ Ruby ง่ายขึ้น

คลิกปุ่ม “ติดตั้ง” เพื่อเริ่มการติดตั้ง เมื่อการติดตั้งเสร็จสมบูรณ์ คุณจะเห็นหน้าจอด้านล่าง

ขั้นตอน 5) คลิกที่เสร็จสิ้น
อย่ายกเลิกการเลือกตัวเลือกที่ติดตั้ง MSYS2 คลิก “เสร็จสิ้น” เพื่อทำการติดตั้งให้เสร็จสมบูรณ์ หน้าต่างพร้อมท์คำสั่งจะเปิดขึ้นดังที่แสดงด้านล่าง

ขั้นตอน 6) ติดตั้ง MSYS2
ขั้นตอนนี้จะติดตั้ง MSYS2 ซึ่งเป็นแพลตฟอร์มการสร้างที่มีตัวจัดการแพ็กเกจเพื่อช่วยให้ติดตั้งแพ็กเกจได้ง่ายขึ้น Windows.

กด Enter เพื่อติดตั้งส่วนประกอบทั้งหมด เนื่องจากส่วนประกอบเหล่านี้จำเป็นสำหรับสภาพแวดล้อมการพัฒนา Ruby on Rails ที่ราบรื่น Windows.

การติดตั้งราง

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

หากคุณติดตั้ง Ruby เวอร์ชันล่าสุด รวมถึง RubyGems และส่วนขยายพื้นฐานไว้แล้ว ให้เรียกใช้คำสั่งต่อไปนี้ที่พรอมต์คำสั่งเพื่อติดตั้ง Rails บนระบบของคุณ: gem install rails.

คุณจะต้องติดตั้งด้วย Node.js หากคุณยังไม่มี เนื่องจากไลบรารีบางตัวที่ Rails ใช้จำเป็นต้องมี Javaสคริปต์รันไทม์จะทำงานได้อย่างถูกต้อง ดาวน์โหลด Node ได้ที่นี่ https://nodejs.org.

แนวทางที่พบได้ทั่วไปและเป็นที่นิยมมากกว่าคือ Windows คือการใช้ Windows Subsystem for Linux คือระบบที่ให้สภาพแวดล้อม GNU/Linux พร้อมด้วยเครื่องมือบรรทัดคำสั่ง ยูทิลิตี้ และแอปพลิเคชันทั่วไปโดยตรง Windows.

การติดตั้ง Ruby บน Mac

Mac ของคุณมี Ruby ติดตั้งไว้แล้ว แต่เวอร์ชันที่ติดตั้งไว้มักจะล้าสมัย ดังนั้นคุณควรติดตั้งเวอร์ชันที่ใหม่กว่า

วิธีที่ง่ายที่สุดคือการใช้โปรแกรมจัดการแพ็กเกจ เช่น homebrewก่อนอื่นคุณอาจต้องติดตั้ง Homebrew โดยเรียกใช้คำสั่งด้านล่างในเทอร์มินัล

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

ขั้นตอนนี้จะแสดงคำเตือนและแจ้งให้คุณป้อนรหัสผ่าน ป้อนรหัสผ่าน Mac ของคุณ (ตัวอักษรจะไม่ปรากฏขณะที่คุณพิมพ์) แล้วกด Enter เมื่อเสร็จแล้ว จากนั้นเรียกใช้คำสั่ง Homebrew นี้เพื่อติดตั้ง Ruby บน Mac ของคุณ

brew install ruby

จากนั้นเรียกใช้คำสั่งนี้:

echo 'export PATH="/usr/local/bin:/usr/local/sbin:$PATH"' >> ~/.bash_profile

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

เพื่อยืนยันว่าการติดตั้งสำเร็จ ให้รันคำสั่งต่อไปนี้ในเทอร์มินัล:

ruby --version

คำสั่งนี้จะแสดงหมายเลขเวอร์ชันของ Ruby ที่คุณติดตั้งไว้ ผลลัพธ์จะมีลักษณะดังนี้:

ruby 2.6.0p0 (2018-12-25 revision 66547) [x86_64-darwin18]

การติดตั้ง Ruby บน Ubuntu (Linux)

วิธีที่ง่ายที่สุดในการติดตั้ง Ruby บน Ubuntu สามารถติดตั้งได้ผ่านตัวจัดการแพ็กเกจ apt รันคำสั่งต่อไปนี้ในเทอร์มินัลเพื่อติดตั้ง Ruby เวอร์ชันล่าสุดจาก apt Ubuntu ที่เก็บ

• sudo apt update – การดำเนินการนี้จะอัปเดตค่าเริ่มต้น Ubuntu ที่เก็บ
• sudo apt install ruby-full – ขั้นตอนนี้จะดาวน์โหลดและติดตั้ง Ruby เวอร์ชันล่าสุด

เพื่อยืนยันการติดตั้ง ให้เรียกใช้คำสั่งต่อไปนี้ รูบี้ –เวอร์ชันคำสั่งนี้จะแสดงเวอร์ชัน Ruby ที่คุณติดตั้งไว้

การติดตั้งรางบน Ubuntu (Linux)

ทำตามขั้นตอนด้านล่างเพื่อติดตั้ง Rails บนเครื่อง Linux ของคุณ

ขั้นตอน 1) อัปเดตตัวจัดการ Gem ของคุณโดยการเรียกใช้คำสั่งนี้ gem update –system ในเทอร์มินัลหรือพรอมต์คำสั่ง

ขั้นตอน 2) วิ่ง รางติดตั้งอัญมณี เพื่อติดตั้ง Rails เวอร์ชันล่าสุดบนคอมพิวเตอร์ของคุณ

ขั้นตอน 3) ติดตั้ง gem bundler เพื่อการจัดการการพึ่งพา gem สำหรับแอปพลิเคชัน Rails ได้อย่างง่ายดาย เรียกใช้คำสั่ง ติดตั้ง gem bundler.

หลักการสองประการของราง

Rails ยึดมั่นในหลักการออกแบบซอฟต์แวร์พื้นฐานและสนับสนุนให้คุณนำหลักการเหล่านั้นไปใช้ด้วย

สองสิ่งที่พบบ่อยที่สุดคือ:

• อย่าพูดซ้ำๆ (แห้ง) – ซึ่งส่งผลให้ได้โค้ดที่กระชับ สม่ำเสมอ และดูแลรักษาง่าย
• อนุสัญญาเกี่ยวกับการกำหนดค่า – Rails มีการตั้งค่าเริ่มต้นที่เหมาะสมกับการใช้งานทั่วไปไว้ล่วงหน้าแล้ว ทำให้การพัฒนาแอปพลิเคชันรวดเร็วและลดจำนวนโค้ดที่ต้องดูแลรักษาลง

Rails – โครงสร้างไฟล์โครงการ

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

rails new todo_app

คำสั่งนี้สร้างไดเร็กทอรีชื่อ แอปสิ่งที่ต้องทำ ในไดเร็กทอรีปัจจุบันที่มีโครงสร้างโฟลเดอร์พื้นฐานของเว็บแอปพลิเคชัน Rails ดังแสดงด้านล่าง

ต่อไปนี้คือไดเร็กทอรีหลักที่สร้างขึ้นสำหรับโปรเจ็กต์:

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

แอป/ตัวควบคุม – จัดเก็บไฟล์คอนโทรลเลอร์ที่ Rails ใช้ในการจัดการคำขอจากฝั่งไคลเอ็นต์

แอพ/สินทรัพย์ – ประกอบด้วยไฟล์คงที่ที่จำเป็นสำหรับส่วนหน้าของแอปพลิเคชัน โดยจัดกลุ่มตามประเภท: Javaต้นฉบับ ไฟล์ รูปภาพ และสไตล์ชีท

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

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

แอพ/มุมมอง – เป็นที่เก็บไฟล์เทมเพลต/เค้าโครงที่ผู้ใช้แอปพลิเคชันของคุณใช้งาน เทมเพลตเหล่านี้จะรวม HTML เข้ากับข้อมูลจากฐานข้อมูล

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

การตั้งค่า – เก็บไฟล์การตั้งค่าต่างๆ เช่น ฐานข้อมูล.yml, สภาพแวดล้อม.rb, เส้นทาง.rbเป็นต้น ซึ่งเป็นสิ่งจำเป็นสำหรับการทำงานของแอปพลิเคชันของคุณ

db – ประกอบด้วยไฟล์และสคริปต์ที่ใช้ในการจัดการฐานข้อมูลแอปพลิเคชันของคุณ

lib – ประกอบด้วยโมดูลเสริมสำหรับแอปพลิเคชันของคุณ

เข้าสู่ระบบ – ประกอบด้วยไฟล์บันทึกข้อมูล เช่น server.log, development.log, test.log และ Production.logใช้สำหรับการดีบักหรือตรวจสอบการทำงานของแอปพลิเคชันของคุณ

สาธารณะ – ประกอบด้วยไฟล์คงที่และสินทรัพย์ที่คอมไพล์แล้ว เช่น ไฟล์ HTML Javaไฟล์สคริปต์ รูปภาพ และไฟล์สไตล์ชีต

ทดสอบ – ประกอบด้วยไฟล์ทดสอบที่คุณเขียนขึ้นเพื่อทดสอบการทำงานของแอปพลิเคชันของคุณ

tmp – ประกอบด้วยไฟล์ชั่วคราว เช่น ไฟล์แคชและไฟล์ PID

ผู้ขาย – ประกอบด้วยไลบรารีของบุคคลที่สาม

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

Gemfile.lock – ต่างจาก Gemfile ที่ระบุรายชื่อ gem ที่คุณต้องการใช้ในแอปพลิเคชันอย่างชัดเจน Gemfile.lock ยังมี gem อื่นๆ ที่ gem ที่ระบุไว้ใน Gemfile นั้นต้องพึ่งพา ซึ่งจะถูกติดตั้งโดยอัตโนมัติเพื่อตอบสนองความต้องการด้านการพึ่งพาเหล่านั้น

Readme.md – ใช้ไฟล์นี้เพื่อแบ่งปันรายละเอียดที่สำคัญเกี่ยวกับแอปพลิเคชันของคุณ เช่น แอปทำอะไร และวิธีการติดตั้งและเรียกใช้งาน

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

config.ru – ไฟล์การกำหนดค่า Rack ที่ให้ส่วนติดต่อกับเว็บเซิร์ฟเวอร์เพื่อเริ่มต้นแอปพลิเคชันของคุณ

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

นี่คือหน้าแรกเริ่มต้นของแอปพลิเคชันของคุณ คุณจะเปลี่ยนหน้าแรกในส่วนถัดไปของบทเรียน Ruby on Rails นี้ คุณสามารถหยุดเซิร์ฟเวอร์ได้โดยการกดปุ่ม CTRL + C.

Rails – สร้างคำสั่ง

คำสั่ง `generate` ใน Rails ใช้เทมเพลตในการสร้างสิ่งที่มีประโยชน์มากมายในแอปพลิเคชันของคุณ ตัวสร้างเหล่านี้ช่วยประหยัดเวลาได้มาก

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

คุณยังสามารถวิ่ง รางสร้าง เพื่อดูคำอธิบายว่าคำสั่งนี้ทำอะไรบ้าง มันแสดงตัวเลือกที่สะดวกและตัวอย่างการใช้งาน ภาพด้านล่างแสดงผลลัพธ์ของการเรียกใช้คำสั่งนี้ รางสร้างตัวควบคุม.

ใช้คำสั่ง `rails generate scaffold` เพื่อสร้างโมเดล วิว และคอนโทรลเลอร์สำหรับแอปพลิเคชันรายการสิ่งที่ต้องทำที่คุณกำลังสร้างโดยอัตโนมัติ รันคำสั่งต่อไปนี้ในเทอร์มินัลของคุณ (ตรวจสอบให้แน่ใจว่าคุณยังอยู่ในเทอร์มินัล) แอปสิ่งที่ต้องทำ ไดเรกทอรี):

rails generate scaffold todo_list title:string description:text

ซึ่งจะสร้างเว็บอินเทอร์เฟซแบบ CRUD (สร้าง อ่าน อัปเดต ลบ) อย่างสมบูรณ์สำหรับตาราง TodoLists

คำสั่งที่มีประโยชน์อีกประการหนึ่งที่ควรรู้คือ รางรถไฟทำลายมันจะย้อนกลับทุกอย่าง รางสร้าง ไม่

ราง--การกำหนดเส้นทาง

ระบบการกำหนดเส้นทางของ Rails หรือที่เรียกว่า Rails router จะจัดการคำขอขาเข้าทั้งหมดไปยังเว็บแอปพลิเคชันของคุณ โดยจะตรวจสอบ... URL ของแต่ละคำขอและแมปไปยังแอ็กชันของคอนโทรลเลอร์ที่รับผิดชอบในการจัดการ โดยใช้ไวยากรณ์ที่ระบุไว้ในไฟล์ routes (config/เส้นทาง.rb).

ไฟล์ routes ควบคุมทุกอย่าง URL แง่มุมหนึ่งของเว็บแอปพลิเคชันของคุณ Rails ใช้การออกแบบ RESTful โดยอิงตามสถาปัตยกรรม REST ซึ่งให้แผนที่ping ระหว่างคำกริยา HTTP และคำขอ URLs ไปยังการกระทำของตัวควบคุม

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

rails db:migrate

ตรวจสอบให้แน่ใจว่าคุณยังอยู่ที่หน้าหลักของแอปพลิเคชัน ( แอปสิ่งที่ต้องทำ ไดเร็กทอรี)

เริ่มเซิร์ฟเวอร์อีกครั้งด้วย เซิร์ฟเวอร์ Rails. ชนิด http://localhost:3000/todo_lists/ เปิดเบราว์เซอร์ของคุณแล้วกด Enter คุณควรจะเห็นหน้าเว็บเหมือนด้านล่างนี้

นี่คือมุมมองรายการสิ่งที่ต้องทำที่คำสั่ง scaffold สร้างขึ้น และถูกควบคุมโดย TodoListsController ดัชนี การกระทำ

เพิ่มรายการสิ่งที่ต้องทำโดยคลิกที่ “สร้างรายการสิ่งที่ต้องทำใหม่” บนหน้าเว็บ คุณจะเห็นหน้าจอดังภาพด้านล่าง

สังเกตเห็น URL คือตอนนี้ http://localhost:3000/todo_lists/newนี่คือหน้าสำหรับสร้างรายการสิ่งที่ต้องทำใหม่ ซึ่งควบคุมโดย TodoListsController ใหม่ วิธี

กรอกชื่อและคำอธิบายของรายการสิ่งที่ต้องทำลงในแบบฟอร์ม แล้วคลิก “สร้างรายการสิ่งที่ต้องทำ” URL ควรเปลี่ยนเป็น http://localhost:3000/todo_lists/1ดังแสดงด้านล่าง

นี่คือหน้าแสดงผลของรายการสิ่งที่ต้องทำ ซึ่งควบคุมโดย TodoListsController โชว์ วิธีการ ถ้าคุณย้อนกลับไป http://localhost:3000/todo_lists/ตอนนี้คุณควรจะเห็นหน้าจอด้านล่างที่มีรายการสิ่งที่ต้องทำใหม่เพิ่มเข้ามาแล้ว

Rails สามารถแมปคำขอแต่ละรายการไปยังแอ็กชัน TodoListsController ที่เกี่ยวข้องโดยใช้คำจำกัดความเส้นทางใน config/เส้นทาง.rb.

ถ้าคุณลองดูไฟล์นี้ คุณจะเห็นเพียงบรรทัดเดียว ทรัพยากร :รายการสิ่งที่ต้องทำซึ่งเป็นวิธีการเขียนเส้นทาง RESTful แบบเริ่มต้นของ Rails บรรทัดเดียวนี้สร้างเส้นทางได้เจ็ดเส้นทาง โดยทั้งหมดจะแมปไปยังเส้นทางที่กำหนดping ไปยังตัวควบคุมรายการสิ่งที่ต้องทำ (TodoLists controller)

ตามธรรมเนียมแล้ว การกระทำแต่ละอย่างในคอนโทรลเลอร์จะสอดคล้องกับการดำเนินการ CRUD (สร้าง อ่าน อัปเดต ลบ) เฉพาะในฐานข้อมูล

วิ่ง เส้นทางรถไฟ ในบรรทัดคำสั่งของคุณเพื่อดูเส้นทางต่างๆ ที่มีอยู่ในแอปพลิเคชันของคุณ รูปด้านล่างแสดงผลลัพธ์ของการเรียกใช้คำสั่ง เส้นทางรถไฟ.

รางรถไฟ – วิว

เลเยอร์การแสดงผล (View Layer) เป็นหนึ่งในส่วนประกอบของโมเดล MVC และมีหน้าที่สร้างการตอบสนอง HTML สำหรับทุกคำขอที่ส่งไปยังแอปพลิเคชันของคุณ โดยค่าเริ่มต้น Rails ใช้ ERB (Embedded Ruby) ซึ่งเป็นระบบเทมเพลตที่มีประสิทธิภาพสำหรับภาษา Ruby

ERB ช่วยให้การเขียนและบำรุงรักษาเทมเพลตทำได้ง่าย โดยการผสมผสานข้อความธรรมดากับโค้ด Ruby เพื่อการแทนที่ตัวแปรและการควบคุมการไหลของโปรแกรม เทมเพลต ERB ใช้... .html.erb การขยาย.

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

แท็กที่มีเครื่องหมายเท่ากับ <%= %> แสดงว่าโค้ดที่ฝังอยู่เป็นนิพจน์ และผลลัพธ์ของโค้ดควรถูกแทนที่ลงในเอาต์พุตเมื่อเทมเพลตแสดงผล

อีกแท็กที่ไม่มีเครื่องหมายเท่ากับ <% %> ระบุให้ตัวแสดงผลทราบว่าผลลัพธ์ของโค้ดไม่ควรถูกแทนที่หรือพิมพ์ในเอาต์พุต

คอนโทรลเลอร์แต่ละตัวในแอปพลิเคชัน Rails ของคุณมีไดเร็กทอรีย่อยที่เกี่ยวข้อง แอพ/มุมมองและการกระทำแต่ละอย่างในตัวควบคุมจะมีค่าที่สอดคล้องกัน .html.erb ไฟล์ในไดเร็กทอรีย่อยนั้น

ลองดูที่ แอพ/มุมมอง ในแอป Todo ที่คุณกำลังสร้าง คุณจะพบโฟลเดอร์ย่อยชื่อ รายการสิ่งที่ต้องทำ ที่มี .html.erb ไฟล์ที่มีชื่อตรงกับการกระทำใน รายการสิ่งที่ต้องทำ ตัวควบคุม

Rails – ActiveRecord, รูปแบบบันทึกที่ใช้งานอยู่ และ ORM

ActiveRecord คือการนำรูปแบบ Active Record มาใช้ในภาษา Ruby ในรูปแบบนี้ คลาสจะแทนตารางในฐานข้อมูล และอินสแตนซ์ของคลาสจะแทนแถวในตารางนั้น

ActiveRecord มักถูกเรียกว่า ORM (Object Relational Map)ping) เลเยอร์ ซึ่งเป็นเทคนิคที่ช่วยให้คุณจัดการฐานข้อมูลโดยใช้ภาษาที่คุณถนัดที่สุด เทคนิคนี้ไม่ขึ้นกับฐานข้อมูลใดๆ ดังนั้นคุณจึงสามารถสลับไปมาระหว่างฐานข้อมูลต่างๆ ได้อย่างง่ายดาย — ตัวอย่างเช่น SQLite, MySQL, PostgreSQL, SQL Server หรือ Oracle — โดยใช้รหัสและตรรกะเดียวกัน

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

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

สิ่งที่คุณต้องทำก็คือตั้งค่าการกำหนดค่าใน config/database.ymlและ ActiveRecord จะจัดการความแตกต่างระหว่างระบบฐานข้อมูลต่างๆ เมื่อคุณเปลี่ยนจากฐานข้อมูลหนึ่งไปยังอีกฐานข้อมูลหนึ่ง คุณไม่จำเป็นต้องเขียนโค้ดใหม่

คุณมุ่งเน้นไปที่ตรรกะของแอปพลิเคชัน และ ActiveRecord จะดูแลรายละเอียดระดับต่ำของการเชื่อมต่อกับฐานข้อมูลของคุณ โดยใช้หลักการตั้งชื่อเพื่อแมปโมเดลกับตารางในฐานข้อมูล

Rails จะใช้คำพหูพจน์กับชื่อคลาสโมเดลของคุณเพื่อค้นหาตารางฐานข้อมูลที่ตรงกัน ดังนั้น สำหรับคลาสหนึ่งๆ รายการสิ่งที่ต้องทำActiveRecord ใช้ตารางฐานข้อมูลที่เรียกว่า รายการสิ่งที่ต้องทำ.

Rails – การโยกย้าย

การสร้างฐานข้อมูล (migration) ใน Rails คือสคริปต์ที่คุณใช้ในการพัฒนาฐานข้อมูลของแอปพลิเคชันของคุณ โดยใช้ในการตั้งค่าหรือเปลี่ยนแปลงฐานข้อมูลโดยไม่ต้องเขียนคำสั่ง SQL ด้วยตนเอง

โปรแกรมนี้ใช้ Ruby ในการกำหนดการเปลี่ยนแปลงโครงสร้างฐานข้อมูล และทำให้สามารถใช้ระบบควบคุมเวอร์ชันเพื่อซิงโครไนซ์ฐานข้อมูลในสภาพแวดล้อมต่างๆ ได้

Rails Migrations ใช้ภาษาเฉพาะโดเมน (DSL) ของ Ruby ซึ่งทำหน้าที่เป็นตัวกลางtracและช่วยให้คุณสามารถใช้งานหรือเปลี่ยนเอ็นจิ้นฐานข้อมูลได้ตามความต้องการของคุณ

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

Rails – สมาคม ActiveRecord

การเชื่อมต่อระหว่างโมเดล ActiveRecord สองตัวเรียกว่า ความสัมพันธ์ (Association) ความสัมพันธ์ช่วยให้การดำเนินการกับเรคอร์ดที่เกี่ยวข้องในโค้ดของคุณง่ายขึ้นมาก โดยทั่วไปมีสี่ประเภทหลักๆ

หนึ่งต่อหนึ่ง: เรคอร์ดหนึ่งๆ จะมีอินสแตนซ์ของโมเดลอื่นเพียงหนึ่งเดียวเท่านั้น ตัวอย่างที่ดีคือโปรไฟล์ผู้ใช้ ผู้ใช้แต่ละคนจะมีโปรไฟล์เพียงโปรไฟล์เดียวเท่านั้น เรคอร์ดนั้นใช้... มีหนึ่ง คำสำคัญ.

หนึ่งถึงหลาย: ความสัมพันธ์ที่พบบ่อยที่สุด — โมเดลหนึ่งมีโมเดลอื่นตั้งแต่ศูนย์ตัวขึ้นไป ใช้ มี_หลาย คำหลักเพื่อแสดงถึงการเชื่อมโยงนี้

หลายต่อหลาย: ค่อนข้างซับซ้อนกว่านั้นเล็กน้อย ActiveRecord มีวิธีการจัดการสองวิธี: has_and_belongs_to_many และ มีหลายอย่าง :ผ่านซึ่งจะทำให้คุณสามารถเข้าถึงโมเดลการเชื่อมต่อที่กำหนดไว้ในตารางแยกต่างหากได้

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

Rails – การตรวจสอบ ActiveRecord

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

การตรวจสอบความถูกต้องยังช่วยเพิ่มความปลอดภัยอีกชั้นหนึ่งเพื่อป้องกันผู้ใช้ที่เป็นอันตรายพยายามแทรกข้อมูลที่เป็นอันตรายลงในฐานข้อมูลของคุณ Rails มี API ที่ใช้งานง่ายสำหรับตัวช่วยตรวจสอบความถูกต้องใน ActiveRecord ซึ่งจะทำให้ฐานข้อมูลของคุณสะอาด ปลอดภัย และปราศจากข้อผิดพลาด

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

เมธอดต่อไปนี้ของ ActiveRecord จะเรียกใช้การตรวจสอบความถูกต้องเมื่อเรียกใช้กับอ็อบเจ็กต์โมเดล: สร้าง สร้าง! บันทึก บันทึก! อัปเดต และอัปเดต!เวอร์ชัน Bang (สร้าง!, บันทึก!, และอัปเดต!) หากเรคอร์ดไม่ถูกต้อง จะส่งข้อยกเว้น ในขณะที่เวอร์ชันที่ไม่ใช้เครื่องหมายตกใจจะส่งคืนค่าเท็จแทน

ตัวช่วยตรวจสอบความถูกต้องของ ActiveRecord ที่ใช้กันทั่วไป ได้แก่:

• ยืนยัน: ตรวจสอบว่าสองฟิลด์มีค่าเดียวกันหรือไม่ เช่น รหัสผ่านและการยืนยันรหัสผ่าน โดยใช้ร่วมกับตัวช่วยตรวจสอบการมีอยู่จริง
• การแสดงตน: ตรวจสอบว่าช่องข้อมูลไม่ว่างเปล่า
• เอกลักษณ์: ช่วยให้มั่นใจได้ว่าค่าของฟิลด์ เช่น ชื่อผู้ใช้ มีค่าที่ไม่ซ้ำกัน
• ความยาว: กำหนดขีดจำกัดความยาวของอักขระในช่องข้อมูล

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

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

Rails – แอคชั่นคอนโทรลเลอร์

ตัวควบคุม Rails เป็นศูนย์กลางของเว็บแอปพลิเคชันของคุณ อำนวยความสะดวกและประสานการสื่อสารระหว่างผู้ใช้ โมเดล และมุมมอง

คลาสคอนโทรลเลอร์ของคุณสืบทอดมาจาก ApplicationControllerซึ่งประกอบด้วยโค้ดที่สามารถเรียกใช้งานได้ในคอนโทรลเลอร์อื่นๆ ทั้งหมด และซึ่งสืบทอดมาจาก แอ็กชันคอนโทรลเลอร์::เบส.

ตัวควบคุมมอบสิ่งต่อไปนี้ให้กับแอปพลิเคชันของคุณ:

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

ราง – การกำหนดค่า

คุณสามารถกำหนดค่าส่วนประกอบต่างๆ เช่น ตัวเริ่มต้น (initializers), ทรัพย์สิน (assets), ตัวสร้าง (generators) และมิดเดิลแวร์ (middlewares) โดยใช้ไฟล์ตัวเริ่มต้นและไฟล์การกำหนดค่าของแอปพลิเคชัน Rails ของคุณได้ การตั้งค่า ไดเร็กทอรี ไฟล์ต่างๆ เช่น config/application.rb, config/environments/development.rbและ config/environments/test.rb มีการใช้งานในที่นี้ คุณยังสามารถเพิ่มการตั้งค่าแบบกำหนดเองสำหรับแอปพลิเคชันของคุณได้อีกด้วย

Rails – การดีบัก

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

วิธีนี้จะหยุดการทำงานชั่วคราว ณ จุดนั้น gem byebug มีคำสั่งให้เลือกใช้หลายคำสั่ง คำสั่งที่ใช้งานได้บ่อยที่สุด ได้แก่:

• ต่อไป: ย้ายไปยังบรรทัดโค้ดถัดไป ข้ามไปping เมธอดทั้งหมดที่ถูกเรียกใช้โดยบรรทัดปัจจุบัน
• ขั้นตอน: คล้ายกับ ถัดไปแต่จะก้าวเข้าไปในแต่ละเมธอดที่เรียกใช้
• หยุดพัก: หยุดการทำงานของโค้ด
• ต่อไป: ดำเนินการโค้ดต่อไป

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

สามารถตรวจสอบไฟล์บันทึกข้อผิดพลาดในสภาพแวดล้อมการใช้งานจริงและจัดการตามความเหมาะสม นอกจากนี้ คุณควรใช้วิธีการพัฒนาแบบทดสอบนำ (Test-Driven Development: TDD) ในการสร้างแอปพลิเคชันของคุณเพื่อให้แน่ใจว่าทุกอย่างทำงานได้ดีก่อนที่จะนำไปใช้งานจริง

คำถามที่พบบ่อย