I have a special interest in the Ruby programming language, so it was the first programming language I learned. Ruby is realistic and concise, and highly scalable. Syntax and structure are easy to see, and there are many language support bases. I want to compile an interesting list of good practices I’ve found during my development with Ruby.
Ruby is integrated a lot of methods. Some methods are very useful and often used, while others are rarely used or their purpose is unknown. Below I will list some of the methods between these two extremes.
1. Tap
The definition of tap according to apidock is as follows:
Yields
xto the block, and then returnsx. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain
To better understand the tap method we can go to a real-world example:
You want to update the value of a user object, and return the result of that object after the update, we have the following code:
1 2 3 4 5 | user = User.first user.assign_attributes(name: "aaa") user.save user |
Writing like this, naturally, at the end of the method, it will return a user variable, which is actually not very good while we know that the tap method can return self. So we can fix the following:
1 2 3 4 5 | User.first.tap do |user| user.assign_attributes(name: "aaa") user.save end |
2. each_with_index
This method is certainly more common than before but sometimes forgotten. It’s like the basic each method, but it gives you a benefit: index
The each_with_index method not only allows you to access each element in the array, but also provides us with the index of the current element. This is quite useful when you want to ignore index-based elements.
We have a small example of each_with_index:
1 2 3 4 5 6 7 8 | pry(main)> [1,2,3,4,5].each_with_index { |val, index| puts "index: #{index} for #{val}" } index: 0 for 1 index: 1 for 2 index: 2 for 3 index: 3 for 4 index: 4 for 5 => [1, 2, 3, 4, 5] |
Although this method repeats many times to handle this situation, it outlines how to use this method. Similar to each_with_index we have Enumerator # with_index
1 2 3 | [1,2,3,4,5].with_index { |val, index| puts "index: #{index} for #{val}" } NoMethodError: undefined method `with_index' for [1, 2, 3, 4, 5]:Array |
As the above example shows that with_index is not an array method, in order for this method to work we must first convert the array to Enumerator. And to do that, there are support methods like .to_enum, each, .map
1 2 3 4 5 6 7 8 | [1,2,3,4,5].each.with_index { |val, index| puts "index: #{index} for #{val}" } index: 0 for 1 index: 1 for 2 index: 2 for 3 index: 3 for 4 index: 4 for 5 => [1, 2, 3, 4, 5] |
There is a small note that each_with_index is equivalent to with_index (0), because they all have an index index starting with 0.
1 2 3 4 5 6 7 8 9 10 11 | pry(main)> [1,2,3].each_with_index { |val, index| puts "index: #{index} for #{val}" } index: 0 for 1 index: 1 for 2 index: 2 for 3 => [1, 2, 3] pry(main)> [1,2,3].each.with_index(0) { |val, index| puts "index: #{index} for #{val}" } index: 0 for 1 index: 1 for 2 index: 2 for 3 => [1, 2, 3] |
The with_index (x) method when we pass the x parameter, the index will start from the x value, and by default when no more parameters are entered, the index will start from 0.
1 2 3 4 5 6 7 8 9 10 11 | pry(main)> [1,2,3].each.with_index(1) { |val, index| puts "index: #{index} for #{val}" } index: 1 for 1 index: 2 for 2 index: 3 for 3 => [1, 2, 3] pry(main)> [1,2,3].each.with_index { |val, index| puts "index: #{index} for #{val}" } index: 0 for 1 index: 1 for 2 index: 2 for 3 => [1, 2, 3] |
3. respond_to?
This method will return true if the object responds with the method name, which may be a symbol. We have the following example has a class including methods public, private, protected.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | pry(main)> class Foo pry(main)* def bar pry(main)* puts "method public" pry(main)* end pry(main)* pry(main)* private pry(main)* def bar_private pry(main)* puts "method private" pry(main)* end pry(main)* pry(main)* protected pry(main)* def bar_protected pry(main)* puts "method protected" pry(main)* end pry(main)* end |
For public methods, we just need to call the following:
1 2 3 4 5 | pry(main)> a = Foo.new => #<Foo:0x00007f116b4d1218> pry(main)> a.respond_to? :bar => true |
For private, protected methods:
1 2 3 4 5 | pry(main)> a.respond_to? :bar_private => false a.respond_to? :bar_protected => false |
We see that with calls like public methods respond_to? returns false. Note that the second parameter of the method respond_to? Very important here, it denotes that respond_to? can find all methods whose scope includes also private methods. We can call respond_to? For the private and protected methods are as follows:
1 2 3 4 5 | pry(main)> a.respond_to? :bar_private, true => true a.respond_to? :bar_protected, true => true |
4. squeeze
This is a very simple method on string, it eliminates consecutive overlapping characters in that string.
1 2 3 | pry(main)> "yellowl moon".squeeze => "yelowl mon" |
When not passed in the parameter it will look for all consecutive duplicates in the string including spaces.
1 2 3 | pry(main)> "yellowl moon".squeeze("b-n") => "yelowl moon" |
When passing a parameter that is a string representing the range of characters in the alphabet, for example, the letters from bn are just searched to eliminate consecutive characters in the bn range, note that here are spaces overlap will not be eliminated.
1 2 3 | pry(main)> " yeowl moon".squeeze(" ") => " yellowl moon" |
Passing the “” parameter will only remove consecutive overlapping spaces.
Conclude:
I hope you enjoyed learning about these methods and trying them out in your project – or even simply playing with them in irb or pry to find out how they work.
Reference: https://apidock.com/ruby/Object/tap https://apidock.com/ruby/Enumerator/each_with_index https://apidock.com/ruby/String/squeeze https: // apidock. com / ruby / Object / respond_to% 3F