Ruby开发技巧

jieforest · 发表于 2013-11-8 09:45

As we saw earlier with #to_ary some of these conversion methods are used internally to Ruby, these are the strict conversion methods, but can also be thought of as the implicit conversion methods. They can be used implicitly because they are strict.

These are used all over the place within Ruby, but as an example #to_int is used to convert the argument to Array#[] to an int, and #to_str is used by raise when its argument isn’t an Exception.

class Line
def initialize(id)
@id = id
end
def to_int
@id
end
end
line = Line.new(2)
names = ["Central", "Circle", "District"]
names[line] #=> "District"
class Response
def initialize(status, message, body)
@status, @message, @body = status, message, body
end
def to_str
"#{@status} #{@message}"
end
end
res = Response.new(404, "Not Found", "")
raise res #=> RuntimeError: 404 Not Found

复制代码

jieforest · 发表于 2013-11-8 10:15

As we saw earlier with #to_ary some of these conversion methods are used internally to Ruby, these are the strict conversion methods, but can also be thought of as the implicit conversion methods. They can be used implicitly because they are strict.

These are used all over the place within Ruby, but as an example #to_int is used to convert the argument to Array#[] to an int, and #to_str is used by raise when its argument isn’t an Exception.

class Line
def initialize(id)
@id = id
end
def to_int
@id
end
end
line = Line.new(2)
names = ["Central", "Circle", "District"]
names[line] #=> "District"
class Response
def initialize(status, message, body)
@status, @message, @body = status, message, body
end
def to_str
"#{@status} #{@message}"
end
end
res = Response.new(404, "Not Found", "")
raise res #=> RuntimeError: 404 Not Found

复制代码

jieforest · 发表于 2013-11-8 10:16

One final conversion method to mention is #to_proc. This is used by the unary & operator in method arguments. & converts a Proc object into a block argument in a method call.

sum = Proc.new {|a, b| a + b}
(1..10).inject(&sum) #=> 55

复制代码

But first unary & will call #to_proc on its operand, this allows it to be used with objects that aren’t Procs, but can be converted to one. A very common use of this that you’ll find in modern Ruby code is using this with a Symbol.

["foo", "bar", "baz"].map(&:upcase) #=> ["FOO", "BAR", "BAZ"]

复制代码

jieforest · 发表于 2013-11-8 10:17

This has been built in to Ruby since version 1.9, but before that you could implement it yourself with some code like this:

class Symbol
def to_proc
Proc.new do |obj|
# call the method named by this symbol on the supplied object
obj.send(self)
end
end
end

复制代码

jieforest · 发表于 2013-11-8 10:17

Here’s an example of using #to_proc and & to simplify initialising Points from an array.

class Point
attr_accessor :x, :y
def initialize(x, y)
@x, @y = x, y
end
def self.to_proc
Proc.new {|ary| new(*ary)}
end
end
[[1, 5], [4, 2]].map(&Point) #=> [#<Point:0x007f87e983af40 @x=1, @y=5>, #<Point:0x007f87e983ace8 @x=4, @y=2>]

复制代码

jieforest · 发表于 2013-11-8 10:18

This is part 3 of a 5-part series on Ruby tips and tricks gleaned from our team’s pull requests over the last two years. Part 1covers blocks and ranges, and part 2 deals with destructuring and type conversions.

Exceptions

Dealing with exceptions can be tricky, and it’s easy to dig a hole for yourself that’s much harder to get out of than in. There’s a couple of rules you can follow that might be a little more work to begin with but pay off in the long run, making your code easier to debug.
First off, don’t use the statement-modifier (postfix) rescue.

Here’s an example method that’ll return nil if there’s an error fetching an item from an array.

def safe_fetch(array, index)
array[index] rescue nil
end

复制代码

jieforest · 发表于 2013-11-9 10:18

However we have no idea what error it’s hiding. The array could be nil, the index nil, the index could be a string, you could have made a typo on array, or any other error you could imagine.

This means we can’t work out the intention of the code from reading it, and the result of unexpected errors doesn’t show up here, but later on in the code when something gets passed that nil. At that point it can be very hard to work out that some unexpected error here is the source of that nil.

It’s going to save a lot of hassle if you use the standard form of rescue, either with the type of error we were expecting, or some logging.

def safe_fetch(array, index)
array[index]
rescue NoMethodError
nil
end
def safe_fetch(array, index)
array[index]
rescue => e
@logger.debug(e) if @logger
nil
end

复制代码

jieforest · 发表于 2013-11-9 10:23

rescue => e is a shortcut for rescue StandardError => e, just like a bare rescue is a shortcut for rescue StandardError. This means the rescue will only rescue from StandardError or subclasses of StandardError.

Generally you should follow Ruby’s example and only rescue from StandardError and its subclasses, never from Exception. Rescuing from Exception can mean you catch things you really shouldn’t, like SystemExit, the exception raised when your program has been asked to exit. If you rescue this you can end up with a program you can’t quit.

Likewise when raising errors you should only raise errors that are subclasses of StandardError, or you could end up with errors that blow though error handling they shouldn’t.

A good pattern to use in your own projects, particularly gems, is to define a general error for your whole project, and then have all others inherit from this.

module MyProject
class Error < StandardError
end
class NotFoundError < Error
end
class PermissionError < Error
end
end

复制代码

jieforest · 发表于 2013-11-9 10:23

This way you can easily rescue from any error in your project with rescue MyProject::Error, or you can be more specific.

A slightly nicer way to write this, giving you an easier to read list is to take advantage of the Class.new method. Class.newgenerates a new class inheriting from the one supplied as an argument. Ruby will also name a class created like this after the first constant it is assigned to.

module MyProject
Error = Class.new(StandardError)
NotFoundError = Class.new(Error)
PermissionError = Class.new(Error)
end

复制代码

One problem you may face with this approach is that not all the errors generated by your code are directly raised by your code. If for example you’re making HTTP requests you’re likely to get connection errors at some point.

Now you could rescue these errors in your code, and raise new errors with types you control, but then you’re discarding valuable debugging information; the original class, message and backtrace.

jieforest · 发表于 2013-11-10 10:26

A workaround for this takes advantage of Ruby allowing you to supply a class or module to rescue. rescue uses the case equality operator #=== to match its arguments against the exception. On Class this returns true if the argument is an instance of the class or instance of a subclass. On Module it returns true if the argument has the module included or extended in to it.

This means if you instead define the base error as a module, and include it into the more specific errors you get the same behaviour as before, but you can also ‘tag’ arbitrary errors raised by other bits of code you are using by extending them with the base error. These can then also be rescued by a rescue of the base error, but keep their original class, message and backtrace (you’ll no longer be able to raise the base error, but that’s ok, you should be raising the more specific errors).

module MyProject
Error = Module.new
class NotFoundError < StandardError
include Error
end
class PermissionError < StandardError
include Error
end
def get(path)
response = do_get(path)
raise NotFoundError, "#{path} not found" if response.code == "404"
response.body
rescue SocketError => e
e.extend(Error)
raise e
end
end
...
begin
get("/example")
rescue MyProject::Error => e
e #=> MyProject::NotFoundError or SocketError
end

复制代码