Ruby

A getter action is a method implementation that gets the value of an instance variable of an object. With the getter method, you can retrieve the value of an instance variable outside the class.
There are multiple ways to have getter action in a class. The most basic implementation is as follows.

For example:

//----start code--------
class Hi
 def initialize(name)
   @name = name
 end
end
obj1 = Hi.new('Bruno)
p obj1.name #=> undefined method `name' for #<Hi:0x007fecd08cb288 @name="Bruno"> (NoMethodError)
//----end code--------

From the above example, the value of obj1.name cannot be retrieved outside Hi class. if you try to retrieve a value of an instance variable outside its class without a getter method, Ruby raises No Method Error.

Defining a getter method within a class will make the value of the name variable within the object.

It is common practice to name a getter method as the instance variable’s name.

//----start code---------
class Hi
 def initialize(name)
   @name = name
 end
 def name
   @name
 end
end
obj1 = Hi.new('Bruno’)
p obj1.name #=> “Bruno”
//----end code--------

A common question in Ruby technical interview questions, don't miss this one.  

# Add the gem in Gemfile 

gem 'rack', :github => 'rack/rack', :branch => 'master' 

# Execute the below command in your terminal 

$ bundle config local.rack ~/Work/git/rack 

Ruby strings can be compared with three operators: 

• == operator Returns true or false 
• eql? operator Returns true or false 
• casecmp method Returns 0 if matched or 1 if not matched 

• Ruby object 

Object is the default root of all Ruby objects. Ruby objects inherit from BasicObject (it is the parent class of all classes in Ruby) which allows creating alternate object hierarchie 

Objects in Ruby are created by calling new method of the class. It is a unique type of method and predefined in the Ruby library. 

Ruby objects are instances of the class. 

• objectName = className.new 

We have a class named Circle. Syntax to create an object circle : 

• circle = Circle.new("10") 

In Ruby, load and require both are used for loading the available code into the current code. 

require` reads and parses files only once, when they were referenced for the first time. 

`load` reads and parses files every time you call `load`. 

require searches for the library in all the defined search paths and also appends .rb or .so to the file name you enter. It also makes sure that a library is only included once. So if your application requires library A and B and library B requries library A too A would be loaded only once. 

With load you need to add the full name of the library and it gets loaded every time you call load - even if it already is in memory 

nil false nil cannot be a value. false can be a value. nil is returned where there is no predicate. 

in case of a predicate, true or false is returned by a method. nil is not a boolean data type. false is a boolean data type. nil is an object of nilclass. false is an object of falseclass. 

hsh.keys.map(&:to_s).sort_by(&:length) 

or: 

hsh.keys.collect(&:to_s).sort_by { |key| key.length } 

or : 

def key_sort hsh 
hsh.keys.collect(&:to_s).sort { |a, b| a.length <=> b.length } end 

There are multiple ways to do this, but one possible answer is: 

(1..20).inject( [0, 1] ) { | fib | fib << fib.last(2).inject(:+) } 

As you go up the sequence fib, you sum, or inject(:+), the last two elements in the array and add the result to the end of fib. 

Note: inject is an alias of reduce 

One of the most frequently posed Ruby interview questions, be ready for it.  

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. 

A call to super() invokes the parent method without any arguments, as presumably expected. 

‘self ‘ keyword in Ruby is used in different situations depending on the scenario. In other words,
One context of a call to ‘self’ keyword refers to the parent class. Whereas in a different context, ‘self’ keyword may refer to a particular instance of a class.

Class definition self

we can refer to ‘self’ keyword when defining a class in Ruby. We have a Hello class, inside which we’re outputting the value of self:

For example:

//----start code--------
class Hello
   puts "Self is: #{self}"
end
//----end code--------

When calling ‘self’ directly inside the context of a class definition, the self is equivalent to the parent class in which it was defined; Hello, in the above case.

Output is

Self is: Hello  

Class method self

A class method is a method that refers only to that class in all contexts. You can define the class method with ‘Self’ keyword. The following example demonstrates how you can define a class method.

//----start code--------
class Hello
 # Define class variable
 @@name = "John Doe"
 # Getter method
 def self.name
   puts "Self inside class method is: #{self}"
   return @@name
 end
end
puts "Hello class method 'name' is: #{Hello.name}"
//----end code--------

As explained earlier ‘self’ inside a class method definition refers to that parent class object — Hello in this case. We also call Hello.name in the output, to show that our class method getter behaves as expected:

//----start code--------
Self inside a class method is: Hello
Hello class method 'name' is: John Doe  
//----end code--------

Lambda is an anonymous function in ruby, which is also be considered an object in Ruby. You will initialize a lambda and execute it by calling ‘call’ on the initialized variable. The following example will explain how to initialize and call lambda.

//----start code--------
l = lambda { "Hello World" }
puts l.call
> Do or do not
//----end code--------

You can also pass arguments to a Lambda. The following example gives a basic understanding of lambdas with arguments.

//----start code--------
l = lambda do |string|
 if string == "try"
return "There's no such thing"
 else
return "Do or do not."
 end
end
puts l.call("try")
>There's no such thing
//----end code--------

You can define a lambda either with do..end or {}. As per convention followed in Ruby,

{} for single line lambdas and do..end for multiline lambdas.

A staple in Ruby interview questions for experienced, be prepared to answer this one.

Ruby is provided with default libraries in the form of classes, which will be accessible after installing ruby in your system. These libraries are referred to as Ruby Standard Library.

Some of the libraries need to be invoked explicitly. ‘Date’ class is a library in ruby where you can get most of the actions related to date and make use of these to implement your requirement. You need to load the ‘date’ module in file or IRB or console where you want to print the current day of the week.

The following example is in IRB,

Load ‘date’ class to get the current day of the week in ruby.

For example:

//----start code--------
> load ‘date’
>   Date.today.strftime("%A")
=> "Sunday"
//----end code--------

From the above example, In the first line, we have loaded the ‘date’ library. Now you will have all the required classes and methods available for you in this IRB console. ‘Date’ is the class that we will be using to get the current day of the week. Date.today will give the current day information such as date, month and year. Calling strftime method on the current day to format and get the desired output. In this case, You will use ‘%A’ to get the current day of the week which is ‘Sunday’. There are also many other options to format the date such as get the month in the letter, month in word, year in the letter, year in 4 digits, year in 2 digits, etc.