Ruby 中的不同括号是什么意思？

小开

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" }

小开

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

小开

最佳答案

It depends on the context:

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
```
[] 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 Hash docs for that last example.
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)
```
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
```

小开

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"

小开

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"]

小开

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

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


def @rank.[]= key, val
# define the instance[a] = b method
end


end