相关疑难解决方法(0)

新的红宝石,穿上你的新手套.

以下两个片段之间是否有任何区别(模糊或实用)？

my_array = [:uno, :dos, :tres]
my_array.each { |item| 
    puts item
}

my_array = [:uno, :dos, :tres]
my_array.each do |item| 
    puts item
end

我意识到括号语法允许你将块放在一行上

my_array.each { |item| puts item }

但除此之外是否有任何令人信服的理由使用一种语法而不是另一种语法？

哪种款式首选？一个与另一个有充分的理由吗？

提前致谢!

1) cmds.each do |cmd|
   end

2) cmds.each { |cmd|
   }

示例代码:

cmds = [ "create", "update", "list", "help" ]

# Block style one
#
cmds.each do |cmd|
  puts "loop1, cmd: #{cmd}"
end

# Block style two
#
cmds.each { |cmd|
  puts "loop2, cmd: #{cmd}"
}

我是Ruby的初学者,所以我很遗憾地问这么简单,但是这个代码有什么问题 -

3.upto(9) {
  print "Hello"
  puts " World"
}

要么

3.upto(9) { |n|
  print "Hello "
  puts n
}

它工作得很好,但我看到的大多数代码示例使用的语法

3.upto(9) do |n|
  print "Hello "
  puts n
end

仅仅是对单个语句使用花括号的约定吗？来自C/C#第一个对我来说似乎更自然,但在罗马时!

我提取了简单的例子:

require 'pp'
x = 1..3
pp x.map do |i| {:value => i, :double => (i*2)} end
pp x.map { |i| {:value => i, :double => (i*2)} }

pp(x.map do |i| {:value => i, :double => (i*2)} end)
pp(x.map { |i| {:value => i, :double => (i*2)} })

我想知道为什么第一个pp产生:

[1, 2, 3]

所有的演讲者都在给予:

[{:value=>1, :double=>2}, {:value=>2, :double=>4}, {:value=>3, :double=>6}]

我认为它与运算符优先级有关.我在哪里可以找到好的解释？

以下问题与" Ruby Print Inject Do Syntax " 问题有关.我的问题是,我们能坚持使用do和end,使其与工作puts或p？

这有效:

a = [1,2,3,4]

b = a.inject do |sum, x|
  sum + x
end
puts b   # prints out 10

所以,它是正确的,inject是Array对象的实例方法,并且此实例方法接受一段代码,然后返回一个数字.如果是这样,那么它应该与调用函数或方法并获取返回值没有什么不同:

b = foo(3)
puts b

要么

b = circle.getRadius()
puts b

在以上两种情况下,我们可以直接说

puts foo(3)
puts circle.getRadius()

因此,使用以下两种方式无法直接使其工作:

a = [1,2,3,4]

puts a.inject do |sum, x|
  sum + x
end

但它给了

ch01q2.rb:7:in `inject': no block given (LocalJumpError)
        from ch01q2.rb:4:in `each'
        from ch01q2.rb:4:in …

可能重复:
Ruby块和未加括号的参数

我不确定我是否理解这种语法错误.我正在使用Carrierwave来管理Rails应用程序中的一些文件上传,我似乎错误地将一个块传递给其中一个方法.

以下是Carrierwave文档中的示例:

version :thumb do
  process :resize_to_fill => [200,200]
end

这就是我的所作所为:

version :full   { process(:resize_to_limit => [960, 960]) }
version :half   { process(:resize_to_limit => [470, 470]) }
version :third  { process(:resize_to_limit => [306, 306]) }
version :fourth { process(:resize_to_limit => [176, 176]) }

我得到以上不起作用syntax error, unexpected '}', expecting keyword_end.有趣的是,以下工作完美:

version :full   do process :resize_to_limit => [960, 960]; end
version :half   do process :resize_to_limit => [470, 470]; end
version :third  do process :resize_to_limit => [306, …

可能重复:
Ruby块和不带括号的参数Ruby
中这些块编码样式的区别或价值是什么？

我一直认为以下只是两种说法相同的方式:

[1,2,3].collect{|i| i * 2}

[1,2,3].collect do |i|
  i * 2
end

但是我在我的一个ERB模板中得到了一些奇怪的行为,其中两个语法似乎做了两件不同的事情.这段代码效果很好:

<%=raw @menu.collect { |m| 
    content_tag("li") {
        link_to(m.capitalize, url_for(:controller => m))
    } 
} %>

但当我重写它时:

<%=raw @menu.collect do |m| 
    content_tag("li") do
        link_to(m.capitalize, url_for(:controller => m))
    end 
end %>

...我最终得到了一串连结的@menu项目.我错过了什么吗？这里有一些细小的语法糖吗？

我最近开始学习ruby,我知道你可以使用这两种语法的代码块.但我刚发现一个我不明白的案例:

#my_hash is a hash in which the keys are strings and the values arrays, but dont think about the specifics fo the code

#if I run my code like this, it works perfectly

my_hash.each do |art|
  puts mystring.gsub(art[0]).each {
    art[1][rand(art[1].length) -1]
  }
end

#but if I use this, it prints "Enumerator"

my_hash.each do |art|
  puts mystring.gsub(art[0]).each do
    art[1][rand(art[1].length) -1]
  end
end

是因为你不能窝对端对吗？我使用的是1.9

puts [1,2,3].map do |x| 
  x + 1 
end.inspect

随着ruby 1.9.2的回归

<Enumerator:0x0000010086be50>

红宝石1.8.7:

# 1
# 2
# 3

分配变量......

x = [1,2,3].map do |x| 
  x + 1 
end.inspect

puts x

[2,3,4]

小胡子块按预期工作:

puts [1,2,3].map { |x| x + 1 }.inspect

[2,3,4]

如果我有课:

class KlassWithSecret
  def initialize
    @secret = 99
  end
end

并运行:

puts KlassWithSecret.new.instance_eval { @secret }

它打印99,但如果我运行:

puts KlassWithSecret.new.instance_eval do
  @secret
end

它返回一个错误: `instance_eval': wrong number of arguments (0 for 1..3) (ArgumentError)

为什么我不能使用do/end块instance_eval？

PS我正在使用Ruby 2.1.0.

我对传球有一点疑问.

def a_method(a, b)
  a + yield(a, b)
end

这很好用.

k = a_method(1, 2) do |x, y| 
  (x + y) * 3 
end
puts k

但这不起作用.

puts a_method(1, 2) do |x, y| 
  (x + y) * 3 
end
# LocalJumpError: no block given (yield)

有人可以向我解释这个吗？

谢谢.Paolo Perrotta从Metaprogramming Ruby中获取的示例.好书.