Wat doet de “kaart”-methode in Ruby?

Ik ben nieuw in programmeren. Kan iemand uitleggen wat .mapzou doen in:

params = (0...param_count).map

Antwoord 1, autoriteit 100%

De methode mapneemt een opsombaar object en een blok en voert het blok uit voor elk element, waarbij elke geretourneerde waarde van het blok wordt uitgevoerd (het oorspronkelijke object is ongewijzigd tenzij u map!):

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

Arrayen Rangezijn opsombare typen. mapmet een blok geeft een array terug. map!muteert de originele array.

Waar is dit nuttig, en wat is het verschil tussen map!en each? Hier is een voorbeeld:

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

De uitvoer:

Danil is a programmer
Edmund is a programmer

Antwoord 2, autoriteit 15%

map, samen met selecten eachis een van Ruby’s werkpaarden in mijn code.

Hiermee kunt u een bewerking uitvoeren op elk van de objecten van uw array en ze allemaal op dezelfde plaats retourneren. Een voorbeeld zou zijn om een reeks getallen met één te verhogen:

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

Als u een enkele methode op de elementen van uw array kunt uitvoeren, kunt u dit in een verkorte stijl als volgt doen:

  1. Om dit met het bovenstaande voorbeeld te doen, moet je zoiets als dit doen

    class Numeric
      def plusone
        self + 1
      end
    end
    [1,2,3].map(&:plusone)
    #=> [2,3,4]
    
  2. Laten we een ander voorbeeld gebruiken om eenvoudiger de ampersand-snelkoppelingstechniek te gebruiken:

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

Het transformeren van gegevens in Ruby gaat vaak gepaard met een cascade van map-bewerkingen. Bestudeer map& select, dit zijn enkele van de meest bruikbare Ruby-methoden in de primaire bibliotheek. Ze zijn net zo belangrijk als each.

(mapis ook een alias voor collect. Gebruik wat conceptueel het beste voor u werkt.)

Meer nuttige informatie:

Als het Enumerableobject gebruikt u eachof mapon bevat een set opsombare elementen (hashes, arrays), je kunt elk van die elementen als volgt declareren in je block-pipes:

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

In het geval van een hash (ook een Enumerableobject, is een hasj gewoon een reeks tuples met speciale instructies voor de tolk). De eerste “pijpparameter” is de sleutel, de tweede is de waarde.

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

om de daadwerkelijke vraag te beantwoorden:

Ervan uitgaande dat paramseen hash is, zou dit de beste manier zijn om er doorheen te plaatsen: gebruik twee blokparameters in plaats van één om de sleutel & amp te vangen; Value Pair voor elke geïnterpreteerde tuple in de hash.

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

Antwoord 3

Ruby 2.4 gebruiken U kunt hetzelfde doen met transform_values, deze functie geëxtraheerd van rails naar Ruby.

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

Antwoord 4

0..param_countbetekent “tot en met param_count”.
0...param_countMiddelen “tot, maar niet inbegrepen param_count”.

Range#mapretourneert geen Enumerable, het kaarten het in kaart voor een array. Het is hetzelfde als Range#to_a.


Antwoord 5

IT “Kaarten” Een functie naar elk item in een Enumerable– in dit geval een bereik. Het zou dus het blok bellen dat één keer is geslaagd voor elk geheel getal van 0 tot param_count(exclusief – u hebt gelijk over de stippen) en retourneer een array die elke retourwaarde bevat.

Hier is de documentatie voor Enumerable#map. Het heeft ook een alias, collect.


Antwoord 6

Kaart is een onderdeel van de slabyable-module. Zeer vergelijkbaar met “Collect” bijvoorbeeld:

 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}

MAP biedt waarden die door een array worden die worden geretourneerd door de blokparameters.


Antwoord 7

#each

#eachvoert een functie uit voor elk element in een array. De volgende twee code-fragmenten zijn equivalent:

x = 10
["zero", "one", "two"].each{|element|
    x++
    puts element
}
x = 10
array = ["zero", "one", "two"]
for i in 0..2
    x++
    puts array[i]
end

#map

#mapPast een functie toe aan elk element van een array, wat de resulterende array retourneert. Het volgende is equivalent:

array = ["zero", "one", "two"]
newArray = array.map{|element| element.capitalize()}
array = ["zero", "one", "two"]
newArray = []
array.each{|element|
    newArray << element.capitalize()
}

#map!

#map!lijkt op #map, maar past de array op zijn plaats aan. De volgende zijn equivalent:

array = ["zero", "one", "two"]
array.map!{|element| element.capitalize()}
array = ["zero", "one", "two"]
array = array.map{|element| element.capitalize()}

Antwoord 8

Voor iedereen die het moet visualiseren:

Hier is het volledige verhaal:

https://richstone.io/rubys-map-collect- methodes-explained-visually/

Other episodes