1

In a common application we use instance variables so that we can access them in our views. But in a Rails api application what would the need be?

Is there any performance difference between using a local or instance variable In this context of Controllers?

I do not understand why rails uses instance variables in the create and index method in an api application generated by scaffold if the variable is not reused

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


def show
    @user = User.find(params[:id])
    render json: UserSerializer.new(@user)
end
Improve this question
1
  • The answers below are clear, but don't forget the fact that a Rails API often still has views in the sense of some_file.json.jbuilder files. Commented Jun 7, 2018 at 16:26

4 Answers 4

Reset to default
5

In this exact example, there is no functional difference.

Is there any performance difference? Or is there material performance difference? I do not know the answer to the first question. The answer to the second question, I imagine, is 'no' unless you are doing this at some unimaginably large scale. Even then, it's hard to imagine.

BTW, you could just do:

def show
  render json: UserSerializer.new(User.find(params[:id]))
end

In your example, there is no need for a variable, either user or @user.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thank you, it is only a question that has arisen, but I have no deep knowledge to know. Thank you :)
5

There is a very clear practical difference in how lexical and instance variables work:

class Thing
  def initialize
    @ivar = "Hello World"
  end
  def foo
    @ivar
  end
end

> Thing.new.foo
=> "Hello World"

Since instance variables are attached to the instance they can be shared among methods of an object without passing by value as typically used by callbacks:

class API::V1::ThingsController < ::ApiController
  before_action :set_thing, except: [:create, :index]

  def show
    respond_with @thing
  end

  # ...

  private

    def set_thing
      @thing = Thing.find(params[:id])
    end
end

This can be immensely useful when considering the convention over configuration focus of rails. Controller IVARs are also available in the view through the view context.

Lexical variables on the other hand only exist in the lexical scope where the are defined (the method, block, proc or lambda):

class Thing
  def initialize
    lex = "Hello World"
  end
  def foo
    lex
  end
end

> Thing.new.foo
NameError: undefined local variable or method `lex' for #<Thing:0x007f87068b5968>

They are preferable when you need a short lived variable with a local scope. Rails also has locals which is actually a hash where you can stuff things when rendering which should not be conflated with the Ruby concept of lexical variables. Rails uses method_missing in the view context to proxy to the locals hash.

The performance difference is most likely extremely negible as both are just variables that are bound to a scope - either the object or a method/block. The lexical variable will recycled by the GC when the scope is closed (the method finishes) though while an instance variable will persist with the object. This is rarely an issue though.

Improve this answer

3 Comments

"Model callbacks are one of the most overused and misused features in Rails." I feel the same way about controller callbacks. So, how about a memoized action thing with @thing ||= Thing.find(params[:id]). Just curious and thanks!
Memoization is a nice extra but I don't think I have ever really needed it.
"Model callbacks are one of the most overused and misused features in Rails." You haven't encountered model code that has a side-effect in a validation yet... C-;
2

The performance difference will be negligible.

But there's two competing guidelines at work. One is "Always use the weakest construction." Don't use double "quotes" if you can use single 'quotes'. Don't use a regular expression if you can use String#index. Don't use an instance variable if you can use a local variable.

The other guideline is "Design for testing." If you use an instance variable, your test can inspect it with assigns(:user). That rule trumps the "weakest construction" rule. So use an instance variable, and write lots of automated tests!

Improve this answer

6 Comments

assigns is depreciated so I would hardly chalk that up to a plus.
What is the replacement for assigns?
The replacement is not poking inside the controller. github.com/rails/rails/issues/18950
...this from the same people who are deprecating the "functional test"...
And the same people who brought you rails in the first place.
|
1

there is no difference talking about functionality in that example. but creating an instance variable is to let that variable be accesible later, maybe on the view or in another method, in this case, talking about api's (you don't have views), if you do not plan to use @user in another method inside that controller for example, you don't need to create it, with just a local variable, it's enough.

talking about performance, I don't think there will be much differences, at least something noticeable.

And as a comment:

"An instance variable continues to exist for the life of the object that holds it. A local variable exists only within a single method, block or module body."

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.