रुबी में "नक्शा" विधि क्या करती है? - रूबी, मानचित्र, रेंज, गणना

मैं प्रोग्रामिंग के लिए नया हूँ। क्या कोई समझा सकता है .map में करेंगे

params = (0...param_count).map

उत्तर:

जवाब के लिए 381 № 1

The map विधि एक संख्यात्मक वस्तु और एक ब्लॉक लेती है, और प्रत्येक तत्व के लिए ब्लॉक चलाती है, ब्लॉक से प्रत्येक लौटाए गए मूल्य को आउटपुट करता है (जब तक आप उपयोग नहीं करते हैं तब तक मूल ऑब्जेक्ट अपरिवर्तित होता है map!):

[1, 2, 3].map { |n| n * n } #=> [1, 4, 9]

Array तथा Range संख्यात्मक प्रकार हैं। map एक ब्लॉक के साथ एक सरणी देता है । map! मूल सरणी रूपांतरित हो जाता है ।

यह कहां उपयोगी है, और क्या अंतर है map! तथा each? यहां एक उदाहरण है:

names = ["danil", "edmund"]

# here we map one array to another, convert each element by some rule
names.map! {|name| name.capitalize } # now names contains ["Danil", "Edmund"]

names.each { |name| puts name + " is a programmer" } # here we just do something with each element

उत्पादन:

Danil is a programmer
Edmund is a programmer

जवाब के लिए 52 № 2

map, साथ में select तथा each मेरे कोड में रूबी "एस workhorses में से एक है ।

यह आप अपने सरणी "s वस्तुओं में से प्रत्येक पर एक ऑपरेशन चलाने के लिए और एक ही स्थान पर उन सब को वापस करने की अनुमति देता है ।एक उदाहरण के लिए एक संख्या की एक सरणी वृद्धि होगी:

[1,2,3].map {|x| x + 1 }
#=> [2,3,4]

यदि आप अपने सरणी "तत्वों तुम यह एक आशुलिपि में कर सकते है जैसे शैली पर एक ही विधि चला सकते हैं:

  1. ऊपर के उदाहरण के साथ ऐसा करने के लिए आप "डी कुछ इस तरह करना है

    class Numeric
    def plusone
    self + 1
    end
    end
    [1,2,3].map(&:plusone)
    #=> [2,3,4]
    
  2. अधिक बस ऐंपरसैंड शॉर्टकट तकनीक का उपयोग करने के लिए, चलो "एस एक अलग उदाहरण का उपयोग करें:

    ["vanessa", "david", "thomas"].map(&:upcase)
    #=> ["VANESSA", "DAVID", "THOMAS"]
    

रूबी में डेटा बदलने अक्सर का झरना शामिल है map कार्रवाई. अध्ययन map और select, वे प्राथमिक पुस्तकालय में सबसे उपयोगी रूबी तरीकों में से कुछ हैं ।वे "पुनः के रूप में बस के रूप में महत्वपूर्ण each

(map के लिए भी एक उपनाम है collect. जो भी आप के लिए सबसे अच्छा काम करता है अवधारणाओं का उपयोग करें.)

अधिक उपयोगी जानकारी:

अगर Enumerable ऑब्जेक्ट आप "पुनः चल रहा है each या map पर Enumerable तत्वों का एक सेट होता है (हैश, arrays), तुम तो अपने ब्लॉक पाइप के अंदर उन तत्वों की एक तरह की घोषणा कर सकते हैं:

[["audi", "black", 2008], ["bmw", "red", 2014]].each do |make, color, year|
puts "make: #{make}, color: #{color}, year: #{year}"
end
# Output:
# make: audi, color: black, year: 2008
# make: bmw, color: red, year: 2014

एक हैश के मामले में (यह भी एक Enumerable वस्तु, एक हैश बस दुभाषिया के लिए विशेष निर्देश के साथ विवेचित की एक सरणी है) ।पहली "पाइप पैरामीटर" कुंजी है, दूसरा मूल्य है ।

{:make => "audi", :color => "black", :year => 2008}.each do |k,v|
puts "#{k} is #{v}"
end
#make is audi
#color is black
#year is 2008

वास्तविक प्रश्न का उत्तर देने के लिए:

ऐसा मानते हुए params एक हैश है, यह सबसे अच्छा तरीका है इसके माध्यम से नक्शा होगा: हैश में प्रत्येक व्याख्या टपल के लिए कुंजी & मूल्य जोड़ी पर कब्जा करने के लिए एक के बजाय दो ब्लॉक मापदंडों का उपयोग करें ।

params = {"one" => 1, "two" => 2, "three" => 3}
params.each do |k,v|
puts "#{k}=#{v}"
end
# one=1
# two=2
# three=3

जवाब के लिए 4 № 3

0..param_count का अर्थ है "अप करने के लिए और सहित param_count" । 0...param_count का अर्थ है "अप करने के लिए, लेकिन param_count सहित नहीं" ।

Range#map वापस नहीं करता है एक Enumerable, यह वास्तव में यह एक सरणी के लिए नक्शे । यह "के रूप में ही एस Range#to_a


जवाब के लिए 4 № 4

रूबी २.४ का उपयोग कर आप एक ही बात कर सकते है का उपयोग transform_values, यह सुविधा रूबी के लिए रेल से निकाला ।

h = {a: 1, b: 2, c: 3}

h.transform_values { |v| v * 10 }
#=> {a: 10, b: 20, c: 30}

जवाब के लिए 3 № 5

यह "नक्शे" एक समारोह में प्रत्येक आइटम के लिए एक Enumerable -इस मामले में, एक सीमा । तो यह एक बार 0 से हर पूर्णांक के लिए पारित ब्लॉक फोन होगा param_count (विशेष-आप "डॉट्स के बारे में फिर से सही) और वापसी एक सरणी प्रत्येक वापसी मूल्य युक्त ।

यहां "के लिए प्रलेखन एस Enumerable#map यह भी एक उपनाम है, collect


उत्तर के लिए 1 № 6

नक्शा enumerable मॉड्यूल का एक हिस्सा है । बहुत उदाहरण के लिए "संग्रह" के समान:

  Class Car

attr_accessor :name, :model, :year

Def initialize (make, model, year)
@make, @model, @year = make, model, year
end

end

list = []
list << Car.new("Honda", "Accord", 2016)
list << Car.new("Toyota", "Camry", 2015)
list << Car.new("Nissan", "Altima", 2014)

p list.map {|p| p.model}

मैप ब्लॉक पैरामीटर्स द्वारा दिए गए हैं जो किसी सरणी के माध्यम से पुनरावृत्ति मान प्रदान करता है ।


संबंधित सवाल
सबसे लोकप्रिय