Ruby中的“地图”方法有什么作用？

我是编程新手。有人可以解释一下该怎么.map做：

params = (0...param_count).map

该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

map以及select和each是我代码中Ruby的主要工作之一。

它允许您对每个数组对象运行操作，并将它们全部返回到同一位置。一个示例是将数字数组加1：

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

在Ruby中转换数据通常涉及一系列map操作。研究map＆select，它们是主库中一些最有用的Ruby方法。它们和一样重要each。

（map也是的别名collect。请在概念上使用最适合您的方法。）

更多有用的信息：

如果您正在运行或运行的Enumerable对象包含一组Enumerable元素（哈希，数组），则可以在块管道中声明每个这些元素，如下所示：eachmap

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

使用ruby 2.4，您可以使用进行相同的操作transform_values，此功能是从rails提取到ruby的。

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

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

0..param_count表示“不超过param_count”。 0...param_count表示“最多，但不包括param_count”。

Range#map不返回Enumerable，而是将其实际映射到数组。与相同Range#to_a。

它将功能“映射”到Enumerable一个范围内的每个项目（在本例中为范围）。因此，它将调用从0到的每个整数传递一次的块param_count（不包括-您对点是正确的），并返回包含每个返回值的数组。

这是的文档Enumerable#map。它还有一个别名collect。

Map是可枚举模块的一部分。与“收集”非常相似，例如：

  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提供了由块参数返回的遍历数组的值。

#each

#each为数组中的每个元素运行一个函数。以下两个代码摘录是等效的：

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

#map将函数应用于数组的每个元素，返回结果数组。以下是等效的：

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

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

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

#map!

#map!就像#map，但是在适当的地方修改数组。以下是等效的：

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

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