Gain insights into Ruby development with 78 tasks tailored for beginners and experienced coders. Explore object-oriented concepts, debug programs, and advance your freelance coding career.

Ruby Is for Fun by Roman Pushkin_468 x 60 copy.png

Dockefile.tar.gz

ruby_emulator

ruby_slot_machine

ruby_roboWar

ruby_Robot-copy

ruby_load

ruby_load-copy

ruby_app

This self-study course written as a book is your first step towards making money by coding and programming from home, and having fun doing it. You will understand how the Ruby language works, and establish a foundation for being a successful freelance developer. This course gives you not only technical detail, but presents knowledge in a friendly format, understandable by all ages, providing a thorough explanation of modern concepts for absolute beginners.

In this course you will find 78 easy to follow tasks, so even people without any programming skill can solve them. Beginners will learn how to create, debug, and understand programs in Ruby. Those who are already familiar with the language will rediscover object-oriented concepts, memory organization, find career advice, and save the planet from a nuclear apocalypse.

Ready to dive into one of the most influential and demanding third generation programming languages? Let's tune in!

The Handbook for Ruby Developers

# Simplifying arrays

The array is an essential data structure. Every programmer should know how to effectively query and update arrays. Ruby offers various methods to simplify array operations, like lookups, updates, calculating several matches based on criteria, adding, removing, bulk operations over all elements, and so on. Ruby’s standard library is compelling, predictable, and straightforward. Programmers love to use it. We hope that you’ll enjoy manipulating arrays with Ruby. Let’s get started!



# The `empty?` method

The question mark indicates that the method returns a Boolean type, `true` or `false`, at the end of a method. We will use the `empty?` method to check whether the array has elements or if it is empty. If the array is empty, the method will return `true`.
```ruby
$ pry
> [].empty?
 => true
```

Remember that the `nil` object doesn’t implement the `empty?` method. So, if some method returns `nil` or an array, which can be empty, we have performed a double-check:

```ruby
arr = some_method

if !arr.nil? && !arr.empty?
  puts arr.inspect
end
```

Also, there is one important detail we don’t want to miss. Every Ruby programmer, sooner or later, will use the Rails framework. Rails has some additional helpers for certain types to simplify our life as developers. For example, Rails will let us avoid double-checks like in the example above. Instead of performing double-checks, we can use the `blank?` method:

```ruby
if !arr.blank?
  puts arr.inspect
end
```

Or its opposite, the `present?` method:

```ruby
if arr.present?
  puts arr.inspect
end
```
Can we agree that the first line looks better than the line below?


```ruby
if !arr.nil? && !arr.empty?
```

In other words, we will use `empty?` when there is no Rails framework, and when we’re working on a Ruby-only project. However, we will always prefer `present?` and `blank?` when working with Rails. These two methods are implemented for many types, and it would be beneficial for us to bookmark this page, so that we can always refer to the following table:


Learn about the variety of methods that are used to simplify array operations in Ruby.


Before We Begin

First Steps

Fundamentals of Ruby

Conditional Statements

Operators and Methods

Arrays

Hash

Fun with Object Oriented Programming

Debugging in Ruby

Ruby Version Manager

Testing Ruby Programs

Wrap Up!

Appendix

Closer Look into Arrays

Simplifying arrays

The `empty?` method

Closer Look into Arrays

Simplifying arrays

The empty? method

The `empty?` method