franzejr / best-ruby Goto Github PK

As started here. We should probably have categories for a bunch of tricks. We may start using some categories, such as: https://youtu.be/aBgnlBoIkVM?t=2m29s

best-ruby.com domain is expired

So far, we just have one best practice for pure Ruby.

Looking forward to see more best practices.

The chapter on combining objects suggests that reduce and inject are different methods for different tasks.

Hi,
It will be better if we display all options list in README like faker gem.
There are 2 advantage of this

1. Easy to understand.

2. Decrease one step in search engine.

   Is it make sense?
   thoughts?

   I can create PR, just let me know

On the page addressing Fixnum#times you state that the developer should favor for loops over Fixnum#times. We generally avoid for loops in Ruby and I've often heard people argue that they should be removed entirely. I think an entire section discussing looping in Ruby would be appropriate. There you could mention that we stay away from for.

The file in question.

Hi, It seems more convenient to read them in a row without opening each file. What do you think?

Probably add a description in the file.

In "Idiomatic Ruby / Combine..." the first statement is extraneous.

hash = {}     # not needed, even misleading
values.inject({}) do |hash, value|
  hash.merge(value => value ** 2)
end

In older versions of ruby, the hash var would collide with the block arg; in modern ruby, they're scoped, so the hash being injected is the {} arg to inject, not the variable.

A more idiomatic version might be:

result = values.inject({}) do |hash, value|
  hash.merge(value => value ** 2)
end 

It would also be useful to note that the use of merge with inject is a bit tricky, and only works because merge returns the hash itself. If the last expression in the block doesn't return the injected value, the inject will fail in weird ways. A less error-prone way to code it is to always return the injected value:

result = values.inject({}) do |hash, value|
  hash[value] = value ** 2
  hash
end

or, as a one-liner:

result = values.inject({}) {|hash, value| hash[value] = value ** 2; hash}

This is suggestion to convert this repo into gitbook (https://www.gitbook.com/)

Once converted it will be easier to browse and can be published as webpage. For example http://developer.gitbook.com/index.html

Why would you ever do

retval = if vals.any?
           do_something(vals)
         else
           do_something_different
         end

over

retval = vals.any? ? do_something(vals) : do_something_different

I think the inner assignment conditional only makes sense when more logic needs to be performed inside the conditions

try is not ruby trick.

I don't know if this is "tricky" enough but I thought this was cool

(head, *tail) = array # break off the first element of the array, and keep the rest separately

source

This code:

users_ids = users.map &:id

Is anything but idiomatic. Something like this:

users_ids = users.map(&:id)

would look like proper Ruby.

Freely floating &: just looks weird.

If we're talking about idiomatic English it should probably also be user_ids as mentioned in #50

We should add more refactoring techniques.