Should I use Symbols in hashes and parameters to optimize memory usage in Ruby?

Question

On this other question here I asked about :symbols and 'strings' and found that the use of :symbols optimizes memory usage by the application.

My question is whether the same goes for hashing:

hash = {:indice => 'valor'}
#em vez de
hash = {indice: 'valor'}

And crossing of parameters:

@post = Post.find_by(:id => 1)
#em vez de
@post = Post.find_by(id: 1)

Answer 1

There’s no difference between

hash = {:indice => 'valor'}    
hash = {indice: 'valor'}

It’s just "syntax sugar," and it only works from 1.9 up.

Answer 2

According to some sources you must do this yes.

The symbols are stored internally in a table as integers without signal, which saves a lot of memory compared to the use of strings. As a result, the comparison between symbols is much faster.

Another advantage is that symbols are immutable, while strings can have content altered and "break" somehow the hash.

But there are always side effects.

One is that the symbols are not collected and will reside "eternally" in the interpreter’s table.

The impact will be small if you use only explicit symbols in the code. However, if you use the function to_sym to get the symbols corresponding to many different strings, especially if these strings have external origin, the use of permanently allocated memory can increase considerably.

---

Specifically talking about the example of the question, the excerpts hash = {:indice => 'valor'} and hash = {indice: 'valor'} are equivalent, the first was used in Ruby until version 1.8 and the second was introduced in Ruby 1.9.

Answer 3

I’ve always used something like

hash = { key: "value" }

You can use methods such as deep_symbolize_keys to transform your hash to symbols (but it’s a Rails method)

https://api.rubyonrails.org/classes/Hash.html#method-i-deep_symbolize_keys