In this article we’re going to explore the following topics:
The Binding class
An instance of the
Binding class is able to encapsulate the execution context of the receiver object.
The execution context is the entire environment needed for a given piece of code to be executed. A code without execution context cannot be properly executed.
The execution context contains the variables, the methods and
self for a given scope.
The Execution Context is a bit more complicated than this. Anyway, let’s keep it simple as it’s not the main topic of this article.
I’ll detail this key-concept in another article.
Binding class is not publicly instantiable — as the
new method is undefined during the
Binding class initialization.
Otherwise, this class can be internally instantiated via the
Kernel#binding method is private, we access this method through the
So the real purpose of this class is:
Encapsulating an Execution Context and being able to access it from another Execution Context.
I know that this notion can be a bit tricky to understand.
Anyway, we’re going to detail 2 concrete examples in the next two sections.
NB: feel free to have a look to the private and protected: a matter of message article if you’re unfamiliar with the
privatekeyword in Ruby.
The TOPLEVEL_BINDING constant
main object is the top-level scope. Any object in Ruby is instantiated, at least, under this scope.
NB: feel free to have a look to the Ruby Object Model article if you’re unfamiliar with the
mainobject in Ruby.
In order to access the Execution Context of the
main object at any time, Ruby provides a global constant named as
Binding#receiver method returns the receiver of the
Kernel#binding message. So, the calling Execution Context is retained — in our case, the
Then we access the
@a variable within an instance of the
Addition class using the
TOPLEVEL_BINDING global constant.
Let’s illustrate the use of the
Binding concept by breaking down a Ruby on Rails concept that you’ve surely worked with: the
show.html.erb template gets access to the
@user instance variable from the
So, how it works behind the scene?
ERB class provides a
result method that takes an instance of the
Binding class as parameter.
So let’s redo the previous example by explicitly instantiating the ERB class to make you understand what happens behind the scene
So, in this example, the instance of ERB can access the
@user variable defined in the
UsersController instance via the
Binding instance passed as parameter of the
May I have your attention please 🎤🎤
Feel free to subscribe here: www.rubycademy.com
Thank you for taking the time to read this post :-)
Feel free to 👏 and share this article if it has been useful for you. 🚀
Here is a link to my last article:
The Enumerable module in Ruby: Part II.