Ruby on Rails 快速指南

什麼是 Ruby？

在我們開始使用 Rails 之前，讓我們回顧一下 Ruby 的一些要點，它是 Rails 的基礎。

Ruby 是以下內容的成功結合：

Smalltalk 的概念優雅，
Python 的易用性和學習性，以及
Perl 的實用性。

Ruby 是：

一種高階程式語言。
像 Perl、Python、Tcl/TK 一樣被解釋執行。
像 Smalltalk、Eiffel、Ada、Java 一樣面向物件。

為什麼選擇 Ruby？

Ruby 起源於日本，現在在美國和歐洲也越來越受歡迎。以下因素促成了它的流行：

易於學習
開源（非常寬鬆的許可證）
豐富的庫
非常容易擴充套件
真正的面向物件
程式碼量少，錯誤更少
樂於助人的社群

儘管我們有很多理由使用 Ruby，但也有一些缺點需要在實施 Ruby 之前考慮：

效能問題 - 雖然它與 Perl 和 Python 競爭，但它仍然是一種解釋型語言，我們不能將其與 C 或 C++ 等高階程式語言相比較。
執行緒模型 - Ruby 不使用原生執行緒。Ruby 執行緒是在虛擬機器中模擬的，而不是作為原生作業系統執行緒執行。

Ruby 程式碼示例

這是一個列印“Hello Ruby”的 Ruby 程式碼示例

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

輸出 - 這將產生以下結果：

Hello Ruby!

嵌入式 Ruby

Ruby 提供了一個名為 ERB（嵌入式 Ruby）的程式，由Seki Masatoshi編寫。ERB 允許您將 Ruby 程式碼放入 HTML 檔案中。ERB 一字一句地讀取，然後在某個點，當它遇到嵌入在文件中的 Ruby 程式碼時，它就開始執行 Ruby 程式碼。

您只需要瞭解兩件事即可準備 ERB 文件：

如果您想執行一些 Ruby 程式碼，請將其括在<%和%>之間。
如果您希望程式碼執行的結果作為輸出的一部分打印出來，請將程式碼括在<%=和%>之間。

這是一個示例。將程式碼儲存在 erbdemo.rb 檔案中。請注意，Ruby 檔案的副檔名為.rb：

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

現在，使用命令列實用程式erb執行程式。

tp> erb erbdemo.rb

這將產生以下結果：

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

什麼是 Rails？

一個極具生產力的 Web 應用程式框架。
由 David Heinemeier Hansson 使用 Ruby 編寫。
使用 Rails 開發 Web 應用程式的速度至少是使用典型 Java 框架的十倍。
一個用於開發基於資料庫的 Web 應用程式的開源 Ruby 框架。
使用資料庫模式配置您的程式碼。
無需編譯階段。

全棧框架

包含建立資料庫驅動 Web 應用程式所需的一切，使用模型-檢視-控制器模式。
作為全棧框架意味著所有層都構建為無縫協同工作，程式碼更少。
需要的程式碼行數少於其他框架。

約定優於配置

Rails 摒棄配置檔案，轉而採用約定、反射和動態執行時擴充套件。
您的應用程式程式碼和正在執行的資料庫已經包含 Rails 需要知道的一切！

Rails 的優勢

Rails 充滿了使您更高效的功能，其中許多功能建立在彼此之上。

超程式設計

在其他框架從頭開始使用大量程式碼生成的地方，Rail 框架使用超程式設計技術來編寫程式。Ruby 是最適合超程式設計的語言之一，Rails 很好地利用了此功能。Rails 也使用程式碼生成，但更多地依賴超程式設計來完成繁重的工作。

Active Record

Rails 引入了 Active Record 框架，該框架將物件儲存到資料庫中。Rails 版本的 Active Record 會發現資料庫模式中的列，並使用超程式設計自動將它們附加到您的域物件。

約定優於配置

大多數 .NET 或 Java 的 Web 開發框架都要求您編寫數頁的配置程式碼。如果您遵循建議的命名約定，Rails 就不需要太多配置。

腳手架

您通常在開發的早期階段建立臨時程式碼，以幫助快速啟動應用程式並瞭解主要元件如何協同工作。Rails 會自動建立您需要的許多腳手架。

內建測試

Rails 建立了簡單的自動化測試，然後您可以擴充套件這些測試。Rails 還提供名為 harness 和 fixture 的支援程式碼，使測試用例更易於編寫和執行。然後，Ruby 可以使用 rake 實用程式執行所有自動化測試。

三個環境

Rails 為您提供了三個預設環境：開發、測試和生產。每個環境的行為略有不同，使您的整個軟體開發生命週期變得更加輕鬆。例如，Rails 為每次測試執行建立一個 Test 資料庫的新副本。

Ruby on Rails - 安裝

要使用 Ruby on Rails 框架開發 Web 應用程式，您需要安裝以下軟體：

Ruby
Rails 框架
Web 伺服器
資料庫系統

我們假設您已經在計算機上安裝了 Web 伺服器和資料庫系統。您可以使用 WEBrick Web 伺服器，它隨 Ruby 一起提供。但是，大多數網站在生產環境中使用 Apache 或 lightTPD Web 伺服器。

Rails 可以與許多資料庫系統一起使用，包括 MySQL、PostgreSQL、SQLite、Oracle、DB2 和 SQL Server。請參閱相應的資料庫系統設定手冊以設定您的資料庫。

讓我們看看在 Windows 和 Linux 上安裝 Rails 的說明。

在 Windows 上安裝 Rails

按照以下步驟安裝 Ruby on Rails。

步驟 1：檢查 Ruby 版本

首先，檢查您是否已安裝 Ruby。開啟命令提示符並鍵入ruby -v。如果 Ruby 響應，並且如果它顯示的版本號在 2.2.2 或更高版本，則鍵入gem --version。如果您沒有收到錯誤，請跳過安裝 Ruby步驟。否則，我們將安裝一個新的 Ruby。

步驟 2：安裝 Ruby

如果未安裝 Ruby，請從rubyinstaller.org下載安裝包。按照下載連結，然後執行生成的安裝程式。這是一個 exe 檔案rubyinstaller-2.2.2.x.exe，只需單擊即可安裝。這是一個非常小的包，您還將獲得 RubyGems 以及此包。請檢視發行說明以獲取更多詳細資訊。

步驟 3：安裝 Rails

安裝 Rails - 載入 Rubygems 後，您可以使用以下命令透過命令列安裝所有 Rails 及其依賴項：

C:\> gem install rails

注意 - 上述命令可能需要一些時間才能安裝所有依賴項。確保在安裝 gems 依賴項時已連線到網際網路。

步驟 4：檢查 Rails 版本

使用以下命令檢查 rails 版本。

C:\> rails -v

輸出

Rails 4.2.4

恭喜！您現在在 Windows 上使用 Rails 了。

在 Linux 上安裝 Rails

我們使用rbenv在 Linux 上安裝 Ruby On Rails。它是一個輕量級的 Ruby 版本管理工具。rbenv提供了一個簡單的安裝過程來管理各種版本的 Ruby，以及一個用於開發 Ruby on Rails 應用程式的可靠環境。

按照以下步驟使用 rbenv 工具安裝 Ruby on Rails。

步驟 1：安裝先決條件依賴項

首先，我們必須安裝git - core和一些幫助安裝 Ruby on Rails 的 ruby 依賴項。使用以下命令使用yum安裝 Rails 依賴項。

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

步驟 2：安裝 rbenv

現在我們將安裝 rbenv 並設定相應的環境變數。使用以下命令集從 git 儲存庫獲取 rbenv。

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

步驟 3：安裝 Ruby

在安裝 Ruby 之前，確定要安裝哪個版本的 Ruby。我們將安裝 Ruby 2.2.3。使用以下命令安裝 Ruby。

tp> rbenv install -v 2.2.3

使用以下命令將當前 Ruby 版本設定為預設版本。

tp> rbenv global 2.2.3

使用以下命令驗證 Ruby 版本。

tp> ruby -v

輸出

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

Ruby 提供了一個名為gem的關鍵字來安裝支援的依賴項；我們稱之為gems。如果您不想安裝 Ruby-gems 的文件，請使用以下命令。

tp> echo "gem: --no-document" > ~/.gemrc

此後，最好安裝 Bundler gem，因為它有助於管理應用程式依賴項。使用以下命令安裝 bundler gem。

tp> gem install bundler

步驟 4：安裝 Rails

使用以下命令安裝 Rails 版本 4.2.4。

tp> install rails -v 4.2.4

使用以下命令使 Rails 可執行檔案可用。

tp> rbenv rehash

使用以下命令檢查 rails 版本。

tp> rails -v

輸出

tp> Rails 4.2.4

Ruby on Rails 框架需要 JavaScript 執行時環境 (Node.js) 來管理 Rails 的功能。接下來，我們將瞭解如何使用 Node.js 來管理 Rails 功能的 Asset Pipeline。

步驟 5：安裝 JavaScript 執行時

讓我們從 Yum 儲存庫安裝 Node.js。我們將從 EPEL yum 儲存庫獲取 Node.js。使用以下命令將 EPEL 包新增到 yum 儲存庫。

tp> sudo yum -y install epel-release

使用以下命令安裝 Node.js 包。

tp> sudo yum install nodejs

恭喜！您現在在 Linux 上使用 Rails 了。

步驟 6：安裝資料庫

預設情況下，Rails 使用 sqlite3，但您可能希望安裝 MySQL、PostgreSQL 或其他 RDBMS。這是可選的；如果您已安裝資料庫，則可以跳過此步驟，並且不必安裝資料庫即可啟動 rails 伺服器。在本教程中，我們使用 PostgreSQL 資料庫。因此，使用以下命令安裝 PostgreSQL。

tp> sudo yum install postgresql-server postgresql-contrib

透過響應y來接受提示。使用以下命令建立 PostgreSQl 資料庫叢集。

tp> sudo postgresql-setup initdb

使用以下命令啟動並啟用 PostgreSQL。

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

保持 Rails 更新

假設您已使用 RubyGems 安裝 Rails，保持其更新相對容易。我們可以在 Windows 和 Linux 平臺上使用相同的命令。使用以下命令：

tp> gem update rails

輸出

以下螢幕截圖顯示了 Windows 命令提示符。Linux 終端也提供了相同的輸出。

這將自動更新您的 Rails 安裝。下次重新啟動應用程式時，它將獲取此最新版本的 Rails。使用此命令時，請確保已連線到網際網路。

安裝驗證

您可以驗證所有內容是否都根據您的要求設定。使用以下命令建立演示專案。

tp> rails new demo

輸出

它將生成一個演示 rail 專案；我們稍後將討論它。目前，我們必須檢查環境是否已設定。接下來，使用以下命令在您的機器上執行 WEBrick Web 伺服器。

tp> cd demo
tp> rails server

它將生成自動程式碼以啟動伺服器

現在開啟您的瀏覽器並鍵入以下內容：

https://:3000

它應該顯示一條訊息，例如“歡迎加入”或“恭喜”。

Ruby on Rails - 框架

框架是一個程式、一組程式和/或程式碼庫，它可以為你編寫大部分應用程式。當你使用框架時，你的工作是編寫應用程式中使其執行你想要執行的特定操作的部分。

當你著手編寫 Rails 應用程式時，撇開配置和其他日常事務，你需要執行三個主要任務 -

描述和建模應用程式的領域 - 領域是應用程式的宇宙。該領域可能是一個音樂商店、一所大學、一個約會服務、一個地址簿或一個硬體庫存。因此，在這裡你需要弄清楚其中有什麼，在這個宇宙中存在哪些實體以及其中的專案如何相互關聯。這相當於建模資料庫結構以保留實體及其關係。
指定在這個領域中可能發生的事情 - 領域模型是靜態的；你需要使其動態化。地址可以新增到地址簿中。音樂樂譜可以從音樂商店購買。使用者可以登入約會服務。學生可以在大學註冊課程。你需要識別領域元素可以參與的所有可能的場景或操作。
選擇和設計領域公開可用的檢視 - 在這一點上，你可以開始以 Web 瀏覽器的方式思考。一旦你確定你的領域有學生，並且他們可以註冊課程，你就可以設想一個歡迎頁面、一個註冊頁面和一個確認頁面等。每個頁面或檢視都向使用者顯示事物在特定時間點的狀態。

基於以上三個任務，Ruby on Rails 處理 Model/View/Controller (MVC) 框架。

Ruby on Rails MVC 框架

Model View Controller 原則將應用程式的工作劃分為三個獨立但緊密協作的子系統。

模型 (ActiveRecord)

它維護物件和資料庫之間的關係，並處理驗證、關聯、事務等。

此子系統在 ActiveRecord 庫中實現，該庫提供了關係資料庫中表與操作資料庫記錄的 Ruby 程式程式碼之間的介面和繫結。Ruby 方法名稱會根據資料庫表的欄位名稱自動生成。

檢視 (ActionView)

它是以特定格式呈現資料，由控制器決定呈現資料觸發。它們是基於指令碼的模板系統，如 JSP、ASP、PHP，並且非常易於與 AJAX 技術整合。

此子系統在 ActionView 庫中實現，該庫是一個基於嵌入式 Ruby (ERb) 的系統，用於定義資料呈現的呈現模板。每個 Web 連線到 Rails 應用程式都會導致顯示檢視。

控制器 (ActionController)

應用程式中用於引導流量的工具，一方面查詢模型以獲取特定資料，另一方面將該資料（搜尋、排序、訊息傳遞）組織成適合給定檢視需求的形式。

此子系統在 ActionController 中實現，它是一個數據代理，位於 ActiveRecord（資料庫介面）和 ActionView（呈現引擎）之間。

MVC 框架的圖形表示

以下是 Ruby on Rails 框架的圖形表示 -

MVC 框架的目錄表示

假設在 Linux 上進行標準預設安裝，你可以在以下位置找到它們 -

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

你會看到包括（但不限於）以下子目錄 -

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

在 Windows 安裝上，你可以在以下位置找到它們 -

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

你會看到包括（但不限於）以下子目錄 -

ActionView 和 ActionController 在 ActionPack 下捆綁在一起。

ActiveRecord 提供了一系列用於操作 SQL 資料庫資料的程式設計技術和快捷方式。ActionController 和 ActionView 提供了用於操作和顯示該資料的功能。Rails 將所有這些結合在一起。

Ruby on Rails - 目錄結構

當你使用 Rails 幫助器指令碼建立應用程式時，它會建立應用程式的整個目錄結構。Rails 知道在該結構中在哪裡找到它需要的東西，因此你無需提供任何輸入。

以下是應用程式建立時幫助器指令碼建立的目錄樹的頂層檢視。除了版本之間的微小更改外，每個 Rails 專案都將具有相同的結構，並使用相同的命名約定。這種一致性為你提供了巨大的優勢；你可以在 Rails 專案之間快速移動，而無需重新學習專案的組織方式。

為了理解這個目錄結構，讓我們使用在安裝章節中建立的demo應用程式。可以使用簡單的幫助器命令rails demo建立它。

現在，進入 demo 應用程式根目錄，如下所示 -

tp> cd demo
demo> dir

你會在 Windows 中找到如下目錄結構 -

現在讓我們解釋每個目錄的目的

app - 它組織你的應用程式元件。它包含用於儲存檢視（檢視和幫助器）、控制器（控制器）和後端業務邏輯（模型）的子目錄。
app/controllers - controllers 子目錄是 Rails 查詢控制器類的地方。控制器處理來自使用者的 Web 請求。
app/helpers - helpers 子目錄儲存任何用於輔助模型、檢視和控制器類的幫助器類。這有助於使模型、檢視和控制器程式碼保持簡潔、專注和整潔。
app/models - models 子目錄儲存對應用程式資料庫中儲存的資料進行建模和封裝的類。在大多數框架中，應用程式的這一部分可能會變得非常雜亂、乏味、冗長且容易出錯。Rails 使其變得非常簡單！
app/view - views 子目錄儲存顯示模板，以便使用應用程式中的資料填充、轉換為 HTML 並返回到使用者的瀏覽器。
app/view/layouts - 儲存用於與檢視一起使用的佈局的模板檔案。這模擬了包裝檢視的常見標題/頁尾方法。在你的檢視中，使用<tt>layout:default</tt>定義佈局，並建立一個名為 default.html.erb 的檔案。在 default.html.erb 中，呼叫<% yield %> 以使用此佈局呈現檢視。
components - 此目錄儲存元件，即捆綁了模型、檢視和控制器的微型獨立應用程式。
config - 此目錄包含應用程式所需的少量配置程式碼，包括你的資料庫配置（在 database.yml 中）、你的 Rails 環境結構（environment.rb）和傳入 Web 請求的路由（routes.rb）。你還可以使用 environments 目錄中找到的檔案，為測試、開發和部署的三個 Rails 環境定製行為。
db - 通常，你的 Rails 應用程式將擁有訪問關係資料庫表的模型物件。你可以使用你建立並放置在此目錄中的指令碼管理關係資料庫。
doc - Ruby 具有一個名為 RubyDoc 的框架，可以自動為你建立的程式碼生成文件。你可以透過程式碼中的註釋來輔助 RubyDoc。此目錄儲存所有 RubyDoc 生成的 Rails 和應用程式文件。
lib - 你會將庫放在這裡，除非它們明確地屬於其他地方（例如供應商庫）。
log - 錯誤日誌放在這裡。Rails 建立了幫助你管理各種錯誤日誌的指令碼。你會找到伺服器的單獨日誌（server.log）和每個 Rails 環境的日誌（development.log、test.log 和 production.log）。
public - 與 Web 伺服器的 public 目錄類似，此目錄包含不會更改的 Web 檔案，例如 JavaScript 檔案（public/javascripts）、圖形（public/images）、樣式表（public/stylesheets）和 HTML 檔案（public）。
script - 此目錄儲存用於啟動和管理你將與 Rails 一起使用的各種工具的指令碼。例如，有一些指令碼可以生成程式碼（generate）和啟動 Web 伺服器（server）。
test - 你編寫的測試和 Rails 為你建立的測試都放在這裡。你會看到用於模擬（mocks）、單元測試（unit）、夾具（fixtures）和功能測試（functional）的子目錄。
tmp - Rails 使用此目錄來儲存用於中間處理的臨時檔案。
vendor - 由第三方供應商提供的庫（例如安全庫或超出基本 Rails 發行版的資料庫實用程式）放在這裡。

除了這些目錄外，demo 目錄中還將有兩個檔案可用。

README - 此檔案包含有關 Rail 應用程式的基本詳細資訊以及上面解釋的目錄結構的描述。
Rakefile - 此檔案類似於 Unix Makefile，有助於構建、打包和測試 Rails 程式碼。這將由隨 Ruby 安裝一起提供的 rake 實用程式使用。

Ruby on Rails - 示例

在本章中，我們將為儲存和管理書籍建立一個簡單但可操作的線上圖書館系統。

此應用程式具有基本架構，並將使用兩個 ActiveRecord 模型構建，以描述儲存的資料型別 -

書籍，描述實際列表。
主題，用於將書籍組合在一起。

建立 Rails 應用程式的工作流程

建立 Rails 應用程式的推薦工作流程如下 -

使用 rails 命令建立應用程式的基本框架。
在 PostgreSQL 伺服器上建立一個數據庫來儲存你的資料。
配置應用程式以瞭解你的資料庫位於何處以及它的登入憑據。
建立 Rails Active Records（模型），因為它們是你將在控制器中使用的業務物件。
生成遷移，簡化資料庫表和列的建立和維護。
編寫控制器程式碼以使你的應用程式活躍起來。
建立檢視以透過使用者介面呈現你的資料。

因此，讓我們從建立我們的圖書館應用程式開始。

建立空的 Rails Web 應用程式

Rails 既是一個執行時 Web 應用程式框架，也是一組幫助器指令碼，這些指令碼可以自動化開發 Web 應用程式時執行的許多操作。在此步驟中，我們將使用一個這樣的幫助器指令碼建立整個目錄結構和初始檔案集以啟動我們的圖書館系統應用程式。

進入 ruby 安裝目錄以建立你的應用程式。
執行以下命令以建立圖書館應用程式的框架。它將在當前目錄中建立目錄結構。

tp> rails new library

這將為圖書館應用程式建立一個子目錄，其中包含一個完整的資料夾和檔案的目錄樹，用於建立一個空的 Rails 應用程式。檢查應用程式的完整目錄結構。檢視Rails 目錄結構以獲取更多詳細資訊。

我們的大部分開發工作將是在library/app子目錄中建立和編輯檔案。以下是如何使用它們的一個快速概述 -

controllers子目錄是 Rails 查詢控制器類的地方。控制器處理來自使用者的 Web 請求。
views子目錄儲存顯示模板，以便使用應用程式中的資料填充、轉換為 HTML 並返回到使用者的瀏覽器。
models子目錄儲存對應用程式資料庫中儲存的資料進行建模和封裝的類。在大多數框架中，應用程式的這一部分可能會變得非常雜亂、乏味、冗長且容易出錯。Rails 使其變得非常簡單。
helpers 子目錄包含任何用於輔助模型、檢視和控制器類的幫助器類。這有助於使模型、檢視和控制器程式碼保持簡潔、重點突出且井井有條。

啟動 Web 伺服器

Rails Web 應用程式幾乎可以在任何 Web 伺服器下執行，但開發 Rails Web 應用程式最方便的方法是使用內建的 WEBrick Web 伺服器。讓我們啟動此 Web 伺服器，然後瀏覽到我們空的庫應用程式 -

此伺服器將從應用程式目錄啟動，如下所示。它在埠號 3000 上執行。

tp> cd ruby\library 
tp\ruby\library\> Rails server

它生成如下所示的自動程式碼以啟動伺服器 -

這將啟動您的 WEBrick Web 伺服器。

現在開啟您的瀏覽器並瀏覽到http://127.0.0.1:3000。如果一切正常，那麼您應該會看到來自 WEBrick 的問候訊息，否則您的設定存在問題。如果一切順利，它將生成如下輸出。

接下來是什麼？

下一章解釋如何為您的應用程式建立資料庫以及訪問這些建立的資料庫所需的配置。

此外，我們將瞭解什麼是 Rails 遷移以及如何使用它來維護資料庫表。

Ruby on Rails - 資料庫設定

在開始本章之前，請確保您的資料庫伺服器已啟動並正在執行。Ruby on Rails 建議建立三個資料庫 - 開發、測試和生產環境各一個數據庫。按照慣例，它們的名字應該是 -

library_development
library_production
library_test

您應該初始化所有三個資料庫，併為它們建立一個具有完全讀寫許可權的使用者和密碼。我們正在使用root使用者 ID 用於我們的應用程式。

MySQL 資料庫設定

在 MySQL 中，我們使用root使用者 ID 用於我們的應用程式。您執行此操作的 MySQL 控制檯會話看起來像 -

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

您可以對另外兩個資料庫library_production和library_test執行相同的操作。

配置 database.yml

此時，您需要讓 Rails 瞭解資料庫的使用者名稱和密碼。您可以在database.yml檔案中執行此操作，該檔案位於您建立的 Rails 應用程式的library\config子目錄中。此檔案包含 MySQL 資料庫的即時配置部分。在您使用的每個部分中，您都需要更改使用者名稱和密碼行以反映您建立的資料庫上的許可權。

完成後，它應該看起來像 -

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

PostgreSQL 資料庫設定

預設情況下，PostgreSQL 不提供任何使用者。我們必須建立新使用者。使用以下命令建立名為rubyuser的使用者。

tp> sudo -u postgres createuser rubyuser -s

如果要為新使用者建立密碼，請使用以下命令。

tp> sudo -u postgres psql

postgres=# \password rubyuser

使用以下命令建立資料庫library_development。

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

使用以下命令建立資料庫library_production。

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

使用以下命令建立資料庫library_test。

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

按Ctrl+D終止 PosgreSQL。

配置 database.yml

此時，您需要讓 Rails 瞭解資料庫的使用者名稱和密碼。您可以在database.yml檔案中執行此操作，該檔案位於您建立的 Rails 應用程式的library\config子目錄中。此檔案包含 PostgreSQL 資料庫的即時配置部分。在每個部分中，您都需要更改使用者名稱和密碼行以反映您建立的資料庫上的許可權。

完成後，它應該如下所示 -

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

接下來是什麼？

接下來的兩章解釋如何對資料庫表進行建模以及如何使用 Rails 遷移來管理這些表。

Ruby on Rails - Active Records

Rails Active Record 是 Rails 提供的物件/關係對映 (ORM) 層。它緊密遵循標準的 ORM 模型，如下所示 -

表對映到類，
行對映到物件，並且
列對映到物件屬性。

Rails Active Records 提供了關係資料庫中的表與操作資料庫記錄的 Ruby 程式程式碼之間的介面和繫結。Ruby 方法名稱會根據資料庫表的欄位名稱自動生成。

每個 Active Record 物件都有用於資料庫訪問的 CRUD（Create、Read、Update 和Delete）方法。此策略允許在資料庫表和應用程式物件之間進行簡單設計和直接對映。

將領域模型轉換為 SQL

將領域模型轉換為 SQL 通常非常簡單，只要您記住必須編寫 Rails 友好的 SQL 即可。實際上，您必須遵循某些規則 -

每個實體（如書籍）在資料庫中都有一個以其命名但使用複數形式的表（books）。
每個這樣的實體匹配表都有一個名為id的欄位，該欄位包含插入到表中的每個記錄的唯一整數。
給定實體 x 和實體 y，如果實體 y 屬於實體 x，則表 y 有一個名為 x_id 的欄位。
任何表中的大部分欄位都儲存該實體的簡單屬性的值（任何數字或字串）。

建立 Active Record 檔案（模型）

要為上一章中介紹的庫應用程式的實體建立 Active Record 檔案，請從應用程式目錄的頂層發出以下命令。

library\> ruby script/generate model Book
library\> ruby script/generate model Subject

上面的rails generate model book命令生成如下自動程式碼 -

您告訴生成器建立名為 Book 和 Subject 的模型以儲存書籍和主題的例項。請注意，您正在將 Book 和 Subject 大寫並使用單數形式。這是您每次建立模型時都應遵循的 Rails 範例。

當您使用 generate 工具時，Rails 會建立包含模型特有的所有方法以及您定義的業務規則的實際模型檔案、用於執行測試驅動開發的單元測試檔案、用於與單元測試一起使用的示例資料檔案（稱為 fixture）以及使建立資料庫表和列變得容易的 Rails 遷移。

除了建立許多其他檔案和目錄外，這還將在app/models目錄中建立名為book.rb和subject.rb的檔案，其中包含一個骨架定義。

book.rb 中的內容 -

class Book < ActiveRecord::Base
end

subject.rb 中的內容 -

class Subject < ActiveRecord::Base
end

在模型之間建立關聯

當您的 rails 應用程式中有多個模型時，您需要在這些模型之間建立連線。您可以透過關聯來實現。Active Record 支援三種類型的關聯 -

一對一 - 當一個專案恰好只有一個另一個專案時，就會存在一對一關係。例如，一個人恰好有一個生日，或者一條狗恰好有一個主人。
一對多 - 當單個物件可以成為許多其他物件的成員時，就會存在一對多關係。例如，一個主題可以包含許多書籍。
多對多 - 當第一個物件與第二個物件的多個物件相關聯，而第二個物件與第一個物件的多個物件相關聯時，就會存在多對多關係。

您可以透過向模型新增宣告來指示這些關聯：has_one、has_many、belongs_to 和 has_and_belongs_to_many。

現在，您需要告訴 Rails 您希望在庫資料系統中建立什麼關係。為此，請修改 book.rb 和 subject.rb 以如下所示 -

class Book < ActiveRecord::Base
   belongs_to :subject
end

我們在上面的示例中使用了單數主題，因為一本 Book 可以屬於一個主題。

class Subject < ActiveRecord::Base
   has_many :books
end

我們在這裡使用了複數 books，因為一個主題可以有多本書。

在模型上實現驗證

驗證的實現是在 Rails 模型中完成的。您輸入資料庫的資料在實際的 Rails 模型中定義，因此在同一位置定義有效資料意味著什麼才是合乎邏輯的。

驗證為 -

title 欄位的值不能為 NULL。
price 欄位的值應為數字。

在app\model子目錄中開啟book.rb，並放入以下驗證 -

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

validates_presence_of - 保護“NOT NULL”欄位免受使用者輸入缺失的影響。
validates_numericality_of - 防止使用者輸入非數字資料。

除了上面提到的驗證之外，還有其他一些常見的驗證。請檢視Rails 快速指南。

接下來是什麼？

在下一章中，我們將學習 Rails 遷移，它允許您使用 Ruby 定義對資料庫模式的更改，從而可以使用版本控制系統使內容與實際程式碼保持同步。

Ruby on Rails - 遷移

Rails 遷移允許您使用 Ruby 定義對資料庫模式的更改，從而可以使用版本控制系統使內容與實際程式碼保持同步。

這有許多用途，包括 -

開發人員團隊 - 如果一個人進行了模式更改，其他開發人員只需更新並執行“rake migrate”。
生產伺服器 - 當您推出新版本時，執行“rake migrate”以使資料庫也保持最新。
多臺機器 - 如果您在桌面和筆記型電腦上或多個位置進行開發，遷移可以幫助您使它們全部同步。

Rails 遷移可以做什麼？

create_table(name, options)
drop_table(name)
rename_table(old_name, new_name)
add_column(table_name, column_name, type, options)
rename_column(table_name, column_name, new_column_name)
change_column(table_name, column_name, type, options)
remove_column(table_name, column_name)
add_index(table_name, column_name, index_type)
remove_index(table_name, column_name)

遷移支援所有基本資料型別 - 以下是遷移支援的資料型別列表 -

string - 用於標題等小型資料型別。
text - 用於較長的文字資料，例如描述。
integer - 用於整數。
float - 用於小數。
datetime 和 timestamp - 將日期和時間儲存到列中。
date 和 time - 只儲存日期或時間。
binary - 用於儲存影像、音訊或電影等資料。
Boolean - 用於儲存 true 或 false 值。

有效的列選項為 - 以下是有效的列選項列表。

limit ( :limit => “50” )
default (:default => “blah” )
null (:null => false 表示NOT NULL)

注意 - Rails 遷移執行的操作可以使用任何前端 GUI 或直接在 SQL 提示符下執行，但 Rails 遷移使所有這些操作都非常容易。

有關這些內容的詳細資訊，請參閱Rails API。

建立遷移

以下是建立遷移的通用語法 -

application_dir> rails generate migration table_name

這將建立檔案 db/migrate/001_table_name.rb。遷移檔案包含描述資料庫表資料結構的基本 Ruby 語法。

注意 - 在執行遷移生成器之前，建議清理模型生成器生成的現有遷移。

我們將建立兩個與我們的三個表相對應的遷移 - books 和 subjects。

Books 遷移應如下所示 -

tp> cd library
library> rails generate migration books

以上命令生成以下程式碼。

主題遷移應如下所示 -

tp> cd library
library> rails generate migration subjects

以上命令生成以下程式碼。

請注意，在建立遷移時，您使用的是小寫的 book 和 subject 以及複數形式。這是一個 Rails 正規化，您每次建立遷移時都應該遵循。

編輯程式碼

轉到應用程式的 db/migrate 子目錄，並使用任何簡單的文字編輯器逐個編輯每個檔案。

修改 001_books.rb 如下所示 -

ID 列將自動建立，因此也不要在這裡建立它。

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

方法self.up用於遷移到新版本，self.down用於在需要時回滾任何更改。目前，上述指令碼將用於建立books表。

修改 002_subjects.rb 如下所示 -

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

上述指令碼將用於建立subjects表，並在 subjects 表中建立五條記錄。

執行遷移

現在您已經建立了所有必需的遷移檔案。現在是時候針對資料庫執行它們了。為此，請轉到命令提示符並轉到應用程式所在的庫目錄，然後鍵入rake migrate，如下所示 -

library> rake db:migrate

如果不存在，這將建立一個“schema_info”表，用於跟蹤資料庫的當前版本 - 每個新的遷移都將是一個新版本，並且將執行任何新的遷移，直到您的資料庫達到當前版本。

Rake是一個 Ruby 構建程式，類似於 Rails 利用的 Unix make 程式，用於簡化複雜任務（如更新資料庫結構等）的執行。

執行生產和測試資料庫的遷移

如果您想指定要用於遷移的 Rails 環境，請使用 RAILS_ENV shell 變數。

例如 -

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

注意 - 在 Windows 中，使用“set RAILS_ENV = production”代替export命令。

接下來是什麼？

現在我們有了資料庫和所需的表。在接下來的兩章中，我們將探討兩個重要的元件，即控制器（ActionController）和檢視（ActionView）。

建立控制器（Action Controller）。
建立檢視（Action View）。

Ruby on Rails - 控制器

Rails 控制器是應用程式的邏輯中心。它協呼叫戶、檢視和模型之間的互動。控制器也是許多重要輔助服務的所在地。

它負責將外部請求路由到內部操作。它非常出色地處理使用者友好的 URL。
它管理快取，這可以使應用程式的效能提升數倍。
它管理輔助模組，這些模組擴充套件了檢視模板的功能，而不會增加其程式碼量。
它管理會話，讓使用者感覺與我們的應用程式進行持續互動。

建立控制器的過程非常簡單，類似於我們之前用於建立模型的過程。我們這裡只建立一個控制器 -

library\> rails generate controller Book

請注意，您正在將 Book 大寫並使用單數形式。這是一個 Rails 正規化，您每次建立控制器時都應該遵循。

此命令完成多個任務，其中以下任務在此相關 -

它建立一個名為app/controllers/book_controller.rb的檔案

如果您檢視 book_controller.rb，您會發現它如下所示 -

class BookController < ApplicationController
end

控制器類繼承自ApplicationController，它是控制器資料夾中的另一個檔案：application.rb。

ApplicationController包含可以在所有控制器中執行的程式碼，並且它繼承自 Rails ActionController::Base 類。

您暫時不需要擔心ApplicationController，因此讓我們在book_controller.rb中定義一些方法存根。根據您的需求，您可以在此檔案中定義任意數量的函式。

修改檔案使其看起來如下所示並儲存您的更改。請注意，您可以根據需要為這些方法命名，但最好使用相關的名稱。

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

現在讓我們逐個實現所有方法。

實現 list 方法

list 方法為您提供資料庫中所有書籍的列表。此功能將透過以下程式碼行實現。在 book_controller.rb 檔案中編輯以下行。

def list
   @books = Book.all
end

list 方法中的@books = Book.all行告訴 Rails 搜尋 books 表並將找到的每一行儲存在 @books 例項物件中。

實現 show 方法

show 方法僅顯示單個書籍的更多詳細資訊。此功能將透過以下程式碼行實現。

def show
   @book = Book.find(params[:id])
end

show 方法的@book = Book.find(params[:id])行告訴 Rails 僅查詢 params[:id] 中定義的 id 的書籍。

params 物件是一個容器，使您能夠在方法呼叫之間傳遞值。例如，當您在 list 方法呼叫的頁面上時，您可以單擊特定書籍的連結，它會透過 params 物件傳遞該書籍的 id，以便 show 可以找到特定的書籍。

實現 new 方法

new 方法讓 Rails 知道您將建立一個新物件。因此，只需在此方法中新增以下程式碼即可。

def new
   @book = Book.new
   @subjects = Subject.all
end

當您向用戶顯示一個頁面以獲取使用者輸入時，將呼叫上述方法。這裡的第二行從資料庫中獲取所有主題並將它們放入一個名為 @subjects 的陣列中。

實現 create 方法

使用 HTML 表單獲取使用者輸入後，是時候將記錄建立到資料庫中了。為此，請編輯 book_controller.rb 中的 create 方法以匹配以下內容 -

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

第一行建立一個名為 @book 的新例項變數，該變數儲存一個由使用者提交的資料構建的 Book 物件。book_params方法用於從物件:books收集所有欄位。資料是從 new 方法透過 params 物件傳遞給 create 的。

下一行是一個條件語句，如果物件成功儲存到資料庫，則將使用者重定向到list方法。如果未儲存，則使用者將被送回 new 方法。redirect_to 方法類似於在網頁上執行元重新整理：它會在沒有任何使用者互動的情況下自動將您轉發到您的目標。

然後@subjects = Subject.all是必需的，以防它沒有成功儲存資料，並且它與 new 選項的情況類似。

實現 edit 方法

edit 方法看起來與 show 方法幾乎相同。這兩種方法都用於根據物件的 id 檢索單個物件並在頁面上顯示它。唯一的區別是 show 方法不可編輯。

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

此方法將被呼叫以在螢幕上顯示資料，以便使用者修改。第二行從資料庫中獲取所有主題並將它們放入一個名為 @subjects 的陣列中。

實現 update 方法

此方法將在 edit 方法之後呼叫，當用戶修改資料並希望將更改更新到資料庫中時。update 方法類似於 create 方法，將用於更新資料庫中現有的書籍。

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

update_attributes 方法類似於 create 使用的 save 方法，但它不是在資料庫中建立新行，而是覆蓋現有行的屬性。

然後@subjects = Subject.all行是必需的，以防它沒有成功儲存資料，那麼它就類似於 edit 選項。

實現 delete 方法

如果要從資料庫中刪除記錄，則可以使用此方法。請按如下方式實現此方法。

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

第一行根據透過 params 物件傳遞的引數查詢分類，然後使用 destroy 方法將其刪除。第二行使用 redirect_to 呼叫將使用者重定向到 list 方法。

顯示主題的其他方法

假設您想為使用者提供根據給定主題瀏覽所有書籍的功能。因此，您可以在 book_controller.rb 中建立一個方法來顯示所有主題。假設方法名稱為show_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

最後，您的book_controller.rb檔案將如下所示 -

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

現在儲存您的控制器檔案。

接下來是什麼？

您已經建立了幾乎所有將在後端工作的方法。接下來，我們將為操作定義路由（URL）。

Ruby on Rails - 路由

路由模組以原生 Ruby 提供 URL 重寫。這是一種將傳入請求重定向到控制器和操作的方法。它替換了 mod_rewrite 規則。最棒的是，Rails 的路由適用於任何 Web 伺服器。路由在 app/config/routes.rb 中定義。

可以將建立路由視為為您的請求繪製地圖。該地圖根據一些預定義的模式告訴它們去哪裡 -

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

示例

讓我們考慮一下我們的圖書館管理應用程式包含一個名為 BookController 的控制器。我們必須為在 BookController 類中定義為方法的那些操作定義路由。

在 library/config/ 目錄中開啟 routes.rb 檔案，並使用以下內容對其進行編輯。

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

routes.rb 檔案定義了應用程式中可用的操作以及操作型別，例如 get、post 和 patch。

使用以下命令列出所有已定義的路由，這些路由對於跟蹤應用程式中的路由問題或讓您全面瞭解您嘗試熟悉的應用程式中的 URL 很有用。

library> rake routes

接下來是什麼？

接下來，我們將建立程式碼以生成螢幕以顯示資料並從使用者那裡獲取輸入。

Ruby on Rails - 檢視

Rails 檢視是一個 ERb 程式，它透過相互可訪問的變數與控制器共享資料。

如果您檢視 library 應用程式的 app/views 目錄，您將看到我們建立的每個控制器的子目錄：book。這些子目錄中的每一個都是在使用 generate 指令碼建立同名控制器時自動建立的。

Rails 會讓您知道您需要為每個新方法建立檢視檔案。您在控制器中定義的每個方法都需要有一個相應的erb檔案，其名稱與方法相同，以顯示方法正在收集的資料。

因此，讓我們為我們在 book_controller.rb 中定義的所有方法建立檢視檔案。在執行這些檢視的同時，同時檢查這些操作是否適用於資料庫。

為 list 方法建立檢視檔案

使用您喜歡的文字編輯器建立一個名為list.html.erb的檔案，並將其儲存到 app/views/book 中。建立並儲存檔案後，重新整理您的 Web 瀏覽器。您應該會看到一個空白頁面；如果看不到，請檢查檔案的拼寫，並確保它與控制器的名稱完全相同。

現在，顯示實際內容。讓我們將以下程式碼放入 list.html.erb 中。

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

要執行的程式碼是檢查 @books 陣列中是否有任何物件。如果陣列為空，.blank?方法返回 true，如果陣列包含任何物件，則返回 false。此 @books 物件是在控制器中的 list 方法內部建立的。

<%= %> 標記之間的程式碼是link_to方法呼叫。link_to 的第一個引數是要在 <a> 標記之間顯示的文字。第二個引數是在單擊連結時呼叫的操作。在本例中，它是 show 方法。最後一個引數是透過 params 物件傳遞的書籍的 id。

現在，嘗試重新整理您的瀏覽器，您應該會看到以下螢幕，因為我們的庫中沒有任何書籍。

為新方法建立檢視檔案

到目前為止，我們的庫中沒有任何書籍。我們必須在系統中建立一些書籍。因此，讓我們設計一個與book_controller.rb中定義的new方法相對應的檢視。

使用您喜歡的文字編輯器建立一個名為new.html.erb的檔案，並將其儲存到app/views/book。將以下程式碼新增到new.html.erb檔案。

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

這裡form_tag方法將Ruby程式碼解釋成一個普通的HTML <form>標籤，使用提供給它的所有資訊。例如，此標籤輸出以下HTML -

<form action = "/book/create" method = "post">

下一個方法是text_field，它輸出一個<input>文字欄位。text_field的引數是物件和欄位名稱。在本例中，物件是book，名稱是title。

Rails方法稱為collection_select，它根據陣列（例如@books）建立一個HTML選擇選單。有五個引數，如下所示 -

:book - 您正在操作的物件。在本例中，它是一個book物件。
:subject_id - 儲存書籍時填充的欄位。
@books - 您正在使用的陣列。
:id - 儲存在資料庫中的值。在HTML方面，這是<option>標籤的value引數。
:name - 使用者在下拉選單中看到的輸出。這是<option>標籤之間的值。

接下來使用的是submit_tag，它輸出一個<input>按鈕，用於提交表單。最後，有一個end方法，它簡單地轉換為</form>。

轉到您的瀏覽器並訪問https://:3000/book/new。這將為您提供以下螢幕。

在此表單中輸入一些資料，然後單擊建立按鈕。在這裡，我在欄位中添加了以下詳細資訊 -

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

當您單擊建立按鈕時，它將呼叫create方法，該方法不需要任何檢視，因為此方法使用list或new方法檢視結果。因此，當您單擊建立按鈕時，資料應成功提交併重定向到列表頁面，其中您現在有一個列出的專案，如下所示 -

如果您單擊連結，您應該會看到另一個模板丟失錯誤，因為您尚未為show方法建立模板檔案。

為show方法建立檢視檔案

此方法將顯示庫中任何書籍的完整詳細資訊。在app/views/book下建立一個show.html.erb檔案，並使用以下程式碼填充它 -

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

這是您第一次充分利用關聯，它使您能夠輕鬆地從相關物件中提取資料。

使用的格式是@variable.relatedObject.column。在本例中，您可以透過@book變數使用belongs_to關聯來提取主題的名稱值。如果單擊任何列出的記錄，它將顯示以下螢幕。

為edit方法建立檢視檔案

建立一個名為edit.html.erb的新檔案，並將其儲存到app/views/book。使用以下程式碼填充它 -

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

此程式碼與new方法非常相似，只是要更新操作而不是建立並定義ID。

在這種情況下，我們對錶單操作使用了form_for標籤。它的效能將優於form_tag。為什麼呢？因為它可以輕鬆地與模型互動。因此，當您需要模型和表單欄位之間的互動時，最好使用form_for標籤。

此時，我們需要修改list方法的檢視檔案。轉到<li></li>元素並將其修改為如下所示 -

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

現在，嘗試使用https://:3000/book/list瀏覽書籍。它將為您提供所有書籍的列表以及編輯選項。當您單擊編輯選項時，您將看到下一個螢幕，如下所示 -

現在，編輯此資訊，然後單擊儲存更改按鈕。這將導致呼叫控制器檔案中可用的update方法，它將更新所有更改的屬性。請注意，update方法不需要任何檢視檔案，因為它使用show或edit方法顯示其結果。

為delete方法建立檢視檔案

使用Ruby on Rails從資料庫中刪除資訊幾乎太容易了。您不需要為delete方法編寫任何檢視程式碼，因為此方法使用list方法顯示結果。因此，讓我們再次修改list.html.erb並新增一個刪除連結。

轉到<li></li>元素並將其修改為如下所示 -

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

:confirm引數會顯示一個JavaScript確認框，詢問您是否真的要執行此操作。如果使用者單擊“確定”，則操作繼續，並且專案被刪除。

現在，嘗試使用https://:3000/book/list瀏覽書籍。它將為您提供所有書籍的列表以及編輯和刪除選項，如下所示 -

現在，使用刪除選項，您可以刪除任何列出的記錄。

為show_subjects方法建立檢視檔案

在app/views/book目錄中建立一個新檔案show_subjects.html.erb，並將以下程式碼新增到其中 -

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

您正在利用關聯透過單個主題的許多書籍列表進行迭代。

現在修改show.html.erb的Subject:行，以便主題列表顯示一個連結。

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

這將在索引頁面上輸出主題列表，以便使用者可以直接訪問它們。

修改list.html.erb以將以下內容新增到檔案的頂部 -

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

現在嘗試使用https://:3000/book/list瀏覽書籍。它將顯示所有主題及其連結，以便您可以瀏覽與該主題相關的所有書籍。

接下來是什麼？

希望您現在對Rails的所有操作都感到滿意。

下一章將解釋如何使用佈局以更好的方式呈現您的資料。我們將向您展示如何在Rails應用程式中使用CSS。

Ruby on Rails - 佈局

佈局定義了HTML頁面的周圍環境。它是定義最終輸出的通用外觀和感覺的地方。佈局檔案位於app/views/layouts中。

此過程涉及定義佈局模板，然後讓控制器知道它存在並使用它。首先，讓我們建立模板。

將一個名為standard.html.erb的新檔案新增到app/views/layouts。您透過檔名讓控制器知道要使用哪個模板，因此建議遵循相同的命名方案。

將以下程式碼新增到新的standard.html.erb檔案並儲存您的更改 -

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

您剛剛新增的所有內容都是標準的HTML元素，除了兩行。stylesheet_link_tag輔助方法輸出一個樣式表<link>。在本例中，我們連結了style.css樣式表。yield命令讓Rails知道它應該放置此處呼叫的方法的html.erb。

現在開啟book_controller.rb並在第一行下方新增以下行 -

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

它指示控制器我們想要使用standard.html.erb檔案中可用的佈局。現在嘗試瀏覽書籍，這將產生以下螢幕。

新增樣式表

到目前為止，我們還沒有建立任何樣式表，因此Rails正在使用預設樣式表。現在讓我們建立一個名為style.css的新檔案，並將其儲存到/public/stylesheets。將以下程式碼新增到此檔案。

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

現在重新整理您的瀏覽器並檢視差異 -

接下來是什麼？

下一章將解釋如何使用Rails腳手架開發應用程式，以允許使用者訪問資料庫中任何記錄的新增、刪除和修改。

Ruby on Rails - 腳手架

在開發Rails應用程式時，特別是那些主要為您提供資料庫中資料的簡單介面的應用程式，使用腳手架方法通常很有用。

腳手架提供的不僅僅是廉價的演示快感。以下是一些好處 -

您可以快速向用戶提供程式碼以獲取反饋。
您會因更快的成功而受到激勵。
您可以透過檢視生成的程式碼來了解Rails的工作原理。
您可以使用腳手架作為基礎來啟動您的開發。

腳手架示例

為了理解腳手架，讓我們建立一個名為cookbook的資料庫和一個名為recipes的表。

建立空的 Rails Web 應用程式

開啟命令視窗並導航到您要建立此cookbook Web應用程式的位置。因此，執行以下命令以建立完整的目錄結構。

tp> rails new cookbook

設定資料庫

以下是建立資料庫的方法 -

mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

要指示Rails如何查詢資料庫，請編輯配置檔案cookbook\config\database.yml並將資料庫名稱更改為cookbook。將密碼留空。完成後，它應如下所示 -

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

Rails允許您在開發模式、測試模式或生產模式下執行，使用不同的資料庫。此應用程式對每個模式使用相同的資料庫。

生成的腳手架程式碼

使用腳手架操作，Rails會動態生成它需要的所有程式碼。透過將scaffold作為指令碼執行，我們可以將所有程式碼寫入磁碟，在那裡我們可以對其進行檢查，然後開始根據我們的需求對其進行調整。

所以現在，讓我們再次開始使用腳手架輔助指令碼手動生成腳手架程式碼 -

cookbook> rails generate scaffold recipe

它生成如下所示的自動檔案 -

控制器

讓我們看看控制器背後的程式碼。此程式碼由scaffold生成器生成。如果開啟app/controllers/recipes_controller.rb，您將找到如下內容 -

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

當Rails應用程式的使用者選擇一個操作（例如“顯示”）時，控制器將執行相應部分中的任何程式碼 - “def show” - 然後預設情況下將呈現同名的模板 - “show.html.erb”。此預設行為可以被覆蓋。

控制器使用ActiveRecord方法（如find、find_all、new、save、update_attributes和destroy）將資料移動到資料庫表和資料庫表之間。請注意，您不必編寫任何SQL語句，rails會自動處理它。

這單行程式碼將使資料庫表活躍起來。它將提供一個簡單的介面來訪問您的資料，以及以下方法 -

建立新條目
編輯當前條目
檢視當前條目
銷燬當前條目

在建立或編輯條目時，腳手架將為您完成所有繁重的工作，如表單生成和處理，甚至提供智慧表單生成，支援以下型別的輸入 -

簡單的文字字串
文字區域（或大塊文字）
日期選擇器
日期時間選擇器

您可以使用Rails遷移建立和維護表。

rake db:migrate RAILS_ENV=development

現在，轉到cookbook目錄並使用以下命令執行Web伺服器 -

cookbook> rails server

現在，開啟瀏覽器並導航到http://127.0.0.1:3000/recipe/new。這將為您提供一個螢幕，用於在recipes表中建立新條目。螢幕截圖如下所示 -

按下建立按鈕建立新食譜後，您的記錄將新增到recipes表中，並顯示以下結果 -

您可以看到編輯、顯示和銷燬記錄的選項。因此，請嘗試使用這些選項。

您還可以使用URL http://127.0.0.1:3000/recipe/list列出recipes表中所有可用的食譜。

增強模型

Rails 會自動為你提供很多錯誤處理功能。為了理解這一點，請在空的 recipe 模型中新增一些驗證規則 -

修改 app/models/recipe.rb 如下，然後測試你的應用程式 -

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

這些條目將提供自動檢查。

validates_length_of - 欄位不能為空且長度不能過長。
validates_uniqueness_of - 重複值會被捕獲。這裡我們給出了自定義訊息，而不是預設的 Rails 錯誤訊息。

建立腳手架的另一種方法

如上所示建立應用程式，以及生成的腳手架程式碼如下所示

rails g scaffold Recipe tittle:string instructions:text

以上程式碼使用 sqlite3 生成包含資料庫的自動檔案，標題和說明列如下面的圖片所示。

我們需要使用以下語法遷移資料庫。

$ rake db:migrate RAILS_ENV=development

最後，使用以下命令列執行應用程式 -

rails server

它將生成如上所示的輸出影像的結果。

檢視

所有檢視和相應的控制器方法都是由scaffold命令建立的，它們位於 app/views/recipes 目錄中。

腳手架有什麼不同？

如果你已經閱讀了前面的章節，你一定已經看到我們建立了列出、顯示、刪除和建立資料等方法，但腳手架會自動完成這項工作。

Ruby on Rails - AJAX

Ajax 代表非同步JavaScript和XML。Ajax 不是一項單一的技術，它是一套多種技術的組合。Ajax 包含以下內容 -

用於網頁標記的 XHTML
用於樣式的 CSS
使用 DOM 進行動態顯示和互動
使用 XML 進行資料操作和交換
使用 XMLHttpRequest 檢索資料
JavaScript 作為將所有這些粘合在一起的膠水

Ajax 使你能夠檢索網頁資料，而無需重新整理整個頁面的內容。在基本的 Web 架構中，使用者單擊連結或提交表單。表單提交到伺服器，然後伺服器傳送迴響應。然後在新的頁面上向用戶顯示響應。

當你與支援 Ajax 的網頁互動時，它會在後臺載入 Ajax 引擎。該引擎是用 JavaScript 編寫的，它負責與 Web 伺服器通訊並將結果顯示給使用者。當你使用支援 Ajax 的表單提交資料時，伺服器會返回一個包含伺服器響應的 HTML 片段，並且只顯示新的或更改的資料，而不是重新整理整個頁面。

有關 AJAX 的完整詳細資訊，你可以檢視我們的 AJAX 教程

Rails 如何實現 Ajax

Rails 擁有一個簡單一致的模型來實現 Ajax 操作。一旦瀏覽器渲染並顯示了初始網頁，不同的使用者操作會導致它顯示一個新的網頁（就像任何傳統的 Web 應用程式一樣）或觸發一個 Ajax 操作 -

某些觸發器觸發 - 此觸發器可能是使用者單擊按鈕或連結、使用者更改表單或欄位中的資料，或者只是一個週期性觸發器（基於計時器）。
Web 客戶端呼叫伺服器 - JavaScript 方法XMLHttpRequest將與觸發器關聯的資料傳送到伺服器上的操作處理程式。資料可能是複選框的 ID、條目欄位中的文字或整個表單。
伺服器執行處理 - 伺服器端操作處理程式（Rails 控制器操作）對資料執行某些操作並將 HTML 片段返回給 Web 客戶端。
客戶端接收響應 - Rails 自動建立的客戶端 JavaScript 接收 HTML 片段並使用它來更新當前頁面 HTML 的指定部分，通常是<div>標籤的內容。

這些步驟是在 Rails 應用程式中使用 Ajax 的最簡單方法，但只需稍加努力，你就可以讓伺服器返回任何型別的資料以響應 Ajax 請求，並且可以在瀏覽器中建立自定義 JavaScript 來執行更復雜的互動。

AJAX 示例

此示例基於腳手架，刪除概念基於 ajax。

在此示例中，我們將對 ponies 表執行列出、顯示和建立操作。如果你不理解腳手架技術，我們建議你首先閱讀前面的章節，然後再繼續學習 Rails 上的 AJAX。

建立應用程式

讓我們從建立應用程式開始，操作如下 -

rails new ponies

以上命令建立了一個應用程式，現在我們需要使用 cd 命令呼叫 app 目錄。它將進入應用程式目錄，然後我們需要呼叫 scaffold 命令。操作如下 -

rails generate scaffold Pony name:string profession:string

以上命令生成包含 name 和 profession 列的腳手架。我們需要如下命令遷移資料庫

rake db:migrate

現在執行 Rails 應用程式，命令如下

rails s

現在開啟 Web 瀏覽器並呼叫 url https://:3000/ponies/new，輸出如下

建立 Ajax

現在使用合適的文字編輯器開啟 app/views/ponies/index.html.erb。使用 :remote => true, :class => 'delete_pony' 更新你的 destroy 行。最後，它看起來如下所示。

建立一個檔案 destroy.js.erb，將其放在其他 .erb 檔案旁邊（在 app/views/ponies 下）。它應該如下所示 -

現在在 destroy.js.erb 中輸入如下所示的程式碼

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

現在開啟你的控制器檔案，該檔案位於 app/controllers/ponies_controller.rb 中，並在 destroy 方法中新增如下所示的程式碼 -

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

最後，控制器頁面如下圖所示。

現在執行應用程式，從 https://:3000/ponies/new 呼叫的輸出，它將如下圖所示

按下建立小馬按鈕，它將生成如下結果

現在單擊後退按鈕，它將顯示所有建立的小馬資訊，如下圖所示

到目前為止，我們一直在使用腳手架，現在單擊刪除按鈕，它將呼叫一個彈出視窗，如下圖所示，該彈出視窗基於 Ajax。

如果單擊確定按鈕，它將從 pony 中刪除記錄。這裡我單擊了確定按鈕。最終輸出如下 -

Ruby on Rails - 檔案上傳

你可能需要讓你的網站訪問者將檔案上傳到你的伺服器上。Rails 使得處理此需求變得非常容易。現在我們將繼續進行一個簡單的小型 Rails 專案。

像往常一樣，讓我們從一個名為testfile的新 Rails 應用程式開始。讓我們使用簡單的 rails 命令建立應用程式的基本結構。

tp> rails new testfile

在開始應用程式開發之前，我們應該安裝如下所示的 gem 檔案 -

gem install carrierwave
gem install bootstrap-sass

開啟你的 gemfile 並將以下兩個 gem 新增到底部，如下圖所示 -

在 gem 檔案中新增 gem 後，我們需要在控制檯中執行以下命令 -

bundle install

建立模型

我們需要建立一個包含兩個字串的模型，分別為 name 和 attachment，如下所示 -

rails g model Resume name:string attachment:string

我們需要建立資料庫遷移，如下所示 -

rake db:migrate

我們需要生成控制器，如下所示 -

rails g controller Resumes index new create destroy

太好了！現在我們已經設定了基本結構。現在我們需要建立一個上傳器。上傳器來自 carrierwave gem，它告訴 carrierwave 如何處理檔案。簡而言之，它包含所有檔案處理功能。執行以下命令以建立上傳器

rails g uploader attachment

現在開啟 resume 模型並呼叫上傳器，如下所示。Resume 模型位於 app/models/resume.rb 中 -

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

在處理控制器之前，我們需要修改我們的 config/routes.db，如下所示 -

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

讓我們編輯控制器，如下所示。

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

讓我們在 css 檔案中新增 bootstrap 實現。css 檔案可能在 app/assets/stylesheets/resumes.css.scss 中

@import "bootstrap";

現在開啟 app/views/layouts/application.html.erb 並新增如下所示的程式碼 -

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

現在我們需要設定索引檢視，如下所示 -

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

現在，讓我們編輯 new.html.erb 並新增我們的表單程式碼。

<% if !@resume.errors.empty? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

現在啟動伺服器並訪問 https://:3000。它將生成類似於以下螢幕的螢幕 -

我們需要做的最後一件事是過濾允許的檔案型別列表。為此，我們需要在 app/uploaders/attachment_uploader.rb 中新增如下所示的簡單程式碼

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

現在啟動伺服器並訪問 https://:3000。現在輸入錯誤的格式，它將生成錯誤訊息，如下所示 -

有關檔案物件的完整詳細資訊，你需要查閱Ruby 參考手冊。

Ruby on Rails - 傳送郵件

Action Mailer是 Rails 元件，它使應用程式能夠傳送和接收電子郵件。在本章中，我們將瞭解如何使用 Rails 傳送電子郵件。讓我們開始使用以下命令建立emails專案。

tp> rails new mailtest

這將建立繼續所需的框架。現在，我們將從配置 ActionMailer 開始。

Action Mailer - 配置

在繼續實際工作之前，您需要按照以下步驟完成配置 -

轉到 emails 專案的 config 資料夾並開啟 environment.rb 檔案，並在該檔案的底部新增以下行。

config.action_mailer.delivery_method = :smtp

它告訴 ActionMailer 你想使用 SMTP 伺服器。如果使用基於 Unix 的作業系統（例如 Mac OS X 或 Linux），也可以將其設定為 :sendmail。

在 environment.rb 的底部新增以下程式碼行。

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

將每個雜湊值替換為你自己的簡單郵件傳輸協議 (SMTP) 伺服器的正確設定。如果你還不知道，可以從你的網際網路服務提供商那裡獲取此資訊。如果你使用的是標準 SMTP 伺服器，則無需更改埠號 25 和身份驗證型別。

你也可以更改預設的電子郵件訊息格式。如果你希望以 HTML 而不是純文字格式傳送電子郵件，請在 config/environment.rb 中新增以下行 -

ActionMailer::Base.default_content_type = "text/html"

ActionMailer::Base.default_content_type 可以設定為 "text/plain"、"text/html" 和 "text/enriched"。預設值為 "text/plain"。

下一步將是建立一個郵件程式

生成郵件程式

使用以下命令生成郵件程式，如下所示 -

tp> cd emails
emails> rails generate mailer Usermailer

這將在 app\mailer 目錄中建立一個檔案 user_mailer.rb。檢查此檔案的內容，如下所示 -

class Emailer < ActionMailer::Base
end

讓我們建立一個方法，如下所示 -

class UserMailer < ApplicationMailer
   default from: 'notifications@example.com'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash - 這是從該郵件程式傳送的任何電子郵件的預設值的雜湊。在這種情況下，我們正在將 :from 標頭設定為此類中所有訊息的值。可以在每個電子郵件的基礎上覆蓋此設定
mail - 實際的電子郵件訊息，我們正在傳遞 :to 和 :subject 標頭。

在 app/views/user_mailer/ 中建立一個名為 welcome_email.html.erb 的檔案。這將是用於電子郵件的模板，以 HTML 格式顯示 -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

接下來，我們將為此應用程式建立一個文字部分，如下所示 -

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

呼叫郵件程式

首先，讓我們建立一個簡單的 User 腳手架

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer 與 Active Job 很好地整合在一起，因此你可以在請求-響應週期之外發送電子郵件，因此使用者不必等待它 -

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

現在，使用 http://127.0.0.1:3000/users/new 測試你的應用程式。它顯示以下螢幕，並使用此螢幕，你將能夠向任何人傳送訊息。

這將傳送您的訊息，並顯示文字訊息“訊息傳送成功”，輸出如下：

sent mail to kittuprasad700@gmail.com (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: notification@example.com
To: kittuprasad700@gmail.com
Message-Id: <559e112d63c57_f1031e7f23467@kiranPro.mail>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

有關如何使用 Rails 傳送電子郵件的更多資訊，請參閱 ActionMailer。

列印頁面

Ruby on Rails 快速指南

Ruby on Rails - 簡介

什麼是 Ruby？

為什麼選擇 Ruby？

Ruby 程式碼示例

嵌入式 Ruby

什麼是 Rails？

全棧框架

約定優於配置

Rails 的優勢

超程式設計

Active Record

約定優於配置

腳手架

內建測試

三個環境

Ruby on Rails - 安裝

在 Windows 上安裝 Rails

步驟 1：檢查 Ruby 版本

步驟 2：安裝 Ruby

步驟 3：安裝 Rails

步驟 4：檢查 Rails 版本

在 Linux 上安裝 Rails

步驟 1：安裝先決條件依賴項

步驟 2：安裝 rbenv

步驟 3：安裝 Ruby

步驟 4：安裝 Rails

步驟 5：安裝 JavaScript 執行時

步驟 6：安裝資料庫

保持 Rails 更新

安裝驗證

Ruby on Rails - 框架

Ruby on Rails MVC 框架

模型 (ActiveRecord)

檢視 (ActionView)

控制器 (ActionController)

MVC 框架的圖形表示

MVC 框架的目錄表示

Ruby on Rails - 目錄結構

Ruby on Rails - 示例

建立 Rails 應用程式的工作流程

建立空的 Rails Web 應用程式

啟動 Web 伺服器

接下來是什麼？

Ruby on Rails - 資料庫設定

MySQL 資料庫設定

配置 database.yml

PostgreSQL 資料庫設定

配置 database.yml

接下來是什麼？

Ruby on Rails - Active Records

將領域模型轉換為 SQL

建立 Active Record 檔案（模型）

在模型之間建立關聯

在模型上實現驗證

接下來是什麼？

Ruby on Rails - 遷移

Rails 遷移可以做什麼？

建立遷移

編輯程式碼

執行遷移

執行生產和測試資料庫的遷移

接下來是什麼？

Ruby on Rails - 控制器

實現 list 方法

實現 show 方法

實現 new 方法

實現 create 方法

實現 edit 方法

實現 update 方法

實現 delete 方法

顯示主題的其他方法

接下來是什麼？

Ruby on Rails - 路由

示例

接下來是什麼？

Ruby on Rails - 檢視

為 list 方法建立檢視檔案

為新方法建立檢視檔案

為show方法建立檢視檔案