Templates, Partials, and Layouts

在 Rails 中，檢視是用於呈現 HTML、XML、JSON 等響應的模板。Rails 的檢視系統支援模板、區域性模板和佈局模板，它們分別用於分離程式碼、提高程式碼重用性和提供統一的外觀。

模板是檢視的基本構建塊。模板可以包含 HTML、Ruby 程式碼和其他標記，以生成動態內容。在 Rails 中，模板通常儲存在 app/views 目錄中，並使用副檔名 .html.erb、.xml.builder 或 .json.jbuilder 等來表示相應的格式。

區域性模板是一種特殊型別的模板，它可以在其他模板中重複使用。區域性模板通常用於呈現通用的部分，例如頁首、頁尾、導航欄等。在 Rails 中，區域性模板通常儲存在 app/views 目錄下的 partials 子目錄中，並使用前導下劃線 _ 來表示。

佈局模板是一種用於定義應用程式的外觀和結構的模板。佈局模板定義了應用程式的共同元素，例如頁首、頁尾、導航欄等。在 Rails 中，佈局模板通常儲存在 app/views/layouts 目錄中，並使用副檔名 .html.erb 或 .html.haml 來表示。您可以在控制器中使用 layout 方法來指定佈局模板。例如，如果您想要使用名為 application.html.erb 的佈局模板，可以在控制器中使用以下程式碼：

class MyController < ApplicationController
  layout 'application'
  # ...
end

在這個例子中，layout 方法告訴 Rails 使用名為 application.html.erb 的佈局模板來呈現該控制器的響應。

總之，Rails 的檢視系統支援模板、區域性模板和佈局模板，它們分別用於分離程式碼、提高程式碼重用性和提供統一的外觀。模板是檢視的基本構建塊，區域性模板可以在其他模板中重複使用，佈局模板用於定義應用程式的外觀和結構。

Templates

在 Rails 中，檢視是用於呈現 HTML、XML、JSON 等響應的模板。檢視通常由一個控制器動作觸發，該動作會渲染一個檢視模板並將其作為響應傳送給使用者端。Rails 檢視系統支援多種格式，例如 HTML、XML、JSON 等，並且可以使用不同的模板語言，例如 ERB、Haml、Slim 等。

檢視模板通常儲存在 app/views 目錄中，並使用副檔名 .html.erb、.xml.builder 或 .json.jbuilder 等來表示相應的格式。模板檔案包含了 HTML、Ruby 程式碼和其他標記，以生成動態內容。在模板中，您可以使用 Ruby 程式碼來存取控制器範例變數和輔助方法，並使用標記來生成 HTML 或其他格式的內容。

例如，以下是一個簡單的 ERB 模板，用於顯示使用者的名稱和電子郵件地址：

<h1><%= @user.name %></h1>
<p><%= @user.email %></p>

在這個例子中，模板使用 <%= %> 標記來呈現 @user 範例變數的值。渲染此模板後，將生成一個包含使用者名稱稱和電子郵件地址的 HTML 頁面。

總之，檢視是用於呈現 HTML、XML、JSON 等響應的模板。模板通常儲存在 app/views 目錄中，並使用副檔名 .html.erb、.xml.builder 或 .json.jbuilder 等來表示相應的格式。模板檔案包含了 HTML、Ruby 程式碼和其他標記，以生成動態內容。在模板中，您可以使用 Ruby 程式碼來存取控制器範例變數和輔助方法，並使用標記來生成 HTML 或其他格式的內容。

Partials

Partials 是 Ruby on Rails 中的一個功能，它允許我們將檢視程式碼分解成多個小塊，以便更好地組織和重用。Partials 通常用於在檢視中呈現重複的程式碼或元件，例如頁首、頁尾、導航欄、表單等。

使用 Partials，我們可以將檢視程式碼分解成多個檔案，並在其他檢視中包含它們。這樣，我們就可以避免重複編寫相同的程式碼，並使程式碼更加易於維護和更新。

以下是一個使用 Partials 的簡單範例：

假設我們有一個顯示部落格文章的檢視 show.html.erb，它包含一個標題、作者和內容。我們可以將這個檢視分解成多個 Partials，如下所示：

# app/views/posts/_header.html.erb

<h1><%= @post.title %></h1>
<p><%= @post.author %></p>

# app/views/posts/_content.html.erb

<p><%= @post.content %></p>

# app/views/posts/show.html.erb

<%= render 'header' %>
<%= render 'content' %>

在這個範例中，我們建立了兩個 Partials _header.html.erb 和 _content.html.erb，它們分別呈現文章的標題、作者和內容。在 show.html.erb 檢視中，我們使用 render 方法包含這兩個 Partials。

Rails 預設會在檢視資料夾中查詢以下劃線開頭的檔案，並將它們視為 Partials。在我們的範例中，Rails 將自動查詢 _header.html.erb 和 _content.html.erb 檔案，並將它們呈現到 show.html.erb 中。

使用 Partials，我們可以將檢視程式碼分解成更小的塊，並在需要時將它們組合在一起。這使得程式碼更加易於管理和重用，從而提高開發效率。

Partial Layouts

Partial Layouts 是 Ruby on Rails 中的一個功能，它允許我們在 Partial 中使用佈局，並可以在需要時覆蓋 Partial 中的佈局。這種方式可以幫助我們更好地組織和重用檢視程式碼，特別是對於一些帶有共同佈局的檢視。

使用 Partial Layouts，我們可以將一個佈局檔案分解成多個 Partial，並在需要時組合在一起。這樣可以使佈局更加靈活和易於管理，從而提高開發效率。

以下是一個使用 Partial Layouts 的簡單範例：

假設我們有一個顯示部落格文章的檢視 show.html.erb，它包含一個標題、作者和內容。我們想要在這個檢視中使用一個佈局，其中包含一個頁首、一個頁尾和一個內容區域。

我們可以將這個佈局分解成多個 Partials，如下所示：

# app/views/layouts/_header.html.erb

<h1>My Blog</h1>

# app/views/layouts/_footer.html.erb

<p>Copyright © 2023 My Blog</p>

# app/views/layouts/_content.html.erb

<%= yield %>

# app/views/layouts/application.html.erb

<%= render 'header' %>
<%= render 'content' %>
<%= render 'footer' %>

在這個範例中，我們建立了三個 Partials _header.html.erb、_content.html.erb 和 _footer.html.erb，它們分別呈現佈局的頁首、內容和頁尾。在 application.html.erb 佈局檔案中，我們使用 render 方法包含這三個 Partials，並使用 yield 方法呈現檢視模板中的內容。

如果我們想要覆蓋某個 Partial 中的佈局，可以在檢視模板中使用 render 方法並指定要覆蓋的 Partial 的名稱，如下所示：

# app/views/posts/show.html.erb

<%= render partial: 'content', layout: 'my_custom_layout' %>

在這個範例中，我們在 show.html.erb 檢視模板中使用 render 方法並指定要呈現的 Partial 的名稱為 content，並且指定使用名為 my_custom_layout 的 Partial Layouts。

Rails 將自動查詢名為 _my_custom_layout.html.erb 或 _my_custom_layout.html.haml 的 Partial Layouts，並將其中包含的 _content.html.erb Partial 呈現到佈局的內容區域中。

使用 Partial Layouts，我們可以更好地組織和重用檢視程式碼，特別是對於一些帶有共同佈局的檢視。這使得程式碼更加易於維護和更新，從而提高開發效率。

View Paths

View Paths 是 Ruby on Rails 中用來查詢檢視模板的一種機制。當我們在控制器中使用 render 方法呈現檢視時，Rails 將自動搜尋檢視模板，並將其呈現到瀏覽器中。

Rails 使用一組預設的 View Paths 來查詢檢視模板。這些 View Paths 包括應用程式檢視目錄、公共檢視目錄、引擎檢視目錄和外掛檢視目錄等。我們也可以通過設定 View Paths 來新增自定義的檢視目錄。

以下是一個簡單的範例，說明如何在 Rails 中設定 View Paths：

假設我們有一個名為 MyApp 的 Rails 應用程式，其中包含一個控制器 PostsController 和一個檢視模板 show.html.erb。預設情況下，Rails 將在 app/views/posts/show.html.erb 中查詢檢視模板。

如果我們想要新增一個自定義的檢視目錄，在其中包含檢視模板，並讓 Rails 在查詢檢視模板時搜尋這個目錄，可以在 config/application.rb 檔案中新增以下程式碼：

# config/application.rb

module MyApp
  class Application < Rails::Application
    # 新增自定義的檢視路徑
    config.paths.add 'app/views/custom', :before => 'app/views'
  end
end

在這個範例中，我們在 config/application.rb 檔案的 config.paths 中新增了一個自定義的檢視路徑 app/views/custom。 :before => 'app/views' 參數列示我們希望這個路徑優先於預設的檢視路徑。

這樣一來，當我們在 PostsController 中使用 render 方法呈現檢視時，Rails 將自動查詢 app/views/custom/posts/show.html.erb 檢視模板，並將其呈現到瀏覽器中。

View Paths 是一種非常靈活和強大的機制，它使我們能夠輕鬆地組織和管理檢視模板，並且能夠支援自定義的檢視路徑。這樣一來，我們可以更好地組織和重用檢視程式碼，從而提高開發效率。

---

如果您還沒有建立您的 User 模型和相應的控制器和檢視，您需要按照以下步驟進行操作：

1. 建立 User 模型和相應的屬性

使用 Rails 生成器建立一個 User 模型，並新增 name 和 email 兩個屬性。您可以使用以下命令：

rails generate model User name:string email:string

這將在 app/models/user.rb 檔案中建立一個名為 User 的模型，並在資料庫中建立一個名為 users 的表，其中包含 name 和 email 兩個字串型別的欄位。

然後執行資料庫遷移以建立 users 表：

rails db:migrate

2. 建立 UsersController 控制器

接下來，您需要建立一個名為 UsersController 的控制器，用於處理與使用者相關的請求。使用以下命令建立控制器：

rails generate controller Users

這將在 app/controllers/users_controller.rb 檔案中建立一個名為 UsersController 的控制器。在 UsersController 中，您需要定義一個名為 show 的動作來顯示使用者的資訊。在 UsersController 中新增以下程式碼：

class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])
  end
end

該動作使用 User.find 方法查詢要顯示的使用者，並將其儲存在一個名為 @user 的範例變數中，以便在檢視中使用。

3. 建立 show 檢視

接下來，您需要建立一個名為 show.html.erb 的檢視檔案，用於顯示使用者的資訊。在 app/views/users 目錄中建立一個名為 show.html.erb 的檔案，並新增以下程式碼：

<h1><%= @user.name %></h1>
<p><%= @user.email %></p>

該檢視使用 @user 範例變數來顯示使用者的名稱和電子郵件。

4. 定義路由

最後，您需要定義一個路由，以便將請求路由到 UsersController 的 show 動作。在 config/routes.rb 檔案中新增以下程式碼：

Rails.application.routes.draw do
  resources :users
end

這將定義一個名為 users 的資源路由，該路由將處理與 User 模型相關的請求。現在您可以通過存取 /users/:id URL 來存取 UsersController 的 show 動作，其中 :id 是要顯示的使用者的 ID。

現在您可以啟動 Rails 伺服器並存取 http://localhost:3000/users/:id，其中 :id 是要顯示的使用者的 ID，以檢視使用者的名稱和電子郵件資訊。

建立響應

從控制器的角度來看，可以通過三種方式建立 HTTP 響應：

• 呼叫render以建立完整響應以傳送回瀏覽器
• 呼叫redirect_to以向瀏覽器傳送 HTTP 重定向狀態程式碼
• 呼叫head以建立僅包含 HTTP 檔頭的響應以傳送回瀏覽器

layout選項

在 Ruby on Rails 中，layout 選項用於指定要用於呈現檢視的佈局檔案。佈局檔案通常包含頁面的共同元素，如頁首、頁尾、導航欄等，可以在多個檢視中重複使用，從而提高程式碼複用性和可維護性。

具體來說，如果你想在控制器方法中使用一個名為 application 的佈局檔案來呈現檢視，可以使用以下程式碼：

def show
  @post = Post.find(params[:id])
  render :show, layout: "application"
end

在這個例子中，render :show 表示要呈現名為 show 的檢視模板，而 layout: "application" 表示要使用名為 application 的佈局檔案來包裝檢視內容。控制器方法使用 render 方法來呈現檢視和佈局，生成最終的響應。

如果不指定 layout 選項，則預設使用名為 application 的佈局檔案。如果你想在某個檢視中禁用佈局，可以使用 layout: false 選項，如下所示：

def index
  @posts = Post.all
  render layout: false
end

在這個例子中，render layout: false 表示不使用任何佈局檔案來呈現檢視內容。控制器方法使用 render 方法來呈現檢視，生成最終的響應。

總之，layout 選項可以方便地指定要用於呈現檢視的佈局檔案，或者禁用佈局。對於具有共同元素的頁面，使用佈局檔案可以提高程式碼複用性和可維護性，從而更有效地開發應用程式。

status選項

在 Ruby on Rails 中，status 選項是用於指定 HTTP 響應狀態碼的選項。HTTP 狀態碼是用於指示伺服器對請求的處理結果的標準化程式碼，例如，200 表示請求成功，404 表示請求的資源不存在等等。

在控制器方法中，可以使用 render 方法的 status 選項來指定要返回的 HTTP 狀態碼。例如，下面的程式碼演示瞭如何在控制器方法中使用 status 選項來返回 404 狀態碼：

def not_found
  render plain: "404 Not Found", status: 404
end

在這個例子中，render plain: "404 Not Found", status: 404 表示要返回一個純文字響應，內容為 "404 Not Found"，並且狀態碼為 404。當用戶端存取這個控制器方法時，伺服器將返回一個帶有 404 狀態碼的響應。

使用 status 選項可以方便地指定要返回的 HTTP 狀態碼，從而更好地指示伺服器對請求的處理結果。在實際應用中，通常會使用一些預定義的狀態碼，如 200、401、404、500 等等，以便使用者端能夠更好地理解伺服器對請求的處理結果。

總之，在 Ruby on Rails 中，status 選項是用於指定 HTTP 響應狀態碼的選項，通常與 render 方法一起使用。它可以方便地指定要返回的狀態碼，以便更好地指示伺服器對請求的處理結果。

formats選項

在 Ruby on Rails 中，formats 選項是用於指定響應格式的選項。響應格式是指伺服器返回給使用者端的資料格式，例如 HTML、JSON、XML 等等。

在控制器方法中，可以使用 render 方法的 formats 選項來指定要返回的響應格式。例如，下面的程式碼演示瞭如何在控制器方法中使用 formats 選項來返回 JSON 格式的響應：

def show
  @user = User.find(params[:id])
  render json: @user, formats: :json
end

在這個例子中，render json: @user, formats: :json 表示要返回一個 JSON 格式的響應，其中的 formats: :json 選項指定了要返回的響應格式為 JSON。當用戶端存取這個控制器方法時，伺服器將返回一個包含使用者資料的 JSON 格式的響應。

使用 formats 選項可以方便地指定要返回的響應格式，以便伺服器返回正確的資料格式。在實際應用中，通常會根據使用者端的請求格式來動態地選擇要返回的響應格式，從而提高應用的靈活性和可延伸性。

總之，在 Ruby on Rails 中，formats 選項是用於指定響應格式的選項，通常與 render 方法一起使用。它可以方便地指定要返回的響應格式，以便伺服器返回正確的資料格式。

variants選項

在 Ruby on Rails 中，variants 選項是用於指定響應變體的選項。響應變體是指根據使用者端的請求屬性（如語言、裝置型別等）生成的不同版本的響應。

在控制器方法中，可以使用 respond_to 方法的 variants 選項來指定要生成的響應變體。例如，下面的程式碼演示瞭如何在控制器方法中使用 variants 選項來生成適合不同裝置型別的響應：

def index
  @articles = Article.all

  respond_to do |format|
    format.html
    format.json
    format.turbo_stream
    format.variant :phone do
      render "index.phone"
    end
  end
end

在這個例子中，respond_to 方法包含了三種預設的響應格式（HTML、JSON 和 Turbo Stream），以及一個使用 variant 選項生成的響應變體。當用戶端通過手機存取這個控制器方法時，伺服器將返回 index.phone 檢視模板對應的 HTML 響應。

使用 variants 選項可以方便地為不同裝置型別生成適合的響應，並提供更好的使用者體驗。在實際應用中，通常會根據使用者端的請求屬性和應用的需求來動態地生成響應變體，從而提高應用的可用性和可延伸性。

總之，在 Ruby on Rails 中，variants 選項是用於指定響應變體的選項，通常與 respond_to 方法一起使用。它可以方便地為不同裝置型別生成適合的響應，並提供更好的使用者體驗。

查詢佈局

在 Ruby on Rails 中，佈局是用於組織檢視模板的共用程式碼的機制。每個控制器都可以有一個預設佈局，也可以在控制器方法中通過 layout 方法指定使用特定的佈局。

佈局通常位於 app/views/layouts 目錄下，以 .html.erb 或 .html.haml 等格式的檔案存在。當檢視模板渲染時，佈局檔案會自動被載入，並將檢視模板的內容嵌入其中指定的位置。

在查詢佈局時，Rails 會按照以下順序搜尋佈局檔案：

1. 首先，Rails 將查詢與控制器名稱相同的佈局檔案。例如，如果當前控制器的名稱為 PostsController，則 Rails 將查詢名為 posts.html.erb 或 posts.html.haml 等格式的佈局檔案。

2. 如果沒有找到與控制器名稱相同的佈局檔案，則 Rails 將查詢名為 application.html.erb 或 application.html.haml 等格式的佈局檔案。這是預設的佈局檔案，適用於所有控制器和檢視。

3. 如果以上兩種情況都沒有找到佈局檔案，則 Rails 將不使用佈局，直接將檢視模板的內容返回給使用者端。

在控制器方法中，可以使用 layout 方法來指定要使用的佈局檔案。例如，下面的程式碼演示瞭如何在控制器方法中使用 layout 方法來指定要使用名為 admin 的佈局檔案：

class Admin::UsersController < ApplicationController
  layout "admin"

  def index
    # ...
  end
end

在這個例子中，layout "admin" 表示要使用名為 admin 的佈局檔案來渲染該控制器方法對應的檢視模板。

總之，在 Ruby on Rails 中，佈局是用於組織檢視模板的共用程式碼的機制。Rails 會按照一定順序查詢佈局檔案，並自動將檢視模板的內容嵌入其中指定的位置。可以使用 layout 方法來指定要使用的佈局檔案。

為控制器指定佈局

在 Ruby on Rails 中，可以為控制器指定預設的佈局，以便在渲染檢視模板時自動應用該佈局。預設情況下，Rails 會使用名為 application.html.erb 或 application.html.haml 的佈局檔案作為所有控制器的預設佈局。

要為控制器指定不同的佈局，可以在控制器類中使用 layout 方法來指定要使用的佈局檔案。例如，假設我們有一個名為 PostsController 的控制器，我們可以在該控制器中指定要使用的佈局檔案：

class PostsController < ApplicationController
  layout "posts_layout"

  def index
    # ...
  end

  def show
    # ...
  end
end

在這個例子中，layout "posts_layout" 表示要使用名為 posts_layout 的佈局檔案作為該控制器的預設佈局。當該控制器的 index 或 show 方法渲染檢視模板時，將自動應用該佈局。

除了在控制器類中使用 layout 方法指定預設佈局外，還可以在控制器方法中使用 render 方法的 layout 選項來指定要使用的佈局檔案。例如，下面的程式碼演示瞭如何在控制器方法中使用 layout 選項來指定要使用名為 dashboard_layout 的佈局檔案：

def dashboard
  @user = current_user
  render layout: "dashboard_layout"
end

在這個例子中，render layout: "dashboard_layout" 表示要使用名為 dashboard_layout 的佈局檔案來渲染該控制器方法對應的檢視模板。

總之，在 Ruby on Rails 中，可以為控制器指定預設的佈局，以便在渲染檢視模板時自動應用該佈局。可以在控制器類中使用 layout 方法或在控制器方法中使用 render 方法的 layout 選項來指定要使用的佈局檔案。

在執行時選擇佈局

在 Ruby on Rails 中，可以在執行時根據應用程式的需求選擇要使用的佈局。這通常是根據使用者的角色、裝置型別或其他條件來動態選擇佈局的。

要在執行時選擇佈局，可以在控制器方法中使用 render 方法的 layout 選項，並將其設定為一個方法名或一個 lambda 表示式。例如，下面的程式碼演示瞭如何在控制器方法中使用 lambda 表示式來動態選擇佈局：

def show
  @post = Post.find(params[:id])

  render layout: -> {
    if current_user.admin?
      "admin_layout"
    else
      "application"
    end
  }
end

在這個例子中，render layout: -> { ... } 表示將 layout 選項設定為一個 lambda 表示式，該 lambda 表示式根據當前使用者是否為管理員來選擇要使用的佈局。如果當前使用者是管理員，則使用名為 admin_layout 的佈局檔案，否則使用預設的 application 佈局檔案。

除了使用 lambda 表示式來動態選擇佈局外，還可以定義一個方法來執行相同的邏輯，並將其作為 layout 選項的值。例如：

def show
  @post = Post.find(params[:id])

  render layout: choose_layout
end

private

def choose_layout
  if current_user.admin?
    "admin_layout"
  else
    "application"
  end
end

在這個例子中，choose_layout 方法根據當前使用者是否為管理員來選擇要使用的佈局，並將其作為 layout 選項的值傳遞給 render 方法。

總之，在 Ruby on Rails 中，可以在執行時根據應用程式的需求選擇要使用的佈局。可以使用 lambda 表示式或定義一個方法來執行相應的邏輯，並將其作為 layout 選項的值傳遞給 render 方法。

佈局繼承

在 Ruby on Rails 中，佈局可以通過繼承來實現程式碼的重用和分離。這意味著一個佈局可以繼承另一個佈局，並且子佈局可以覆蓋父佈局中的內容或新增新的內容。

要實現佈局繼承，可以在佈局檔案中使用 yield 方法來指定子檢視模板嵌入佈局中的位置。然後，在子檢視模板中，可以使用 content_for 方法來定義要嵌入到父佈局中的內容。例如，假設我們有一個名為 application.html.erb 的預設佈局檔案：

<!DOCTYPE html>
<html>
<head>
  <title>My Application</title>
  <%= stylesheet_link_tag    'application', media: 'all' %>
  <%= javascript_include_tag 'application' %>
  <%= csrf_meta_tags %>
</head>
<body>

<%= yield %>

</body>
</html>

在這個例子中，yield 方法表示子檢視模板的內容將嵌入到 <body> 標籤中。

現在，假設我們想要為特定的控制器或檢視建立一個自定義佈局，並從預設佈局中繼承一些內容。我們可以建立一個名為 posts.html.erb 的佈局檔案，並在其中指定要繼承的佈局檔案，如下所示：

<% content_for :head do %>
  <meta name="description" content="My posts page description">
<% end %>

<% content_for :content do %>
  <%= yield %>
<% end %>

<%= render template: "layouts/application" %>

在這個例子中，content_for 方法表示要嵌入到父佈局中的內容。我們定義了兩個 content_for 塊，一個用於新增自定義的 <meta> 標籤到 <head> 中，另一個用於嵌入子檢視模板的內容。然後，我們使用 render 方法來渲染預設的 application.html.erb 佈局，並將其包含在子佈局中。

通過這種方式，我們可以建立一個自定義佈局，並從預設佈局中繼承一些內容。在子檢視模板中，我們可以使用 content_for 方法來新增要嵌入到父佈局中的內容。

總之，在 Ruby on Rails 中，可以使用佈局繼承來實現程式碼的重用和分離。可以在佈局檔案中使用 yield 方法來指定子檢視模板嵌入佈局中的位置，並在子檢視模板中使用 content_for 方法來定義要嵌入到父佈局中的內容。

假設你有一個名為「應用程式」的 Ruby on Rails 應用程式，並且你想要建立一個包含頭部和腳部的預設佈局，以及一個特定於「歡迎」頁面的子佈局。你可以按照以下步驟進行操作：

1. 建立預設佈局檔案 app/views/layouts/application.html.erb，並將所有共同部分放在其中：

<!DOCTYPE html>
<html>
<head>
  <title>應用程式</title>
</head>
<body>

<header>
  <!-- 共同部分：頭部 -->
  <h1>應用程式</h1>
  <nav>
    <ul>
      <li><a href="/">首頁</a></li>
      <li><a href="/about">關於</a></li>
    </ul>
  </nav>
</header>

<main>
  <%= yield %>
</main>

<footer>
  <!-- 共同部分：腳部 -->
  <p>&copy; 2023 應用程式</p>
</footer>

</body>
</html>

在這個例子中，yield 方法表示子檢視模板的內容將嵌入到 <main> 標籤中。

2. 建立一個特定於「歡迎」頁面的子佈局檔案 app/views/layouts/welcome.html.erb，並繼承預設佈局檔案，並使用 content_for 方法新增特定於子佈局的內容：

<% content_for :title do %>
  <!-- 特定於子佈局的內容：標題 -->
  <title>歡迎 - 應用程式</title>
<% end %>

<% content_for :main do %>
  <!-- 特定於子佈局的內容：歡迎資訊 -->
  <h2>歡迎來到應用程式！</h2>
  <p>這是一個演示 Ruby on Rails 應用程式。</p>
<% end %>

<%= render template: "layouts/application" %>

在這個例子中，我們使用 content_for 方法分別定義了 :title 和 :main 塊，用於新增特定於子佈局的標題和歡迎資訊。然後，我們使用 render 方法來渲染預設的 application.html.erb 佈局，並將其包含在子佈局中。

3. 建立一個特定於「歡迎」頁面的檢視檔案 app/views/welcome/index.html.erb，並使用 content_for 方法填充子佈局中的塊：

<% content_for :main do %>
  <!-- 特定於子佈局的內容：歡迎資訊 -->
  <h2>歡迎來到應用程式！</h2>
  <p>這是一個演示 Ruby on Rails 應用程式。</p>
  <p>這是歡迎頁面的內容。</p>
<% end %>

在這個例子中，我們使用 content_for 方法在檢視檔案中填充了子佈局中的 :main 塊，新增了歡迎頁面的內容。

通過這樣的方式，你可以建立一個具有共同部分的預設佈局，並從中繼承特定於頁面的子佈局，並在檢視檔案中填充子佈局中的塊。這樣就可以實現程式碼的重用和分離。

模板繼承

在 Rails 中，可以使用模板繼承來避免重複的程式碼，並更好地組織檢視。具體來說，你可以建立一個基礎模板，包含網頁的通用結構和元素，然後在其他模板中繼承它並新增特定的內容。

以下是一個簡單的例子，演示如何在 Rails 中使用模板繼承：

首先，建立一個名為 application.html.erb 的基礎模板，如下所示：

<!DOCTYPE html>
<html>
<head>
  <title>My App</title>
  <%= stylesheet_link_tag 'application', media: 'all' %>
  <%= javascript_include_tag 'application' %>
  <%= csrf_meta_tags %>
</head>
<body>
  <header>
    <h1>My App</h1>
    <nav>
      <ul>
        <li><%= link_to 'Home', root_path %></li>
        <li><%= link_to 'About', about_path %></li>
        <li><%= link_to 'Contact', contact_path %></li>
      </ul>
    </nav>
  </header>
  
  <main>
    <%= yield %>
  </main>
  
  <footer>
    &copy; My App <%= Time.current.year %>
  </footer>
</body>
</html>

在這個例子中，基礎模板包含一個頂部導航欄和一個底部版權資訊，還包括一個名為 yield 的預留位置，用於在繼承模板中插入內容。

接下來，建立一個名為 home.html.erb 的繼承模板，如下所示：

<% content_for :title do %>
  Home
<% end %>

<h2>Welcome to My App</h2>
<p>This is the home page.</p>

在這個例子中，繼承模板包含一個標題和一些文字內容，它繼承了基礎模板並新增了特定的內容。

最後，建立一個名為 about.html.erb 的繼承模板，如下所示：

<% content_for :title do %>
  About
<% end %>

<h2>About My App</h2>
<p>This is the about page.</p>

在這個例子中，繼承模板包含一個標題和一些文字內容，它也繼承了基礎模板並新增了特定的內容。

現在，在瀏覽器中存取這些頁面時，Rails 將使用基礎模板中的通用結構和元素，並使用繼承模板中的特定內容來渲染頁面。你還可以在繼承模板中使用 content_for 方法來定義標題和其他預留位置，以便在基礎模板中設定。

總之，在 Rails 中，使用模板繼承可以幫助你更好地組織檢視，避免重複的程式碼，並提高程式碼的可維護性。

使用redirect_to

在 Rails 中，redirect_to 方法用於將使用者重定向到另一個 URL。它通常用於在控制器動作中執行一些操作後，將使用者重定向到不同的頁面。以下是一個簡單的例子：

class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      redirect_to @user
    else
      render 'new'
    end
  end
end

在這個例子中，create 動作建立一個新的使用者，並嘗試將其儲存到資料庫中。如果儲存成功，使用者將被重定向到使用者詳情頁面。如果儲存失敗，使用者將被重定向回用戶建立頁面。

redirect_to 方法可以接受多種引數，包括 URL、路徑、路由助手、模型範例等。下面是一些常見的用法：

1. 重定向到 URL：

redirect_to "https://www.example.com"

2. 重定向到路徑：

redirect_to "/users"

3. 重定向到路由助手：

redirect_to users_path

4. 重定向到模型範例：

redirect_to @user

在這個例子中，Rails 將使用 user_path(@user) 路由助手生成使用者詳情頁面的 URL。

除了指定重定向目標外，redirect_to 方法還可以接受可選引數，用於指定重定向的型別、狀態碼、提示資訊等。例如：

redirect_to @user, notice: "User was successfully created."

在這個例子中，Rails 將使用 user_path(@user) 路由助手生成使用者詳情頁面的 URL，並將一個名為 "notice" 的引數傳遞給目標頁面。

總之，在 Rails 中，redirect_to 方法是一個非常有用的工具，可以幫助你將使用者重定向到不同的頁面，並傳遞相關資訊。

獲取不同的重定向狀態碼

在 Rails 中，redirect_to 方法預設使用 302 Found 狀態碼進行重定向，這意味著重定向的頁面是暫時性的，並且瀏覽器會向新的頁面發出 GET 請求。但是，有時候你可能需要使用不同的重定向狀態碼，以便更好地控制重定向行為。

以下是一些常見的重定向狀態碼和它們的含義：

• 301 Moved Permanently：指示請求的資源已永久移動到新位置，以後應該使用新的 URL。
• 302 Found (預設值)：指示請求的資源已暫時移動到新位置，瀏覽器應該使用新的 URL 進行請求。
• 303 See Other：指示請求的資源可以在另一個 URL 中找到，應該使用 GET 方法進行請求。
• 307 Temporary Redirect：指示請求的資源已暫時移動到新位置，瀏覽器應該使用原始請求的方式進行請求。
• 308 Permanent Redirect：指示請求的資源已永久移動到新位置，以後應該使用新的 URL。

要使用不同的重定向狀態碼，可以將狀態碼作為 redirect_to 方法的第二個引數傳遞。例如，要使用 301 Moved Permanently 狀態碼進行重定向，可以這樣寫：

redirect_to new_url, status: 301

在這個例子中，new_url 是你要重定向到的新 URL，而 status: 301 則表示要使用 301 Moved Permanently 狀態碼進行重定向。

除了使用數位狀態碼之外，Rails 還提供了一些常數，可以更方便地指定常見的狀態碼。例如，要使用 303 See Other 狀態碼進行重定向，可以這樣寫：

redirect_to new_url, status: :see_other

在這個例子中，:see_other 是一個常數，表示 303 See Other 狀態碼。

總之，在 Rails 中，使用不同的重定向狀態碼可以幫助你更好地控制重定向行為，並提高使用者體驗。

render和的區別redirect_to

render 和 redirect_to 是 Rails 中兩個常用的控制器方法，它們都用於返回響應給使用者，但是它們的作用和用法有所不同。

render 方法用於渲染檢視模板，並將其作為響應傳送給使用者。它通常在控制器動作中執行一些操作後，將結果呈現給使用者。例如：

def show
  @user = User.find(params[:id])
  render :show
end

在這個例子中，show 動作查詢一個使用者，並將其賦值給 @user 變數。然後，它通過 render 方法將 show.html.erb 檢視模板渲染成 HTML，最終將其作為響應傳送給使用者。

redirect_to 方法用於將使用者重定向到另一個 URL。它通常在控制器動作中執行一些操作後，將使用者重定向到不同的頁面。例如：

def create
  @user = User.new(user_params)
  if @user.save
    redirect_to @user
  else
    render :new
  end
end

在這個例子中，create 動作建立一個新的使用者，並嘗試將其儲存到資料庫中。如果儲存成功，使用者將被重定向到使用者詳情頁面。如果儲存失敗，使用者將被重定向回用戶建立頁面。

因此，render 和 redirect_to 的主要區別在於它們的作用和用法不同。render 用於呈現檢視，而 redirect_to 用於將使用者重定向到不同的頁面。在使用它們時，你需要根據你的需求選擇正確的方法，以便實現你的業務邏輯。

用於head構建僅檔頭響應

在 Rails 中，可以使用 head 方法來構建僅包含檔頭的響應。這個方法常常用於在控制器中處理 AJAX 請求或者其他需要返回空響應的場景中。

head 方法接受兩個引數：第一個參數列示響應的狀態碼，第二個參數列示響應的檔頭。如果不需要設定檔頭，第二個引數可以省略。例如，要返回一個 200 OK 狀態碼的空響應，可以這樣寫：

head :ok

在這個例子中，head 方法構建了一個只包含狀態碼的響應，並將其傳送給使用者端。

除了 :ok，head 方法還支援其他常見的狀態碼，例如 :created，:unprocessable_entity，:not_found 等等。你也可以使用數位狀態碼來構建響應，例如 head 404 表示返回一個 404 Not Found 狀態碼的響應。

如果你需要設定檔頭，可以將檔頭資訊作為雜湊引數傳遞給 head 方法。例如，要返回一個包含自定義檔頭的 200 OK 響應，可以這樣寫：

head :ok, 'X-Request-Id' => '123'

在這個例子中，第二個引數是一個雜湊，它包含一個名為 X-Request-Id 的自定義檔頭。當用戶端收到響應時，它將包含這個自定義檔頭。

總之，head 方法是一個快速簡便的方法，用於構建僅包含檔頭的響應。在處理 AJAX 請求或其他需要返回空響應的場景中，它非常有用。

結構佈局

在 Rails 中，結構佈局（Stuctured Layouts）是一種常用的組織檢視模板的方式。與傳統的佈局不同，結構佈局使用巢狀的檢視模板來組織頁面內容，這樣可以更靈活地構建複雜的頁面。

結構佈局基於以下兩個核心概念：

1. yield 方法：用於在佈局中插入檢視模板的內容。

2. content_for 方法：用於在檢視模板中定義可以在佈局中使用的內容塊。

通過這兩個方法的結合使用，可以實現在佈局和檢視模板之間更加靈活的組織方式。

下面是一個簡單的例子，展示瞭如何建立一個包含結構佈局的 Rails 應用：

1. 首先，在 app/views/layouts 目錄下建立一個名為 application.html.erb 的檔案，用於定義應用程式的預設佈局。這個檔案通常包含一個 HTML 頭部和尾部，以及一個 yield 方法，用於插入檢視模板的內容：

<!DOCTYPE html>
<html>
  <head>
    <title>My App</title>
  </head>
  <body>
    <%= yield %>
  </body>
</html>

2. 然後，在檢視模板中，可以使用 content_for 方法定義一個或多個內容塊，例如：

<% content_for :sidebar do %>
  <h1>My Sidebar</h1>
  <p>This is my awesome sidebar.</p>
<% end %>

<h1>My Page</h1>
<p>This is my awesome page.</p>

在這個例子中，content_for :sidebar 定義了一個名為 :sidebar 的內容塊，其中包含一個標題和一些文字內容。<%= yield %> 將會在應用佈局中插入這個內容塊。

3. 最後，在佈局中，可以使用 yield 方法來插入檢視模板的內容，並使用 content_for 方法來插入檢視模板中定義的內容塊，例如：

<!DOCTYPE html>
<html>
  <head>
    <title>My App</title>
  </head>
  <body>
    <div id="sidebar">
      <%= content_for?(:sidebar) ? yield(:sidebar) : '' %>
    </div>
    <div id="content">
      <%= yield %>
    </div>
  </body>
</html>

在這個例子中，佈局將檢視模板的內容插入到一個名為 :content 的內容塊中，並使用 content_for?(:sidebar) 來檢查檢視模板中是否定義了 :sidebar 的內容塊。如果存在，佈局將使用 yield(:sidebar) 將其插入到佈局中的側邊欄區域中。

總之，結構佈局是一種靈活的組織檢視模板的方式，在構建複雜的頁面時非常有用。通過使用 yield 和 content_for 方法，可以更加靈活地組織頁面內容，並將佈局和檢視模板分離開來，使應用程式更具可維護性和可延伸性。

這裡是幾個常用的 Rails 輔助方法，用於在檢視模板中生成 HTML 標籤：

1. auto_discovery_link_tag：用於在 HTML 頁面頭部新增自動發現連結標籤，以便瀏覽器可以自動發現頁面的 RSS 或 Atom 提要auto_discovery_link_tag 是一個 Rails 輔助方法，用於在 HTML 頁面頭部新增自動發現連結標籤，以便瀏覽器可以自動發現頁面的 RSS 或 Atom 提要。這個方法通常在佈局檔案中使用，以便將自動發現連結標籤新增到每個頁面的頭部。

   在 Rails 中，可以使用以下方式來使用 auto_discovery_link_tag：

   <%= auto_discovery_link_tag(:rss, feed_url) %>
   <%= auto_discovery_link_tag(:atom, feed_url) %>
   

   在這個例子中，auto_discovery_link_tag 接受兩個引數。第一個參數列示提要的型別，可以是 :rss 或 :atom。第二個參數列示提要的 URL，通常是一個指向包含提要內容的 URL。

   當這個方法被呼叫時，它會生成一個自動發現連結標籤，並將其新增到頁面頭部。例如，如果你在佈局檔案中新增了這兩行程式碼，並且 feed_url 變數包含了一個指向你的 RSS 或 Atom 提要的 URL，那麼 Rails 將會為每個頁面新增下面這些標籤：

   <link rel="alternate" type="application/rss+xml" href="http://example.com/feed.rss" />
   <link rel="alternate" type="application/atom+xml" href="http://example.com/feed.atom" />
   

   這些標籤告訴瀏覽器，頁面包含一個或多個提要，並提供了一個指向提要內容的 URL。瀏覽器可以利用這些標籤自動發現並訂閱提要內容，使使用者可以更方便地跟蹤網站的更新。

   總之，auto_discovery_link_tag 是一個方便的 Rails 輔助方法，用於向 HTML 頁面新增自動發現連結標籤。在使用提要的網站中，這個方法可以提供更好的使用者體驗，使使用者可以更方便地跟蹤網站的更新。

2. javascript_include_tag：用於在 HTML 頁面中引入 JavaScript 檔案。可以接受一個或多個檔名作為引數，並生成對應的 <script> 標籤。例如：

<%= javascript_include_tag 'application' %>

這個方法將會生成一個指向 app/assets/javascripts/application.js 檔案的 <script> 標籤。如果你需要引入多個檔案，可以在引數中列出它們的檔名，例如：

<%= javascript_include_tag 'jquery', 'application' %>

這個方法將會生成兩個 <script> 標籤，分別指向 app/assets/javascripts/jquery.js 和 app/assets/javascripts/application.js 檔案。

3. stylesheet_link_tag：用於在 HTML 頁面中引入 CSS 檔案。與 javascript_include_tag 類似，這個方法也可以接受一個或多個檔名作為引數，並生成對應的 <link> 標籤。例如：

<%= stylesheet_link_tag 'application' %>

這個方法將會生成一個指向 app/assets/stylesheets/application.css 檔案的 <link> 標籤。如果你需要引入多個檔案，可以在引數中列出它們的檔名，例如：

<%= stylesheet_link_tag 'bootstrap', 'application' %>

這個方法將會生成兩個 <link> 標籤，分別指向 app/assets/stylesheets/bootstrap.css 和 app/assets/stylesheets/application.css 檔案。

4. image_tag：用於在 HTML 頁面中插入圖片。可以接受一個圖片檔名作為引數，並生成對應的 <img> 標籤。例如：

<%= image_tag 'logo.png' %>

這個方法將會生成一個指向 app/assets/images/logo.png 檔案的 <img> 標籤。如果需要設定其他屬性，比如 alt 或 class，可以在第二個引數中指定，例如：

<%= image_tag 'logo.png', alt: 'My Logo', class: 'logo' %>

5. video_tag：用於在 HTML 頁面中插入視訊。可以接受一個視訊檔名作為引數，並生成對應的 <video> 標籤。例如：

<%= video_tag 'my_video.mp4' %>

這個方法將會生成一個指向 app/assets/videos/my_video.mp4 檔案的 <video> 標籤。如果需要設定其他屬性，比如 controls 或 autoplay，可以在第二個引數中指定，例如：

<%= video_tag 'my_video.mp4', controls: true, autoplay: true %>

6. audio_tag：用於在 HTML 頁面中插入音訊。可以接受一個音訊檔名作為引數，並生成對應的 <audio> 標籤。例如：

<%= audio_tag 'my_audio.mp3' %>

這個方法將會生成一個指向 app/assets/audios/my_audio.mp3 檔案的 <audio> 標籤。如果需要設定其他屬性，比如 controls 或 autoplay，可以在第二個引數中指定，例如：

<%= audio_tag 'my_audio.mp3', controls: true, autoplay: true %>

這些輔助方法是 Rails 非常常用的一部分，它們可以簡化檢視模板的開發，使開發者可以更方便地生成 HTML 標籤。

理解yield

在 Ruby 中，yield 是一個非常有用的關鍵字，可以用於將控制權傳遞給一個呼叫方法的程式碼塊（block）。具體來說，當一個方法中包含了 yield 關鍵字時，它會在執行過程中暫停並將控制權傳遞給呼叫者傳遞進來的程式碼塊，然後等待程式碼塊完成後再繼續執行。

下面是一個簡單的例子，用於說明如何使用 yield：

def my_method
  puts "Start of method"
  yield
  puts "End of method"
end

my_method do
  puts "Inside the block"
end

在上面的例子中，my_method 定義了一個程式碼塊，其中包含了 yield 關鍵字。當 my_method 被呼叫時，它會執行前兩行輸出，然後將控制權傳遞給傳遞進來的程式碼塊，在程式碼塊中執行輸出，然後返回 my_method 繼續執行最後一行輸出。

因此，呼叫 my_method 時將會輸出：

Start of method
Inside the block
End of method

這個例子只是 yield 的一種使用方式。實際上，yield 可以用於更復雜的情況下，例如傳遞引數，多次呼叫程式碼塊等。在 Ruby 中，yield 是一個非常強大的工具，可以幫助開發者寫出更靈活、更可重用的程式碼。

使用content_for方法

content_for 是 Rails 檢視中非常有用的一個方法，它允許我們在檢視中定義一個內容塊，並在該塊中填充任意內容。這樣可以使檢視檔案更加靈活，從而使開發更加高效。

具體來說，content_for 方法可以在檢視檔案中定義一個命名的內容塊。例如：

# app/views/layouts/application.html.erb

<!DOCTYPE html>
<html>
  <head>
    <title><%= content_for?(:title) ? yield(:title) : "My App" %></title>
  </head>
  <body>
    <%= yield %>
  </body>
</html>

在上面的程式碼中，我們定義了一個名為 title 的內容塊，並在 HTML 的 <title> 標籤中使用了該塊。如果在檢視檔案中不使用 content_for 填充 title 塊，則預設使用 "My App" 作為標題。

現在，我們可以在檢視檔案中呼叫 content_for 方法來填充該塊。例如：

# app/views/posts/index.html.erb

<% content_for :title do %>
  My Blog
<% end %>

<h1>Welcome to my blog!</h1>

在上面的程式碼中，我們在 posts/index.html.erb 檢視檔案中使用 content_for 來填充 title 塊。這樣，檢視檔案中的 <title> 標籤將會被設定為 "My Blog"。

content_for 方法還可以用於填充其他內容塊，例如頁頭、頁尾、導航等。使用 content_for 方法可以使檢視檔案更加靈活，從而使我們的 Rails 應用更加易於維護和擴充套件。