用 Ruby 踩踩四人帮

最新推荐文章于 2024-07-24 15:11:29 发布

秋风

最新推荐文章于 2024-07-24 15:11:29 发布

阅读量970

点赞数

分类专栏：软件技术文章标签： ruby 设计模式 accessor class header decorator

软件技术专栏收录该内容

69 篇文章 0 订阅

订阅专栏

上上周在书店看到一本《Ruby设计模式》，捡起来 10 分钟看完，扔了（别问我为什么……）
下面用 Ruby 写写设计模式，顺便批一批 Java 和 Gof。

1.Factory 和 Abstract Factory

class Factory
  attr_accessor :product
  def produce
    @product.new
  end
end
class Product
  #..
end
fac = Factory.new
fac.product = Product
fac.produce

Java写的工厂有这么简单，这么容易重用么？

2.Builder

# 工头
class Director
  def build_with builder
	acc = ''
	[:header, :body, :footer].each do |m|
	  acc += builder.__send__ m if builder.respond_to? m
	end
	acc
  end
end
# 工人
class HTMLBuilder
  def header; '<html><title>html builder</title>';end
  def body;	  '<body>html builder</body>'        ;end
  def footer; '</html>'                          ;end
end
class XMLBuilder
  def header; '<?xml version="1.0" charset="utf-8">';end
  def body;   '<root>xml builder</root>'            ;end
end
d = Director.new
puts(d.build_with HTMLBuilder.new)
puts(d.build_with XMLBuilder.new)

注意：Ruby的工序并不依赖于Builder的类，只要有方法签名就行了。
interface 这种束手束脚，加强耦合的东西完全不需要~

3.Prototype
依样画葫芦。
这里用一点 trick (evil ruby)：

require 'evil'
class Prototype
  # ...
end
class Concrete
  include Prototype.as_module
end

4.Adapter
Ruby 包装方法易如反掌：

class Adaptee
  def talk; puts 'Adaptee';end
end
class Adapter < Adaptee
  alias talkee talk
  def talk
	puts 'before Adaptee'
	talkee
	puts 'after Adaptee'
  end
end
Adapter.new.talk

很多没学过设计模式的 Ruby 程序员天天用 adapter……

5.Composite
这个 pattern 是给没有多重继承又没法 mixin 的语言用的。
Ruby 只需要 include module。

6.Decorator

module Colorful
  attr_acessor :color
end
class Widget
end
w = Widget.new    # w 作为 Widget 的实例，没有 color 方法
w.color = 'blue' rescue puts 'w has no color'
w.extend Colorful # 现在 w 有 color 方法了
w.color = 'blue'
puts w.color

可怜的 Java 程序员需要学习设计模式才能写出 decorator。

7.Flyweight

# 重量级对象的瘦身法：如果创建参数相同，则返回同一个对象
class FlyweightFactory
  class Glyph
	def initialize key
	  @key = key
	  sleep 1 # 睡一秒，以体现这个对象创建的“重量级”
	  @square = key ** 2
	  @cubic = key ** 3
	end
	attr_reader :key, :square, :cubic
  end
  def produce key
	@glyphs ||= {}
    @glyphs[key] || (@glyphs[key] = Glyph.new key)
  end
end
ff = FlyweightFactory.new
g1 = ff.produce 2
g2 = ff.produce 2
puts (g1.object_id == g2.object_id)

不得不说 || 是很爽的语法。
另外 Ruby 的 Hash 可以用数组作 key，如果 Glyph 的构造函数需要更多参数，只需要把 produce 里的 key 改成 *key

8.Proxy
Proxy 和 Adapter 的区别只在接口上，它们在 Ruby 中是一样的。
这说明了：1.大道至简; 2.Gof 模式的语言局限性。

9.Chain of Responsibility
如果没有 proc，代码是做不到这么清晰简洁的：

class Chain
  def initialize
	@chain = []
  end
  def add_handler &block
	@chain << block
  end
  def handle req
	@chain.each do |e|
	  # 如果handler返回 false(未处理)，则让下一个处理
	  result = e[req] 
	  return result if result
	end
	false
  end	
end
c = Chain.new
c.add_handler {|req| req == 1 ? "1:handled" : puts "1:not my responsibility" }
c.add_handler {|req| req == 2 ? "2:handled" : puts "2:not my responsibility" }
puts(c.handle 1)
puts(c.handle 2)

10.Command
本质：一次调用可以同时执行多个方法。GUI 编程中处理事件很常用。
因为 Java 不能直接传递方法，所以把简单的问题复杂化了……
btw：真不理解 swing 优美在哪里……

class Command
  def initialize
	@executors = []
  end
  # 另一种方法是让 executors 保存一组对象，每个都带 execute 方法
  # ——但是这么简单的事情就需要一组接口，一组实现？
  def add_executor &block
	@executors << block
  end
  def execute
	@executors.each {|x| x.call }
  end
end
c = Command.new
c.add_executor{ puts 'executor 1' }
c.add_executor{ puts 'executor 2' }
c.execute

Command 是和 Chain 很相似的东西，可能某天会有人写一本 "Pattern of Patterns" 吧。

11.Template Method
Java 一说模板，C++ 和 Ruby 就笑了。
例（偷懒“重用”一下写过的代码）：

# 穷举法检验 de Morgan 定理
class Fixnum
  %w[a1 a2 a3 b1 b2 b3].each_with_index do |name, idx|
    define_method name, do
      self & (1<<idx) == 0 ? false : true
    end
  end
end
0b1000000.times do |n|
  n.instance_eval %q[
    if !((a1&&b1) || (a2&&b2) || (a3&&b3)) != !(a1&&b1) && !(a2&&b2) && !(a3&&b3)
      puts 'blah'
    end
  ]
end

12.Iterator 和 Visitor
这些模式还是作古吧。
有太多简单的方式进行迭代(map, inject, each, each_with_index，sort ...)
关键点还是语言对泛型和匿名函数的支持。

13.Mediator
将各个类的相互依赖性扔到一个中介类之中。
老老实实的写个中介类？大概会像这样：

class Mediator
  def initialize seller, buyer
	@seller = seller
	@buyer = buyer
  end
  def sell
	@seller.sell
  end
  def buy
	@buyer.buy
  end
end

发现问题了吗？ Mediator 出现的根源还是静态类型(是不会推断的那种)带来的耦合。
Duck Typing (check respond_to? instead of class) 早已解耦，根本不需要中介。

14.Strategy
提供运行时选择策略（算法）的可能。
假设 Array 有两种方法：bubble_sort 和 quick_sort
按照 Gof 的教诲，我们可能会这样想：

class Array
  def sort options
	if options[:strategy].to_sym == :bubble_sort
	  bubble_sort()
    elsif options[:strategy].to_sym == :quick_sort
	  quick_sort()
	end
  end
end
arr.sort :strategy => strategy

根本就是没事找事……看看 Ruby 动态选择调用方法多简单：

Ruby代码

arr.__send__ strategy

15.Singleton

module SingletonClass
  class << self
	# methods
  end
end

听说有人用两百行实现了严格的 singleton，膜拜中。

结论：
如果没有类型声明和继承，很多依赖性都会消失无踪，接口也无用武之地了。
设计模式大都是 Interface Hack 汇总，枯燥无味、思想僵化、限制创造力，早该下架了。
学设计模式不如学 Ruby Python。
Java 语言(注意不是平台)的弱点导致大量的冗余代码。
所谓从善如流，有功夫写冗余代码不如多写几个测试。
Java 语言(注意不是平台)的历史意义在于：将程序员从过早考虑效率的传统中解放了出来，现在也该功成身退了。

秋风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
用 Ruby 踩踩四人帮

上上周在书店看到一本《Ruby设计模式》，捡起来 10 分钟看完，扔了（别问我为什么……）下面用 Ruby 写写设计模式，顺便批一批 Java 和 Gof。1.Factory 和 Abstract Factoryclass Factory attr_accessor :product def produce @product.new endend
复制链接

扫一扫

专栏目录