14 Most Asked Questions About Ruby
Tags: ruby
Published: 2020-06-19 12:45:02

Ruby is one of the popular programming languages which was developed by Yukihiro Matsumoto in the mid-1990s. Ruby is a general-purpose language and is easy to learn. So, today we will be talking about the top 14 most asked questions about Ruby.

So, let’s get started.

## 14 Most Asked Questions About Ruby

### 1. How to write a switch statement in Ruby?

**Answer:**

You can use `case` expression.

```
case x
when 1..5
  "It's between 1 and 5"
when 6
  "It's 6"
when "foo", "bar"
  "It's either foo or bar"
when String
  "You passed a string"
else
  "You gave me #{x} -- I have no idea what to do with that."
end
```

Ruby compares the object in the `when` clause with the object in the `case` clause using the `===` operator. For example, `1..5 === x`, and not `x === 1..5`.

This allows for sophisticated `when` clauses as seen above. Ranges, classes, and all sorts of things can be tested for rather than just equality.

Unlike `switch` statements in many other languages, Ruby’s `case` does not have <a href="https://en.wikipedia.org/wiki/Switch_statement#Fallthrough">fall-through</a>, so there is no need to end each `when` with a `break`. You can also specify multiple matches in a single `when` clause like `when "foo", "bar"`.

**Alternative Answer:**

`case...when` behaves a bit unexpectedly when handling classes. This is due to the fact that it uses the `===` operator.

That operator works as expected with literals, but not with classes:

```
1 === 1           # => true
Fixnum === Fixnum # => false
```

This means that if you want to do a `case ... when` over an object’s class, this will not work:

```
obj = 'hello'
case obj.class
when String
  print('It is a string')
when Fixnum
  print('It is a number')
else
  print('It is not a string or number')
end
``` 

Will print “It is not a string or number”.


Fortunately, this is easily solved. The `===` operator has been defined so that it returns `true` if you use it with a class and supply an instance of that class as the second operand:

```
Fixnum === 1 # => true
```

In short, the code above can be fixed by removing the `.class`:

```
obj = 'hello'
case obj  # was case obj.class
when String
  print('It is a string')
when Fixnum
  print('It is a number')
else
  print('It is not a string or number')
end
```

### 2. How to check if a value exists in an array in Ruby?

**Answer:**

You can use `include?`:

```
>> ['Cat', 'Dog', 'Bird'].include? 'Dog'
=> true
```

**Alternative Answer:**

There is an `in?` method in `ActiveSupport` (part of Rails) since v3.1. So within Rails, or if you `require 'active_support'`, you can write:

```
'Unicorn'.in?(['Cat', 'Dog', 'Bird']) # => false
```

On the other hand, there is no `in` operator or `#in?` method in Ruby itself, even though it has been proposed before, <a href="https://bugs.ruby-lang.org/issues/3845">in particular by Yusuke Endoh</a> a top-notch member of ruby-core.

On the other hand, the reverse method `include?` exists, for all `Enumerables` including `Array`, `Hash`, `Set`, `Range`:

```
['Cat', 'Dog', 'Bird'].include?('Unicorn') # => false
```

Note that if you have many values in your array, they will all be checked one after the other (i.e. `O(n)`), while that lookup for a hash will be constant time (i.e `O(1)`). So if your array is constant, for example, it is a good idea to use a <a href="https://ruby-doc.org/stdlib-2.2.2/libdoc/set/rdoc/Set.html">Set</a> instead. E.g:

```
require 'set'
ALLOWED_METHODS = Set[:to_s, :to_i, :upcase, :downcase
                       # etc
                     ]

def foo(what)
  raise "Not allowed" unless ALLOWED_METHODS.include?(what.to_sym)
  bar.send(what)
end
```

A quick test reveals that calling `include?` on a 10 element `Set` is about 3.5x faster than calling it on the equivalent `Array` (if the element is not found).

But, be wary when using `include?` on a `Range`, there are subtleties, so refer to <a href="https://ruby-doc.org/core-1.9.3/Range.html#method-i-include-3F">the doc</a> and compare with `cover`?

### 3. How to convert a string to a lower or upper case in Ruby?

**Answer:**

Ruby has a few methods for changing the case of strings. To convert to lowercase, use `downcase`:

```
"hello James!".downcase    #=> "hello james!"
```

Similarly, `upcase` capitalizes every letter and `capitalize` capitalizes the first letter of the string but lowercases the rest:

```
"hello James!".upcase      #=> "HELLO JAMES!"
"hello James!".capitalize  #=> "Hello james!"
"hello James!".titleize    #=> "Hello James!"
```

If you want to modify a string in place, you can add an exclamation point to any of those methods:

```
string = "hello James!"
string.downcase!
string   #=> "hello james!"
```

**Alternative Answer:**

You can find out all the methods available on a String by opening irb and running:

```
"MyString".methods.sort
```

And for a list of the methods available for strings in particular:

```
"MyString".own_methods.sort
```

### 4. How to pass command-line arguments to a rake task?

**Answer:**

Options and dependencies need to be inside arrays:

```
namespace :thing do
  desc "it does a thing"
  task :work, [:option, :foo, :bar] do |task, args|
    puts "work", args
  end

  task :another, [:option, :foo, :bar] do |task, args|
    puts "another #{args}"
    Rake::Task["thing:work"].invoke(args[:option], args[:foo], args[:bar])
    # or splat the args
    # Rake::Task["thing:work"].invoke(*args)
  end

end
```

Then

```
rake thing:work[1,2,3]
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}

rake thing:another[1,2,3]
=> another {:option=>"1", :foo=>"2", :bar=>"3"}
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}
```

NOTE: variable `task` is the task object, not very helpful unless you know/care about Rake internals.

**Rails Note:** If running the task from rails, it is best to preload the environment by adding `=> [:environment]` which is a way to set up dependent tasks.

 ```
 task :work, [:option, :foo, :bar] => [:environment] do |task, args|
    puts "work", args
  end
```

**Alternative Answer:**

You can specify formal arguments in rake by adding symbol arguments to the task call. For example:

```
require 'rake'

task :my_task, [:arg1, :arg2] do |t, args|
  puts "Args were: #{args} of class #{args.class}"
  puts "arg1 was: '#{args[:arg1]}' of class #{args[:arg1].class}"
  puts "arg2 was: '#{args[:arg2]}' of class #{args[:arg2].class}"
end

task :invoke_my_task do
  Rake.application.invoke_task("my_task[1, 2]")
end

# or if you prefer this syntax...
task :invoke_my_task_2 do
  Rake::Task[:my_task].invoke(3, 4)
end

# a task with prerequisites passes its 
# arguments to it prerequisites
task :with_prerequisite, [:arg1, :arg2] => :my_task #<- name of prerequisite task

# to specify default values, 
# we take advantage of args being a Rake::TaskArguments object
task :with_defaults, :arg1, :arg2 do |t, args|
  args.with_defaults(:arg1 => :default_1, :arg2 => :default_2)
  puts "Args with defaults were: #{args}"
end
```

Then, from the command line:

```
> rake my_task[1,false]
Args were: {:arg1=>"1", :arg2=>"false"} of class Rake::TaskArguments
arg1 was: '1' of class String
arg2 was: 'false' of class String

> rake "my_task[1, 2]"
Args were: {:arg1=>"1", :arg2=>"2"}

> rake invoke_my_task
Args were: {:arg1=>"1", :arg2=>"2"}

> rake invoke_my_task_2
Args were: {:arg1=>3, :arg2=>4}

> rake with_prerequisite[5,6]
Args were: {:arg1=>"5", :arg2=>"6"}

> rake with_defaults
Args with defaults were: {:arg1=>:default_1, :arg2=>:default_2}

> rake with_defaults['x','y']
Args with defaults were: {:arg1=>"x", :arg2=>"y"}
```

As demonstrated in the second example, if you want to use spaces, the quotes around the target name are necessary to keep the shell from splitting up the arguments at the space.

Looking at the code in **rake.rb**, it appears that rake does not parse task strings to extract arguments for prerequisites, so you can’t do `task :t1 => "dep[1,2]"`. The only way to specify different arguments for a prerequisite would be to invoke it explicitly within the dependent task action, as in `:invoke_my_task` and `:invoke_my_task_2`.

Note that some shells (like zsh) require you to escape the brackets: `rake my_task\['arg1'\]`.

### 5. How to call shell commands from Ruby?

**Answer:**

First, note that when Ruby calls out to a shell, it typically calls `/bin/sh`, not Bash. Some Bash syntax is not supported by `/bin/sh` on all systems.

Here are ways to execute a shell script:

```
cmd = "echo 'hi'" # Sample string that can be used
```

i. **Kernel#**, commonly called backticks – `cmd`This is like many other languages, including Bash, PHP, and Perl. It returns the result (i.e. standard output) of the shell command.
Docs: http://ruby-doc.org/core/Kernel.html#method-i-60

```
value = `echo 'hi'` 
value = `#{cmd}` 
```

ii. Built-in syntax, `%x( cmd )` Following the `x` character is a delimiter, which can be any character. If the delimiter is one of the characters `(`, `[`, `{`, or `<`, the literal consists of the characters up to the matching closing delimiter, taking account of nested delimiter pairs. For all other delimiters, the literal comprises the characters up to the next occurrence of the delimiter character. String interpolation `#{ ... }` is allowed. It returns the result (i.e. standard output) of the shell command, just like the backticks.
Docs: http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
  
```
value = %x( echo 'hi' )
value = %x[ #{cmd} ]
```

iii. `Kernel#system` Executes the given command in a subshell. Returns `true` if the command was found and run successfully, `false` otherwise. Docs: http://ruby-doc.org/core/Kernel.html#method-i-system

```
wasGood = system( "echo 'hi'" )
wasGood = system( cmd )
```

iv. `Kernel#exec` Replaces the current process by running the given external command. Returns none, the current process is replaced and never continues. Docs: http://ruby-doc.org/core/Kernel.html#method-i-exec

```
exec( "echo 'hi'" )
exec( cmd ) # Note: this will never be reached because of the line above
```

Here’s some extra advice: `$?`, which is the same as `$CHILD_STATUS`, accesses the status of the last system executed command if you use the backticks, `system()` or `%x{}`. You can then access the `exitstatus` and `pid` properties:

```
$?.exitstatus
```

**Alternative Answer:**

Using the `%x` literal, which makes it easy (and readable!) to use quotes in a command, like so:

```
directorylist = %x[find . -name '*test.rb' | sort]
```

Which, in this case, will populate file list with all test files under the current directory, which you can process as expected:

```
directorylist.each do |filename|
  filename.chomp!
  # work with file
end
```

### 6. How to make –no-ri –no-rdoc the default for gem install?

**Answer:**

You just add the following line to your local `~/.gemrc` file (it is in your home folder):

 ```
 gem: --no-document
 ```

or you can add this line to the global `gemrc` config file.

Here is how to find it (in Linux):

```
strace gem source 2>&1 | grep gemrc
```

**Alternative Answer:**

i. From <a href="https://rvm.io/gemsets/basics">RVM’s documentation:</a>

Just add this line to your `~/.gemrc` or `/etc/gemrc`:

 ```
 gem: --no-rdoc --no-ri 
 ```

**Note:** The original answer was:

```
install: --no-rdoc --no-ri 
update: --no-rdoc --no-ri 
```

This is no longer valid; the RVM docs have since been updated, thus the current answer to only include the `gem` directive is the correct one.

ii. Note that `--no-ri` and `--no-rdoc` have been deprecated according to the new <a href="https://guides.rubygems.org/command-reference/#gem_install">guides</a>. The recommended way is to use `--no-document` in `~/.gemrc` or `/etc/gemrc`.

```
install: --no-document
update: --no-document
```

or

```
gem: --no-document
```

### 7. What is attr_accessor in Ruby?

**Answer:**

Let’s say you have a class `Person`.

```
class Person
end

person = Person.new
person.name # => no method error
```

Obviously we never defined method `name`. Let’s do that.

```
class Person
  def name
    @name # simply returning an instance variable @name
  end
end

person = Person.new
person.name # => nil
person.name = "Dennis" # => no method error
```

We can read the name, but that doesn’t mean we can assign the name. Those are two different methods. The former is called reader and the latter is called writer. We didn’t create the writer yet so let’s do that.

```
class Person
  def name
    @name
  end

  def name=(str)
    @name = str
  end
end

person = Person.new
person.name = 'Dennis'
person.name # => "Dennis"
```

Now we can write and read instance variable `@name` using reader and writer methods. Except, this is done so frequently, why waste time writing these methods every time? We can do it easier.

```
class Person
  attr_reader :name
  attr_writer :name
end
```

Even this can get repetitive. When you want both reader and writer just use accessor!

```
class Person
  attr_accessor :name
end

person = Person.new
person.name = "Dennis"
person.name # => "Dennis"
```

Works the same way! And guess what: the instance variable `@name` in our person object will be set just like when we did it manually, so you can use it in other methods.

```
class Person
  attr_accessor :name

  def greeting
    "Hello #{@name}"
  end
end

person = Person.new
person.name = "Dennis"
person.greeting # => "Hello Dennis"
```

**Alternative Answer:**

<a href="https://ruby-doc.org/core-2.0.0/Module.html#method-i-attr_accessor">attr_accessor</a> is just a method.

The trick is that `class` is not a definition in Ruby (it is “just a definition” in languages like C++ and Java), but it is an expression that evaluates. It is during this evaluation when the `attr_accessor` method is invoked which in turn modifies the current class – remember the implicit receiver: `self.attr_accessor`, where `self` is the “open” class object at this point.

The need for `attr_accessor` , is, well:

i. Ruby, like Smalltalk, does not allow instance variables to be accessed outside of methods for that object. That is, instance variables cannot be accessed in the `x.y` form as is common in say, Java or even Python. In Ruby `y` is always taken as a message to send (or “method to call”). Thus the `attr_*` methods create wrappers which proxy the instance `@variable` access through dynamically created methods.

### 8. Why is it bad style to `rescue Exception => e` in Ruby?

**Answer:**

Use `StandardError` instead for general exception catching. When the original exception is re-raised (e.g. when rescuing to log the exception only), rescuing `Exception` is probably okay.

`Exception` is the root of <a href="http://rubylearning.com/images/exception.jpg">Ruby’s exception hierarchy</a>, so when you `rescue Exception` you rescue from everything, including subclasses such as `SyntaxError`, `LoadError`, and `Interrupt`.

Rescuing `Interrupt` prevents the user from using <kbd>CTRL</kbd><kbd>C</kbd> to exit the program.

Rescuing `SignalException` prevents the program from responding correctly to signals. It will be unkillable except by `kill -9`.

Rescuing `SyntaxError` means that `evals` that fail will do so silently.

All of these can be shown by running this program, and trying to <kbd>CTRL</kbd><kbd>C</kbd> or `kill` it:

```
loop do
  begin
    sleep 1
    eval "djsakru3924r9eiuorwju3498 += 5u84fior8u8t4ruyf8ihiure"
  rescue Exception
    puts "I refuse to fail or be stopped!"
  end
end
```

Rescuing from `Exception` isn’t even the default. Doing

```
begin
  # iceberg!
rescue
  # lifeboats
end
```

does not rescue from `Exception`, it rescues from `StandardError`. You should generally specify something more specific than the default `StandardError`, but rescuing from `Exception` broadens the scope rather than narrowing it, and can have catastrophic results and make bug-hunting extremely difficult.

If you have a situation where you do want to rescue from `StandardError` and you need a variable with the exception, you can use this form:

```
begin
  # iceberg!
rescue => e
  # lifeboats
end
```

which is equivalent to:

```
begin
  # iceberg!
rescue StandardError => e
  # lifeboats
end
```

One of the few common cases where it’s sane to rescue from `Exception` is for logging/reporting purposes, in which case you should immediately re-raise the exception:

```
begin
  # iceberg?
rescue Exception => e
  # do some logging
  raise # not enough lifeboats ;)
end
```

**Alternative Answer:**

The real rule is: Don’t throw away exceptions. The objectivity of the author of your quote is questionable, as evidenced by the fact that it ends with

> or I will stab you

Of course, be aware that signals (by default) throw exceptions, and normally long-running processes are terminated through a signal, so catching Exception and not terminating on signal exceptions will make your program very hard to stop. So don’t do this:

```
#! /usr/bin/ruby

while true do
  begin
    line = STDIN.gets
    # heavy processing
  rescue Exception => e
    puts "caught exception #{e}! ohnoes!"
  end
end
```

No, really, don’t do it. Don’t even run that to see if it works.

However, say you have a threaded server and you want all exceptions to not:

- be ignored (the default)
- stop the server (which happens if you say `thread.abort_on_exception = true`).

Then this is perfectly acceptable in your connection handling thread:

```
begin
  # do stuff
rescue Exception => e
  myLogger.error("uncaught #{e} exception while handling connection: #{e.message}")
    myLogger.error("Stack trace: #{backtrace.map {|l| "  #{l}\n"}.join}")
end
```

The above works out to a variation of Ruby’s default exception handler, with the advantage that it doesn’t also kill your program. Rails does this in its request handler.

Signal exceptions are raised in the main thread. Background threads won’t get them, so there is no point in trying to catch them there.

This is particularly useful in a production environment, where you do not want your program to simply stop whenever something goes wrong. Then you can take the stack dumps in your logs and add to your code to deal with specific exception further down the call chain and in a more graceful manner.

Note also that there is another Ruby idiom which has much the same effect:

```
a = do_something rescue "something else"
```

In this line, if `do_something` raises an exception, it is caught by Ruby, thrown away, and a is assigned `"something else"`.

Generally, don’t do that, except in special cases where you know you don’t need to worry. One example:

```
debugger rescue nil
```

The `debugger` function is a rather nice way to set a breakpoint in your code, but if running outside a debugger, and Rails, it raises an exception. Now theoretically you shouldn’t be leaving debug code lying around in your program but you might want to keep it there for a while for some reason, but not continually run your debugger.

Note:

i. If you’ve run someone else’s program that catches signal exceptions and ignores them, (say the code above) then:
- in Linux, in a shell, type `pgrep ruby`, or `ps | grep ruby`, look for your offending program’s PID, and then run `kill -9 <PID>`.
- in Windows, use the Task Manager (<kbd>CTRL</kbd>–<kbd>SHIFT</kbd>–<kbd>ESC</kbd>), go to the “processes” tab, find your process, right-click it, and select “End process”.

ii.  If you are working with someone else’s program which is, for whatever reason, peppered with these ignore-exception blocks, then putting this at the top of the mainline is one possible cop-out:

```
%W/INT QUIT TERM/.each { |sig| trap sig,"SYSTEM_DEFAULT" }
```

This causes the program to respond to the normal termination signals by immediately terminating, bypassing exception handlers, with no cleanup. So it could cause data loss or similar. Be careful!
  
iii.  If you need to do this:

```
begin
     do_something
    rescue Exception => e
      critical_cleanup
      raise
    end
```

you can actually do this:

```
begin
      do_something
    ensure
      critical_cleanup
    end
```

In the second case, `critical cleanup` will be called every time, whether or not an exception is thrown.

### 9. How to install a specific version of a ruby gem?

**Answer:**

Use the `-v` flag:

```
$ gem install fog -v 1.8
```

**Alternative Answer:**

Use the `--version` parameter (shortcut `-v`):

```
$ gem install rails -v 0.14.1
```

You can also use version comparators like `>=` or `~`>

```
$ gem install rails -v '~> 0.14.0'
```

Or with newer versions of gem even:

```
$ gem install rails:0.14.4 rubyzip:'< 1'
…
Successfully installed rails-0.14.4
Successfully installed rubyzip-0.9.9
```

### 10. What does `class << self` do in Ruby?

**Answer:**

First, the ``class << foo`` syntax opens up `foo`‘s singleton class (eigenclass). This allows you to specialize the behavior of methods called on that specific object.

```
a = 'foo'
class << a
  def inspect
    '"bar"'
  end
end
a.inspect   # => "bar"

a = 'foo'   # new object, new singleton class
a.inspect   # => "foo"
```

Now, to answer the question: `class << self` opens up `self`‘s singleton class, so that methods can be redefined for the current `self` object (which inside a class or module body is the class or module itself). Usually, this is used to define class/module (“static”) methods:

```
class String
  class << self
    def value_of obj
      obj.to_s
    end
  end
end

String.value_of 42   # => "42"
```

This can also be written as a shorthand:

```
class String
  def self.value_of obj
    obj.to_s
  end
end
```

Or even shorter:

```
def String.value_of obj
  obj.to_s
end
```

When inside a function definition, `self` refers to the object the function is being called with. In this case, `class << self` opens the singleton class for that object; one use of that is to implement a poor man’s state machine:

```
class StateMachineExample
  def process obj
    process_hook obj
  end

private
  def process_state_1 obj
    # ...
    class << self
      alias process_hook process_state_2
    end
  end

  def process_state_2 obj
    # ...
    class << self
      alias process_hook process_state_1
    end
  end

  # Set up initial state
  alias process_hook process_state_1
end
```

So, in the example above, each instance of `StateMachineExample` has `process_hook` aliased to `process_state_1`, but note how in the latter, it can redefine `process_hook` (for `self` only, not affecting other `StateMachineExample` instances) to `process_state_2`. So, each time a caller calls the `process` method (which calls the redefinable `process_hook`), the behavior changes depending on what state it’s in.

**Alternative Answer:**

In Ruby, there are three types of methods that can be applied to a class:

- Instance methods
- Singleton methods
- Class methods

Instance methods and class methods are almost similar to their homonymous in other programming languages.

```
class Foo  
  def an_instance_method  
    puts "I am an instance method"  
  end  
  def self.a_class_method  
    puts "I am a class method"  
  end  
end

foo = Foo.new

def foo.a_singleton_method
  puts "I am a singletone method"
end
```

Another way of accessing an `Eigenclass` (which includes singleton methods) is with the following syntax (`class <<`):

```
foo = Foo.new

class << foo
  def a_singleton_method
    puts "I am a singleton method"
  end
end
```

Now you can define a singleton method for `self` which is the class `Foo` itself in this context:

```
class Foo
  class << self
    def a_singleton_and_class_method
      puts "I am a singleton method for self and a class method for Foo"
    end
  end
end
```

### 11. What does %w(array) mean?

**Answer:**

`%w(foo bar)` is a shortcut for `["foo", "bar"]`. Meaning it’s a notation to write an array of strings separated by spaces instead of commas and without quotes around them. You can find a list of ways of writing literals in <a href="https://www.zenspider.com/ruby/quickref.html#types">zenspider’s quickref</a>.

**Alternative Answer:**

`%w()` is a “word array” – the elements are delimited by spaces and it returns an array of strings.

There are other % literals:

- `%r()` is another way to write a regular expression.
- `%q()` is another way to write a single-quoted string (and can be multi-line, which is useful)
- `%Q()` gives a double-quoted string
- `%x()` is a shell command
- `%i()` gives an array of symbols (Ruby >= 2.0.0)
- `%s()` turns `foo` into a symbol (`:foo`)

### 12. How to generate a random string in Ruby?

**Answer:**

```
(0...8).map { (65 + rand(26)).chr }.join
```

```
(0...50).map { ('a'..'z').to_a[rand(26)] }.join
```

And the last one that’s even more confusing, but more flexible and wastes fewer cycles:

```
o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
string = (0...50).map { o[rand(o.length)] }.join
```

**Alternative Answer:**

```
require 'securerandom'
random_string = SecureRandom.hex

# outputs: 5b5cd0da3121fc53b4bc84d0c8af2e81 (i.e. 32 chars of 0..9, a..f)
```

SecureRandom also has methods for:

- base64
- random_bytes
- random_number

### 13. How to check whether a string contains a substring in Ruby?

**Answer:**

You can use the `include?` method:

```
my_string = "abcdefg"
if my_string.include? "cde"
   puts "String includes 'cde'"
end
```

**Alternative Answer:**

If the case is irrelevant, then a **case-insensitive regular expression** is a good solution:

```
'aBcDe' =~ /bcd/i  # evaluates as true
```

This will also work for multi-line strings.

### 14. Multi-Line Comments in Ruby?

**Answer:**

You can do as following:

```
#!/usr/bin/env ruby

=begin
Every body mentioned this way
to have multiline comments.

The =begin and =end must be at the beginning of the line or
it will be a syntax error.
=end

puts "Hello world!"

<<-DOC
Also, you could create a docstring.
which...
DOC

puts "Hello world!"

"..is kinda ugly and creates
a String instance, but I know one guy
with a Smalltalk background, who
does this."

puts "Hello world!"

##
# most
# people
# do
# this
```

**Alternative Answer:**

You can also do as following:

```
=begin
My 
multiline
comment
here
=end
```

**In Conclusion**

These are the most asked questions about the Ruby programming language. If you have any suggestions or any confusion, please comment below. We will be glad to help you.

Hope this article helped you.

**Original Source:** <a href="https://thedevpost.com/blog/top-14-questions-about-ruby/">DevPostbyTruemark</a>