Ruby Developer Interview Preparation Guide

Download PDF

Class libraries in Ruby consist of a variety of domains, such as data types, thread programming, various domains, etc.

Yes, with the help of the send method.

Given the class Test:

class Test
private
def method
p "I am a private method"
end
end
We can execute the private method using send:

>> Test.new.send(:method)
"I am a private method"

ORM stands for Object Relationship Model that models the classes and helps in setting a relationship between the existing models.

Functions:

1. It allows the classes to be mapped to the table that is present in the database and objects get mapped to the rows in database table.

2. It shows the relationship that exists between the object and frame it using the model to display the output to the users.

3. It keeps the data in the database according to its relationships and performs the functions accordingly.

Modules are Ruby’s way of grouping methods, classes, and constants together to provide a namespace for preventing name clashes. The second purpose of modules is to use them as mixins. Technically, Ruby only supports single inheritance, but by using modules as mixins, it is possible to share code among different classes—a key advantage of multiple inheritance—without having to give up the simplicity of the single inheritance paradigm.

The “include” makes the module’s methods available to the instance of a class, while “extend” makes these methods available to the class itself.

The syntax for Ruby collect Iterator collection = collection.collect.

Unlike the puts statement, which outputs the entire string onto the screen. The Putc statement can be used to output one character at a time.

Ruby regular expression is a special sequence of characters that helps you match or find other strings. A regular expression literal is a pattern between arbitrary delimiters or slashes followed by %r.

Dynamic Scaffolding:
It automatically creates the entire content and user interface at runtime
It enables to generation of new, delete, edit methods for the use in application
It does not need a database to be synchronized

Static Scaffolding:
It requires manual entry in the command to create the data with their fields
It does not require any such generation to take place
It requires the database to be migrated

Rake is a Ruby Make; it is a Ruby utility that substitutes the Unix utility ‘make’, and uses a ‘Rakefile’ and ‘.rake files’ to build up a list of tasks. In Rails, Rake is used for normal administration tasks like migrating the database through scripts, loading a schema into the database, etc.

The Hash class in Ruby’s core library returns value by using a standard “= =” comparison on the keys. It means that the value stored for a symbol key cannot be retrieved using the equivalent string. While the HashWithIndifferentAccess treats Symbol keys and String keys as equivalent.

Rails Migration can do following things

☛ Create table
☛ Drop table
☛ Rename table
☛ Add column
☛ Rename column
☛ Change column
☛ Remove column and so on

Symbol is different from variables in following aspects

☛ It is more like a string than variable
☛ In Ruby string is mutable but a Symbol is immutable
☛ Only one copy of the symbol requires to be created
☛ Symbols are often used as the corresponding to enums in Ruby

In Ruby False indicates a Boolean datatype, while Nil is not a data type, it have an object_id 4.

Ruby: It is an object oriented programming language inspired by PERL and PYTHON.
Rails: It is a framework used for building web application

☛ App/controllers: A web request from the user is handled by the Controller. The controller sub-directory is where Rails looks to find controller classes
☛ App/helpers: The helper’s sub-directory holds any helper classes used to assist the view, model and controller classes.

To create migration command includes

C:rubyapplication>ruby script/generate migration table_name

You can execute your application by uncommenting the line in environment.rb

path=> rootpath conf/environment.rb

config.frameworks = [ action_web_service, :action_mailer, :active_record]

☛ super(): A call to super() invokes the parent method without any arguments, as presumably expected. As always, being explicit in your code is a good thing.
☛ super call: A call to super invokes the parent method with the same arguments that were passed to the child method. An error will therefore occur if the arguments passed to the child method don’t match what the parent is expecting.

In Ruby,

☛ A constant should begin with an uppercase letter, and it should not be defined inside a method
☛ A local must begin with the _ underscore sign or a lowercase letter
☛ A global variable should begin with the $ sign. An uninitialized global has the value of “nil” and it should raise a warning. It can be referred anywhere in the program.
☛ A class variable should begin with double @@ and have to be first initialized before being used in a method definition

The four types of variables in Ruby are as follows:

☛ Global variables begin with $ and are accessible from anywhere within the Ruby program regardless of where they are declared—it stands to reason that they must be handled with care.
☛ Local variables begin with a lowercase letter or an underscore. The scope of a local variable is confined to the code construct within which it is declared.
☛ Class variables begin with @@ and are shared by all instances of the class that it is defined in.
☛ Instance variables begin with @ and are similar to class variables except that they are local to a single instance of a class in which they are instantiated.

MVC stands for Model View Controller.

Model is the data structure that your program uses.

The View is the part that interacts with the screen or the next level up.

The Controller generally processes data between the model and view.

For example, a model will define your table in the database, the controller will dictate what to do behind the scenes and what to display in the view next. The view part generates the user interface which presents data to the user.

Let’s take an example of creating a form. The submit form will be a view file, from that view file, when you click on the submit button it goes to the respective controller where you have written your business code about what happens on submitting the application/form, and from that controller the data will be saved in the database.

Thus MVC helps to split up the the business logic, database access and presentation. This is very useful in most web applications, and now lately into software/desktop applications.

def productarray()
return array.inject(:*)
end

== – Checks if the value of two operands are equal (often overridden to provide a class-specific definition of equality).

=== – Specifically used to test equality within the when clause of a case statement (also often overridden to provide meaningful class-specific semantics in case statements).

eql? – Checks if the value and type of two operands are the same (as opposed to the == operator which compares values but ignores types). For example, 1 == 1.0 evaluates to true, whereas 1.eql?(1.0) evaluates to false.

equal? – Compares the identity of two objects; i.e., returns true iff both operands have the same object id (i.e., if they both refer to the same object). Note that this will return false when comparing two identical copies of the same object.

☛ The symbol in Ruby on rails act the same way as the string but the difference is in their behaviors that are opposite to each other.
☛ The difference remains in the object_id, memory and process time for both of them when used together at one time.
☛ Strings are considered as mutable objects. Whereas, symbols, belongs to the category of immutable.
☛ Strings objects are mutable so that it takes only the assignments to change the object information. Whereas, information of, immutable objects gets overwritten.
☛ String objects are written like
p: “string object jack”.object_id #=>2250 or
p: “string object jack”.to_sym.object_id #=> 2260, and
p: “string object jack”. to_s_object_id #=> 2270

☛ Symbols are used to show the values for the actions like equality or non-equality to test the symbols faster then the string values.