Ruby编程中的语法使用风格推荐
使用 :: 引用常量（包括类和模块）和构造器 (比如 Array() 或者 Nokogiri::HTML())。
永远不要使用 :: 来调用方法。
# bad SomeClass::some_method some_object::some_method # good SomeClass.some_method some_object.some_method SomeModule::SomeClass::SOME_CONST SomeModule::SomeClass()
使用括号将def的参数括起来。当方法不接收任何参数的时候忽略括号。
# bad
def some_method()
# body omitted
end
# good
def some_method
# body omitted
end
# bad
def some_method_with_arguments arg1, arg2
# body omitted
end
# good
def some_method_with_arguments(arg1, arg2)
# body omitted
end
从来不要使用 for， 除非你知道使用它的准确原因。大多数时候迭代器都可以用来替for。for 是由一组 each 实现的 (因此你正间接添加了一级)，但是有一个小道道 - for并不包含一个新的 scope (不像 each)并且在它的块中定义的变量在外面也是可以访问的。
arr = [1, 2, 3]
# bad
for elem in arr do
puts elem
end
# note that elem is accessible outside of the for loop
elem #=> 3
# good
arr.each { |elem| puts elem }
# elem is not accessible outside each's block
elem #=> NameError: undefined local variable or method `elem'
在多行的 if/unless 中坚决不要使用 then。
# bad if some_condition then # body omitted end # good if some_condition # body omitted end
在多行的 if/unless 总是把条件放在与 if/unless 的同一行。
# bad if some_condition do_something do_something_else end # good if some_condition do_something do_something_else end
喜欢三元操作运算（"htmlcode">
# bad result = if some_condition then something else something_else end # good result = some_condition "htmlcode"># bad some_condition "htmlcode"># bad result = if some_condition then something else something_else end # good result = some_condition "htmlcode"># bad if condition result = x else result = y end # good result = if condition x else y end在 one-line cases 的时候使用 when x then ...。替代的语法when x: xxx已经在Ruby 1.9中移除。
不要使用when x; ...。查看上面的规则。
使用 ! 替代 not.
# 差 - 因为操作符有优先级，需要用括号。 x = (not something) # good x = !something 避免使用 !!. # bad x = 'test' # obscure nil check if !!x # body omitted end x = false # double negation is useless on booleans !!x # => false # good x = 'test' unless x.nil"htmlcode"># bad # boolean expression if some_condition and some_other_condition do_something end # control flow document.saved"htmlcode"># bad if some_condition do_something end # good do_something if some_condition # another good option some_condition && do_something布尔表达式使用&&/||, and/or用于控制流程。（经验Rule:如果你必须使用额外的括号（表达逻辑），那么你正在使用错误的的操作符。）
# boolean expression if some_condition && some_other_condition do_something end # control flow document.save"htmlcode"># bad if some_condition do_something end # good do_something if some_condition # another good option some_condition and do_something永远不要使用 unless 和 else 组合。将它们改写成肯定条件。
# bad unless success"htmlcode"># bad if (x > 10) # body omitted end # good if x > 10 # body omitted end在多行 while/until 中不要使用 while/until condition do 。
# bad while x > 5 do # body omitted end until x > 5 do # body omitted end # good while x > 5 # body omitted end until x > 5 # body omitted end当你有单行主体时，尽量使用 while/until 修饰符。
# bad while some_condition do_something end # good do_something while some_condition否定条件判断尽量使用 until 而不是 while 。
# bad do_something while !some_condition # good do_something until some_condition循环后条件判断使用 Kernel#loop 和 break，而不是 begin/end/until 或者 begin/end/while。
# bad begin puts val val += 1 end while val < 0 # good loop do puts val val += 1 break unless val < 0 end忽略围绕内部 DSL 方法参数的括号 (如：Rake, Rails, RSpec)，Ruby 中带有 "关键字" 状态的方法（如：attr_reader，puts）以及属性存取方法。所有其他的方法调用使用括号围绕参数。
class Person attr_reader :name, :age # omitted end temperance = Person.new('Temperance', 30) temperance.name puts temperance.age x = Math.sin(y) array.delete(e) bowling.score.should == 0忽略隐式选项 hash 外部的花括号。
# bad user.set({ name: 'John', age: 45, permissions: { read: true } }) # good user.set(name: 'John', age: 45, permissions: { read: true })内部 DSL 方法的外部括号和大括号。
class Person < ActiveRecord::Base # bad validates(:name, { presence: true, length: { within: 1..10 } }) # good validates :name, presence: true, length: { within: 1..10 } end方法调用不需要参数，那么忽略圆括号。
# bad Kernel.exit!() 2.even"htmlcode">names = ['Bozhidar', 'Steve', 'Sarah'] # bad names.each do |name| puts name end # good names.each { |name| puts name } # bad names.select do |name| name.start_with"htmlcode">require 'tempfile' # bad def with_tmp_dir Dir.mktmpdir do |tmp_dir| Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments end end # good def with_tmp_dir(&block) Dir.mktmpdir do |tmp_dir| Dir.chdir(tmp_dir, &block) end end with_tmp_dir do |dir| puts "dir is accessible as parameter and pwd is set: #{dir}" end避免在不需要流的控制使用 return。
# bad def some_method(some_arr) return some_arr.size end # good def some_method(some_arr) some_arr.size end避免在不需要的地方使用 self(它仅仅在调用一些 self 做写访问的时候需要)(It is only required when calling a self write accessor.)
# bad def ready"htmlcode">class Foo attr_accessor :options # ok def initialize(options) self.options = options # both options and self.options are equivalent here end # bad def do_something(options = {}) unless options[:when] == :later output(self.options[:message]) end end # good def do_something(params = {}) unless params[:when] == :later output(options[:message]) end end end不要在条件表达式里使用 = （赋值）的返回值，除非条件表达式在圆括号内被赋值。
这是一个相当流行的 ruby 方言，有时被称为 safe assignment in condition。
# bad (+ a warning) if v = array.grep(/foo/) do_something(v) ... end # good (MRI would still complain, but RuboCop won't) if (v = array.grep(/foo/)) do_something(v) ... end # good v = array.grep(/foo/) if v do_something(v) ... end在任何可以的地方使用快捷的 self assignment 操作符。
# bad x = x + y x = x * y x = x**y x = x / y x = x || y x = x && y # good x += y x *= y x **= y x /= y x ||= y x &&= y只有在变量没有被初始化的时候使用 ||= 来初始化变量。
# set name to Vozhidar, only if it's nil or false name ||= 'Bozhidar'不要使用||=来初始化布尔变量。（想想如果当前值为false的时候会发生什么。）
# bad - would set enabled to true even if it was false enable ||= true # good enabled = true if enabled.nil"htmlcode"># bad if something something = something.downcase end # bad something = something "htmlcode"># bad Array === something (1..100) === 7 /something/ === some_string # good something.is_a"htmlcode"># bad $:.unshift File.dirname(__FILE__) # good require 'English' $LOAD_PATH.unshift File.dirname(__FILE__) 从来不要在方法名和（参数）开括号之间使用空格。 # bad f (3+2) + 1 # good f(3 + 2) +1如果方法的第一个参数以开括号开始，通常使用括号把它们全部括起来。例如f((3 + 2) + 1)。
通常使用 -w 选项运行 Ruby 解释器，在你忘记上面所诉规则，ruby 将会提示你。
定义单行块使用新的 lambda 语法。定义多行块中使用 lambda 方法。
# bad l = lambda { |a, b| a + b } l.call(1, 2) # correct, but looks extremely awkward l = ->(a, b) do tmp = a * 7 tmp * b / 50 end # good l = ->(a, b) { a + b } l.call(1, 2) l = lambda do |a, b| tmp = a * 7 tmp * b / 50 end用 proc 而不是 Proc.new。
# bad p = Proc.new { |n| puts n } # good p = proc { |n| puts n } 匿名方法 和 块 用 proc.call() 而不是 proc[] 或 proc.()。 # bad - looks similar to Enumeration access l = ->(v) { puts v } l[1] # also bad - uncommon syntax l = ->(v) { puts v } l.(1) # good l = ->(v) { puts v } l.call(1)未使用的块参数和局部变量使用 _。它也可以接受通过 _ 来使用（即使它有少了些描述性）。
这个惯例由 Ruby 解释器以及 RuboCop 这样的工具组织其将会抑制它们的未使用参数警告。
# bad result = hash.map { |k, v| v + 1 } def something(x) unused_var, used_var = something_else(x) # ... end # good result = hash.map { |_k, v| v + 1 } def something(x) _unused_var, used_var = something_else(x) # ... end # good result = hash.map { |_, v| v + 1 } def something(x) _, used_var = something_else(x) # ... end使用 $stdout/$stderr/$stdin 而不是 STDOUT/STDERR/STDIN。STDOUT/STDERR/STDIN 是常量，虽然在 Ruby 中是可以给常量重新赋值的（可能是重定向到某个流），但解释器会警告如果你执意这样。
使用 warn 而不是 $stderr.puts。除了更加清晰简洁，如果你需要的话，
warn 还允许你抑制（suppress）警告（通过 -W0 将警告级别设为 0）。倾向使用 sprintf 和它的别名 format 而不是相当隐晦的 String#% 方法.
# bad '%d %d' % [20, 10] # => '20 10' # good sprintf('%d %d', 20, 10) # => '20 10' # good sprintf('%{first} %{second}', first: 20, second: 10) # => '20 10' format('%d %d', 20, 10) # => '20 10' # good format('%{first} %{second}', first: 20, second: 10) # => '20 10'倾向使用 Array#join 而不是相当隐晦的使用字符串作参数的 Array#*。
# bad %w(one two three) * ', ' # => 'one, two, three' # good %w(one two three).join(', ') # => 'one, two, three'当处理你希望像 Array 那样对待的变量，但是你不确定它是一个数组时，
使用 [*var] or Array() 而不是显式的 Array 检查。
# bad paths = [paths] unless paths.is_a"htmlcode">上一篇：Ruby元编程的一些值得注意的地方# bad do_something if x >= 1000 && x <= 2000 # good do_something if (1000..2000).include"htmlcode"># bad if x % 2 == 0 end if x % 2 == 1 end if x == nil end # good if x.even"htmlcode"># bad END { puts 'Goodbye!' } # good at_exit { puts 'Goodbye!' }避免使用 flip-flops 。
避免使用嵌套的条件来控制流程。
当你可能断言不合法的数据，使用一个防御语句。一个防御语句是一个在函数顶部的条件声明，这样如果数据不合法就能尽快的跳出函数。
# bad def compute_thing(thing) if thing[:foo] update_with_bar(thing) if thing[:foo][:bar] partial_compute(thing) else re_compute(thing) end end end # good def compute_thing(thing) return unless thing[:foo] update_with_bar(thing[:foo]) return re_compute(thing) unless thing[:foo][:bar] partial_compute(thing) end
下一篇：Ruby中百分号和字面值的使用示例
几个月来，英特尔、微软、AMD和其它厂商都在共同推动“AI PC”的想法，朝着更多的AI功能迈进。在近日，英特尔在台北举行的开发者活动中，也宣布了关于AI PC加速计划、新的PC开发者计划和独立硬件供应商计划。
在此次发布会上，英特尔还发布了全新的全新的酷睿Ultra Meteor Lake NUC开发套件，以及联合微软等合作伙伴联合定义“AI PC”的定义标准。