Effective Ruby

1.false:

0 is true; true.class > TrueClass; false.class > FalseClass; 只有 false 和 nil 为false；如果你要区分false和nil，可以使用nil? 或 == 操作符，并将false作为左操作对象，以防止 == 这个方法被覆盖。

2.nil:

所有对象的value都可能为nil;都来之 BasicObject. 一个类的对象被另外一个类的对象替换（多态）鸭子类型duck typing. 接口高于类型。 is_a? or respond_to? NomethodError; 任何对象都可能是nil，做好防范。可以将nil.to_s to_i; Array#compact 可以去除nil元素；

3.perl =~ $: $_:

message =~/^ERROR:\s+(.+)$/; $1 ; 这个$1不是全局变量，而是表示匹配的第一组的内容；是特殊全局变量。这里会费解，改成 m= message.match(/^ERROR:\s+(.+)$/) ; m[1]; String#match 返回MatchData; $: = $LOAD_PATH 别名； Kernel#readline; Kernel#print with $_ ；

4.冻结freeze:

networks=["192.168.1"]; networks.delete_if do {|net| !ping(net + ".1"}; freeze冻结数组；数组冻结，无法增删，但元素依然可变； [...].map!(&:freeze).freeze; Defaults.freeze; 三个级别的冻结： 模块，对象，对象里面的元素；

5.ambiguous 语义不清的问题:

'808'.split(/0/); dirs = ['usr','local']; File.join(*dirs); dirs.map(&:length);$VERBOSE=true or -w or RUBYOPT=-w 会显示提示；

6.Object:

对象是变量的容器，称为实例变量，并代表对象的状态，特殊内部变量-连接唯一的类；类是方法和常量的容器，是它的所有实例的方法。 超类就是类的父类，有特殊变量跟踪超类。模块和类的区别是模块没有new方法；单例类。。。再定义类的方法self..会生成一个匿名的类在实例的链条上.
BasicObject> Kernel> Object >SomeModuleInPerson > Person > Customer.
Customer.singleton_class.instance_methods(false) 查看单例类。
Customer.superclass; Customer.ancestors; Customer.included_modules;

7.用super调父类，要注意():

super 会把宿主方法的所有参数全部传递过去.enclosing method;

8. initialize and initialize_copy:

def initialize(name,grade) {super(name; @grade = grade}; dup和clone 也可以构建新对象的副本,可以定义initialize_copy方法来初始化副本。

9.setter:

setter方法时候需要指定接受者；attr_accessor attr_write; self.first = ...;调用非setter方法，不需要显式指定接收者；

10. Struct or Hash:

key-value 用hash; hash 作为公共接口是没有访问限制的。Reading = Struct.new(:data, :high, :low); Reading.new(Date.parse(..),..,..) Struct是属性列表；里面也可以定义方法； 将Struct返回值设置为常量，像类一样使用他。

11.namespace:

定义类和打开修改类是一种写法，ruby里的类是可以修改的。命名空间是一种保证常量唯一性的方式。module Notebooks; sytle= Notebooks::Binding.new； ::Array 和 Cluster::Array 是不同的；Object::Array === ::Array; 命名空间就是为了程序之间的和平相处。

12. == 等价has 4个部分的检查:

"foo" == "foo" => true; "foo".equal?("foo") => false; == 会做隐式转换。 1== 1.0 => true; ；equal? 意味着 object_id (同一个内存块); case表达式使用 ===； Regexp 类定义了=== ，所以 /er/ === "Her" is true, but "Her" === /er/ is false; [1,2,3].is_a(Array) true; [1,2,3] === Array => false; Array === [1,2,3] => true; === 接受者=== 参数 means 参数.is_a?(接受者)；

13. <=> 对象的排序:

Version attr_reader(:major, :minor, :patch); version.split('.')map(&:to_i); Array#detect{}...;

14. protected:

在相关类之间共享私有信息；

15.优先使用实例变量:

@@开头的变量是类变量，bind在类上。； 单例模式；private_class_method(:new, :dup, :clone) def self.instance @@single ||= new; 其实类方法是一个假象，类方法实际上是一个类的对象的实例方法。Singleton模块作为Ruby标准库的一部分；require('singleton'); class Configuration include(Singleton) end;

16.传值还是引用:

Marshal.load Marshal.dump; b.each(&:upcase!); dup 和clone方法只会进行浅拷贝。

17.数组参数:

initialize(toppings) {Array(toppings}.each do |topping| ...} 转换为Array让代码更加健康。

18. 标准库里面的Set:

Array#include? 的时间复杂度是O(n),数量变多，时间就边长。Hash#include? O(log n); Hash[permissions.map{|p|} [p,true]]; require('set'); @permissions= Set.new(permissions) ; Set是一个无序容器。有序容器SortedSet类。如果不需要顺序，又存在很多条记录要判断是否Include?(x),那么Set是最好的选择。

19. reduce方法折叠集合:

Enumerable模块的类，可对集合进行过滤，遍历和转化。map和select；还有个可以管理一切的方法 reduce(or inject), reduce可以转换结构；接受者，每个元素被调用一次，并产生返回值，累加器。 enum.reduce(0){|accumulator, element| accumulator + element} 0初始值；建议你总是使用一个带有起始值的累加器。 enum.reduce(0, :+);
数组转成Hash; array.reduce({}) {|hash, element| hash.update(element => true)}
users.select{|u| u.age>=21}.map(&:name) 获取大于等于21的names数组。比较低效；
User.reduce([]) {|names, user| names << user.name if user.age >=21 ; names}

20. Hash的初始值:

Hash.new(10); h[:missing_key] => 10; h={}; h[:weekdays] = h.fetch(:weekdays, []) << "Monday" ---> ["Monday"]

21.对集合和核心类优先使用委托而非继承:

is a，还是 has a， 委托就是有一个。。。require('forwardable'); class RaisingHash extend(Forwardable) include(Enumerable) def_delegators(@hash, :[], :[]=, :delete, :each, :keys, :values, :length, :empty?, :has_keys) end Forwardable模块让使用委托的过程变得容易。 del_delegator(@hash, :delete, :erase!)

22. raise:

raise("coffee machine low on water") => raise(RuntimeError, "coffee machine low on water")
异常的处理是基于类型的。Exception or StandardError ; class CoffeeTooWeakError < StandardError; end
raise(CoffeeTooWeakError, "coffee to water ratio too low")
super("invalid temperature: #@temperature") raise(TemperatureError.new(180))

23.catch the most detail regular exceptions:

如果你recuse列举很多异常需要catch，那不能清晰表达你的意思。rescue NetworkConnectionError => retry loginc... ; rescue InvalidRecordError => # Send record to support staff...;
rescue => e service.record(e) # 发送给支持团队。如果service.record(e)里面的异常可能会替换原来的异常。导致异常丢失。resuce语句中throw的异常将会替换当前异常并利害当前的作用域。将原始异常作为参数传递给交给第三方处理。

24. block and ensure:

分配-使用-释放；file = File.open(file_name, 'w'_...file.close;因为又垃圾回收的原因，中途发生异常也会被回收资源，但是你不确定什么时候会被回收，所以你如果能及时处理，那更好。那么就算需要begin。。。ensure file.close if file end;也可以通过 File.open(file_name, 'w') do |file| ...end，这种block的方式。块执行晚后文件会被关闭。将资源管理简单化。 简单化的资源管理，也衍生出一个 传block给方法的问题，可以用class Lock def self.acquire ; lock =new ; lock.exclusive_lock!; if block_given? yield(lock) else lock # Act more like Lock::new. end ensure if block_given? # ...end end end; 没有绑定块时候，Lock::acquire 。。。； 类方法上使用块和ensure语句将资源管理的逻辑抽离出来。

25. ensure里面不要用return:

也不要用throw；一般不要在里面改变控制流，会抛弃异常。比如 begin 。raise。 ensure next; end