在上一篇中，我们探讨了Rails MVC架构中的视图职责。视图的作用是展现数据，并提供用户与应用程序交互的界面。而在本章中，我们将重点关注控制器的职责。控制器是MVC架构中承上启下的一环，它负责处理用户的请求，协调模型与视图，确保应用程序能够顺利运行。

控制器的基本概念

在Rails中，控制器的主要任务是接收用户的请求并将请求路由到相应的模型或视图。控制器从模型获取数据，然后选择一个视图来展示这些数据。每个控制器都是 ApplicationController 的子类，Rails会根据约定的命名规则将URL请求映射到相应的控制器和动作。

控制器的基本结构

一个控制器通常包含多个“动作”，每个动作对应一个用户请求。以下是一个简单的控制器示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)
    if @article.save
      redirect_to @article
    else
      render :new
    end
  end

  private

  def article_params
    params.require(:article).permit(:title, :body)
  end
end

在这个 ArticlesController 中，我们可以看到几个动作的定义：

• index：列出所有文章。
• show：显示特定文章的详细信息。
• new：展示一张表单以创建新文章。
• create：处理表单提交，创建新文章。

控制器的职责

控制器在Rails应用程序中的主要职责包括：

1. 处理请求和响应：
   控制器负责从请求中获取参数，处理逻辑，并确定要渲染的视图或重定向到其他页面。

2. 协调模型与视图：
   控制器从模型获取数据，并将这些数据传递给视图进行展示。

3. 用户输入的验证：
   控制器负责接收来自用户的输入，并通过模型进行验证，确保数据的合法性和完整性。

4. 应用逻辑：
   控制器可以包含一些基本的应用逻辑，比如条件判断、流程控制等。

5. 授权和认证：
   控制器通常会涉及用户的权限和身份验证逻辑，确保用户请求的合法性。

路由与控制器的关系

在Rails中，路由（Routes）负责将HTTP请求映射到相应的控制器和动作。我们可以在 config/routes.rb 文件中定义应用程序的路由。例如：

1
2
3

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

上述代码将自动为 ArticlesController 创建一组RESTful路由，包括 index, show, new, create, edit, update, 和 destroy 等动作。

案例：文章管理系统

假设我们正在构建一个简单的文章管理系统，以下是一些使用控制器的典型场景：

列出所有文章

在 index 动作中，我们将所有的文章从数据库中检索出来，并传递给视图进行渲染：

1
2
3

def index
  @articles = Article.all
end

对应的视图 index.html.erb 可以这样写：

1
2
3
4
5
6

<h1>Articles</h1>

<% @articles.each do |article| %>
  <h2><%= link_to article.title, article_path(article) %></h2>
  <p><%= article.body %></p>
<% end %>

创建新文章

在 create 动作中，我们从表单中接收数据，并通过模型保存它：

1
2
3
4
5
6
7
8

def create
  @article = Article.new(article_params)
  if @article.save
    redirect_to @article
  else
    render :new
  end
end

这里的 article_params 方法用于强参数（Strong Parameters），确保只允许特定的参数被接受。

控制器中的过滤器

除了基本的动作，Rails还支持控制器过滤器，可以在动作执行前后跑特定的代码。例如，我们可以在控制器中使用 before_action 来进行用户身份验证：

1
2
3
4
5

class ArticlesController < ApplicationController
  before_action :authenticate_user!

  # 其他动作...
end

这里的 authenticate_user! 方法可以是一个确保用户已经登录的逻辑。

总结

控制器在Rails MVC架构中扮演着至关重要的角色，它负责处理用户请求、协调模型与视图并实现应用逻辑。在实际开发中，通过合理设计控制器，可以确保代码的可读性和可维护性。

在下一篇中，我们将讨论Rails与数据库的连接，深入探索Rails的ActiveRecord模型如何与数据库交互。敬请期待！

在上一章中，我们讨论了Rails的MVC架构，其中控制器的职责对于开发者来说至关重要。在本章中，我们将他探讨Rails如何与数据库进行连接，了解如何配置数据库及其相关设置，以及如何进行基本的数据库操作。这是构建动态Web应用程序的重要一步，因为数据库存储了应用程序的数据。

数据库连接概要

Rails使用Active Record作为其对象关系映射（ORM）框架，使得与数据库的交互更加抽象和方便。通过Active Record，我们可以使用Ruby代码而不是SQL语句来实现数据的操作。Rails支持多种数据库，如SQLite、PostgreSQL、MySQL等。在本教程中，我们将以SQLite为例，因为它在开发环境中简单易用。

创建Rails应用并配置数据库

首先，让我们确保你已经安装了Rails。如果还没有安装，可以通过以下命令来安装：

1

gem install rails

接下来，我们创建一个新的Rails应用：

1

rails new my_app --database=sqlite3

这里的--database=sqlite3参数告诉Rails使用SQLite作为数据库。

创建完应用后，我们可以查看config/database.yml文件，这是Rails与数据库连接的配置文件。默认情况下，Rails会为各个环境（development、test、production）提供相应的数据库配置。在开发环境中，配置看起来大致如下：

1
2
3
4
5

development:
  adapter: sqlite3
  database: db/development.sqlite3
  pool: 5
  timeout: 5000

这个配置指定了我们使用SQLite3数据库，数据库文件为db/development.sqlite3。

生成数据库并建立连接

要与数据库连接，我们需要生成数据库。在终端中输入以下命令：

1

rails db:create

此命令会根据database.yml中的配置创建相应的数据库。在创建完成后，Rails将会自动连接到数据库。

可以通过以下命令查看数据库是否成功创建：

1

sqlite3 db/development.sqlite3

这条命令将打开SQLite数据库命令行界面，你可以在这里执行SQL查询，验证连接是否成功。

使用Active Record进行数据操作

一旦数据库连接建立，就可以开始使用Active Record进行数据操作了。首先，我们来生成一个模型以便与数据库交互。例如，我们可以创建一个名为Post的模型，代表一篇文章。

1

rails generate model Post title:string body:text

这个命令将生成一个名为Post的模型，以及对应的数据库迁移文件。迁移文件包括了数据库表的定义，包括字段和对应的数据类型。

接下来，我们需要运行迁移，使数据库结构更新：

1

rails db:migrate

执行后，SQLite数据库中将会创建一个posts表，其中包括title和body两个字段。

在控制器中使用模型

接下来，我们可以在控制器中使用Post模型来创建和读取数据。我们可以添加一个控制器来处理与Post模型相关的请求。

生成控制器：

1

rails generate controller Posts

在生成的app/controllers/posts_controller.rb文件中，添加以下代码来创建和显示文章：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end

  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to posts_path
    else
      render :new
    end
  end

  private

  def post_params
    params.require(:post).permit(:title, :body)
  end
end

在这里，index方法用于获取所有文章，而create方法用于创建新文章。post_params方法用于强参数，确保只能接收允许的参数。

查看数据

要查看文章数据，我们可以在app/views/posts/index.html.erb文件中添加以下代码：

1
2
3
4
5
6

<h1>All Posts</h1>
<ul>
  <% @posts.each do |post| %>
    <li><strong><%= post.title %></strong>: <%= post.body %></li>
  <% end %>
</ul>

这段代码会显示所有文章的标题和内容。

小结

在本章中，我们详细探讨了如何在Rails应用程序中配置和连接数据库。我们创建了一个简单的Post模型，并通过控制器实现了数据的创建与显示。通过使用Active Record，我们可以方便地与数据库进行交互，而不必从头编写SQL查询。

在下一章中，我们将进一步扩展数据库操作的知识，探索如何生成和管理数据库迁移，以便进行更复杂的数据库结构更改和版本控制。

在上一章中，我们讨论了如何让 Rails 应用程序与数据库连接。如今，我们开始学习如何使用数据库迁移来管理数据库架构的更改。数据库迁移是 Rails 提供的一种内置功能，可以让我们以版本管理的方式来更新数据库结构。通过使用迁移，我们不仅可以创建和修改数据库表，还可以轻松地回滚到以前的状态，确保我们的数据库管理更加灵活和可靠。

什么是数据库迁移？

数据库迁移是一个版本控制系统，用于记录数据库结构的演变。每个迁移都对应一个数据库操作，如创建表、增加列或修改数据类型。通过迁移，开发者可以轻松地共享和应用这些更改，而不必手动管理 SQL 脚本。

在 Rails 中，迁移以 Ruby 文件的形式存在，通常保存在 db/migrate 目录下。每个迁移都以时间戳开头，例如 20230215123456_create_users.rb，表明它的创建时间。

生成迁移

要生成一个新的数据库迁移，我们可以使用 Rails 提供的命令行工具。我们以创建一个 users 表为例。可以通过以下命令生成迁移文件：

1

rails generate migration CreateUsers

此命令会在 db/migrate 目录下创建一个新的迁移文件，文件名类似于 20230215123456_create_users.rb。接下来，我们打开这个文件并定义我们要执行的数据库操作。

定义迁移内容

每个迁移文件包含两个主要的方法：change 和 up / down。在本例中，我们将使用 change 方法来创建一个新的用户表。

打开刚生成的迁移文件，内容大致如下：

1
2
3
4
5
6
7
8
9

class CreateUsers < ActiveRecord::Migration[6.0]
  def change
    create_table :users do |t|
      t.string :name
      t.string :email
      t.timestamps
    end
  end
end

在这个例子中，我们定义了一个 users 表，其中有 name 和 email 两个字符串类型的列，以及两个时间戳字段 created_at 和 updated_at。t.timestamps 方法会自动添加这两个字段。

运行迁移

定义好迁移后，我们可以通过运行以下命令来执行迁移：

1

rails db:migrate

这条命令会根据我们定义的迁移内容更新数据库结构。在成功运行后，可以通过数据库管理工具或 Rails 控制台来查看 users 表。

回滚和再次迁移

如果在执行迁移后想要撤销更改，可以使用以下命令回滚：

1

rails db:rollback

这会撤销上一次迁移操作。假如我们需要多次回滚，可以多次执行这个命令；也可以使用 rails db:rollback STEP=n，其中 n 是步数，这样可以一次性回滚多个迁移。

如果再次运行 rails db:migrate，迁移会重新应用到数据库中。

结论

通过这个小节，我们已经了解了如何生成和定义数据库迁移，以及如何执行和回滚迁移操作。使用迁移可以显著提升数据库管理的效率，使团队协作更为便捷。

在接下来的章节中，我们将深入了解如何使用 ActiveRecord 进行数据库操作，它是与数据库交互的强大工具，为我们的应用程序提供了一个简洁的接口。整个过程将使我们更好地掌握 Rails 数据库操作的核心概念与技巧。

在前一篇文章中，我们讨论了如何生成数据库迁移，以便创建和修改数据库结构。现在，我们将深入了解如何使用ActiveRecord与数据库进行交互。ActiveRecord是Rails的ORM（对象关系映射）工具，使我们能够通过Ruby代码与数据库进行交互，而不必编写原始的SQL查询。

ActiveRecord简介

ActiveRecord提供了一种简单而强大的方式来操作数据库。每个数据库表对应一个ActiveRecord模型，模型的实例对应表中的一行记录。你可以使用模型来创建、读取、更新和删除记录，这些操作统称为CRUD操作。

创建新记录

要在数据库中创建一条新的记录，你可以使用create方法。假设我们有一个User模型，它对应于users表，你可以像下面这样创建一个新用户：

1
2
3
4
5
6

# app/models/user.rb
class User < ApplicationRecord
end

# 创建一个新用户
User.create(name: "Alice", email: "alice@example.com")

这个示例中，我们调用了User.create方法，传入一个包含name和email的哈希。ActiveRecord会自动将这些信息插入到数据库中。

查询记录

ActiveRecord提供了多种查询数据库记录的方法。最常用的是all、find和where。

查询所有记录

1
2

# 查询所有用户
users = User.all

查询特定记录

1
2

# 按ID查询特定用户
user = User.find(1)

条件查询

1
2

# 查询所有邮箱以@example.com结尾的用户
users = User.where("email LIKE ?", "%@example.com")

更新记录

一旦你找到一个记录，你可以直接修改它的属性，然后调用save方法保存变化。例如：

1
2
3

user = User.find(1)
user.name = "Bob"
user.save

或者更简洁地使用update方法：

1

user.update(name: "Bob")

删除记录

要删除一条记录，你可以使用destroy方法：

1
2

user = User.find(1)
user.destroy

ActiveRecord回调

ActiveRecord支持多种回调，这些回调允许你在创建、更新或删除记录时添加自定义逻辑。例如，你可以在创建用户之前确保所有用户的电子邮件都是唯一的：

1
2
3
4
5
6
7
8
9
10
11
12

class User < ApplicationRecord
  before_save :ensure_email_is_unique

  private

  def ensure_email_is_unique
    if User.exists?(email: email)
      errors.add(:email, "已经存在，请使用其他邮箱。")
      throw(:abort) # 中止保存操作
    end
  end
end

批量操作

对于需要一次性插入多个记录的场景，ActiveRecord提供了import方法。假设我们有一个Product模型，可以这样批量创建产品：

1
2
3
4
5
6
7

products = [
  { name: "Product1", price: 100 },
  { name: "Product2", price: 200 },
  { name: "Product3", price: 300 }
]

Product.insert_all(products)

小结

在本章节中，我们学习了如何使用ActiveRecord与数据库交互，执行常见的CRUD操作，并了解了如何使用回调和批量操作。ActiveRecord的强大之处在于它提供了一种简洁且优雅的方式来处理数据库操作，而不需要编写繁琐的SQL。

在下一章节中，我们将探索RESTful路由与理解RESTful架构，这将帮助我们在Rails应用中更好地组织资源和控制器，进一步提升我们的全栈开发能力。

在前一篇我们讨论了如何通过ActiveRecord进行数据库操作。在构建Rails应用时，理解如何通过RESTful路由来组织我们的资源是至关重要的。本篇将深入探讨RESTful架构的基础概念，帮助你理解如何为你的应用定义资源及其动作。

什么是REST?

REST（Representational State Transfer）是一种软件架构风格，主要用于网络应用的设计。RESTful架构通过一系列标准的HTTP方法（如GET、POST、PUT、DELETE）来操作资源，让API的设计更加简洁与一致。

主要特点

• 资源是核心：在REST中，所有内容都是资源，每个资源都由一个URI（统一资源标识符）表示。
• 无状态交互：每个请求都必须包含处理请求所需的所有信息，服务器不会在请求间保存状态。
• 使用HTTP方法：REST通过标准化的HTTP方法来定义资源的操作。

Rails中的RESTful路由

在Rails中，我们常常需要定义RESTful路由，以轻松地对资源进行CRUD（创建、读取、更新、删除）操作。Rails内置了对RESTful路由的完美支持。

基本的资源路由

想象一下，我们有一个简单的博客应用，其中有一个Post资源。我们可以在config/routes.rb文件中使用resources方法来定义RESTful路由：

1
2
3

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

这个简单的一行代码会生成一组标准的路由，包括：

• GET /posts - 列出所有帖子
• GET /posts/:id - 显示一个特定的帖子
• POST /posts - 创建一个新帖子
• PATCH/PUT /posts/:id - 更新一个特定的帖子
• DELETE /posts/:id - 删除一个特定的帖子

了解这些路由后，我们可以用以下命令来查看所有路由：

1

rails routes

这将为你展示所有设计生成的RESTful路由和对应的控制器动作。

路由与控制器的连接

为了使上述路由生效，我们需要创建对应的控制器，并实现一些动作。可以通过以下命令生成一个控制器：

1

rails generate controller Posts

然后在app/controllers/posts_controller.rb中定义你的动作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end

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

  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post, notice: 'Post was successfully created.'
    else
      render :new
    end
  end

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

  def update
    @post = Post.find(params[:id])
    if @post.update(post_params)
      redirect_to @post, notice: 'Post was successfully updated.'
    else
      render :edit
    end
  end

  def destroy
    @post = Post.find(params[:id])
    @post.destroy
    redirect_to posts_url, notice: 'Post was successfully destroyed.'
  end

  private

  def post_params
    params.require(:post).permit(:title, :content)
  end
end

这里有几个需要注意的点：

1. 参数强制：使用post_params方法来确保只允许特定的参数被传递。
2. 基本动作：定义了index, show, new, create, edit, update和destroy七个基本操作，形成完整的CRUD功能。

结论

在本篇中，我们介绍了RESTful架构的基本概念，并演示了如何在Rails中处理RESTful路由。在接下来的章节中，我们将深入探讨如何定义资源和具体的路由方法，进一步丰富我们的Rails应用。

了解了这些基础概念后，你应该能够为你的Rails应用合理地设计RESTful路由，并结合控制器及视图来实现完整的功能。我鼓励你在实际项目中多多实践，以加深对这些概念的理解。

在上一章中，我们深入探讨了 RESTful 架构的核心理念及其在 Rails 应用中的重要性。在本章中，我们将专注于如何在 Ruby on Rails 中定义资源和设置路由，以便使我们的控制器和视图能够处理 HTTP 请求。

资源的定义

在 Rails 中，资源是指一组相关的对象，它们通常由一个模型类（Model）对应。我们常见的资源例子包括用户（Users）、文章（Articles）或评论（Comments）。每个资源都对应着一个尽量符合 RESTful 风格的 URL，这样可以方便地进行操作。

例如，如果我们有一个 Article 资源，它可能对应的 URL 结构如下：

• GET /articles - 显示所有文章
• GET /articles/new - 显示创建新文章的表单
• POST /articles - 创建新文章
• GET /articles/:id - 显示特定文章
• GET /articles/:id/edit - 显示编辑特定文章的表单
• PATCH/PUT /articles/:id - 更新特定文章
• DELETE /articles/:id - 删除特定文章

通过这些 URL，我们可以明确地看出哪些动作对应于 HTTP 方法，从而符合 REST 的约定。

定义资源的路由

在 Rails 中，我们通过在 config/routes.rb 文件中定义资源的路由来实现这一目标。Rails 提供了 resources 方法，使得配置路由变得非常简单。接下来，我们看一个实际的示例：

1
2
3
4

# config/routes.rb
Rails.application.routes.draw do
  resources :articles
end

通过调用 resources :articles，Rails 自动为我们的 Article 资源生成了一组标准的 RESTful 路由。在这个设置下，Rails 将为我们定义的 Article 资源生成一系列重要的路由。

我们可以使用 Rails 提供的命令来查看生成的路由：

1

rails routes

这将输出类似于以下的结果：

1
2
3
4
5
6
7
8

    articles GET    /articles(.:format)          articles#index
             POST   /articles(.:format)          articles#create
 new_article GET    /articles/new(.:format)      articles#new
edit_article GET    /articles/:id/edit(.:format) articles#edit
     article GET    /articles/:id(.:format)      articles#show
             PATCH  /articles/:id(.:format)      articles#update
             PUT    /articles/:id(.:format)      articles#update
             DELETE /articles/:id(.:format)      articles#destroy

上述输出展示了为 articles 资源生成的所有路由。每一行都对应于特定的 HTTP 请求，适用于我们正在构建的 Article 资源。

自定义路由

虽然使用 resources 方法生成标准的 RESTful 路由非常方便，但有时我们可能需要自定义某些路由。比如，我们可能想为 articles 资源添加一个名为 archive 的自定义操作。代码示例如下：

1
2
3
4
5
6
7
8

# config/routes.rb
Rails.application.routes.draw do
  resources :articles do
    member do
      get 'archive'
    end
  end
end

在这个例子中，member 块中的 get 'archive' 表示我们希望在特定的文章（即某个 ID 的文章）上调用 archive 操作。

执行 rails routes 将展示更新后的路由：

1

archive_article GET    /articles/:id/archive(.:format) articles#archive

通过这种方式，我们可以灵活地为资源添加额外的路由，满足更复杂的业务需求。

小结

在本章中，我们学习了如何在 Ruby on Rails 中定义资源和相应的 RESTful 路由。我们通过具体的示例清晰地了解了如何使用 resources 方法来快速生成路由，以及如何进行自定义配置。掌握了这些知识后，我们可以有效地管理应用中的数据。接下来，我们将继续探讨使用 Rails 的路由助手，以更方便地生成和链接路由。

在前一章中，我们讨论了如何定义资源和路由，理解了RESTful架构的基础以及如何在Rails中创建路由。现在，我们将深入探讨如何使用Rails的路由助手，这些助手为我们提供了简便的方法来生成URL和路径，使我们的代码更加简洁和可维护。

1. 什么是路由助手？

在Rails中，路由助手是由路由配置自动生成的方法。它们使得在应用中生成路径和URL变得简单。采用RESTful设计模式的Rails应用通常会生成一组路由助手，例如，对于一个名为articles的资源，我们会得到诸如articles_path和new_article_path之类的助手方法。

2. 常用的路由助手

以articles资源为例，Rails为我们提供了以下路由助手：

• articles_path: 指向所有文章的列表页面。
• new_article_path: 指向创建新文章的页面。
• edit_article_path(article): 指向编辑指定文章的页面。
• article_path(article): 指向具体某一篇文章的页面。

2.1 使用示例

在我们的Rails应用中，假设我们需要创建一个指向所有文章的链接，以及一个指向新文章创建页面的链接。代码如下：

1
2

<%= link_to '所有文章', articles_path %>
<%= link_to '创建新文章', new_article_path %>

通过使用这些路由助手，我们的代码变得清晰易懂，且在更改路由时只需在路由文件中更新定义，而无须逐一查找和更新每个链接。

3. 动态路由助手

在使用某些助手方法时，我们需要传递参数，例如在编辑或查看单篇文章时。以edit_article_path(article)为例，article是一个Article对象，我们需要传递该对象作为参数。具体如下：

1
2
3
4
5
6
7

<% @articles.each do |article| %>
  <p>
    <%= article.title %>
    <%= link_to '编辑', edit_article_path(article) %>
    <%= link_to '查看', article_path(article) %>
  </p>
<% end %>

在以上代码中，我们遍历了所有文章，并为每篇文章生成了“编辑”和“查看”链接。edit_article_path(article) 和 article_path(article) 会根据文章的ID自动生成相应的URL。

4. URL和路径助手的区别

URL和路径虽然在实际使用中常常混淆，但在Rails中有明确的区别：

• 路径助手：生成相对路径，例如 /articles。
• URL助手：生成绝对URL，例如 http://localhost:3000/articles。

在Rails中，*_path形式的方法会返回相对路径，而*_url形式的方法会返回完整URL。示例：

1

<%= link_to '全部文章', articles_url %>

5. 使用命名路由

Rails允许我们为路由定义自定义名称，以便在生成助手时提供更具描述性的名字。例如：

1

get 'about_us', to: 'pages#about', as: :about

这样，我们可以使用about_path来生成指向“关于我们”页面的链接：

1

<%= link_to '关于我们', about_path %>

6. 路由助手的局部和全局调用

在Rails视图文件中，路由助手可直接使用。但在控制器和其他Ruby类中调用时，我们可以使用以下方法：

1

Rails.application.routes.url_helpers.articles_path

这种方式在某些情况下非常有用，比如我们需要在后台操作或生成邮件时。

结论

在本章中，您已经学习了如何使用Rails的路由助手来生成路径和URL，了解了助手的不同种类以及动态生成链接的方式。正确使用路由助手不仅能够提高代码的可读性和可维护性，还能帮助我们更快速地进行网站的调整和改动。

在下一章，我们将转向视图层，探讨如何构建和使用Rails视图和模板，继续深入Rails开发的各个方面。准备好迎接这个激动人心的新阶段了吗？让我们一起开始探索视图的世界吧！

在 Ruby on Rails 框架中，视图层是应用程序中处理用户界面的部分。视图负责呈现数据并与用户进行交互，它能够将控制器发送的数据以易于理解的格式展现出来。在本节中，我们将深入探讨 Rails 中的视图和模板，以及如何利用它们构建用户友好的界面。

视图的基础

在 Rails 中，每个控制器通常关联一个视图。视图文件存放在 app/views 目录下，通常以控制器名称为子目录。例如，如果有一个名为 PostsController 的控制器，其对应的视图文件夹将是 app/views/posts。

每个操作（或动作）都有一个与之相关联的视图模板。例如，PostsController 中的 index 动作将寻找 app/views/posts/index.html.erb 文件。这里的 .html.erb 是指该文件使用了 Ruby 的 ERB 模板引擎，允许在 HTML 中嵌入 Ruby 代码。

使用实例

假设我们有一个简单的博客应用。在 PostsController 中，我们有一个 index 动作，用于显示所有帖子。在该动作中，我们可能会获取所有的帖子并将其传递给视图：

1
2
3
4
5

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end
end

在 app/views/posts/index.html.erb 文件中，我们可以使用如下代码呈现帖子列表：

1
2
3
4
5
6
7

<h1>所有帖子</h1>

<ul>
  <% @posts.each do |post| %>
    <li><%= post.title %></li>
  <% end %>
</ul>

在这个视图中，<% %> 用于执行 Ruby 代码，而 <%= %> 则用于输出结果。当用户访问 /posts 路由时，Rails 会渲染这个视图，并将所有帖子以列表的形式展示出来。

部分视图（Partial）

在实际应用中，多个视图可能会共享一些相同的代码。为了解决这个问题，Rails 提供了部分视图的概念。部分视图是可重用的模板，可以包含在其他视图中。

例如，我们可以创建一个部分视图 _post.html.erb，用于呈现单个帖子的内容：

1
2

<!-- app/views/posts/_post.html.erb -->
<li><%= post.title %> - <%= link_to '查看', post_path(post) %></li>

然后在 index.html.erb 中，我们可以引用这个部分视图，避免代码重复：

1
2
3
4
5

<h1>所有帖子</h1>

<ul>
  <%= render @posts %>
</ul>

布局（Layout）

Rails 还支持布局（Layouts），用于定义整个应用的通用外观，如页眉和页脚。布局文件存放在 app/views/layouts 中，默认布局文件为 application.html.erb。

在布局文件中，我们可以使用 yield 方法来指定内容所在的位置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<!-- app/views/layouts/application.html.erb -->
<!DOCTYPE html>
<html>
<head>
  <title>My Blog</title>
</head>
<body>
  <header>
    <h1>我的博客</h1>
  </header>

  <%= yield %>

  <footer>
    <p>版权所有 &copy; 2023 我的博客</p>
  </footer>
</body>
</html>

所有视图都会在布局文件中渲染，确保在每个页面上都有一致的结构。

总结

在 Rails 中，视图层通过 ERB 模板引擎将数据与 HTML 结合，帮助开发者构建出动态的用户界面。通过使用部分视图和布局，我们能够更好地管理视图代码，提高代码的重用性和可维护性。

在下一节中，我们将深入探讨 ERB 模板引擎的使用，它为我们的视图层添加了更多的动态功能。在这之前，确保你理解了视图层的基础知识以及如何在 Rails 应用中使用它们。

在上一章中，我们了解了视图层的基本概念，以及在 Ruby on Rails 中视图如何与控制器和模型交互。这一章将重点讨论使用 ERB 模板引擎来创建动态视图。ERB（Embedded Ruby）允许我们在 HTML 中嵌入 Ruby 代码，从而生成动态的内容。

什么是 ERB？

ERB 是 Ruby 提供的一种模板系统，它允许你在 .html.erb 文件中将 Ruby 代码嵌入到 HTML 中。当 Rails 处理请求时，会渲染这些 ERB 文件并生成最终的 HTML 代码。ERB 主要有两个标签：

• <% %>：用来执行 Ruby 代码，但不将结果输出到模板中。
• <%= %>：用来执行 Ruby 代码，并将结果输出到模板中。

使用 ERB 模板的例子

让我们来看看一个具体的例子，假设我们有一个名为 PostsController 的控制器，它负责显示博客文章。

步骤 1：生成控制器和视图

首先，使用 Rails 命令生成一个 PostsController 和相关的视图。

1

rails generate controller Posts index show

这将生成 PostsController 和两个视图文件：index.html.erb 和 show.html.erb。

步骤 2：定义控制器动作

接下来，我们在 PostsController 中定义 index 和 show 动作：

1
2
3
4
5
6
7
8
9

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end

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

步骤 3：创建 ERB 视图

index.html.erb

在 app/views/posts/index.html.erb 文件中，我们将使用 ERB 来显示所有帖子的信息：

1
2
3
4
5
6
7
8
9

<h1>博客文章列表</h1>

<ul>
  <% @posts.each do |post| %>
    <li>
      <a href="<%= post_path(post) %>"><%= post.title %></a>
    </li>
  <% end %>
</ul>

在这个示例中，我们使用 <% %> 来遍历每个帖子，并使用 <%= %> 输出帖子标题和生成链接。

show.html.erb

在 app/views/posts/show.html.erb 文件中，我们展示单个帖子的详细信息：

1
2
3

<h1><%= @post.title %></h1>
<p><%= @post.content %></p>
<a href="<%= posts_path %>">返回文章列表</a>

这里，我们也使用了 ERB 标签来显示帖子的标题和内容。

ERB 标签的更多用法

除了基本的输出，ERB 还支持条件语句和循环等更复杂的逻辑。

条件语句示例

我们可以使用条件语句来根据帖子的状态显示不同的信息。例如，在 show.html.erb 中添加一个条件：

1
2
3
4
5

<% if @post.published? %>
  <p>这是公开帖子。</p>
<% else %>
  <p>此帖子尚未发布。</p>
<% end %>

迭代和块

ERB 还可以用于生成表格或其他结构。例如，我们可以在 index.html.erb 中用表格显示帖子列表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<table>
  <thead>
    <tr>
      <th>标题</th>
      <th>创建时间</th>
    </tr>
  </thead>
  <tbody>
    <% @posts.each do |post| %>
      <tr>
        <td><%= post.title %></td>
        <td><%= post.created_at.strftime('%Y-%m-%d') %></td>
      </tr>
    <% end %>
  </tbody>
</table>

在这个示例中，我们使用了 ERB 来生成一张表，其中每一行都是一个帖子的信息，展示标题和创建时间。

结论

这一章我们深入探讨了如何使用 ERB 模板引擎来创建动态视图。通过结合 Ruby 代码和 HTML，我们能够生成灵活且动态的内容。ERB 的标签使我们能够在视图中写入逻辑，使得渲染的 HTML 更加个性化和丰富。

在下一章中，我们将学习部分视图和布局，以进一步提高视图的复用性和结构化设计。通过正确利用部分视图和布局，我们可以让 Rails 应用更加简洁和高效。

在 Ruby on Rails 中，视图和模板的设计是构建用户界面的重要组成部分。在前一篇中，我们介绍了如何使用 ERB 模板引擎来渲染视图。在本篇中，我们将深入探讨如何创建部分视图和布局，以提高代码的重用性和可维护性。

什么是部分视图？

部分视图（Partial）是用于将视图划分为更小、更可重用组件的视图。部分视图的主要目的是减少重复代码，并使代码结构更加清晰。你可以将一些可以共享的元素提取到单独的部分视图中，从而在不同的视图中重用它们。

创建部分视图

要创建部分视图，我们首先需要在视图目录中创建一个以下划线开头的文件，例如 _form.html.erb。下面是一个创建部分视图的步骤：

1. 创建部分视图文件
   在 app/views/posts/ 目录下创建一个文件 _form.html.erb，这个部分视图将用于显示一个表单。

   1 2 3 4 5 6 7 8 9 10 11 12 13

   <div class="post-form"> <%= form_with model: @post do |form| %> <div class="form-group"> <%= form.label :title %> <%= form.text_field :title, class: "form-control" %> </div> <div class="form-group"> <%= form.label :content %> <%= form.text_area :content, class: "form-control" %> </div> <%= form.submit "提交", class: "btn btn-primary" %> <% end %> </div>

2. 在主视图中渲染部分视图
   在 app/views/posts/new.html.erb 和 app/views/posts/edit.html.erb 中，我们可以使用 render 方法来引入这个部分视图，示例如下：

   1 2	<h1>创建新帖子</h1> <%= render 'form' %>

   1 2	<h1>编辑帖子</h1> <%= render 'form' %>

这种方式使得我们可以复用相同的表单代码，而不需要在每个视图中重复书写。

布局（Layouts）

布局是指在额外的视图外部添加的结构和样式。布局可以定义整个应用程序的页面框架，例如头部、脚部和导航菜单。每个视图都可以系统地使用相同的布局，从而提供一致的用户体验。

创建布局

在 Rails 中，布局文件通常位于 app/views/layouts 目录下。默认的布局文件是 application.html.erb。下面是一个简单的布局示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<!DOCTYPE html>
<html>
<head>
  <title>我的博客</title>
  <%= csrf_meta_tags %>
  <%= csp_meta_tag %>
  
  <%= stylesheet_link_tag 'application', media: 'all' %>
  <%= javascript_pack_tag 'application' %>
</head>

<body>
  <header>
    <h1>我的博客</h1>
    <nav>
      <ul>
        <li><%= link_to '首页', root_path %></li>
        <li><%= link_to '创建帖子', new_post_path %></li>
      </ul>
    </nav>
  </header>

  <main>
    <%= yield %> <!-- 视图内容将在这里插入 -->
  </main>

  <footer>
    <p>&copy; <%= Time.now.year %> 我的博客</p>
  </footer>
</body>
</html>

在这个布局中，我们使用了 yield 关键字来指示在布局中插入的视图内容。每个视图都将会在 <main> 标签内展示。

使用布局

默认情况下，Rails 会使用 application.html.erb 作为所有视图的布局文件。如果你需要为特定的视图使用不同的布局，可以在控制器中指定。例如：

1
2
3
4
5

class PostsController < ApplicationController
  layout "special_layout", only: [:show]
  
  # 其他控制器代码...
end

在这个例子中，show 动作将使用名为 special_layout.html.erb 的布局文件，而其他动作将继续使用默认的布局文件。

案例结合

假设我们已经创建了一个 Posts 控制器，并在控制器中定义了 new 和 edit 方法，来分别处理新帖子创建和帖子编辑的请求。现在，我们可以结合上述部分视图和布局的使用，来实现一个完整的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class PostsController < ApplicationController
  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post, notice: '帖子创建成功！'
    else
      render :new
    end
  end
  
  def edit
    @post = Post.find(params[:id])
  end

  def update
    @post = Post.find(params[:id])
    if @post.update(post_params)
      redirect_to @post, notice: '帖子更新成功！'
    else
      render :edit
    end
  end

  private

  def post_params
    params.require(:post).permit(:title, :content)
  end
end

在 new.html.erb 和 edit.html.erb 中，我们分别渲染了 _form.html.erb 部分视图，使用布局来提供页面的整体结构，从而实现了代码的组织和界面的一致性。

小结

在这一节中，我们探讨了如何使用部分视图和布局来构建更灵活、可重用的视图。在实际开发中，这种结构将有助于减少代码重复，提高维护性。在下一篇教程中，我们将继续研究如何处理表单，创建用户输入的表单以支持动态数据输入。

在前一章中，我们讨论了如何在 Rails 应用程序中使用部分视图和布局来构建优雅的页面结构。这一节的重点是如何创建和处理表单，特别是在用户需要输入数据时。表单是 web 应用中与用户交互的重要部分，是获取用户输入并进行处理的主要途径。

创建表单

基本的表单生成

在 Rails 中，生成表单非常简单。我们可以使用 Rails 提供的表单辅助方法来创建。假设我们正在构建一个简单的博客应用，用户可以创建新的博客文章。我们将会创建一个表单，用于输入文章的标题和内容。

首先，我们需要生成一个文章模型。如果你还没有创建模型，可以使用以下命令：

1
2

rails generate model Article title:string content:text
rails db:migrate

接下来，在 articles_controller.rb 中，我们需要添加一个 new 方法来渲染创建表单。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class ArticlesController < ApplicationController
  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)
    if @article.save
      redirect_to @article, notice: 'Article was successfully created.'
    else
      render :new
    end
  end

  private

  def article_params
    params.require(:article).permit(:title, :content)
  end
end

在这个代码片段中，new 方法初始化了一个新的文章对象，而 create 方法则处理了表单提交。

创建视图文件

现在，我们需要创建一个视图文件来显示这个表单。在 app/views/articles 目录中，创建一个名为 new.html.erb 的文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<%= form_with model: @article, local: true do |form| %>
  <% if @article.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(@article.errors.count, "error") %> prohibited this article from being saved:</h2>
      <ul>
        <% @article.errors.full_messages.each do |message| %>
          <li><%= message %></li>
        <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :title %>
    <%= form.text_field :title %>
  </div>

  <div class="field">
    <%= form.label :content %>
    <%= form.text_area :content %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

在这个视图中，我们使用了 form_with 辅助方法来生成表单。form_with 会自动关联我们的文章模型，并根据模型的属性生成相应的输入字段。

表单各部分的解释

• form.label: 用于生成标签，方便用户理解输入框是干什么的。
• form.text_field: 创建一个文本输入框，用于输入标题。
• form.text_area: 创建一个文本区域，适合输入内容。
• form.submit: 生成一个提交按钮。

通过这样的结构，当用户提交表单时，会触发 create 方法，数据会被检查并保存到数据库中。如果存在错误，用户将看到错误消息并能够修正这些错误。

小结

本章介绍了如何在 Rails 中创建表单，步入用户输入数据的流程。我们学习了如何使用 form_with 方法生成表单，并在表单中添加错误处理机制，为用户提供良好的交互体验。

接下来，我们将在下一章中讨论如何处理表单提交，解析用户输入的数据，并实现相应的业务逻辑。确保您已经理解了表单的创建，这对于处理用户交互至关重要。

在 Ruby on Rails 中，处理表单提交的内容是 Web 应用程序的核心功能之一。用户通过表单提交的数据可以用来创建、更新或删除数据库中的记录。在本节中，我们将详细探讨如何接收和处理表单数据，以便有效地管理用户交互。

前置条件

在正式开始之前，请确保您已经完成了上一章节的内容：创建表单。我们在这一章节中将承接上一个章节的内容，特别是关于如何生成和展示表单的部分。

假设我们已经有一个简单的 Post 模型，它包含 title 和 content 字段，我们希望用户能够通过表单提交新博客文章。

路由设置

我们需要确保我们的路由设置正确。打开 config/routes.rb 文件，确保有如下内容：

1
2
3

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

这将为 posts 资源生成标准的 RESTful 路由，包括 new, create, edit, update 和 destroy 动作。

控制器设置

接下来，确保我们在 PostsController 中定义了 create 动作。打开 app/controllers/posts_controller.rb 文件，并添加 create 方法。该方法会处理表单数据并将其保存到数据库中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class PostsController < ApplicationController
  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)

    if @post.save
      redirect_to @post, notice: 'Post was successfully created.'
    else
      render :new
    end
  end

  private

  def post_params
    params.require(:post).permit(:title, :content)
  end
end

代码解析

在上面的代码中：

• new 方法用于初始化一个新的 Post 对象，并将其传递给视图。
• create 方法用于处理表单的提交。我们通过 Post.new(post_params) 创建一个新的 Post 实例，然后调用 save 方法将其保存到数据库。如果保存成功，通过 redirect_to 方法重定向到新创建的文章页面，并显示成功消息；如果保存失败，则重新渲染表单。

我们还定义了 post_params 方法，该方法使用 params.require 和 permit 确保只允许 title 和 content 两个参数，以防止潜在的安全问题。

视图设置

接下来，是实现视图部分。确保在 app/views/posts/new.html.erb 文件中，您有类似以下的表单代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<%= form_with(model: @post, local: true) do |form| %>
  <% if @post.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(@post.errors.count, "error") %> prohibited this post from being saved:</h2>

      <ul>
        <% @post.errors.full_messages.each do |message| %>
          <li><%= message %></li>
        <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :title %>
    <%= form.text_field :title %>
  </div>

  <div class="field">
    <%= form.label :content %>
    <%= form.text_area :content %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

视图代码解析

在这个表单视图中，我们使用了 form_with 生成一个表单，model: @post 表示该表单是为 @post 实例生成的。我们还检查了是否有任何错误，如果有，我们就会展示这些错误信息。

• 表单包含两个字段：title 和 content，并使用 form.label 和 form.text_field 来生成相关的输入控件。
• form.submit 用于生成提交按钮。

总结

在这一节中，我们学习了如何处理用户提交的表单数据。我们创建了一个 PostsController 中的 create 动作，处理从表单提交的数据，并通过 post_params 方法确保我们的应用程序安全地处理数据。最后，我们还编写了一个简单的视图，允许用户输入 title 和 content。

通过这些代码，我们已经能够接受用户的输入并将其保存在数据库中。接下来，在下一章节中，我们将讨论表单验证，确保我们的输入数据的合法性和有效性。这将帮助提升用户体验和数据一致性。

在继续之前，请确保您已成功地创建了文章，并且一切运行正常。准备好迎接表单验证的挑战吧！