Ruby中编写类与模块的风格指南

2024-03-28 19:00:02 27

在class定义里使用一致的结构。

classPerson
#extendandincludegofirst
extendSomeModule
includeAnotherModule

#constantsarenext
SOME_CONSTANT=20

#afterwardswehaveattributemacros
attr_reader:name

#followedbyothermacros(ifany)
validates:name

#publicclassmethodsarenextinline
defself.some_method
end

#followedbypublicinstancemethods
defsome_method
end

#protectedandprivatemethodsaregroupedneartheend
protected

defsome_protected_method
end

private

defsome_private_method
end
end

倾向使用module，而不是只有类方法的class。类别应该只在创建实例是合理的时候使用。

#bad
classSomeClass
defself.some_method
#bodyomitted
end

defself.some_other_method
end
end

#good
moduleSomeClass
module_function

defsome_method
#bodyomitted
end

defsome_other_method
end
end

当你希望将模块的实例方法变成class方法时，偏爱使用module_function胜过extendself。

#bad
moduleUtilities
extendself

defparse_something(string)
#dostuffhere
end

defother_utility_method(number,string)
#dosomemorestuff
end
end

#good
moduleUtilities
module_function

defparse_something(string)
#dostuffhere
end

defother_utility_method(number,string)
#dosomemorestuff
end
end

Whendesigningclasshierarchiesmakesurethattheyconformtothe
LiskovSubstitutionPrinciple.

在设计类层次的时候确保他们符合LiskovSubstitutionPrinciple原则。(译者注:LSP原则大概含义为:如果一个函数中引用了父类的实例,则一定可以使用其子类的实例替代,并且函数的基本功能不变.(虽然功能允许被扩展))

Liskov替换原则：子类型必须能够替换它们的基类型<br/>
1.如果每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换为o2时,程序P的行为没有变化，那么类型T2是类型T1的子类型。<br/>
2.换言之，一个软件实体如果使用的是一个基类的话，那么一定适用于其子类，而且它根本不能察觉出基类对象和子类对象的区别。只有衍生类替换基类的同时软件实体的功能没有发生变化，基类才能真正被复用。<br/>
3.里氏代换原则由BarbarLiskov(芭芭拉.里氏)提出，是继承复用的基石。<br/>
4.一个继承是否符合里氏代换原则，可以判断该继承是否合理（是否隐藏有缺陷）。

努力使你的类尽可能的健壮[SOLID](http://en.wikipedia.org/wiki/SOLID_object-oriented_design\))。(

总是为你自己的类提供to_s方法,用来表现这个类（实例）对象包含的对象.

classPerson
attr_reader:first_name,:last_name

definitialize(first_name,last_name)
@first_name=first_name
@last_name=last_name
end

defto_s
"#@first_name#@last_name"
end
end

使用attr功能成员来定义各个实例变量的访问器或者修改器方法。

#bad
classPerson
definitialize(first_name,last_name)
@first_name=first_name
@last_name=last_name
end

deffirst_name
@first_name
end

deflast_name
@last_name
end
end

#good
classPerson
attr_reader:first_name,:last_name

definitialize(first_name,last_name)
@first_name=first_name
@last_name=last_name
end
end

避免使用attr。使用attr_reader和attr_accessor作为替代。

#bad-createsasingleattributeaccessor(deprecatedin1.9)
attr:something,true
attr:one,:two,:three#behavesasattr_reader

#good
attr_accessor:something
attr_reader:one,:two,:three

考虑使用Struct.new,它可以定义一些琐碎的accessors,
constructor（构造函数）和comparison（比较）操作。

#good
classPerson
attr_reader:first_name,:last_name

definitialize(first_name,last_name)
@first_name=first_name
@last_name=last_name
end
end

#better
classPerson<Struct.new(:first_name,:last_name)
end

考虑使用Struct.new，它替你定义了那些琐碎的存取器（accessors），构造器（constructor）以及比较操作符（comparisonoperators）。

#good
classPerson
attr_accessor:first_name,:last_name

definitialize(first_name,last_name)
@first_name=first_name
@last_name=last_name
end
end

#better
Person=Struct.new(:first_name,:last_name)do
end

不要去extend一个Struct.new-它已经是一个新的class。扩展它会产生一个多余的class层级
并且可能会产生怪异的错误如果文件被加载多次。

考虑添加工厂方法来提供灵活的方法来创建特定类实例。

classPerson
defself.create(potions_hash)
#bodyomitted
end
end

鸭子类型（duck-typing）优于继承。

#bad
classAnimal
#abstractmethod
defspeak
end
end

#extendsuperclass
classDuck<Animal
defspeak
puts'Quack!Quack'
end
end

#extendsuperclass
classDog<Animal
defspeak
puts'Bau!Bau!'
end
end

#good
classDuck
defspeak
puts'Quack!Quack'
end
end

classDog
defspeak
puts'Bau!Bau!'
end
end

Avoidtheusageofclass(@@)variablesduetotheir"nasty"behavior
ininheritance.

避免使用类变量（@@）因为他们讨厌的继承习惯（在子类中也可以修改父类的类变量）。

classParent
@@class_var='parent'

defself.print_class_var
puts@@class_var
end
end

classChild<Parent
@@class_var='child'
end

Parent.print_class_var#=>willprint"child"

正如上例看到的,所有的子类共享类变量,并且可以直接修改类变量,此时使用类实例变量是更好的主意.

根据方法的用途为他们分配合适的可见度(private,protected)，不要让所有的方法都是public(这是默认设定)。这是Ruby不是Python。

public,protected,和private等可见性关键字应该和其（指定）的方法具有相同的缩进。并且不同的可见性关键字之间留一个空格。

classSomeClass
defpublic_method
#...
end

private

defprivate_method
#...
end

defanother_private_method
#...
end
end

使用defself.method来定义单例方法.当代码重构时,这将使得代码更加容易因为类名是不重复的.

classTestClass
#bad
defTestClass.some_method
#bodyomitted
end

#good
defself.some_other_method
#bodyomitted
end

#Alsopossibleandconvenientwhenyou
#havetodefinemanysingletonmethods.
class<<self
deffirst_method
#bodyomitted
end

defsecond_method_etc
#bodyomitted
end
end
end

classSingletonTest
defsize
25
end
end

test1=SingletonTest.new
test2=SingletonTest.new
deftest2.size
10
end
test1.size#=>25
test2.size#=>10

本例中，test1與test2屬於同一類別，但test2具有重新定義的size方法，因此兩者的行為會不一樣。只給予單一物件的方法稱為单例方法(singletonmethod)。

Ruby中编写类与模块的风格指南

热门推荐

随机推荐