Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Ruby's hash is a Swiss-army knife

akshaykhot.com

Post reply on HN
Print view View original

1–10 of 81 posts

Re: Ruby's hash is a Swiss-army knife

#3

Post by j_crick »

It should be noted that ** operator works like .merge, and also accounts for the order of key definition in a given hash declaration (whatever is declared earlier gets overwritten if a key with same name is used in the same hash declaration later).

Re: Ruby's hash is a Swiss-army knife

#4

Post by thibaut_barrere »

block_dagger wrote: post #2

Ruby’s Hash is probably the handiest data structure I’ve ever encountered. Thanks Matz.

Definitely! As a matter of fact, this is the default data structure I use when writing Ruby ETL code (e.g. https://github.com/thbar/kiba/wiki).

Methods like "except" (https://docs.ruby-lang.org/en/3.2/Hash.html#method-i-except) or "fetch" (raising an error on missing key) are very convenient to write defensive data processing code!

Similarly, in Elixir, I use Maps a lot for the same type of jobs (https://hexdocs.pm/elixir/1.15.4/Map.html), with similar properties.

Re: Ruby's hash is a Swiss-army knife

#6

Post by andolanra »

Since Ruby 3, the automatic coercion of keywords to a hash—the second example underneath "Passing Hash to Functions" in this post—is considered a legacy style and is generally frowned upon in new code. That is to say, code like the second call to `foo` here:

    def foo(kwargs = {})
      kwargs
    end
    
    foo({k: 1})  # ok: passing hash argument
    foo(k: 1)    # ok: keywords coerced to hash
One of the strongest arguments for avoiding this sugar is that it makes the code more brittle in the face of future changes. In particular, in the example above, if we add a new keyword argument to `foo`, then any call which omitted the curly braces will break, while calls which used them will keep working fine:

    # added a new keyword arg here
    def foo(kwargs = {}, frob: false)
      kwargs
    end
    
    foo({k: 1})  # still ok: `frob` defaults to false
    foo(k: 1)    # ArgumentError: no keyword: :k
This is touched on in the blog post describing the extensive changes made to keywords in Ruby 3: https://www.ruby-lang.org/en/news/2019/12/12/separation-of-p...

Re: Ruby's hash is a Swiss-army knife

#7

Post by software_writer »

andolanra wrote: post #6

Since Ruby 3, the automatic coercion of keywords to a hash—the second example underneath "Passing Hash to Functions" in this post—is considered a legacy style and is generally frowned upon in new code. That is to say, code like the second call to `foo` here: def foo(kwargs = {}) kwargs end foo({k: 1}) # ok: passing hash argument foo(k: 1) # ok: keywords coerced to hash One of the strongest arguments for avoiding this…

You're right, thanks for the demo and sharing the link, really appreciated. I'll update the article to mention this.

Re: Ruby's hash is a Swiss-army knife

#8

Post by software_writer »

drbojingle wrote: post #5

PHP's associative array is very similar yea?

Yes, hashes in Ruby, associative arrays in PHP, maps in Go[1], dictionaries in Python[2] and C#[3] represent the same concept, a collection of key-value pairs.

[1]: https://gobyexample.com/maps [2]: https://docs.python.org/3/tutorial/datastructures.html#dicti... [3]: https://learn.microsoft.com/en-us/dotnet/api/system.collecti...

Re: Ruby's hash is a Swiss-army knife

#9

Post by my_new_account0 »

software_writer wrote: post #8
drbojingle wrote: post #5

PHP's associative array is very similar yea?

Yes, hashes in Ruby, associative arrays in PHP, maps in Go[1], dictionaries in Python[2] and C#[3] represent the same concept, a collection of key-value pairs. [1]: https://gobyexample.com/maps [2]: https://docs.python.org/3/tutorial/datastructures.html#dicti... [3]: https://learn.microsoft.com/en-us/dotnet/api/system.collecti...

Yes. The OP's post is basically "baby's first API." The are a very handy API but relying on them at scale is much less efficient than structs or arrays. This post doesn't even go into the different performance characters of these APIs, which can be a major foot gun.

I've noticed a lot of novice-level posts on here lately. Although I admit the post was very well written.

Re: Ruby's hash is a Swiss-army knife

#10

Post by johannes1234321 »

drbojingle wrote: post #5

PHP's associative array is very similar yea?

Selling it as associative array is nice. (And I know the docs do that, too)

It's a doubly linked list, array, hashmap all in one, with some weird magic when handling numeric indices.

There's often the time when using another language that I made a bad choice by picking either an array or hash or list while later I need one of the other properties PHP would give me by default. The extra cost for most uses is neglectible.

Post reply on HN