31+ Ruby Interview Questions And Answers

Metaprogramming refers to writing code that generates other code during runtime. In Ruby, it's used for creating methods dynamically, altering class inheritance, and more. This powerful feature leverages Ruby's reflective abilities.

You can call a method dynamically using the send method or with method(:method_name).call. Both allow you to invoke a method when you don't know which method will be called ahead of time.

You handle exceptions in Ruby using a begin/rescue/end block. The code that could raise an exception is placed in the begin block, and the rescue block contains code to run if an exception occurs.

include makes a module's methods available as instance methods of the class, while extend makes them available as class methods.

You declare a constant in Ruby by starting its name with an uppercase letter. Constants are intended to remain unchanged once assigned.

A proc is a type of closure in Ruby, similar to a block but can be stored in a variable. Lambdas are a type of proc with stricter argument handling and distinct return behavior—they return from the lambda itself rather than the encompassing method.

Ruby uses a mark-and-sweep garbage collection algorithm. It marks objects that are still in use and sweeps away those that aren't to free up memory.

The code will return 123. The 'binding' method captures the context of the method's local and instance variables at the point of method execution, allowing 'context.eval' to access 'value'.

You create a mixin in Ruby by declaring a module and including it in a class using the include keyword. Mixins allow for code reusability and adding functions to a class without traditional inheritance.

You can use methods like Marshal.dump to serialize an object to a byte stream and Marshal.load to deserialize it back into a Ruby object.

The load path is a collection of directory paths that Ruby searches when looking to load files with require or load. Adding directories to this path allows Ruby to find and include external libraries.

To make this code more Ruby idiomatic, you can use the collect method with a shorthand block, like so:

array.collect(&:**2)

Duck Typing is a programming concept in Ruby where the class of an object is less important than the methods it defines. As the saying goes, 'If it quacks like a duck, it is a duck.' It allows for flexible method invocation.

In Ruby, self refers to the current object, context, or class. It is used within methods to refer to the object instance or within class and module definitions to refer to the class or module itself.

You can test if a variable is an instance of a class or module using the is_a? or kind_of? methods.

Sure, here's how you can define a module as a namespace for a class:

module MyNamespace
  class MyClass
    # Class implementation
  end
end

instance = MyNamespace::MyClass.new