¿Qué hace el método de "mapa" en Ruby?

Soy nuevo en programación. ¿Alguien puede explicar qué .mapharía en:

params = (0...param_count).map

El mapmétodo toma un objeto enumerable y un bloque, y ejecuta el bloque para cada elemento, generando cada valor devuelto desde el bloque (el objeto original no cambia a menos que use map!):

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

Arrayy Rangeson tipos enumerables. mapcon un bloque devuelve una matriz. map!Muta la matriz original.

¿Dónde es útil esto y cuál es la diferencia entre map!y each? Aquí hay un ejemplo:

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

La salida:

Danil is a programmer
Edmund is a programmer

map, junto con selecty eaches uno de los caballos de batalla de Ruby en mi código.

Le permite ejecutar una operación en cada uno de los objetos de su matriz y devolverlos a todos en el mismo lugar. Un ejemplo sería incrementar una matriz de números en uno:

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

Si puede ejecutar un método único en los elementos de su matriz, puede hacerlo en un estilo abreviado como este:

1. Para hacer esto con el ejemplo anterior, tendría que hacer algo como esto

   class Numeric
     def plusone
       self + 1
     end
   end
   [1,2,3].map(&:plusone)
   #=> [2,3,4]
   

2. Para usar más simplemente la técnica de ampersand shortcut, usemos un ejemplo diferente:

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

La transformación de datos en Ruby a menudo implica una cascada de mapoperaciones. Estudie mapy select, son algunos de los métodos Ruby más útiles en la biblioteca primaria. Son tan importantes como each.

( maptambién es un alias para collect. Usa lo que funcione mejor para ti conceptualmente).

Más información útil:

Si el objeto Enumerable en el que está ejecutando eacho mapcontiene un conjunto de elementos Enumerable (hashes, matrices), puede declarar cada uno de esos elementos dentro de sus tuberías de bloque de la siguiente manera:

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

En el caso de un Hash (también un Enumerableobjeto, un Hash es simplemente un conjunto de tuplas con instrucciones especiales para el intérprete). El primer "parámetro de tubería" es la clave, el segundo es el valor.

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

Para responder la pregunta real:

Suponiendo que paramses un hash, esta sería la mejor manera de mapearlo: use dos parámetros de bloque en lugar de uno para capturar el par clave y valor para cada tupla interpretada en el hash.

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

Usando ruby ​​2.4 puedes hacer lo mismo usando transform_valuesesta característica extraída de rieles a ruby.

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

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

0..param_countsignifica "hasta e incluido param_count". 0...param_countsignifica "hasta, pero sin incluir param_count".

Range#mapno devuelve un Enumerable, en realidad lo asigna a una matriz. Es lo mismo que Range#to_a.

"Asigna" una función a cada elemento en un Enumerable- en este caso, un rango. Por lo tanto, llamaría al bloque pasado una vez por cada entero de 0 a param_count(exclusivo: tiene razón sobre los puntos) y devolvería una matriz que contiene cada valor de retorno.

Aquí está la documentación para Enumerable#map. También tiene un alias, collect.

El mapa es una parte del módulo enumerable. Muy similar a "recoger" Por ejemplo:

  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 proporciona valores que se repiten en una matriz que son devueltos por los parámetros del bloque.

#each

#eachejecuta una función para cada elemento en una matriz. Los siguientes dos extractos de código son equivalentes:

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

#mapaplica una función a cada elemento de una matriz, devolviendo la matriz resultante. Los siguientes son equivalentes:

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

array = ["zero", "one", "two"]

newArray = []
array.each{|element|
    newArray << element.capitalize()
}

#map!

#map!es como #map, pero modifica la matriz en su lugar. Los siguientes son equivalentes:

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

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