स्ट्रिंग्स की सरणी को प्रतीकों की सरणी में कैसे परिवर्तित करें?

Question

मैं प्रतीकों के लिए नीचे दिए स्ट्रिंग सरणी के तत्वों परिवर्तित करना चाहते हैं, और उत्पादन के लिए उन्हें मैं क्या कर रहा हूँ पर

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"] 

देखो:

strings.each { |x| puts x.to_sym } 

कोई सफलता। मैं क्या गलत कर रहा हूं?

Answer 1

उपयोग map बजाय each:

>> strings.map &:to_sym 
=> [:HTML, :CSS, :JavaScript, :Python, :Ruby] 

कारण अपने each तरीका नहीं प्रतीत होता है:

>> strings.map { |x| x.to_sym } 
=> [:HTML, :CSS, :JavaScript, :Python, :Ruby] 

रूबी 1.8.7 के लिए और बाद में या ActiveSupport शामिल साथ, तो आप इस वाक्य रचना का उपयोग कर सकते काम यह है कि प्रतीक के साथ puts को कॉल करने से प्रतीकों के स्ट्रिंग का प्रतिनिधित्व होता है (यानी : के बिना)। इसके अतिरिक्त, आप चीजों को लूपिंग और आउटपुट कर रहे हैं; आप वास्तव में एक नई सरणी नहीं बना रहे हैं।

Answer 2

@icktoofay सही जवाब है, लेकिन सिर्फ मदद से आप बेहतर ढंग से समझने each विधि, आपके द्वारा each का उपयोग कर एक ही बात कर सकते हैं: अतिरिक्त टिप्पणी पर

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"] 
symbols = [] # an empty array to hold our symbols 
strings.each { |s| symbols << s.to_sym } 

Answer 3

icktoofay already gave the correct answer.

:

strings.map { |x| x.to_sym } 

आपको एक नई सरणी मिलती है, मूल सरणी अपरिवर्तित है।

इसका इस्तेमाल करने के लिए आपको इसे एक और चर के लिए असाइन कर सकते हैं:

string2 = strings.map { |x| x.to_sym } 

आप स्ट्रिंग को संशोधित करना चाहते हैं, तो आप map! उपयोग कर सकते हैं:

strings.map! { |x| x.to_sym } 

Answer 4

मैं

की तरह कुछ करना चाहते हैं

strings.map! &:to_sym 

Answer 5

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

strings.each do |s| 
symbols.push(s.to_sym) 

Answer 6

स्वच्छ एक लाइनर:

%w(HTML CSS JavaScript Python Ruby).map(&:to_sym) 

& तर्क कहता है एक ब्लॉक के रूप में व्यवहार किया जाना चाहिए, जैसे कि सरणी का निर्माण और प्रत्येक तत्व को to_sym लागू होते हैं।

Answer 7

@ cb24 के जवाब आम तौर पर सबसे उपयुक्त है, मैं एक और एक

strings.collect {|x| x.to_sym } 

मैं था कुछ मानक और @ cb24 के जवाब ज्यादातर मामलों में सबसे अच्छा काम करता है, जब वहाँ में कुछ और तत्व हैं के साथ कि समाधान की तुलना करना चाहते थे सरणी, लेकिन यदि यह एक बहुत ही छोटी सरणी होती है, तो संग्रह विधि थोड़ा तेज़ी से काम करती है।

मैं यहां कोड और परिणाम प्रकाशित करता हूं, यह मेरा असली पहला बेंचमार्क है इसलिए अगर मुझे कुछ गड़बड़ हो तो कुछ प्रतिक्रिया की सराहना की जाएगी। > प्रतीक और प्रतीक - - मैं इसे दोनों स्ट्रिंग पर किया था

n = 1000000 

a = [:a,:b,:c,:d,:e,:f,:g,:h,:i].freeze #A "long" array of symbols 

Benchmark.bm do |x| 
    x.report { n.times { a.map(&:to_s)} } 
    x.report { n.times { a.collect{|x| x.to_s}} } 
end 

     user  system  total  real 
    2.040000 0.010000 2.050000 ( 2.056784) 
    2.100000 0.010000 2.110000 ( 2.118546) 


b = [:a, :b].freeze #Small array 

Benchmark.bm do |x| 
    x.report { n.times { b.map(&:to_s)} } 
    x.report { n.times { b.collect{|x| x.to_s}} } 
end 


     user  system  total  real 
    0.610000 0.000000 0.610000 ( 0.622231) 
    0.530000 0.010000 0.540000 ( 0.536087) 



w = %w(a b).freeze #Again, a small array, now of Strings 
Benchmark.bm do |x| 
    x.report { n.times { w.map(&:to_sym)} } 
    x.report { n.times { w.collect{|x| x.to_sym}} } 
end 

     user  system  total  real 
    0.510000 0.000000 0.510000 ( 0.519337) 
    0.440000 0.010000 0.450000 ( 0.447990) 



y = %w(a b c d e f g h i j k l m n o p q).freeze #And a pretty long one 
Benchmark.bm do |x| 
    x.report { n.times { y.map(&:to_sym)} } 
    x.report { n.times { y.collect{|x| x.to_sym}} } 
end 

     user  system  total  real 
    2.870000 0.030000 2.900000 ( 2.928830) 
    3.240000 0.030000 3.270000 ( 3.371295) 

मोड़ अंक मैं गणना नहीं की थी> स्ट्रिंग लेकिन यह काफी रोचक है, मैंने कहीं पढ़ा है कि कुछ सुधार जहां कम सरणियों के साथ बनाया है, के सबसे बाद से वे केवल कुछ तत्व लंबे हैं।