序言
笔者有幸参加了一次Code Retreat活动，整个过程很有收获，本文通过Golang语言来回放一下。
需求一：判断某个单词是否包含数字
这个需求比较简单，代码实现如下：
func HasDigit(word string) bool {
for _, c := range word {
if unicode.IsDigit(c) {
return true
}
}
return false
}
需求二：判断某个单词是否包含大写字母
有了需求一的基础后，可以通过copy-paste快速实现需求二：
func HasDigit(word string) bool {
for _, c := range word {
if unicode.IsDigit(c) {
return true
}
}
return false
}
func HasUpper(word string) bool {
for _, c := range str {
if unicode.IsUpper(c) {
return true
}
}
return false
}
很明显，HasDigit函数和HasUpper函数除过if的条件判断外，其余代码都一样，所以我们使用抽象这个强大的屠龙刀来消除重复:
- 定义一个接口CharSpec，作为所有字符谓词的抽象，方法Satisfy用来判断谓词是否为真
- 针对需求一定义具有原子语义的谓词IsDigit
- 针对需求二定义具有原子语义的谓词IsUpper
谓词相关代码实现如下：
type CharSpec interface {
Satisfy(c rune) bool
}
type IsDigit struct {
}
func (i IsDigit) Satisfy(c rune) bool {
return unicode.IsDigit(c)
}
type IsUpper struct {
}
func (i IsUpper) Satisfy(c rune) bool {
return unicode.IsUpper(c)
}
要完成需求，还必须将谓词注入给单词的Has语义函数，而Exists具有Has语义，同时表达力很强：
func Exists(word string, spec CharSpec) bool {
for _, c := range word {
if spec.Satisfy(c) {
return true
}
}
return false
}
通过Exists判断某个单词word是否包含数字：
isDigit := IsDigit{}
ok := Exists(word, isDigit)
...
通过Exists判断某个单词word是否包含大写字母：
isUpper := IsUpper{}
ok := Exists(word, isUpper)
...
其实需求二的故事还没讲完:)
对于普通的程序员来说，能完成上面的代码已经很好了，而对于经验丰富的程序员来说，在需求一刚完成后可能就发现了新的变化方向，即单词的Has语义和字符的Is语义是两个不同的变化方向，所以在需求二开始前就通过重构分离了变化方向：
type IsDigit struct {
}
func (i IsDigit) Satisfy(c rune) bool {
return unicode.IsDigit(c)
}
func Exists(word string, spec IsDigit) bool {
for _, c := range word {
if spec.Satisfy(c) {
return true
}
}
return false
}
通过Exists判断某个单词word是否包含数字：
isDigit := IsDigit{}
ok := Exists(word, isDigit)
...
在需求二出来后，谓词被第一颗子弹击中，我们根据Uncle Bob的建议，应用开放封闭原则，于是也就写出了普通程序员在需求二中消除重复后的代码。
殊途同归，这并不是巧合，而是有理论依据。
我们一起回顾一下 袁英杰先生 提出的正交设计四原则：
- 一个变化导致多处修改：消除重复
- 多个变化导致一处修改：分离不同的变化方向
- 不依赖不必要的依赖：缩小依赖范围
- 不依赖不稳定的依赖：向着稳定的方向依赖
这四个原则的提出是针对简单设计四原则中的第二条“消除重复”，使得目标的达成有章可循。我们应用正交设计四原则，可以将系统分解成很多单一职责的小类（也有一些小函数），然后再将它们根据需要而灵活的组合起来。
细细品味正交设计四原则，你就会发现：第一条是被动策略，而后三条是主动策略。这就是说，第一条是一种事后补救的策略，而后三条是一种事前预防的策略，目标都是为了消除重复。
从上面的分析可以看出，普通的程序员习惯使用被动策略，而经验丰富的程序员更喜欢使用主动策略。Anyway，他们殊途同归，都消除了重复。
需求三：判断某个单词是否包含_
不管是包含下划线还是中划线，都有原子语义Equals，我们将代码快速实现：
type Equals struct {
c rune
}
func (e Equals) Satisfy(c rune) bool {
return c == e.c
}
通过Exists判断某个单词word是否包含_：
isUnderline := Equals{'_'}
ok := Exists(word, isUnderline)
...
需求四：判断某个单词是否不包含_
字母是下划线的谓词是Equals，那么字母不是下划线的谓词就是给Equals前增加一个修饰语义Not，Not修饰谓词后是一个新的谓词，代码实现如下：
type Not struct {
spec CharSpec
}
fun (n Not) Satisfy(c rune) bool {
return !n.spec.Satisfy(c)
}
单词不包含下划线，就不是Exists语义了，而是ForAll语义，代码实现如下：
func ForAll(word string, spec CharSpec) bool {
for _, c := range str {
if !spec.Satisfy(c) {
return false
}
}
return true
}
通过ForAll判断某个单词word是否不包含_：
isNotUnderline := Not{Equals{'_'}}
ok := ForAll(word, isNotUnderline)
...
功能虽然实现了，但是我们发现Exists函数和ForAll函数有很多代码是重复的，使用重构基本手法Extract Method：
func expect(word string, spec CharSpec, ok bool) bool {
for _, c := range word {
if spec.Satisfy(c) == ok {
return ok
}
}
return !ok
}
func Exists(word string, spec CharSpec) bool {
return expect(word, spec, true)
}
func ForAll(word string, spec CharSpec) bool {
return expect(word, spec, false)
}
需求五：判断某个单词是否包含_或者＊
字母是x或y的谓词具有组合语义AnyOf，其中x为Equals{'_'}，y为Equals{'*'}，代码实现如下：
type AnyOf struct {
specs []CharSpec
}
func (a AnyOf) Satisfy(c rune) bool {
for _, spec := range a.specs {
if spec.Satisfy(c) {
return true
}
}
return false
}
通过Exists判断某个单词word是否包含_或*：
isUnderlineOrStar := AnyOf{[]CharSpec{Equals{'_'}, Equals{'*'}}}
ok := Exists(word, isUnderlineOrStar)
...
需求六：判断某个单词是否包含空白符，但除去空格
空白符包括空格、制表符和换行符等，具体见下面代码：
func IsSpace(r rune) bool {
// This property isn't the same as Z; special-case it.
if uint32(r) <= MaxLatin1 {
switch r {
case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0:
return true
}
return false
}
return isExcludingLatin(White_Space, r)
}
字母是空白符的谓词还没有实现，我们定义具有原子语义的谓词IsSpace：
type IsSpace struct {
}
func (i IsSpace) Satisfy(c rune) bool {
return unicode.IsSpace(c)
}
字母是x和y的谓词具有组合语义AllOf，其中x为IsSpace，y为Not{Equals{' '}}，代码实现如下：
type AllOf struct {
specs []CharSpec
}
func (a AllOf) Satisfy(c rune) bool {
for _, spec := range a.specs {
if !spec.Satisfy(c) {
return false
}
}
return true
}
通过Exists判断某个单词word是否包含空白符，但除去空格：
isSpaceAndNotBlank := AllOf{[]CharSpec{IsSpace{}, Not{Equals{' '}}}}
ok := Exists(word, isSpaceAndNotBlank)
...
需求七：判断某个单词是否包含字母x，且不区分大小写
不区分大小写是一种具有修饰语义的谓词IgnoreCase，代码实现如下：
type IgnoreCase struct {
spec CharSpec
}
func (i IgnoreCase) Satisfy(c rune) bool {
return i.spec.Satisfy(unicode.ToLower(c))
}
通过Exists判断某个单词word是否包含字母x，且不区分大小写：
isXIgnoreCase := IgnoreCase{Equals{'x'}}
ok := Exists(word, isXIgnoreCase)
...
小结
在需求的实现过程中，我们不断应用正交设计四原则，最终得到了很多小类（也有一些小函数），再通过组合来完成一个个既定需求，不但领域表达力强，而且非常灵活，容易应对变化。
字符的谓词是本文的重点，有以下三类
| 分类 | 谓词 |
|---|---|
| 原子语义 | IsDigit IsUpper Equals IsSpace |
| 修饰语义 | Not IgnoreCase |
| 组合语义 | AnyOf AllOf |
它的领域模型如下所示：
