Question

我想生成文本并将其插入数组。请帮忙。

new_vrms = Array.new[3] {"placeholder"}
puts "How many registration marks do you require?"
        how_many = gets.chomp!()
        i = 0
        while i < how_many.to_i do
                prefix =('a'..'z').to_a.shuffle.first(2).join
                year = 68
                suffix =('a'..'z').to_a.shuffle.first(3).join
                aVRM = (prefix.to_s + year.to_s + suffix.to_s)
                aVRM = aVRM.upcase!
                puts ("#{aVRM} added to index #{i}")
                #new_vrms.insert(0, 1)  <-Array.rb:14:in `<main>': undefined method `insert' for nil:NilClass (NoMethodError)
                #new_vrms.push << @aVRM  <-Array.rb:15:in `<main>': undefined method `push' for nil:NilClass (NoMethodError)
                #new_vrms[i] = ("#{aVRM}")  <- Array.rb:16:in `<main>': undefined method `[]=' for nil:NilClass (NoMethodError)
                i += 1
        end         
        puts ("Succesfully generated "+ i.to_s + " registration marks")

Answer 1

错误在于数组初始化。红宝石将您所拥有的（Array.new[3]）视为

(Array.new)[3]

您要将3作为参数传递给new。

Array.new(3)

Answer 2

这通常是关于OPs代码的扩展注释，因此请不要投票（同意就可以投票）。

您从

开始

new_vrms = Array.new[3] {"placeholder"}

@Sergio在这里已经确定了您的问题，但是除此之外，无需初始化数组每个元素的值（“占位符”），甚至不需要固定数组的大小。实际上，您显然希望返回包含how_many个元素的数组，而how_many尚不知道。因此，您只需在此处创建一个空数组：

new_vrms = Array.new(0)

与

相同

new_vrms = Array.new

更常见的书写方式

new_vrms = []

接下来，您询问用户数组中应包含多少个元素：

how_many = gets.chomp!()

如果用户输入"3"，则gets将返回"3\n"，而gets.chomp将返回"3"。请注意，在无参数的情况下，无需以chomp结尾的方法（此处为()）。同样，chomp!也不是错误的，但通常使用非突变版本chomp。您希望how_many是一个整数，但是不要是一个字符串（gets总是返回一个字符串）。因此，您需要将其转换为整数：

how_many = gets.chomp.to_i

但是，如果您查看String#to_i的文档，则会看到"123abc".to_i #=> 123，也就是"123\n".to_i #=> 123，这意味着在转换文档时不需要chomp字符串转换为整数：

how_any = gets.to_i

我们现在知道我们希望重复循环（how_many）的次数，因此您将要使用迭代器和块而不是while循环：

how_many.times do |i|
  ...<your code to add elements to new_vrms>
end
new_vrms  # return the computed value

请参见Integer#times。

您正在重复计算prefix和suffix的代码，因此让我们将其作为一个单独的方法：

LETTERS = ('A'..'Z').to_a 
  #=> ["A", "B", "C",...,"X", "Y", "Z"] 

def random_3_letters
  LETTERS.sample(3).join
end

请参见Array#sample，它提供了一种更直接的方法来计算字母的随机三元组。（此外，我们可以从大写字母数组中提取内容，因此我们以后无需将样本转换为大写字母。¹我创建了常量LETTERS，因此我们不需要在每次调用该方法时创建数组。我们现在可以编写该块了。

YEAR = "68"
how_many.times do |i|
  prefix = random_3_letters
  suffix = random_3_letters
  aVRM = prefix + YEAR + SUFFIX
  puts "#{aVRM} added to index #{i}")
  new_vrms.push(aVRM) 
end
new_vrms

实际上，没有理由定义变量prefix和suffix，因为我们可以简化如下。

YEAR = "68"
how_many.times do |i| 
  aVRM = random_3_letters + YEAR + random_3_letters
  puts "#{aVRM} added to index #{i}")
  new_vrms.push(aVRM) 
end
new_vrms

如果希望打印aVRM的每个元素的值，最好从循环外部进行操作-更通常是从方法外部进行包装。如果从块中提取了语句puts "#{aVRM} added to index #{i}")，则不再使用块变量i，因此可以将其省略：

YEAR = "68"

def doit
  new_vrms = []
  gets.to_i.times do 
    new_vrms << random_3_letters + YEAR + random_3_letters
  end
  new_vrms 
end

请注意，我已将Array#push更改为更常用的Array＃<<，并替换了变量how_many和aVRS。

经验丰富的Rubyist可能会进一步加强这一点（尽管也会在实际代码中检查输入值的有效性）

LETTERS = ('A'..'Z').to_a 
YEAR = "68"

def doit
  gets.to_i.times.with_object([]) do |_,new_vrms|
    new_vrms << (random_3_letters + YEAR + random_3_letters)
  end
end

def random_3_letters
  LETTERS.sample(3).join
end

doit  # entering "4"
  #=> ["ZPI68LWY", "PQV68HLD", "IZG68JCH", "EAC68WLY"]

请注意，通过使用Enumerator#with_object，我们在末尾消除了语句new_vrms = []和new_vrms，这是因为with_object导致块返回“对象”，因此值new_vrms。

^{1请注意，您永远不要写str = str.upcase!，因为如果str.upcase!已被大写，nil将返回str（因此，{{1 }}）。参见String#upcase!。没有对接收者进行任何更改时，许多“爆炸”方法str返回...!。}

将变量插入数组

2 个答案: