What do the different brackets in Ruby Mean?

Question

In Ruby, what's the difference between {} and []?

{} seems to be used for both code blocks and hashes.

are [] only for arrays?

The documention isn't very clear.

Answer 1

Broadly speaking, you're correct. As well as hashes, the general style is that curly braces {} are often used for blocks that can fit all onto one line, instead of using do/end across several lines.

Square brackets [] are used as class methods in lots of Ruby classes, including String, BigNum, Dir and confusingly enough, Hash. So:

Hash["key" => "value"]

is just as valid as:

{ "key" => "value" }

Answer 2

Yes, [1,2,3] creates an array with the integers 1, 2, and 3 mapped to [0], [1], and [2]/

If I remember correctly, you can define arrays with the curly braces if you use integers for keys instead of strings or symbols. I could be wrong about that, so double check.

The IRB is great for practicing a lot of this basic syntax stuff--it gives good feedback.

EDIT:

I just had a chance to fire up the IRB, and you don't actually get an Array when using numeric keys. I checked by trying to add an element with the '<<' method, and I received a NoMethodError.

Answer 3

a few examples:

[1, 2, 3].class
# => Array

[1, 2, 3][1]
# => 2

{ 1 => 2, 3 => 4 }.class
# => Hash

{ 1 => 2, 3 => 4 }[3]
# => 4

{ 1 + 2 }.class
# SyntaxError: compile error, odd number list for Hash

lambda { 1 + 2 }.class
# => Proc

lambda { 1 + 2 }.call
# => 3

Answer 4

It depends on the context:

1.

When on their own, or assigning to a variable, [] creates arrays, and {} creates hashes. e.g.

a = [1,2,3] # an array
b = {1 => 2} # a hash

2.

[] can be overridden as a custom method, and is generally used to fetch things from hashes (the standard library sets up [] as a method on hashes which is the same as fetch)
There is also a convention that it is used as a class method in the same way you might use a static Create method in C# or Java. e.g.

a = {1 => 2} # create a hash for example
puts a[1] # same as a.fetch(1), will print 2

Hash[1,2,3,4] # this is a custom class method which creates a new hash

See the ruby library docs for that last example

3.

This is probably the most tricky one -
{} is also syntax for blocks, but only when passed to a method OUTSIDE the arguments parens.
When you invoke methods without parens, ruby looks at where you put the commas to figure out where the arguments end (where the parens would have been, had you typed them)

e.g.

1.upto(2) { puts 'hello' } # it's a block
1.upto 2 { puts 'hello' } # syntax error, ruby can't figure out where the function args end
1.upto 2, { puts 'hello' } # the comma means "argument", so ruby sees it as a hash - this won't work because puts 'hello' isn't a valid hash

Answer 5

The square brackets [ ] are used to initialize arrays. The documentation for initializer case of [ ] is in

ri Array::[]

The curly brackets { } are used to initialize hashes. The documentation for initializer case of { } is in

ri Hash::[]

The square brackets are also commonly used as a method in many core ruby classes, like Array, Hash, String, and others.

You can access a list of all classes that have method "[ ]" defined with

ri []

most methods also have a "[ ]=" method that allows to assign things, for example:

s = "hello world"
s[2]     # => 108 is ascii for e
s[2]=109 # 109 is ascii for m
s        # => "hemlo world"

Curly brackets can also be used instead of "do ... end" on blocks, as "{ ... }".

Another case where you can see square brackets or curly brackets used - is in the special initializers where any symbol can be used, like:

%w{ hello world } # => ["hello","world"]
%w[ hello world ] # => ["hello","world"]
%r{ hello world } # => / hello world /
%r[ hello world ] # => / hello world /
%q{ hello world } # => "hello world"
%q[ hello world ] # => "hello world"
%q| hello world | # => "hello world"

Answer 6

Another, not so obvious, usage of [] is as a synonym for Proc#call and Method#call. This might be a little confusing the first time you encounter it. I guess the rational behind it is that it makes it look more like a normal function call.

E.g.

proc = Proc.new { |what| puts "Hello, #{what}!" }
meth = method(:print)

proc["World"]
meth["Hello",","," ", "World!", "\n"]

Answer 7

note that you can define the [] method for your own classes

class A
 def [](position)
   # do something
 end
end