Ruby on Rails Instance Variables vs Local Variables Explained

By the end of this page, you will understand the difference between instance variables like @title and local variables like title in Ruby and Ruby on Rails. You will learn how scope works, why Rails views often use @variables, and how to choose the right kind of variable in controllers, views, and methods.

In Ruby, the @ symbol changes the kind of variable you are using.

• title is a local variable
• @title is an instance variable

These are not the same variable.

Local variables

A local variable exists only within the current scope, such as:

• a method
• a block
• a small section of code

Example:

def show_name
  name = "Ruby"
  puts name
end

Here, name only exists inside show_name.

Instance variables

An instance variable belongs to a specific object instance. It can usually be accessed by different methods of that same object.

Example:

class Book
  def set_title
    @title = "Eloquent Ruby"
  end

  def print_title
    puts @title
  end
end

If runs first, can use the same because both methods are working with the same object.

Think of local and instance variables like storage places in a house.

• title is like a note on your desk. Only the person currently sitting there can use it.
• @title is like a label attached to the room. Anyone working in that room later can still see it.

In Rails:

• a controller action can create @title
• the matching view can read that same @title

But a local variable like title is temporary. It stays only inside the method where it was created.

So if you need data only for a few lines, use a local variable. If you need data to stay attached to the current controller object and be visible to the view, use an instance variable.

Basic syntax

title = "Hello"     # local variable
@title = "Hello"    # instance variable

Local variable example

def greeting
  message = "Welcome"
  puts message
end

message exists only inside the greeting method.

Instance variable example

class Greeting
  def set_message
    @message = "Welcome"
  end

  def show_message
    puts @message
  end
end

g = Greeting.new
g.set_message
g.show_message

Output:

Welcome

@message is stored in the object, so one method can set it and another can read it.

Consider this Rails controller action:

class PagesController < ApplicationController
  def home
    title = "Local title"
    @title = "Instance title"
  end
end

And this view:

<p><%= @title %></p>
<p><%= title %></p>

What happens step by step

1. Rails receives a request for the home action.
2. Rails creates a controller object for that request.
3. Inside home, title = "Local title" creates a local variable.
4. That local variable exists only inside the home method.
5. @title = "Instance title" creates an instance variable on the controller object.
6. The action finishes.
7. Rails renders the view connected to that action.
8. The view can access @title because it is attached to the controller instance.
9. The view cannot access title because the local variable stopped existing when the method ended.

Result

In Rails controllers

A controller fetches data and exposes it to the view.

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

The view can then display @post.

In forms and edit pages

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

The form uses @user to fill in existing values.

For temporary calculations inside a method

def total_price
  subtotal = 100
  tax = 10
  subtotal + tax
end

subtotal and tax are local variables because they are only needed inside that method.

In Ruby classes outside Rails

Instance variables store object state.

In real Rails projects, developers usually prefer local variables by default and use instance variables only when data must be shared with the view or across methods of the same object.

Common controller pattern

class ProductsController < ApplicationController
  def show
    @product = Product.find(params[:id])
  end
end

This is standard because the view needs @product.

Common service or model pattern

def discounted_price(price)
  discount = 0.2
  price - (price * discount)
end

discount stays local because nothing outside the method needs it.

Using instance variables for object state

class ReportBuilder
  def initialize(records)
    @records = records
  end

   
    .map(&)
  

1. Expecting a local variable to be available in the view

Broken example:

class PostsController < ApplicationController
  def index
    title = "Posts"
  end
end

<h1><%= title %></h1>

Why it fails:

• title is local to the controller method
• the view cannot access it

Fix:

def index
  @title = "Posts"
end

2. Using instance variables for everything

Broken style:

def sum
  @x = 1
  @y = 2
  @z = @x + @y
end

Why it is a problem:

Local variable vs instance variable

• Local variable: short-lived and limited in scope
• Instance variable: attached to an object and available to that object's methods

In a Rails controller

name = "Ruby"     # local variable
@name = "Ruby"    # instance variable

• name and @name are different variables
• Local variables exist only in the current method or block
• Instance variables belong to an object
• In Rails controllers, instance variables are available in views
• Use local variables for temporary values
• Use instance variables for shared object state or controller data for templates
• Unset instance variables are nil

Quick rule

• Need it only inside one method? Use title
• Need it in the view or across object methods? Use @title

Rails example

def show
  @post = Post.find(params[:id]) # view can use this
  post_count = 5                 # view cannot use this
end

Common error

<%= title %>

What does @ mean before a variable in Ruby?

It means the variable is an instance variable, which belongs to a specific object.

What is the difference between title and @title in Rails?

title is a local variable and only exists in the current scope. @title is an instance variable and is available to the controller object and its view.

Why do Rails views often use @variables?

Because Rails exposes controller instance variables to the view template for rendering.

Should I always use @variables in a Rails controller?

No. Use instance variables only for data the view needs. Use local variables for temporary values inside the action.

What happens if I use an instance variable without setting it?

Its value is nil.

Can two methods in the same class use the same instance variable?

Yes, if they run on the same object instance.

Is @title the same as a global variable?

No. A global variable starts with $, not @. Instance variables are limited to one object.

• Variable scope — Helps explain where a variable can be accessed.
• Ruby objects and classes — Instance variables make more sense once you understand objects.
• Rails controllers and views — Important because instance variables are commonly passed from controllers to views.
• Methods in Ruby — Local variables often live inside methods.
• Class variables in Ruby — Useful for comparing @variable with @@variable.
• Constants in Ruby — Another common variable-like construct with different rules.
• Rails instance variables in views — A direct follow-up topic for template rendering patterns.