रुबी में अलग-अलग ब्रैकेट का क्या अर्थ है?

रुबी में, {} और [] के बीच क्या अंतर है?

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

क्या [] केवल सरणी के लिए हैं?

दस्तावेज बहुत स्पष्ट नहीं है।

0
ro fr bn

6 उत्तर

ये संदर्भ पर निर्भर करता है:

  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 Hash 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)

    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
    
0
जोड़ा
साइड नोट: हैश # fetch बिल्कुल हैश # [] नहीं है। {: ए => 1,: बी => 2}। फ़ेच (: सी) इंडेक्स त्रुटि: कुंजी नहीं मिली
जोड़ा लेखक tokland, स्रोत
@tokland : c नहीं मिला
जोड़ा लेखक YoYoYonnY, स्रोत
"एक सम्मेलन भी है कि इसका उपयोग क्लास विधि के रूप में किया जाता है उसी तरह आप सी # या जावा में एक स्थिर निर्माण विधि का उपयोग कर सकते हैं।" यह वही जवाब है जिसे मैं ढूंढ रहा था। रूबी के बारे में मुझे सबसे ज्यादा नफरत है इसका एक उत्कृष्ट उदाहरण भी; रूबी कोड पढ़ने के लिए आपको बहुत सी अस्पष्ट छोटी सी चीजें जाननी होंगी।
जोड़ा लेखक Tony, स्रोत

कुछ उदाहरण:

[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
0
जोड़ा
लैम्ब्डा {1 + 2} [] # => 3
जोड़ा लेखक ms-ati, स्रोत

व्यापक रूप से बोलते हुए, आप सही हैं। साथ ही हैश, सामान्य शैली यह है कि घुंघराले ब्रेसिज़ {} अक्सर ब्लॉक के लिए उपयोग किया जाता है जो do / end का उपयोग करने के बजाय सभी पंक्तियों में फिट हो सकता है कई लाइनों में।

स्क्वायर ब्रैकेट <�कोड> [] स्ट्रिंग, बिग्नम, डिर और भ्रमित रूप से पर्याप्त, हैश सहित कई रूबी कक्षाओं में कक्षा विधियों के रूप में उपयोग किया जाता है। इसलिए:

Hash["key" => "value"]

जैसा कि मान्य है:

{ "key" => "value" }
0
जोड़ा

ध्यान दें कि आप अपनी कक्षाओं के लिए [] विधि को परिभाषित कर सकते हैं:

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

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

end
0
जोड़ा
@rank। क्या है?
जोड़ा लेखक FeifanZ, स्रोत

स्क्वायर ब्रैकेट [] का उपयोग सरणी को आरंभ करने के लिए किया जाता है। [] के प्रारंभिक मामले के लिए प्रलेखन में है

ri Array::[]

घुंघराले ब्रैकेट {} का उपयोग हैश शुरू करने के लिए किया जाता है। {} के प्रारंभिक मामले के लिए प्रलेखन में है

ri Hash::[]

स्क्वायर ब्रैकेट्स को आम तौर पर कई कोर रूबी कक्षाओं में एक विधि के रूप में उपयोग किया जाता है, जैसे ऐरे, हैश, स्ट्रिंग और अन्य।

आप उन सभी वर्गों की एक सूची तक पहुंच सकते हैं जिनके साथ परिभाषित विधि "[]" है

ri []

अधिकांश विधियों में एक "[] =" विधि भी होती है जो चीजों को असाइन करने की अनुमति देती है, उदाहरण के लिए:

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

घुंघराले ब्रैकेट का उपयोग ब्लॉक पर "डू ... एंड" के बजाय भी किया जा सकता है, जैसे कि "{...}"।

एक और मामला जहां आप स्क्वायर ब्रैकेट या घुंघराले ब्रैकेट का उपयोग कर सकते हैं - विशेष प्रारंभकर्ताओं में है जहां किसी भी प्रतीक का उपयोग किया जा सकता है, जैसे:

%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"
0
जोड़ा

एक और, इतना स्पष्ट नहीं, [] का उपयोग प्रो # कॉल और विधि # कॉल के पर्याय के रूप में है। पहली बार जब आप इसे सामना करते हैं तो यह थोड़ा भ्रमित हो सकता है। मुझे लगता है कि इसके पीछे तर्कसंगत यह है कि यह एक सामान्य फंक्शन कॉल की तरह दिखता है।

जैसे

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

proc["World"]
meth["Hello",","," ", "World!", "\n"]
0
जोड़ा
कभी नहीं जानता था, धन्यवाद!
जोड़ा लेखक Tilendor, स्रोत