Rails中product = Product.new与@product的区别及实例变量数据库访问方法

Hey there, let's tackle these two Rails questions clearly—they're super common when you're getting started with the framework!

1. Differences between product = Product.new and @product in Rails #

First, let's clarify: Product.new creates a new, unsaved Product object regardless of what variable you assign it to. The real difference is in the variable type (local vs instance) and how Rails treats them:

• Scope is the biggest factor

  • product is a local variable: it only exists within the exact code block where it's defined. For example, if you define it inside a controller's create method, you can't access it in the index method, and you definitely can't use it in your view template.
  • @product is an instance variable: it belongs to the current controller instance. This means it's automatically accessible in the view template that corresponds to the controller action. This is how Rails shares data between controllers and views.

• Rails helper methods leverage instance variables
  Many built-in Rails helpers (like form_with, link_to, or render) automatically recognize instance variables. For example:

  # In your controller
  @product = Product.new
  
  # In your view
  <%= form_with model: @product do |form| %>
    # This automatically generates a form that POSTs to /products
  <% end %>
  

  If you used a local variable product instead, you'd have to explicitly specify the URL: form_with model: product, url: products_path.

• No difference in the object's state
  Whether you assign Product.new to a local or instance variable, the underlying Product object is the same: it's not saved to the database yet, and has all the default attribute values. The variable type only changes where you can use it.

2. Using instance variables to access database data via Rails models #

Instance variables are key for passing database data between your models, controllers, and views. Here's how it works:

In Controllers (the most common use case) #

Controllers act as the middleman between models and views. You'll use model class methods to query the database, then assign the result to an instance variable so the view can access it:

# app/controllers/products_controller.rb
class ProductsController < ApplicationController
  def show
    # Fetch a single product from the database by ID, assign to @product
    @product = Product.find(params[:id])
  end

  def index
    # Fetch all products from the database, assign to @products
    @products = Product.all
  end
end

Then in your view (like app/views/products/show.html.erb), you can directly access the instance variable to display data:

<h1><%= @product.name %></h1>
<p>Price: $<%= @product.price %></p>

Inside Models #

Rails automatically maps database table columns to instance variables in your model objects. When you fetch a record from the database, Rails populates these instance variables with the column values, and generates getter/setter methods for you to access them.

For example, if your products table has a name column, your Product model will have a name method that returns the value of the @name instance variable:

class Product < ApplicationRecord
  # Rails handles the @name, @price, etc. instance variables automatically
end

# In a controller or console
product = Product.find(1)
product.name # => Returns the value of the @name instance variable (from the database)

You can also define custom instance variables in models to store temporary or computed data:

class Product < ApplicationRecord
  def sale_price
    @sale_price ||= price * 0.9 # Cache the computed sale price in an instance variable
  end
end

Here, @sale_price is a custom instance variable that stores the calculated sale price, so we don't recompute it every time we call sale_price.

内容的提问来源于stack exchange，提问作者rushi reddy